@dcl/sdk-commands 7.1.4-4692707982.commit-108fa71 → 7.1.4

package/dist/commands/start/index.js

@@ -114,24 +114,22 @@ async function main(options) {
     if (workspace.projects.length > 1)
         (0, beautiful_logs_1.printWarning)(options.components.logger, 'Support for multiple projects is still experimental.');
     for (const project of workspace.projects) {
-        if (project.kind === 'scene') {
-            (0, beautiful_logs_1.printCurrentProjectStarting)(options.components.logger, project, workspace);
-            // first run `npm run build`, this can be disabled with --skip-build
-            // then start the embedded compiler, this can be disabled with --no-watch
-            if (watch) {
-                await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': true, _: [] } }, project);
-            }
-            else if (!skipBuild) {
-                await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': false, _: [] } }, project);
-            }
-            // track the event
-            baseCoords = (0, scene_validations_1.getBaseCoords)(project.scene);
-            options.components.analytics.track('Preview started', {
-                projectHash: await (0, project_files_1.b64HashingFunction)(project.workingDirectory),
-                coords: baseCoords,
-                isWorkspace: false
-            });
+        (0, beautiful_logs_1.printCurrentProjectStarting)(options.components.logger, project, workspace);
+        // first run `npm run build`, this can be disabled with --skip-build
+        // then start the embedded compiler, this can be disabled with --no-watch
+        if (watch) {
+            await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': true, _: [] } }, project);
+        }
+        else if (!skipBuild) {
+            await (0, build_1.buildScene)({ ...options, args: { '--dir': project.workingDirectory, '--watch': false, _: [] } }, project);
         }
+        // track the event
+        baseCoords = (0, scene_validations_1.getBaseCoords)(project.scene);
+        options.components.analytics.track('Preview started', {
+            projectHash: await (0, project_files_1.b64HashingFunction)(project.workingDirectory),
+            coords: baseCoords,
+            isWorkspace: false
+        });
     }
     (0, beautiful_logs_1.printProgressInfo)(options.components.logger, 'Starting preview server');
     const port = await (0, get_free_port_1.getPort)(options.args['--port'] || 0);

package/dist/commands/start/server/endpoints.js

@@ -36,11 +36,12 @@ function smartWearableNameToId(name) {
 }
 async function setupEcs6Endpoints(components, router, workspace) {
     const catalystUrl = new URL(await (0, config_1.getCatalystBaseUrl)(components));
-    // handle old preview scene.json DEPRECATED
+    const baseFolders = workspace.projects.map(($) => $.workingDirectory);
+    // handle old preview scene.json
     router.get('/scene.json', async () => {
         return {
             headers: { 'content-type': 'application/json' },
-            body: components.fs.createReadStream(path.join(workspace.projects[0].workingDirectory, 'scene.json'))
+            body: components.fs.createReadStream(path.join(baseFolders[0], 'scene.json'))
         };
     });
     router.get('/lambdas/explore/realms', async (ctx) => {
@@ -71,7 +72,8 @@ async function setupEcs6Endpoints(components, router, workspace) {
     router.get('/lambdas/profiles', async (ctx, next) => {
         const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
         try {
-            const previewWearables = await getAllPreviewWearables(components, workspace, {
+            const previewWearables = await getAllPreviewWearables(components, {
+                baseFolders,
                 baseUrl
             });
             if (previewWearables.length === 1) {
@@ -134,43 +136,22 @@ async function setupEcs6Endpoints(components, router, workspace) {
     });
     serveStatic(components, workspace, router);
     // TODO: get workspace scenes & wearables...
-    await serveFolders(components, router, workspace);
+    await serveFolders(components, router, baseFolders);
 }
 exports.setupEcs6Endpoints = setupEcs6Endpoints;
-async function serveFolders(components, router, workspace) {
+async function serveFolders(components, router, baseFolders) {
     const catalystUrl = await (0, config_1.getCatalystBaseUrl)(components);
     router.get('/content/contents/:hash', async (ctx, next) => {
         if (ctx.params.hash && ctx.params.hash.startsWith('b64-')) {
             const fullPath = path.resolve(Buffer.from(ctx.params.hash.replace(/^b64-/, ''), 'base64').toString('utf8'));
-            // find a project that we are talking about. NOTE: this filter is not exhaustive
-            //   relative paths should be used instead
-            const baseProject = workspace.projects.find((project) => fullPath.startsWith(project.workingDirectory));
             // only return files IF the file is within a baseFolder
-            if (!baseProject) {
+            if (!baseFolders.find((folder) => fullPath.startsWith(folder))) {
                 return next();
             }
-            if (path.resolve(fullPath) === path.resolve(baseProject.workingDirectory)) {
-                // if we are talking about the root directory, then we must return the json of the entity
-                const entity = await fakeEntityV3FromProject(components, baseProject, project_files_1.b64HashingFunction);
-                if (!entity)
-                    return { status: 404 };
-                return {
-                    headers: {
-                        'x-timestamp': Date.now().toString(),
-                        'x-sent': 'true',
-                        'cache-control': 'no-cache,private,max-age=1'
-                    },
-                    body: entity
-                };
-            }
-            if (!(await components.fs.fileExists(fullPath)))
-                return { status: 404 };
-            if (await components.fs.directoryExists(fullPath))
-                return { status: 404 };
             return {
                 headers: {
-                    'x-timestamp': Date.now().toString(),
-                    'x-sent': 'true',
+                    'x-timestamp': Date.now(),
+                    'x-sent': true,
                     'cache-control': 'no-cache,private,max-age=1'
                 },
                 body: components.fs.createReadStream(fullPath)
@@ -183,7 +164,7 @@ async function serveFolders(components, router, workspace) {
             return [];
         }
         const requestedPointers = new Set(pointers && typeof pointers === 'string' ? [pointers] : pointers);
-        const resultEntities = await getSceneJson(components, workspace, Array.from(requestedPointers));
+        const resultEntities = await getSceneJson(components, baseFolders, Array.from(requestedPointers));
         const remote = (0, catalyst_requests_1.fetchEntityByPointer)(components, catalystUrl.toString(), pointers.filter(($) => !$.match(/-?\d+,-?\d+/)));
         const serverEntities = Array.isArray(remote) ? remote : [];
         return [...resultEntities, ...serverEntities];
@@ -203,8 +184,9 @@ async function serveFolders(components, router, workspace) {
     });
     router.get('/preview-wearables/:id', async (ctx) => {
         const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
-        const wearables = await getAllPreviewWearables(components, workspace, {
-            baseUrl
+        const wearables = await getAllPreviewWearables(components, {
+            baseUrl,
+            baseFolders
         });
         const wearableId = ctx.params.id;
         return {
@@ -219,44 +201,40 @@ async function serveFolders(components, router, workspace) {
         return {
             body: {
                 ok: true,
-                data: await getAllPreviewWearables(components, workspace, { baseUrl })
+                data: await getAllPreviewWearables(components, { baseUrl, baseFolders })
             }
         };
     });
 }
-async function getAllPreviewWearables(components, workspace, { baseUrl }) {
-    // NOTE: the explorers should use the /entities/active endpoint to retrieve the wearables. This endpoint should be removed
+async function getAllPreviewWearables(components, { baseFolders, baseUrl }) {
     const wearablePathArray = [];
-    for (const project of workspace.projects) {
-        if (project.kind === 'wearable') {
-            const wearableJsonPath = path.resolve(project.workingDirectory, 'wearable.json');
-            if (await components.fs.fileExists(wearableJsonPath)) {
-                wearablePathArray.push(wearableJsonPath);
-            }
+    for (const wearableDir of baseFolders) {
+        const wearableJsonPath = path.resolve(wearableDir, 'wearable.json');
+        if (await components.fs.fileExists(wearableJsonPath)) {
+            wearablePathArray.push(wearableJsonPath);
         }
     }
     const ret = [];
-    for (const project of workspace.projects) {
+    for (const wearableJsonPath of wearablePathArray) {
         try {
-            if (project.kind === 'wearable')
-                ret.push(await serveWearable(components, project, baseUrl));
+            ret.push(await serveWearable(components, wearableJsonPath, baseUrl));
         }
         catch (err) {
-            components.logger.error(`Couldn't mock the wearable ${project.workingDirectory}. Please verify the correct format and scheme.` + err);
+            components.logger.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.` + err);
         }
     }
     return ret;
 }
-async function serveWearable(components, project, baseUrl) {
-    const wearableJsonPath = path.join(project.workingDirectory, 'wearable.json');
+async function serveWearable(components, wearableJsonPath, baseUrl) {
+    const wearableDir = path.dirname(wearableJsonPath);
     const wearableJson = JSON.parse((await components.fs.readFile(wearableJsonPath)).toString());
     if (!sdk_1.WearableJson.validate(wearableJson)) {
         const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
         components.logger.error(`Unable to validate wearable.json properly, please check it.` + errors);
         throw new Error(`Invalid wearable.json (${wearableJsonPath})`);
     }
-    const projectFiles = await (0, project_files_1.getProjectPublishableFilesWithHashes)(components, project.workingDirectory, project_files_1.b64HashingFunction);
-    const contentFiles = (0, project_files_1.projectFilesToContentMappings)(project.workingDirectory, projectFiles);
+    const projectFiles = await (0, project_files_1.getProjectPublishableFilesWithHashes)(components, wearableDir, project_files_1.b64HashingFunction);
+    const contentFiles = (0, project_files_1.projectFilesToContentMappings)(wearableDir, projectFiles);
     const thumbnailFiltered = contentFiles.filter(($) => $.file === 'thumbnail.png');
     const thumbnail = thumbnailFiltered.length > 0 && thumbnailFiltered[0].hash && `${baseUrl}/${thumbnailFiltered[0].hash}`;
     const wearableId = 'urn:8dc2d7ad-97e3-44d0-ba89-e8305d795a6a';
@@ -289,10 +267,10 @@ async function serveWearable(components, project, baseUrl) {
         }
     };
 }
-async function getSceneJson(components, workspace, pointers) {
+async function getSceneJson(components, projectRoots, pointers) {
     const requestedPointers = new Set(pointers);
     const resultEntities = [];
-    const allDeployments = await Promise.all(workspace.projects.map((project) => fakeEntityV3FromProject(components, project, project_files_1.b64HashingFunction)));
+    const allDeployments = await Promise.all(projectRoots.map(async (projectRoot) => fakeEntityV3FromFolder(components, projectRoot, project_files_1.b64HashingFunction)));
     for (const pointer of Array.from(requestedPointers)) {
         // get deployment by pointer
         const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer));
@@ -348,9 +326,6 @@ function serveStatic(components, workspace, router) {
             if (!(await components.fs.fileExists(fullPath))) {
                 return next();
             }
-            if (await components.fs.directoryExists(fullPath)) {
-                return { status: 404 };
-            }
             const headers = {
                 'x-timestamp': Date.now(),
                 'x-sent': true,
@@ -379,49 +354,44 @@ function serveStatic(components, workspace, router) {
         };
     });
 }
-async function fakeEntityV3FromProject(components, project, hashingFunction) {
-    const projectFiles = await (0, project_files_1.getProjectPublishableFilesWithHashes)(components, project.workingDirectory, hashingFunction);
-    const contentFiles = (0, project_files_1.projectFilesToContentMappings)(project.workingDirectory, projectFiles);
-    if (project.kind === 'scene') {
-        const sceneJsonPath = path.resolve(project.workingDirectory, 'scene.json');
+async function fakeEntityV3FromFolder(components, projectRoot, hashingFunction) {
+    const sceneJsonPath = path.resolve(projectRoot, 'scene.json');
+    let isParcelScene = true;
+    const wearableJsonPath = path.resolve(projectRoot, 'wearable.json');
+    if (await components.fs.fileExists(wearableJsonPath)) {
+        try {
+            const wearableJson = JSON.parse(await components.fs.readFile(wearableJsonPath, 'utf-8'));
+            if (!sdk_1.WearableJson.validate(wearableJson)) {
+                const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
+                components.logger.error(`Unable to validate wearable.json properly, please check its schema.` + errors);
+                components.logger.error(`Invalid wearable.json (${wearableJsonPath})`);
+            }
+            else {
+                isParcelScene = false;
+            }
+        }
+        catch (err) {
+            components.logger.error(`Unable to load wearable.json`);
+            components.logger.error(err);
+        }
+    }
+    if ((await components.fs.fileExists(sceneJsonPath)) && isParcelScene) {
         const sceneJson = JSON.parse(await components.fs.readFile(sceneJsonPath, 'utf-8'));
         const { base, parcels } = sceneJson.scene;
         const pointers = new Set();
         pointers.add(base);
         parcels.forEach(($) => pointers.add($));
+        const projectFiles = await (0, project_files_1.getProjectPublishableFilesWithHashes)(components, projectRoot, hashingFunction);
+        const contentFiles = (0, project_files_1.projectFilesToContentMappings)(projectRoot, projectFiles);
         return {
             version: 'v3',
             type: schemas_1.EntityType.SCENE,
-            id: await hashingFunction(project.workingDirectory),
+            id: await hashingFunction(projectRoot),
             pointers: Array.from(pointers),
             timestamp: Date.now(),
             metadata: sceneJson,
             content: contentFiles
         };
     }
-    else if (project.kind === 'wearable') {
-        const wearableJsonPath = path.resolve(project.workingDirectory, 'wearable.json');
-        try {
-            const wearableJson = JSON.parse(await components.fs.readFile(wearableJsonPath, 'utf-8'));
-            if (!sdk_1.WearableJson.validate(wearableJson)) {
-                const errors = (sdk_1.WearableJson.validate.errors || []).map((a) => `${a.data} ${a.message}`).join('');
-                components.logger.error(`Unable to validate wearable.json properly, please check its schema.` + errors);
-                components.logger.error(`Invalid wearable.json (${wearableJsonPath})`);
-            }
-            return {
-                version: 'v3',
-                type: schemas_1.EntityType.WEARABLE,
-                id: await hashingFunction(project.workingDirectory),
-                pointers: Array.from([await hashingFunction(project.workingDirectory)]),
-                timestamp: Date.now(),
-                metadata: wearableJson,
-                content: contentFiles
-            };
-        }
-        catch (err) {
-            components.logger.error(`Unable to load wearable.json`);
-            components.logger.error(err);
-        }
-    }
     return null;
 }

package/dist/logic/project-validations.d.ts

@@ -7,11 +7,7 @@ export type SceneProject = {
     kind: 'scene';
     scene: Scene;
 } & BaseProject;
-export type WearableProject = {
-    kind: 'wearable';
-    wearable: any;
-} & BaseProject;
-export type ProjectUnion = SceneProject | WearableProject;
+export type ProjectUnion = SceneProject;
 /**
  * Asserts that the workingDirectory is a valid project
  */

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dcl/sdk-commands",
   "description": "",
-  "version": "7.1.4-4692707982.commit-108fa71",
+  "version": "7.1.4",
   "author": "Decentraland",
   "bin": {
     "sdk-commands": "./dist/index.js"
   },
   "dependencies": {
     "@dcl/hashing": "1.1.3",
-    "@dcl/inspector": "7.1.4-4692707982.commit-108fa71",
+    "@dcl/inspector": "7.1.4",
     "@dcl/linker-dapp": "0.7.0",
     "@dcl/mini-comms": "1.0.1-20230216163137.commit-a4c75be",
     "@dcl/protocol": "1.0.0-4671230683.commit-a8d74c3",
@@ -60,5 +60,5 @@
     "displayName": "SDK",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "108fa711aa994addfc08b2307455c2fad67f3b05"
+  "commit": "3f2952c5e02d012a18b91605485925bc3dd6f756"
 }