underpost 2.8.82 → 2.8.85

package/src/server/client-build.js

@@ -17,11 +17,11 @@ import dotenv from 'dotenv';
 import AdmZip from 'adm-zip';
 import * as dir from 'path';
 import { shellExec } from './process.js';
-import swaggerAutoGen from 'swagger-autogen';
 import { SitemapStream, streamToPromise } from 'sitemap';
 import { Readable } from 'stream';
 import { buildIcons, buildTextImg, getBufferPngText } from './client-icons.js';
 import Underpost from '../index.js';
+import { buildDocs } from './client-build-docs.js';
 
 dotenv.config();
 
@@ -333,14 +333,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
               'utf8',
             );
-
-            // const title = `${metadata && metadata.title ? metadata.title : cap(client)}${
-            //   view.title ? ` | ${view.title}` : view.path !== '/' ? ` | ${titleFormatted(view.path)}` : ''
-            // }`;
-
-            const title = `${
-              view.title ? `${view.title} | ` : view.path !== '/' ? `${titleFormatted(view.path)} | ` : ''
-            }${metadata && metadata.title ? metadata.title : cap(client)}`;
+            const title = metadata.title ? metadata.title : title;
 
             const canonicalURL = `https://${host}${path}${
               view.path === '/' ? (path === '/' ? '' : '/') : path === '/' ? `${view.path.slice(1)}/` : `${view.path}/`
@@ -441,27 +434,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   case 'CyberiaDefaultSplashScreen':
                   case 'NexodevSplashScreen':
                   case 'DefaultSplashScreen':
-                    if (backgroundImage) {
+                    if (backgroundImage)
                       ssrHeadComponents += SrrComponent({
+                        ...metadata,
                         backgroundImage: (path === '/' ? path : `${path}/`) + backgroundImage,
                       });
-                      // `data:image/${backgroundImage.split('.').pop()};base64,${fs
-                      //     .readFileSync()
-                      //     .toString('base64')}`,
-                      break;
-                    } else {
-                      ssrHeadComponents += SrrComponent({ metadata });
-                      break;
-                      const bufferBackgroundImage = await getBufferPngText({
-                        text: ' ',
-                        textColor: metadata?.themeColor ? metadata.themeColor : '#ececec',
-                        size: '100x100',
-                        bgColor: metadata?.themeColor ? metadata.themeColor : '#ececec',
-                      });
-                      ssrHeadComponents += SrrComponent({
-                        backgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
-                      });
-                    }
+                    else ssrHeadComponents += SrrComponent({ metadata });
+                    break;
 
                   case 'CyberiaSplashScreenLore': {
                     ssrBodyComponents += SrrComponent({
@@ -557,145 +536,16 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
       }
 
       if (!enableLiveRebuild && !process.argv.includes('l') && !process.argv.includes('deploy') && docsBuild) {
-        // https://www.pullrequest.com/blog/leveraging-jsdoc-for-better-code-documentation-in-javascript/
-        // https://jsdoc.app/about-configuring-jsdoc
-        // https://jsdoc.app/ Block tags
-
-        const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
-        jsDocsConfig.opts.destination = `./public/${host}${path === '/' ? path : `${path}/`}docs/`;
-        jsDocsConfig.opts.theme_opts.title = metadata && metadata.title ? metadata.title : undefined;
-        jsDocsConfig.opts.theme_opts.favicon = `./public/${host}${path === '/' ? path : `${path}/favicon.ico`}`;
-        fs.writeFileSync(`./jsdoc.json`, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
-        logger.warn('build jsdoc view', jsDocsConfig.opts.destination);
-        shellExec(`npm run docs`, { silent: true });
-
-        // coverage
-        if (!fs.existsSync(`./coverage`)) {
-          shellExec(`npm test`);
-        }
-        const coverageBuildPath = `${jsDocsConfig.opts.destination}/coverage`;
-        fs.mkdirSync(coverageBuildPath, { recursive: true });
-        fs.copySync(`./coverage`, coverageBuildPath);
-
-        // uml
-        // shellExec(`node bin/deploy uml ${host} ${path}`);
-
-        // https://swagger-autogen.github.io/docs/
-
-        const basePath = path === '/' ? `${process.env.BASE_API}` : `/${process.env.BASE_API}`;
-
-        const doc = {
-          info: {
-            version: packageData.version, // by default: '1.0.0'
-            title: metadata?.title ? `${metadata.title}` : 'REST API', // by default: 'REST API'
-            description: metadata?.description ? metadata.description : '', // by default: ''
-          },
-          servers: [
-            {
-              url:
-                process.env.NODE_ENV === 'development'
-                  ? `http://localhost:${port}${path}${basePath}`
-                  : `https://${host}${path}${basePath}`, // by default: 'http://localhost:3000'
-              description: `${process.env.NODE_ENV} server`, // by default: ''
-            },
-          ],
-          tags: [
-            // by default: empty Array
-            {
-              name: 'user', // Tag name
-              description: 'User API operations', // Tag description
-            },
-          ],
-          components: {
-            schemas: {
-              userRequest: {
-                username: 'user123',
-                password: 'Password123',
-                email: 'user@example.com',
-              },
-              userResponse: {
-                status: 'success',
-                data: {
-                  token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjp7Il9pZCI6IjY2YzM3N2Y1N2Y5OWU1OTY5YjgxZG...',
-                  user: {
-                    _id: '66c377f57f99e5969b81de89',
-                    email: 'user@example.com',
-                    emailConfirmed: false,
-                    username: 'user123',
-                    role: 'user',
-                    profileImageId: '66c377f57f99e5969b81de87',
-                  },
-                },
-              },
-              userUpdateResponse: {
-                status: 'success',
-                data: {
-                  _id: '66c377f57f99e5969b81de89',
-                  email: 'user@example.com',
-                  emailConfirmed: false,
-                  username: 'user123222',
-                  role: 'user',
-                  profileImageId: '66c377f57f99e5969b81de87',
-                },
-              },
-              userGetResponse: {
-                status: 'success',
-                data: {
-                  _id: '66c377f57f99e5969b81de89',
-                  email: 'user@example.com',
-                  emailConfirmed: false,
-                  username: 'user123222',
-                  role: 'user',
-                  profileImageId: '66c377f57f99e5969b81de87',
-                },
-              },
-              userLogInRequest: {
-                email: 'user@example.com',
-                password: 'Password123',
-              },
-              userBadRequestResponse: {
-                status: 'error',
-                message: 'Bad request. Please check your inputs, and try again',
-              },
-            },
-            securitySchemes: {
-              bearerAuth: {
-                type: 'http',
-                scheme: 'bearer',
-              },
-            },
-          },
-        };
-
-        // plantuml
-        logger.info('copy plantuml', `${rootClientPath}/docs/plantuml`);
-        fs.copySync(`./src/client/public/default/plantuml`, `${rootClientPath}/docs/plantuml`);
-
-        logger.warn('build swagger api docs', doc.info);
-
-        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`);
-        }
-
-        /* NOTE: If you are using the express Router, you must pass in the 'routes' only the 
-root file where the route starts, such as index.js, app.js, routes.js, etc ... */
-
-        await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
-
-        const htmlFiles = await fs.readdir(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}`);
-        for (const htmlFile of htmlFiles) {
-          if (htmlFile.match('.html')) {
-            fs.writeFileSync(
-              `./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`,
-              fs
-                .readFileSync(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`, 'utf8')
-                .replaceAll('Tutorials', 'References'),
-              'utf8',
-            );
-          }
-        }
+        await buildDocs({
+          host,
+          path,
+          port,
+          metadata,
+          apis,
+          publicClientId,
+          rootClientPath,
+          packageData,
+        });
       }
 
       if (client) {

package/src/server/conf.js

@@ -89,12 +89,19 @@ const Config = {
 };
 
 const loadConf = (deployId, envInput, subConf) => {
+  if (deployId === 'current') {
+    console.log(process.env.DEPLOY_ID);
+    return;
+  }
   if (deployId === 'clean') {
-    shellExec(`git checkout package.json`);
-    shellExec(`git checkout .env.production`);
-    shellExec(`git checkout .env.development`);
-    shellExec(`git checkout .env.test`);
-    shellExec(`git checkout jsdoc.json`);
+    const path = envInput ?? '.';
+    fs.removeSync(`${path}/.env`);
+    shellExec(`git checkout ${path}/.env.production`);
+    shellExec(`git checkout ${path}/.env.development`);
+    shellExec(`git checkout ${path}/.env.test`);
+    if (fs.existsSync(`${path}/jsdoc.json`)) shellExec(`git checkout ${path}/jsdoc.json`);
+    shellExec(`git checkout ${path}/package.json`);
+    shellExec(`git checkout ${path}/package-lock.json`);
     return;
   }
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
@@ -1171,7 +1178,7 @@ const writeEnv = (envPath, envObj) =>
     'utf8',
   );
 
-const buildCliDoc = (program) => {
+const buildCliDoc = (program, oldVersion, newVersion) => {
   let md = shellExec(`node bin help`, { silent: true, stdout: true }).split('Options:');
   const baseOptions =
     `## ${md[0].split(`\n`)[2]}
@@ -1207,13 +1214,15 @@ const buildCliDoc = (program) => {
       `
   `;
   });
+  md = md.replaceAll(oldVersion, newVersion);
   fs.writeFileSync(`./src/client/public/nexodev/docs/references/Command Line Interface.md`, md, 'utf8');
   fs.writeFileSync(`./cli.md`, md, 'utf8');
   const readmeSplit = `pwa-microservices-template</a>`;
   const readme = fs.readFileSync(`./README.md`, 'utf8').split(readmeSplit);
   fs.writeFileSync(
     './README.md',
-    readme[0] +
+    (
+      readme[0] +
       readmeSplit +
       `
 
@@ -1223,7 +1232,8 @@ const buildCliDoc = (program) => {
       
 <a target="_top" href="https://github.com/underpostnet/pwa-microservices-template/blob/master/cli.md">See complete CLI Docs here.</a>
       
-`,
+`
+    ).replaceAll(oldVersion, newVersion),
     'utf8',
   );
 };

package/src/server/process.js

@@ -10,8 +10,6 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-// process.exit();
-
 const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
 
 const ProcessController = {
@@ -63,27 +61,26 @@ const shellCd = (cd, options = { disableLog: false }) => {
   return shell.cd(cd);
 };
 
-function pbcopy(data) {
-  switch (process.platform) {
-    case 'linux':
-      {
-        // sudo dnf install xclip
-        // sudo apt update
-        // sudo apt install xclip
-        // paste: xclip -o
-        // copy:
-        // shellExec(`echo "${data}" | xclip -sel clip`, { async: true });
-      }
+const openTerminal = (cmd, options = { single: false }) => {
+  if (options.single === true) {
+    shellExec(`setsid gnome-terminal -- bash -ic "${cmd}; exec bash" >/dev/null 2>&1 &`);
+    return;
+  }
+  shellExec(`gnome-terminal -- bash -c "${cmd}; exec bash" & disown`, {
+    async: true,
+    stdout: true,
+  });
+};
 
-      break;
+const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
 
-    default:
-      break;
-  }
+// list all terminals: pgrep gnome-terminal
+// list last terminal: pgrep -n gnome-terminal
+const getTerminalPid = () => JSON.parse(shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true }));
 
+function pbcopy(data) {
   clipboard.writeSync(data || '🦄');
-
   logger.info(`copied to clipboard`, clipboard.readSync());
 }
 
-export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy };
+export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, openTerminal, getTerminalPid, daemonProcess };

package/src/server/valkey.js

@@ -5,22 +5,71 @@ import { loggerFactory } from './logger.js';
 
 const logger = loggerFactory(import.meta);
 
+// Per-instance registries keyed by `${host}${path}`
 const ValkeyInstances = {};
+const DummyStores = {}; // in-memory Maps per instance
+const ValkeyStatus = {}; // 'connected' | 'dummy' | 'error' | undefined
 
-let valkeyEnabled = true;
+// Backward-compatible overall flag: true if any instance is connected
+const isValkeyEnable = () => Object.values(ValkeyStatus).some((s) => s === 'connected');
 
-const disableValkeyErrorMessage = 'valkey is not enabled';
-
-const isValkeyEnable = () => valkeyEnabled;
+const _instanceKey = (opts = { host: '', path: '' }) => `${opts.host || ''}${opts.path || ''}`;
 
 const createValkeyConnection = async (
-  instance = { host: '', port: 0 },
-  valkeyServerConnectionOptions = { host: '', port: 0 },
+  instance = { host: '', path: '' },
+  valkeyServerConnectionOptions = { host: '', path: '' },
 ) => {
-  ValkeyInstances[`${instance.host}${instance.path}`] = await ValkeyAPI.valkeyClientFactory(
-    valkeyServerConnectionOptions,
-  );
-  return ValkeyInstances[`${instance.host}${instance.path}`];
+  const key = _instanceKey(instance);
+  // Initialize dummy store for the instance
+  if (!DummyStores[key]) DummyStores[key] = new Map();
+
+  try {
+    const client = await ValkeyAPI.valkeyClientFactory(valkeyServerConnectionOptions);
+
+    // Attach listeners for visibility
+    client.on?.('ready', () => {
+      ValkeyStatus[key] = 'connected';
+      logger.info('Valkey connected', { instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('error', (err) => {
+      // Switch to dummy if not yet connected
+      if (ValkeyStatus[key] !== 'connected') {
+        ValkeyStatus[key] = 'dummy';
+      } else {
+        ValkeyStatus[key] = 'error';
+      }
+      logger.warn('Valkey error', { err: err?.message, instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('end', () => {
+      if (ValkeyStatus[key] !== 'dummy') ValkeyStatus[key] = 'error';
+      logger.warn('Valkey connection ended', { instance, status: ValkeyStatus[key] });
+    });
+
+    // Probe connectivity with a short timeout
+    const probe = async () => {
+      try {
+        // basic ping via SET/GET roundtrip
+        const probeKey = `__vk_probe_${Date.now()}`;
+        await client.set(probeKey, '1');
+        await client.get(probeKey);
+        ValkeyStatus[key] = 'connected';
+      } catch (e) {
+        ValkeyStatus[key] = 'dummy';
+        logger.warn('Valkey probe failed, falling back to dummy', { instance, error: e?.message });
+      }
+    };
+
+    // Race with timeout to avoid hanging
+    await Promise.race([probe(), new Promise((resolve) => setTimeout(resolve, 1000))]);
+
+    ValkeyInstances[key] = client;
+    if (!ValkeyStatus[key]) ValkeyStatus[key] = 'dummy';
+  } catch (err) {
+    ValkeyStatus[key] = 'dummy';
+    logger.warn('Valkey client creation failed, using dummy', { instance, error: err?.message });
+  }
+
+  return ValkeyInstances[key];
 };
 
 const selectDtoFactory = (payload, select) => {
@@ -33,18 +82,12 @@ const selectDtoFactory = (payload, select) => {
 
 const valkeyClientFactory = async (options) => {
   const valkey = new Valkey({
-    // port: 6379,
-    // host: 'valkey-service.default.svc.cluster.local',
     port: options?.port ? options.port : undefined,
     host: options?.host ? options.host : undefined,
+    // Keep retry strategy minimal; state handled in createValkeyConnection
     retryStrategy: (attempt) => {
-      if (attempt === 1) {
-        valkey.disconnect();
-        valkeyEnabled = false;
-        logger.warn('Valkey service not enabled', { ...options, valkeyEnabled });
-        return;
-      }
-      return 1000; // 1 second interval attempt
+      if (attempt === 1) return undefined; // stop aggressive retries early
+      return 1000; // retry interval if library continues
     },
   }); // Connect to 127.0.0.1:6379
   // new Valkey(6380); // 127.0.0.1:6380
@@ -60,34 +103,52 @@ const valkeyClientFactory = async (options) => {
   return valkey;
 };
 
-const getValkeyObject = async (options = { host: '', port: 0 }, key = '') => {
-  if (!valkeyEnabled) {
-    logger.warn(disableValkeyErrorMessage + ' get', key);
-    return null;
-  }
-  const object = await ValkeyInstances[`${options.host}${options.path}`].get(key);
+const getValkeyObject = async (options = { host: '', path: '' }, key = '') => {
+  const k = _instanceKey(options);
+  const status = ValkeyStatus[k];
   try {
-    return JSON.parse(object);
-  } catch (error) {
-    logger.error(error);
-    return object;
+    if (status === 'connected' && ValkeyInstances[k]) {
+      const value = await ValkeyInstances[k].get(key);
+      if (value == null) return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        // not JSON, return raw string
+        return value;
+      }
+    }
+  } catch (err) {
+    logger.warn('Valkey get failed, using dummy', { key, err: err?.message });
   }
+  // Dummy fallback returns stored value as-is (string or object)
+  return DummyStores[k]?.get(key) ?? null;
 };
 
-const setValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify(payload));
+const setValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  const k = _instanceKey(options);
+  const isString = typeof payload === 'string';
+  const value = isString ? payload : JSON.stringify(payload);
+  try {
+    if (ValkeyStatus[k] === 'connected' && ValkeyInstances[k]) {
+      return await ValkeyInstances[k].set(key, value);
+    }
+  } catch (err) {
+    logger.warn('Valkey set failed, writing to dummy', { key, err: err?.message });
+  }
+  if (!DummyStores[k]) DummyStores[k] = new Map();
+  // Store raw string or object accordingly
+  DummyStores[k].set(key, isString ? payload : payload);
+  return 'OK';
 };
 
-const updateValkeyObject = async (options = { host: '', port: 0 }, key = '', payload = {}) => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
-  const object = await getValkeyObject(key);
-  object.updatedAt = new Date().toISOString();
-  return await ValkeyInstances[`${options.host}${options.path}`].set(key, JSON.stringify({ ...object, ...payload }));
+const updateValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  let base = await getValkeyObject(options, key);
+  if (typeof base !== 'object' || base === null) base = {};
+  base.updatedAt = new Date().toISOString();
+  return await setValkeyObject(options, key, { ...base, ...payload });
 };
 
-const valkeyObjectFactory = async (options = { host: 'localhost', object: {} }, module = '') => {
-  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
+const valkeyObjectFactory = async (options = { host: 'localhost', object: {} }, model = '') => {
   const idoDate = new Date().toISOString();
   options.object = options.object || {};
   const { object } = options;
@@ -95,7 +156,7 @@ const valkeyObjectFactory = async (options = { host: 'localhost', object: {} },
   object._id = _id;
   object.createdAt = idoDate;
   object.updatedAt = idoDate;
-  switch (module) {
+  switch (model) {
     case 'user': {
       const role = 'guest';
       object._id = `${role}${_id}`;
@@ -115,7 +176,7 @@ const valkeyObjectFactory = async (options = { host: 'localhost', object: {} },
       };
     }
     default:
-      throw new Error(`module schema not found: ${module}`);
+      throw new Error(`model schema not found: ${model}`);
   }
 };