fix(scene): create scene assets through Asset Manager

Author: YuchenWell

src/api/scene/scene.ts

@@ -18,11 +18,11 @@ import {
 } from './schema';
 import { description, param, result, title, tool } from '../decorator/decorator.js';
 import { COMMON_STATUS, CommonResultType, getCommonErrorStatus } from '../base/schema-base';
-import { Scene, TSceneTemplateType } from '../../core/scene';
+import { Scene } from '../../core/scene';
+import { assetManager } from '../../core/assets';
 import { ComponentApi } from './component';
 import { NodeApi } from './node';
 import { PrefabApi } from './prefab';
-import { options } from '../../core/builder/platforms/android/i18n/en';
 
 export class SceneApi {
     public component: ComponentApi;
@@ -126,16 +126,22 @@ export class SceneApi {
     @result(SchemaCreateResult)
     async createScene(@param(SchemaCreateOptions) options: TCreateOptions): Promise<CommonResultType<TCreateResult>> {
         try {
-            const data = await Scene.create({
-                type: 'scene',
-                baseName: options.baseName,
-                targetDirectory: options.dbURL,
-                templateType: options.templateType as TSceneTemplateType,
-            });
-            
+            const assetInfo = await assetManager.createAssetByType(
+                'scene',
+                options.dbURL,
+                options.baseName,
+                { templateName: options.templateType ?? '2d' },
+            );
+            const data: TCreateResult = {
+                assetName: assetInfo.name,
+                assetUuid: assetInfo.uuid,
+                assetUrl: assetInfo.url,
+                assetType: assetInfo.type,
+            };
+
             return {
                 code: COMMON_STATUS.SUCCESS,
-                data: data as TCreateResult,
+                data,
             };
         } catch (e) {
             console.error(e);

tests/scene-create-asset-backend.test.ts

@@ -0,0 +1,112 @@
+const mockCreateAssetByType = jest.fn();
+const mockSceneCreate = jest.fn();
+
+jest.mock('../src/api/decorator/decorator.js', () => ({
+    description: () => jest.fn(),
+    param: () => jest.fn(),
+    result: () => jest.fn(),
+    title: () => jest.fn(),
+    tool: () => jest.fn(),
+}), { virtual: true });
+
+jest.mock('../src/core/assets', () => ({
+    assetManager: {
+        createAssetByType: (...args: unknown[]) => mockCreateAssetByType(...args),
+    },
+}));
+
+jest.mock('../src/core/scene', () => ({
+    NodeType: {
+        EMPTY: 'Node',
+        SPRITE: 'Sprite',
+    },
+    SCENE_TEMPLATE_TYPE: ['2d', '3d'],
+    Scene: {
+        create: (...args: unknown[]) => mockSceneCreate(...args),
+    },
+}));
+
+import { SceneApi } from '../src/api/scene/scene';
+import { COMMON_STATUS } from '../src/api/base/schema-base';
+
+describe('scene-create AssetManager backend', () => {
+    beforeEach(() => {
+        mockCreateAssetByType.mockReset();
+        mockSceneCreate.mockReset();
+        jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    it('creates the scene through AssetManager and maps the legacy identifier result', async () => {
+        mockCreateAssetByType.mockResolvedValue({
+            name: 'Main.scene',
+            uuid: 'scene-uuid',
+            url: 'db://assets/scenes/Main.scene',
+            type: 'cc.SceneAsset',
+        });
+
+        const result = await new SceneApi().createScene({
+            baseName: 'Main',
+            dbURL: 'db://assets/scenes',
+            templateType: '3d',
+        });
+
+        expect(mockCreateAssetByType).toHaveBeenCalledWith(
+            'scene',
+            'db://assets/scenes',
+            'Main',
+            { templateName: '3d' },
+        );
+        expect(result).toEqual({
+            code: COMMON_STATUS.SUCCESS,
+            data: {
+                assetName: 'Main.scene',
+                assetUuid: 'scene-uuid',
+                assetUrl: 'db://assets/scenes/Main.scene',
+                assetType: 'cc.SceneAsset',
+            },
+        });
+        expect(mockSceneCreate).not.toHaveBeenCalled();
+    });
+
+    it('uses the 2d template by default and still performs zero Scene RPCs', async () => {
+        mockCreateAssetByType.mockResolvedValue({
+            name: 'Default.scene',
+            uuid: 'default-scene-uuid',
+            url: 'db://assets/Default.scene',
+            type: 'cc.SceneAsset',
+        });
+
+        const result = await new SceneApi().createScene({
+            baseName: 'Default',
+            dbURL: 'db://assets',
+        });
+
+        expect(result.code).toBe(COMMON_STATUS.SUCCESS);
+        expect(mockCreateAssetByType).toHaveBeenCalledWith(
+            'scene',
+            'db://assets',
+            'Default',
+            { templateName: '2d' },
+        );
+        expect(mockSceneCreate).not.toHaveBeenCalled();
+    });
+
+    it('returns the existing scene-create failure contract without falling back to Scene RPC', async () => {
+        mockCreateAssetByType.mockRejectedValue(new Error('asset creation failed'));
+
+        const result = await new SceneApi().createScene({
+            baseName: 'Broken',
+            dbURL: 'db://assets',
+        });
+
+        expect(result).toEqual({
+            code: COMMON_STATUS.FAIL,
+            reason: 'asset creation failed',
+        });
+        expect(mockSceneCreate).not.toHaveBeenCalled();
+    });
+});