@dcl/sdk-commands 7.1.4 → 7.1.5-4704298040.commit-f6a337a

package/dist/commands/start/index.js

@@ -114,22 +114,24 @@ 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) {
-        (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);
+        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
+            });
         }
-        // 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,12 +36,11 @@ function smartWearableNameToId(name) {
 }
 async function setupEcs6Endpoints(components, router, workspace) {
     const catalystUrl = new URL(await (0, config_1.getCatalystBaseUrl)(components));
-    const baseFolders = workspace.projects.map(($) => $.workingDirectory);
-    // handle old preview scene.json
+    // handle old preview scene.json DEPRECATED
     router.get('/scene.json', async () => {
         return {
             headers: { 'content-type': 'application/json' },
-            body: components.fs.createReadStream(path.join(baseFolders[0], 'scene.json'))
+            body: components.fs.createReadStream(path.join(workspace.projects[0].workingDirectory, 'scene.json'))
         };
     });
     router.get('/lambdas/explore/realms', async (ctx) => {
@@ -72,8 +71,7 @@ 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, {
-                baseFolders,
+            const previewWearables = await getAllPreviewWearables(components, workspace, {
                 baseUrl
             });
             if (previewWearables.length === 1) {
@@ -136,22 +134,43 @@ async function setupEcs6Endpoints(components, router, workspace) {
     });
     serveStatic(components, workspace, router);
     // TODO: get workspace scenes & wearables...
-    await serveFolders(components, router, baseFolders);
+    await serveFolders(components, router, workspace);
 }
 exports.setupEcs6Endpoints = setupEcs6Endpoints;
-async function serveFolders(components, router, baseFolders) {
+async function serveFolders(components, router, workspace) {
     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 (!baseFolders.find((folder) => fullPath.startsWith(folder))) {
+            if (!baseProject) {
                 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(),
-                    'x-sent': true,
+                    'x-timestamp': Date.now().toString(),
+                    'x-sent': 'true',
                     'cache-control': 'no-cache,private,max-age=1'
                 },
                 body: components.fs.createReadStream(fullPath)
@@ -164,7 +183,7 @@ async function serveFolders(components, router, baseFolders) {
             return [];
         }
         const requestedPointers = new Set(pointers && typeof pointers === 'string' ? [pointers] : pointers);
-        const resultEntities = await getSceneJson(components, baseFolders, Array.from(requestedPointers));
+        const resultEntities = await getSceneJson(components, workspace, 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];
@@ -184,9 +203,8 @@ async function serveFolders(components, router, baseFolders) {
     });
     router.get('/preview-wearables/:id', async (ctx) => {
         const baseUrl = `${ctx.url.protocol}//${ctx.url.host}/content/contents`;
-        const wearables = await getAllPreviewWearables(components, {
-            baseUrl,
-            baseFolders
+        const wearables = await getAllPreviewWearables(components, workspace, {
+            baseUrl
         });
         const wearableId = ctx.params.id;
         return {
@@ -201,40 +219,44 @@ async function serveFolders(components, router, baseFolders) {
         return {
             body: {
                 ok: true,
-                data: await getAllPreviewWearables(components, { baseUrl, baseFolders })
+                data: await getAllPreviewWearables(components, workspace, { baseUrl })
             }
         };
     });
 }
-async function getAllPreviewWearables(components, { baseFolders, baseUrl }) {
+async function getAllPreviewWearables(components, workspace, { baseUrl }) {
+    // NOTE: the explorers should use the /entities/active endpoint to retrieve the wearables. This endpoint should be removed
     const wearablePathArray = [];
-    for (const wearableDir of baseFolders) {
-        const wearableJsonPath = path.resolve(wearableDir, 'wearable.json');
-        if (await components.fs.fileExists(wearableJsonPath)) {
-            wearablePathArray.push(wearableJsonPath);
+    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);
+            }
         }
     }
     const ret = [];
-    for (const wearableJsonPath of wearablePathArray) {
+    for (const project of workspace.projects) {
         try {
-            ret.push(await serveWearable(components, wearableJsonPath, baseUrl));
+            if (project.kind === 'wearable')
+                ret.push(await serveWearable(components, project, baseUrl));
         }
         catch (err) {
-            components.logger.error(`Couldn't mock the wearable ${wearableJsonPath}. Please verify the correct format and scheme.` + err);
+            components.logger.error(`Couldn't mock the wearable ${project.workingDirectory}. Please verify the correct format and scheme.` + err);
         }
     }
     return ret;
 }
-async function serveWearable(components, wearableJsonPath, baseUrl) {
-    const wearableDir = path.dirname(wearableJsonPath);
+async function serveWearable(components, project, baseUrl) {
+    const wearableJsonPath = path.join(project.workingDirectory, 'wearable.json');
     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, wearableDir, project_files_1.b64HashingFunction);
-    const contentFiles = (0, project_files_1.projectFilesToContentMappings)(wearableDir, projectFiles);
+    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 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';
@@ -267,10 +289,10 @@ async function serveWearable(components, wearableJsonPath, baseUrl) {
         }
     };
 }
-async function getSceneJson(components, projectRoots, pointers) {
+async function getSceneJson(components, workspace, pointers) {
     const requestedPointers = new Set(pointers);
     const resultEntities = [];
-    const allDeployments = await Promise.all(projectRoots.map(async (projectRoot) => fakeEntityV3FromFolder(components, projectRoot, project_files_1.b64HashingFunction)));
+    const allDeployments = await Promise.all(workspace.projects.map((project) => fakeEntityV3FromProject(components, project, project_files_1.b64HashingFunction)));
     for (const pointer of Array.from(requestedPointers)) {
         // get deployment by pointer
         const theDeployment = allDeployments.find(($) => $ && $.pointers.includes(pointer));
@@ -326,6 +348,9 @@ 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,
@@ -354,44 +379,49 @@ function serveStatic(components, workspace, router) {
         };
     });
 }
-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) {
+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');
         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(projectRoot),
+            id: await hashingFunction(project.workingDirectory),
             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,7 +7,11 @@ export type SceneProject = {
     kind: 'scene';
     scene: Scene;
 } & BaseProject;
-export type ProjectUnion = SceneProject;
+export type WearableProject = {
+    kind: 'wearable';
+    wearable: any;
+} & BaseProject;
+export type ProjectUnion = SceneProject | WearableProject;
 /**
  * Asserts that the workingDirectory is a valid project
  */

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@dcl/sdk-commands",
   "description": "",
-  "version": "7.1.4",
+  "version": "7.1.5-4704298040.commit-f6a337a",
   "author": "Decentraland",
   "bin": {
     "sdk-commands": "./dist/index.js"
   },
   "dependencies": {
     "@dcl/hashing": "1.1.3",
-    "@dcl/inspector": "7.1.4",
+    "@dcl/inspector": "7.1.5-4704298040.commit-f6a337a",
     "@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": "3f2952c5e02d012a18b91605485925bc3dd6f756"
+  "commit": "f6a337a9f93f7738174df9448d5a735ebc9468a1"
 }