cyberia 3.2.9 → 3.2.22

package/bin/build.js

@@ -1,104 +1,65 @@
+#! /usr/bin/env node
+
+import { Command } from 'commander';
 import fs from 'fs-extra';
-import { loggerFactory } from '../src/server/logger.js';
-import { shellExec } from '../src/server/process.js';
 import dotenv from 'dotenv';
+import { loggerFactory } from '../src/server/logger.js';
 import { getCapVariableName } from '../src/client/components/core/CommonJs.js';
-import { getPathsSSR } from '../src/server/conf.js';
+import {
+  getPathsSSR,
+  resolveDeployList,
+  syncPrivateConf,
+  syncDeployIdSources,
+  buildTemplate,
+  updatePrivateEngineTestRepo,
+} from '../src/server/conf.js';
+import { loadDeployCatalog } from '../src/server/catalog.js';
+import UnderpostRepository from '../src/cli/repository.js';
 
 const baseConfPath = './engine-private/conf/dd-cron/.env.production';
 if (fs.existsSync(baseConfPath)) dotenv.config({ path: baseConfPath, override: true });
 
 const logger = loggerFactory(import.meta);
 
-const confName = process.argv[2];
 const basePath = '../pwa-microservices-template';
-const repoName = `engine-${confName.split('dd-')[1]}`;
-const deployList = (confName === 'dd' ? fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8') : confName).split(
-  ',',
-);
-
-logger.info('Build repository', {
-  confName,
-  repoName,
-  basePath,
-  deployList,
-});
-
-if (process.argv.includes('conf')) {
-  for (const _confName of deployList) {
-    const _repoName = `engine-${_confName.split('dd-')[1]}`;
-    const privateRepoName = `${_repoName}-private`;
-    const privateGitUri = `${process.env.GITHUB_USERNAME}/${privateRepoName}`;
-
-    if (!fs.existsSync(`../${privateRepoName}`)) {
-      shellExec(`cd .. && underpost clone ${privateGitUri}`, { silent: true });
-    } else {
-      shellExec(`cd ../${privateRepoName} && git checkout . && git clean -f -d && underpost pull . ${privateGitUri}`, {
-        silent: true,
-      });
-    }
-    const toPath = `../${privateRepoName}/conf/${_confName}`;
-    fs.removeSync(toPath);
-    fs.mkdirSync(toPath, { recursive: true });
-    fs.copySync(`./engine-private/conf/${_confName}`, toPath);
-    fs.removeSync(`../${privateRepoName}/replica`);
-    if (fs.existsSync(`./engine-private/replica`)) {
-      const replicas = await fs.readdir(`./engine-private/replica`);
-      for (const replica of replicas)
-        if (replica.match(_confName))
-          fs.copySync(`./engine-private/replica/${replica}`, `../${privateRepoName}/replica/${replica}`);
-    }
 
-    if (fs.existsSync(`./engine-private/itc-scripts`)) {
-      const itcScripts = await fs.readdir(`./engine-private/itc-scripts`);
-      for (const itcScript of itcScripts)
-        if (itcScript.match(_confName))
-          fs.copySync(`./engine-private/itc-scripts/${itcScript}`, `../${privateRepoName}/itc-scripts/${itcScript}`);
-    }
-    switch (_confName) {
-      case 'dd-cyberia':
-        fs.copySync(`./engine-private/cyberia-instances/FOREST`, `../${privateRepoName}/cyberia-instances/FOREST`);
-        break;
-      default:
-        break;
-    }
-    shellExec(
-      `cd ../${privateRepoName}` +
-        ` && git add .` +
-        ` && underpost cmt . ci engine-core-conf 'Update ${_confName} conf'` +
-        ` && underpost push . ${privateGitUri}`,
-      {
-        silent: true,
-      },
-    );
+/**
+ * Assembles a single deploy id's public template under {@link basePath}: pulls in
+ * its deploy-id-specific public sources, then mirrors the APIs, client components,
+ * SSR assets, manifests, and packaging declared by its conf into the template repo.
+ * @param {string} confName - A concrete deploy id (e.g. `dd-prototype`).
+ */
+const buildDeployTemplate = async (confName) => {
+  const repoName = `engine-${confName.split('dd-')[1]}`;
+  const catalog = await loadDeployCatalog(confName);
+
+  if (catalog.sourceMoves.length) {
+    UnderpostRepository.API.sparseCheckoutDirectory(`conf/${confName}`);
+    if (catalog.sourceMoves.some(([src]) => !fs.existsSync(src))) UnderpostRepository.API.pullSourceRepo(repoName);
   }
-  process.exit(0);
-}
+  syncDeployIdSources(catalog.sourceMoves);
 
-if (confName === 'dd') {
-  for (const _confName of deployList) {
-    shellExec(`node bin/build ${_confName}`);
-  }
-  process.exit(0);
-}
+  const confDir = `./engine-private/conf/${confName}`;
+  const DefaultConf = {
+    server: JSON.parse(fs.readFileSync(`${confDir}/conf.server.json`, 'utf8')),
+    client: JSON.parse(fs.readFileSync(`${confDir}/conf.client.json`, 'utf8')),
+    ssr: JSON.parse(fs.readFileSync(`${confDir}/conf.ssr.json`, 'utf8')),
+  };
 
-const { DefaultConf } = await import(`../conf.${confName}.js`);
-
-{
   for (const host of Object.keys(DefaultConf.server)) {
     for (const path of Object.keys(DefaultConf.server[host])) {
       const { apis, ws } = DefaultConf.server[host][path];
       if (apis)
         for (const api of apis) {
-          {
-            const originPath = `./src/api/${api}`;
-            logger.info(`Build`, originPath);
-            fs.copySync(originPath, `${basePath}/src/api/${api}`);
+          const apiSrc = `./src/api/${api}`;
+          if (fs.existsSync(apiSrc)) {
+            logger.info(`Build`, apiSrc);
+            fs.copySync(apiSrc, `${basePath}/src/api/${api}`);
           }
-          {
-            const originPath = `./src/client/services/${api}`;
-            logger.info(`Build`, originPath);
-            fs.copySync(originPath, `${basePath}/src/client/services/${api}`);
+          const serviceSrc = `./src/client/services/${api}`;
+          if (fs.existsSync(serviceSrc)) {
+            logger.info(`Build`, serviceSrc);
+            fs.copySync(serviceSrc, `${basePath}/src/client/services/${api}`);
           }
         }
 
@@ -107,9 +68,7 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
       }
     }
   }
-}
 
-{
   for (const client of Object.keys(DefaultConf.client)) {
     const capName = getCapVariableName(client);
     for (const component of Object.keys(DefaultConf.client[client].components)) {
@@ -134,9 +93,7 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
       }
     }
   }
-}
 
-{
   for (const client of Object.keys(DefaultConf.ssr)) {
     const ssrPaths = getPathsSSR(DefaultConf.ssr[client]);
     for (const originPath of ssrPaths) {
@@ -148,63 +105,40 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
   }
 
   if (!fs.existsSync(`${basePath}/.github/workflows`))
-    fs.mkdirSync(`${basePath}/.github/workflows`, {
-      recursive: true,
-    });
+    fs.mkdirSync(`${basePath}/.github/workflows`, { recursive: true });
 
   const originPackageJson = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
   const packageJson = JSON.parse(fs.readFileSync(`${basePath}/package.json`, 'utf8'));
   packageJson.name = repoName.replace('engine-', '');
 
   switch (confName) {
-    case 'dd-cyberia':
+    case 'dd-cyberia': {
       fs.copyFileSync(`./bin/cyberia.js`, `${basePath}/bin/cyberia.js`);
       fs.copyFileSync(
         `./.github/workflows/publish.cyberia.ci.yml`,
         `${basePath}/.github/workflows/publish.cyberia.ci.yml`,
       );
-      delete packageJson.bin.underpost;
+      if (packageJson.bin) delete packageJson.bin.underpost;
+      if (!packageJson.bin) packageJson.bin = {};
       packageJson.bin.cyberia = 'bin/index.js';
-      packageJson.keywords = [
-        'cyberia',
-        'object-layer',
-        'game-engine',
-        'assets-management',
-        'web3',
-        'atlas-sprite-sheet',
-      ];
-      packageJson.description = 'Cyberia Engine - Object Layer and Assets Management Microservice';
-      const { CyberiaDependencies } = await import(`../src/client/components/cyberia-portal/CommonCyberiaPortal.js`);
+      packageJson.keywords = catalog.keywords;
+      packageJson.description = catalog.description;
+      const { CyberiaDependencies } = await import(`../src/api/cyberia-server-defaults/cyberia-server-defaults.js`);
       packageJson.dependencies = {
         ...originPackageJson.dependencies,
         ...CyberiaDependencies,
       };
       fs.writeFileSync(`${basePath}/bin/index.js`, fs.readFileSync(`./bin/cyberia.js`, 'utf8'), 'utf8');
+      // Canonical Cyberia doc; engine-cyberia/README.md is a generated copy — never hand-edited.
       fs.writeFileSync(
         `${basePath}/README.md`,
-        fs.readFileSync(`./src/client/public/cyberia-docs/CYBERIA-CLI.md`, 'utf8'),
+        fs.readFileSync(`./src/client/public/cyberia-docs/CYBERIA.md`, 'utf8'),
         'utf8',
       );
       fs.copySync(`./hardhat`, `${basePath}/hardhat`);
-      for (const path of [
-        '/src/grpc/cyberia',
-        '/src/client/ssr/pages/CyberiaServerMetrics.js',
-        '/src/server/object-layer.js',
-        '/src/server/atlas-sprite-sheet-generator.js',
-        '/src/server/shape-generator.js',
-        '/src/server/semantic-layer-generator.js',
-        '/src/server/semantic-layer-generator-floor.js',
-        '/src/server/semantic-layer-generator-skin.js',
-        '/src/server/semantic-layer-generator-resource.js',
-        '/test/shape-generator.test.js',
-        '/src/server/besu-genesis-generator.js',
-        '/src/runtime/cyberia-server',
-        '/src/runtime/cyberia-client',
-        '/.github/workflows/hardhat.ci.yml',
-        '/src/client/public/cyberia-docs',
-      ])
-        fs.copySync(`.${path}`, `${basePath}${path}`);
-
+      for (const path of catalog.templatePaths) fs.copySync(`.${path}`, `${basePath}${path}`);
+      break;
+    }
     default:
       break;
   }
@@ -232,8 +166,6 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
       `${basePath}/manifests/deployment/${confName}-development`,
     );
 
-  // Copy conf.<deploy-id>.js to conf.js for the respective deployment
-  fs.copyFileSync(`./conf.${confName}.js`, `${basePath}/conf.js`);
   fs.copyFileSync(`./manifests/deployment/${confName}-development/proxy.yaml`, `${basePath}/proxy.yaml`);
   fs.copyFileSync(`./manifests/deployment/${confName}-development/deployment.yaml`, `${basePath}/deployment.yaml`);
   const pvPvcPath = `./manifests/deployment/${confName}-development/pv-pvc.yaml`;
@@ -242,6 +174,51 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
   if (fs.existsSync(`./src/ws/${confName.split('-')[1]}`)) {
     fs.copySync(`./src/ws/${confName.split('-')[1]}`, `${basePath}/src/ws/${confName.split('-')[1]}`);
   }
-  fs.copyFileSync(`.gitignore`, `${basePath}/.gitignore`);
-  shellExec(`cd ${basePath} && npm install --ignore-scripts`);
-}
+  fs.writeFileSync(
+    `${basePath}/.gitignore`,
+    fs.readFileSync(`.gitignore`, 'utf8').split('# Ignore ERP / CRM custom prototypes src')[0],
+  );
+};
+
+const program = new Command();
+
+program
+  .name('build')
+  .description('Assemble deploy id public templates and sync their private configuration repos.')
+  .argument('<conf-name>', 'Deploy id, comma-separated list, or the "dd" meta id (fans out via dd.router).')
+  .argument('[env]', 'Environment label (informational; kept for CI invocation compatibility).')
+  .option('--conf', 'Sync each deploy id private configuration repo and exit (no template assembly).')
+  .option(
+    '--no-template-rebuild',
+    'Skip the from-scratch base template reconstruction before assembly (assemble onto the existing template).',
+  )
+  .option(
+    '--update-private',
+    'After assembling each deploy id, publish it to its private test source repo (underpostnet/engine-test-<id>) for isolated test deploys.',
+    false,
+  )
+  .action(async (confName, env, options) => {
+    const deployList = resolveDeployList(confName);
+    logger.info('Build repository', { confName, basePath, deployList, conf: !!options.conf });
+
+    if (options.conf) {
+      for (const deployId of deployList) {
+        const { privateConfPaths } = await loadDeployCatalog(deployId);
+        syncPrivateConf(deployId, privateConfPaths);
+      }
+      return;
+    }
+
+    // Reconstruct the base template from 0 before assembly so no src from a previous
+    // build run leaks into this one. Opt out with --no-template-rebuild.
+    if (options.templateRebuild) await buildTemplate({ toPath: basePath });
+
+    for (const deployId of deployList) {
+      await buildDeployTemplate(deployId);
+      // Publish the just-assembled tree to the deploy id's private test repo so a
+      // pod started with `--private-test-repo` clones this work-in-progress source.
+      if (options.updatePrivate) await updatePrivateEngineTestRepo(deployId);
+    }
+  });
+
+await program.parseAsync();

package/bin/build.template.js

@@ -0,0 +1,33 @@
+#! /usr/bin/env node
+
+import { Command } from 'commander';
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import { loggerFactory } from '../src/server/logger.js';
+import { buildTemplate, updatePrivateTemplateRepo } from '../src/server/conf.js';
+
+if (fs.existsSync('./engine-private/conf/dd-cron/.env.production'))
+  dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
+else dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const program = new Command();
+
+program
+  .name('build.template')
+  .description('Rebuild the standalone pwa-microservices-template from scratch out of the engine source tree.')
+  .argument('[src-path]', 'Engine source root to sync from.', './')
+  .argument('[to-path]', 'Template output path.', '../pwa-microservices-template')
+  .option('--update-private', 'Update private template repository', false)
+  .action(async (srcPath, toPath, options) => {
+    try {
+      if (options.updatePrivate) return await updatePrivateTemplateRepo();
+      await buildTemplate({ srcPath: srcPath.replaceAll(`'`, ''), toPath: toPath.replaceAll(`'`, '') });
+    } catch (error) {
+      logger.error(error, error.stack);
+      process.exit(1);
+    }
+  });
+
+await program.parseAsync();