cyberia 3.0.3 → 3.2.5

package/src/server/client-build-docs.js

@@ -59,6 +59,10 @@ const buildApiDocs = async ({
         name: 'user',
         description: 'User API operations',
       },
+      {
+        name: 'object-layer',
+        description: 'Object Layer API operations',
+      },
     ],
     components: {
       schemas: {
@@ -150,6 +154,70 @@ const buildApiDocs = async ({
           },
         },
       },
+      objectLayerResponse: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', example: 'success' },
+          data: {
+            type: 'object',
+            properties: {
+              _id: { type: 'string', example: '66c377f57f99e5969b81de89' },
+              data: {
+                type: 'object',
+                properties: {
+                  stats: {
+                    type: 'object',
+                    properties: {
+                      effect: { type: 'number', example: 0 },
+                      resistance: { type: 'number', example: 0 },
+                      agility: { type: 'number', example: 0 },
+                      range: { type: 'number', example: 0 },
+                      intelligence: { type: 'number', example: 0 },
+                      utility: { type: 'number', example: 0 },
+                    },
+                  },
+                  item: {
+                    type: 'object',
+                    properties: {
+                      id: { type: 'string', example: 'skin-default' },
+                      type: { type: 'string', example: 'skin' },
+                      description: { type: 'string', example: 'Default skin layer' },
+                      activable: { type: 'boolean', example: false },
+                    },
+                  },
+                  ledger: {
+                    type: 'object',
+                    properties: {
+                      type: { type: 'string', example: 'semi-fungible' },
+                      address: { type: 'string', example: '0x0000000000000000000000000000000000000000' },
+                      tokenId: { type: 'string', example: '' },
+                    },
+                  },
+                  render: {
+                    type: 'object',
+                    properties: {
+                      cid: { type: 'string', example: '' },
+                      metadataCid: { type: 'string', example: '' },
+                    },
+                  },
+                },
+              },
+              cid: { type: 'string', example: '' },
+              sha256: { type: 'string', example: 'abc123def456...' },
+            },
+          },
+        },
+      },
+      objectLayerBadRequestResponse: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', example: 'error' },
+          message: {
+            type: 'string',
+            example: 'Bad request. Please check your inputs, and try again',
+          },
+        },
+      },
       securitySchemes: {
         bearerAuth: {
           type: 'http',
@@ -221,7 +289,7 @@ const buildApiDocs = async ({
     const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
     const routes = [];
     for (const api of apis) {
-      if (['user'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
+      if (['user', 'object-layer'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
     }
 
     await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
@@ -264,17 +332,38 @@ const buildApiDocs = async ({
  * @param {string} options.path - The base path for the documentation
  * @param {Object} options.metadata - Metadata for the documentation
  * @param {string} options.publicClientId - Client ID used to resolve the tutorials/references directory
+ * @param {Object} options.docs - Documentation config from server conf
+ * @param {string} options.docs.jsJsonPath - Path to the JSDoc JSON config file
  */
-const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
+const buildJsDocs = async ({ host, path, metadata = {}, publicClientId, docs }) => {
   const logger = loggerFactory(import.meta);
-  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
+
+  const jsDocSourcePath = docs.jsJsonPath;
+  if (!fs.existsSync(jsDocSourcePath)) {
+    logger.warn('jsdoc config not found, skipping', jsDocSourcePath);
+    return;
+  }
+  const jsDocsConfig = JSON.parse(fs.readFileSync(jsDocSourcePath, 'utf8'));
+  logger.info('using jsdoc config', jsDocSourcePath);
 
   jsDocsConfig.opts.destination = `./public/${host}${path === '/' ? path : `${path}/`}docs/`;
   jsDocsConfig.opts.theme_opts.title = metadata?.title ? metadata.title : undefined;
   jsDocsConfig.opts.theme_opts.favicon = `./public/${host}${path === '/' ? '/' : `${path}/`}favicon.ico`;
 
   const tutorialsPath = `./src/client/public/${publicClientId}/docs/references`;
-  if (fs.existsSync(tutorialsPath)) {
+
+  if (Array.isArray(docs.references) && docs.references.length > 0) {
+    fs.mkdirSync(tutorialsPath, { recursive: true });
+    for (const refPath of docs.references) {
+      if (fs.existsSync(refPath)) {
+        const fileName = refPath.split('/').pop();
+        fs.copySync(refPath, `${tutorialsPath}/${fileName}`);
+        logger.info('copied reference to tutorials', refPath);
+      }
+    }
+  }
+
+  if (fs.existsSync(tutorialsPath) && fs.readdirSync(tutorialsPath).length > 0) {
     jsDocsConfig.opts.tutorials = tutorialsPath;
     if (jsDocsConfig.opts.theme_opts.sections && !jsDocsConfig.opts.theme_opts.sections.includes('Tutorials')) {
       jsDocsConfig.opts.theme_opts.sections.push('Tutorials');
@@ -284,10 +373,10 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
     delete jsDocsConfig.opts.tutorials;
   }
 
-  fs.writeFileSync(`./jsdoc.json`, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
+  fs.writeFileSync(jsDocSourcePath, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
   logger.warn('build jsdoc view', jsDocsConfig.opts.destination);
 
-  shellExec(`npm run docs`, { silent: true });
+  shellExec(`npx jsdoc -c ${jsDocSourcePath}`, { silent: true });
 };
 
 /**
@@ -297,20 +386,45 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
  * @param {Object} options - Coverage build options
  * @param {string} options.host - The hostname for the coverage
  * @param {string} options.path - The base path for the coverage
+ * @param {Object} options.docs - Documentation config from server conf
+ * @param {string} options.docs.coveragePath - Directory where to run npm run coverage
  */
-const buildCoverage = async ({ host, path }) => {
+const buildCoverage = async ({ host, path, docs }) => {
   const logger = loggerFactory(import.meta);
-  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
+  const jsDocSourcePath = docs.jsJsonPath;
+  const jsDocsConfig = JSON.parse(fs.readFileSync(jsDocSourcePath, 'utf8'));
+  const coveragePath = docs.coveragePath;
+  const coverageOutputDir = docs.coverageOutputDir || 'coverage';
 
-  if (!fs.existsSync(`./coverage`)) {
-    shellExec(`npm test`);
+  const coverageOutputPath = `${coveragePath}/coverage`;
+  if (!fs.existsSync(coverageOutputPath)) {
+    const pkgPath = `${coveragePath}/package.json`;
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if (pkg.scripts && pkg.scripts.coverage) {
+        logger.info('generating coverage report', coveragePath);
+        shellExec(`cd ${coveragePath} && npm run coverage`, { silent: true });
+      } else if (pkg.scripts && pkg.scripts.test) {
+        logger.info('generating coverage via test', coveragePath);
+        shellExec(`cd ${coveragePath} && npm test`, { silent: true });
+      }
+    }
   }
 
-  const coverageBuildPath = `${jsDocsConfig.opts.destination}coverage`;
-  fs.mkdirSync(coverageBuildPath, { recursive: true });
-  fs.copySync(`./coverage`, coverageBuildPath);
-
-  logger.warn('build coverage', coverageBuildPath);
+  if (fs.existsSync(coverageOutputPath) && fs.readdirSync(coverageOutputPath).length > 0) {
+    const coverageBuildPath = `${jsDocsConfig.opts.destination}${coverageOutputDir}`;
+    fs.mkdirSync(coverageBuildPath, { recursive: true });
+    // Hardhat 3 outputs HTML to coverage/html/; Hardhat 2 / c8 output directly to coverage/
+    const coverageHtmlSubdir = `${coverageOutputPath}/html`;
+    if (fs.existsSync(coverageHtmlSubdir) && fs.existsSync(`${coverageHtmlSubdir}/index.html`)) {
+      fs.copySync(coverageHtmlSubdir, coverageBuildPath);
+    } else {
+      fs.copySync(coverageOutputPath, coverageBuildPath);
+    }
+    logger.warn('build coverage', coverageBuildPath);
+  } else {
+    logger.warn('no coverage output found, skipping', coverageOutputPath);
+  }
 };
 
 /**
@@ -326,6 +440,7 @@ const buildCoverage = async ({ host, path }) => {
  * @param {string} options.publicClientId - Client ID for the public documentation
  * @param {string} options.rootClientPath - Root path for client files
  * @param {Object} options.packageData - Package.json data
+ * @param {Object} options.docs - Documentation config from server conf
  */
 const buildDocs = async ({
   host,
@@ -336,9 +451,10 @@ const buildDocs = async ({
   publicClientId,
   rootClientPath,
   packageData,
+  docs,
 }) => {
-  await buildJsDocs({ host, path, metadata, publicClientId });
-  await buildCoverage({ host, path });
+  await buildJsDocs({ host, path, metadata, publicClientId, docs });
+  await buildCoverage({ host, path, docs });
   await buildApiDocs({
     host,
     path,

package/src/server/client-build-live.js

@@ -5,7 +5,7 @@
  */
 
 import fs from 'fs-extra';
-import { Config, loadConf } from './conf.js';
+import { Config, loadConf, readConfJson } from './conf.js';
 import { loggerFactory } from './logger.js';
 import { buildClient } from './client-build.js';
 
@@ -17,14 +17,14 @@ const logger = loggerFactory(import.meta);
  * @memberof clientLiveBuild
  */
 const clientLiveBuild = async () => {
-  if (fs.existsSync(`./tmp/client.build.json`)) {
+  if (fs.existsSync(`/tmp/client.build.json`)) {
     const deployId = process.argv[2];
     const subConf = process.argv[3];
     let clientId = 'default';
     let host = 'default.net';
     let path = '/';
     let baseHost = `${host}${path === '/' ? '' : path}`;
-    let views = Config.default.client[clientId].views;
+    let views;
     let apiBaseHost;
     let apiBaseProxyPath;
 
@@ -33,19 +33,8 @@ const clientLiveBuild = async () => {
       (fs.existsSync(`./engine-private/conf/${deployId}`) || fs.existsSync(`./engine-private/replica/${deployId}`))
     ) {
       loadConf(deployId, subConf);
-      const confClient = JSON.parse(
-        fs.readFileSync(
-          fs.existsSync(`./engine-private/replica/${deployId}`)
-            ? `./engine-private/replica/${deployId}/conf.client.json`
-            : fs.existsSync(`./engine-private/conf/${deployId}/conf.client.json`)
-            ? `./engine-private/conf/${deployId}/conf.client.json`
-            : `./conf/conf.client.json`,
-          'utf8',
-        ),
-      );
-      const confServer = JSON.parse(
-        fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`, 'utf8'),
-      );
+      const confClient = readConfJson(deployId, 'client');
+      const confServer = readConfJson(deployId, 'server');
       host = process.argv[4];
       path = process.argv[5];
       clientId = confServer[host][path].client;
@@ -53,6 +42,8 @@ const clientLiveBuild = async () => {
       baseHost = `${host}${path === '/' ? '' : path}`;
       apiBaseHost = confServer[host][path].apiBaseHost;
       apiBaseProxyPath = confServer[host][path].apiBaseProxyPath;
+    } else {
+      views = Config.default.client[clientId].views;
     }
 
     logger.info('Live build config', {
@@ -67,7 +58,7 @@ const clientLiveBuild = async () => {
       apiBaseProxyPath,
     });
 
-    const updates = JSON.parse(fs.readFileSync(`./tmp/client.build.json`, 'utf8'));
+    const updates = JSON.parse(fs.readFileSync(`/tmp/client.build.json`, 'utf8'));
     const liveClientBuildPaths = [];
     for (let srcPath of updates) {
       srcPath = srcPath.replaceAll('/', `\\`);
@@ -102,7 +93,7 @@ const clientLiveBuild = async () => {
     }
     logger.info('liveClientBuildPaths', liveClientBuildPaths);
     await buildClient({ liveClientBuildPaths, instances: [{ host, path }] });
-    fs.removeSync(`./tmp/client.build.json`);
+    fs.removeSync(`/tmp/client.build.json`);
   }
 };