cyberia 3.2.9 → 3.2.22

package/src/server/catalog-underpost.js

@@ -0,0 +1,61 @@
+/**
+ * Underpost platform content catalog — the base `pwa-microservices-template`.
+ *
+ * @module src/server/catalog-underpost.js
+ * @namespace UnderpostCatalog
+ */
+
+/**
+ * Workflow + service files re-added to the template after the engine-only strip.
+ * @constant {string[]}
+ * @memberof UnderpostCatalog
+ */
+const TEMPLATE_RESTORE_PATHS = [
+  `./src/server/catalog-underpost.js`,
+  `./.github/workflows/pwa-microservices-template-page.cd.yml`,
+  `./.github/workflows/pwa-microservices-template-test.ci.yml`,
+  `./.github/workflows/npmpkg.ci.yml`,
+  `./.github/workflows/ghpkg.ci.yml`,
+  `./.github/workflows/gitlab.ci.yml`,
+  `./.github/workflows/publish.ci.yml`,
+  `./.github/workflows/release.cd.yml`,
+  `./src/client/services/user/guest.service.js`,
+  './src/api/user/guest.service.js',
+  './src/ws/IoInterface.js',
+  './src/ws/IoServer.js',
+  './manifests/deployment/dd-default-development',
+];
+
+/**
+ * npm keywords for the standalone Underpost platform / template package.
+ * @constant {string[]}
+ * @memberof UnderpostCatalog
+ */
+const TEMPLATE_KEYWORDS = [
+  'underpost',
+  'underpost-platform',
+  'cli',
+  'toolchain',
+  'ci-cd',
+  'devops',
+  'kubernetes',
+  'k3s',
+  'kubeadm',
+  'lxd',
+  'baremetal',
+  'container-orchestration',
+  'image-management',
+  'pwa',
+  'workbox',
+  'microservices',
+];
+
+/**
+ * npm description for the standalone Underpost platform / template package.
+ * @constant {string}
+ * @memberof UnderpostCatalog
+ */
+const TEMPLATE_DESCRIPTION =
+  'Underpost Platform — end-to-end CI/CD and application-delivery toolchain CLI. Covers bare metal, Kubernetes, K3s, kubeadm, LXD, container/image orchestration, secrets, databases, cron jobs, monitoring, SSH, runners, PWA + Workbox delivery, and release orchestration. Extensible via downstream CLIs.';
+
+export { TEMPLATE_RESTORE_PATHS, TEMPLATE_KEYWORDS, TEMPLATE_DESCRIPTION };

package/src/server/catalog.js

@@ -0,0 +1,77 @@
+/**
+ * Dynamic product-catalog resolver.
+ *
+ * Product catalogs (`catalog-<suffix>.js`, e.g. `catalog-cyberia`, `catalog-prototype`)
+ * are loaded lazily by deploy id via ES dynamic `import()` so the base build
+ * (`bin/build`) and template assembly (`bin/build.template`) never statically
+ * depend on any product module. Removing a product catalog simply makes its
+ * deploy id resolve to the empty catalog — nothing else breaks.
+ *
+ * Each product catalog default-exports the uniform shape documented in
+ * {@link module:src/server/catalog-cyberia}.
+ *
+ * @module src/server/catalog.js
+ * @namespace Catalog
+ */
+
+import fs from 'fs-extra';
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+
+const catalogDir = path.dirname(fileURLToPath(import.meta.url));
+
+/** Empty product catalog returned for deploy ids without a dedicated module. */
+const EMPTY_CATALOG = {
+  sourceMoves: [],
+  privateConfPaths: [],
+  templatePaths: [],
+  stripPaths: [],
+  keywords: [],
+  description: '',
+};
+
+/**
+ * Loads a single deploy id's product catalog. The suffix after `dd-` selects the
+ * module (`dd-cyberia` → `catalog-cyberia.js`). Returns {@link EMPTY_CATALOG} when
+ * the deploy id has no dedicated catalog or the module cannot be loaded.
+ *
+ * @method loadDeployCatalog
+ * @param {string} deployId - A concrete deploy id (e.g. `dd-cyberia`).
+ * @returns {Promise<object>} The product catalog (uniform shape).
+ * @memberof Catalog
+ */
+const loadDeployCatalog = async (deployId) => {
+  const suffix = (deployId ?? '').split('dd-')[1];
+  if (!suffix) return EMPTY_CATALOG;
+  try {
+    const mod = await import(`./catalog-${suffix}.js`);
+    return { ...EMPTY_CATALOG, ...(mod.default ?? {}) };
+  } catch {
+    return EMPTY_CATALOG;
+  }
+};
+
+/**
+ * Loads every product catalog present alongside this module (`catalog-*.js`,
+ * excluding the base `catalog-underpost` and this resolver). Used to aggregate
+ * product `stripPaths` for the base template without naming any product.
+ *
+ * @method loadProductCatalogs
+ * @returns {Promise<object[]>} Loaded product catalogs (uniform shape).
+ * @memberof Catalog
+ */
+const loadProductCatalogs = async () => {
+  const catalogs = [];
+  for (const file of fs.readdirSync(catalogDir)) {
+    if (!/^catalog-.+\.js$/.test(file) || file === 'catalog-underpost.js') continue;
+    try {
+      const mod = await import(`./${file}`);
+      if (mod.default) catalogs.push({ ...EMPTY_CATALOG, ...mod.default });
+    } catch {
+      /* a malformed/removed product catalog must not break the base build */
+    }
+  }
+  return catalogs;
+};
+
+export { loadDeployCatalog, loadProductCatalogs, EMPTY_CATALOG };

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

@@ -399,7 +399,7 @@ const buildCoverage = async ({ docs, docsDestination }) => {
         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 });
+        shellExec(`cd ${coveragePath} && npm test`, { silent: true, silentOnError: true });
       }
     }
   }

package/src/server/client-build.js

@@ -724,23 +724,24 @@ const buildClient = async (
       const ssrPath = path === '/' ? path : `${path}/`;
       const Render = await ssrFactory();
 
-      if (views) {
-        const jsSrcPath = `./src/client/sw/core.sw.js`;
-
-        const jsPublicPath = `${rootClientPath}/sw.js`;
-
-        if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
-          const jsSrc = await transformClientJs(jsSrcPath, {
-            dists,
-            proxyPath: path,
-            baseHost,
-            minify: minifyBuild,
-            externalizeBareImports: false,
-          });
-
-          fs.writeFileSync(jsPublicPath, jsSrc, 'utf8');
-        }
+      const swSrcPath = `./src/client/sw/core.sw.js`;
+      const swPublicPath = `${rootClientPath}/sw.js`;
+      const swShouldRebuild =
+        views && !(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === swSrcPath));
+      // Transformed SW JS is held in memory; it gets prepended with renderPayload
+      // and written once below, after PRE_CACHED_RESOURCES are known.
+      let swTransformedJs = '';
+      if (swShouldRebuild) {
+        swTransformedJs = await transformClientJs(swSrcPath, {
+          dists,
+          proxyPath: path,
+          baseHost,
+          minify: minifyBuild,
+          externalizeBareImports: false,
+        });
+      }
 
+      if (views) {
         if (
           !(
             enableLiveRebuild &&
@@ -750,9 +751,8 @@ const buildClient = async (
           )
         )
           for (const view of views) {
-            const buildPath = `${
-              rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
-            }${view.path === '/' ? view.path : `${view.path}/`}`;
+            const buildPath = `${rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
+              }${view.path === '/' ? view.path : `${view.path}/`}`;
 
             if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath, { recursive: true });
 
@@ -768,9 +768,8 @@ const buildClient = async (
             fs.writeFileSync(`${buildPath}${buildId}.js`, jsSrc, 'utf8');
             const title = metadata.title ? metadata.title : title;
 
-            const canonicalURL = `https://${host}${path}${
-              view.path === '/' ? (path === '/' ? '' : '/') : path === '/' ? `${view.path.slice(1)}/` : `${view.path}/`
-            }`;
+            const canonicalURL = `https://${host}${path}${view.path === '/' ? (path === '/' ? '' : '/') : path === '/' ? `${view.path.slice(1)}/` : `${view.path}/`
+              }`;
 
             let ssrHeadComponents = ``;
             let ssrBodyComponents = ``;
@@ -904,12 +903,12 @@ const buildClient = async (
               `${buildPath}index.html`,
               minifyBuild
                 ? await minify(htmlSrc, {
-                    minifyCSS: true,
-                    minifyJS: true,
-                    collapseBooleanAttributes: true,
-                    collapseInlineTagWhitespace: true,
-                    collapseWhitespace: true,
-                  })
+                  minifyCSS: true,
+                  minifyJS: true,
+                  collapseBooleanAttributes: true,
+                  collapseInlineTagWhitespace: true,
+                  collapseWhitespace: true,
+                })
                 : htmlSrc,
               'utf8',
             );
@@ -967,119 +966,85 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
       }
 
       if (client) {
-        let PRE_CACHED_RESOURCES = [];
-
-        const normalizePrecacheRoutePath = (candidatePath) => {
-          const routePath =
-            typeof candidatePath === 'string' && candidatePath.trim().length > 0 ? candidatePath.trim() : '/offline';
-          const withLeadingSlash = routePath.startsWith('/') ? routePath : `/${routePath}`;
-          const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, '');
-          return withoutTrailingSlash.length > 0 ? withoutTrailingSlash : '/';
-        };
-
-        const toPrecacheIndexUrl = (routePath) => {
-          const normalizedRoutePath = normalizePrecacheRoutePath(routePath);
-          return `${path === '/' ? '' : path}${normalizedRoutePath === '/' ? '' : normalizedRoutePath}/index.html`;
-        };
-
-        for (const pageType of ['offline', 'pages']) {
-          if (confSSR[getCapVariableName(client)] && confSSR[getCapVariableName(client)][pageType]) {
-            for (const page of confSSR[getCapVariableName(client)][pageType]) {
-              const SsrComponent = await ssrFactory(`./src/client/ssr/${pageType}/${page.client}.js`);
-
-              const htmlSrc = Render({
-                title: page.title,
-                ssrPath,
-                ssrHeadComponents: '<base target="_top">',
-                ssrBodyComponents: SsrComponent(),
-                renderPayload: {
-                  apiBaseProxyPath,
-                  apiBaseHost,
-                  apiBasePath: process.env.BASE_API,
-                  version: Underpost.version,
-                  ...(isDevelopment ? { dev: true } : undefined),
-                },
-                renderApi: {
-                  JSONweb,
-                },
-              });
-
-              const buildPath = `${
-                rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
-              }${page.path === '/' ? page.path : `${page.path}/`}`;
-
-              // Install-time precache is intentionally restricted to SSR offline pages.
-              // All other routes/assets are loaded lazily at runtime.
-              if (pageType === 'offline') {
-                PRE_CACHED_RESOURCES.push(toPrecacheIndexUrl(page.path));
-              }
-
-              if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath, { recursive: true });
-
-              const buildHtmlPath = `${buildPath}index.html`;
-
-              logger.info('ssr page build', buildHtmlPath);
-
-              fs.writeFileSync(
-                buildHtmlPath,
-                minifyBuild
-                  ? await minify(htmlSrc, {
-                      minifyCSS: true,
-                      minifyJS: true,
-                      collapseBooleanAttributes: true,
-                      collapseInlineTagWhitespace: true,
-                      collapseWhitespace: true,
-                    })
-                  : htmlSrc,
-                'utf8',
-              );
-            }
-          }
-        }
+        const proxyPrefix = path === '/' ? '' : path;
+        const buildIndexUrl = (routePath) => `${proxyPrefix}${routePath === '/' ? '' : routePath}/index.html`;
+
+        // SSR views: a single declarative array. The role of each view (regular
+        // page vs. offline/maintenance fallback) is expressed by per-entry flags;
+        // fallback-flagged views are also precached so the SW can serve them
+        // when the network is unreachable.
+        const ssrClientConf = confSSR[getCapVariableName(client)] || {};
+        const ssrViews = Array.isArray(ssrClientConf.views) ? ssrClientConf.views : [];
+        const PRE_CACHED_RESOURCES = [];
+        let offlineFallbackUrl = null;
+        let maintenanceFallbackUrl = null;
+
+        for (const view of ssrViews) {
+          const SsrComponent = await ssrFactory(`./src/client/ssr/views/${view.client}.js`);
+
+          const htmlSrc = Render({
+            title: view.title,
+            ssrPath,
+            ssrHeadComponents: '<base target="_top">',
+            ssrBodyComponents: SsrComponent(),
+            renderPayload: {
+              apiBaseProxyPath,
+              apiBaseHost,
+              apiBasePath: process.env.BASE_API,
+              version: Underpost.version,
+              ...(isDevelopment ? { dev: true } : undefined),
+            },
+            renderApi: { JSONweb },
+          });
 
-        {
-          const cacheScope = path === '/' ? 'root' : path.replaceAll('/', '_');
-          const ssrClientConf = confSSR[getCapVariableName(client)] || {};
-          const ssrOfflinePages = Array.isArray(ssrClientConf.offline) ? ssrClientConf.offline : [];
-          const normalizeSsrRoutePath = (candidatePath, fallbackPath) => {
-            const value =
-              typeof candidatePath === 'string' && candidatePath.trim().length > 0
-                ? candidatePath.trim()
-                : fallbackPath;
-            const withLeadingSlash = value.startsWith('/') ? value : `/${value}`;
-            const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, '');
-            return withoutTrailingSlash.length > 0 ? withoutTrailingSlash : '/';
-          };
+          const buildPath = `${rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
+            }${view.path === '/' ? view.path : `${view.path}/`}`;
 
-          const offlineSsrPage =
-            ssrOfflinePages.find(
-              (page) =>
-                page?.client === 'NoNetworkConnection' ||
-                /no\s*network|offline/i.test(`${page?.title || ''} ${page?.client || ''} ${page?.path || ''}`),
-            ) || ssrOfflinePages[0];
+          const indexUrl = buildIndexUrl(view.path);
+          if (view.offlineDefault) {
+            offlineFallbackUrl = indexUrl;
+            PRE_CACHED_RESOURCES.push(indexUrl);
+          }
+          if (view.maintenanceDefault) {
+            maintenanceFallbackUrl = indexUrl;
+            PRE_CACHED_RESOURCES.push(indexUrl);
+          }
 
-          const maintenanceSsrPage =
-            ssrOfflinePages.find(
-              (page) =>
-                page?.client === 'Maintenance' ||
-                /maintenance/i.test(`${page?.title || ''} ${page?.client || ''} ${page?.path || ''}`),
-            ) || ssrOfflinePages[1];
+          if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath, { recursive: true });
+          const buildHtmlPath = `${buildPath}index.html`;
+          logger.info('ssr view build', buildHtmlPath);
 
-          const offlinePath = normalizeSsrRoutePath(offlineSsrPage?.path, '/offline');
-          const maintenancePath = normalizeSsrRoutePath(maintenanceSsrPage?.path, '/maintenance');
+          fs.writeFileSync(
+            buildHtmlPath,
+            minifyBuild
+              ? await minify(htmlSrc, {
+                minifyCSS: true,
+                minifyJS: true,
+                collapseBooleanAttributes: true,
+                collapseInlineTagWhitespace: true,
+                collapseWhitespace: true,
+              })
+              : htmlSrc,
+            'utf8',
+          );
+        }
 
+        if (swShouldRebuild) {
+          const cacheScope = path === '/' ? 'root' : path.replaceAll('/', '_');
           const renderPayload = {
             PRE_CACHED_RESOURCES: uniqueArray(PRE_CACHED_RESOURCES),
             PROXY_PATH: path,
-            CACHE_PREFIX: `engine-core-v3-${cacheScope}`,
-            OFFLINE_PATH: offlinePath,
-            MAINTENANCE_PATH: maintenancePath,
+            CACHE_PREFIX: `engine-core-${cacheScope}`,
+            OFFLINE_URL: offlineFallbackUrl || buildIndexUrl('/offline'),
+            MAINTENANCE_URL: maintenanceFallbackUrl || buildIndexUrl('/maintenance'),
           };
+
+          // Single write: prepend the payload prelude to the transformed SW JS.
           fs.writeFileSync(
-            `${rootClientPath}/sw.js`,
+            swPublicPath,
             `self.renderPayload = ${JSONweb(renderPayload)};
 self.__WB_DISABLE_DEV_LOGS = true;
-${fs.readFileSync(`${rootClientPath}/sw.js`, 'utf8')}`,
+${swTransformedJs}`,
             'utf8',
           );
         }