@underpostnet/underpost 2.7.94 → 2.8.1

package/src/client/ssr/offline/Maintenance.js

@@ -0,0 +1,63 @@
+const s = (el) => document.querySelector(el);
+
+const append = (el, html) => s(el).insertAdjacentHTML('beforeend', html);
+
+const getLang = () =>
+  (localStorage.getItem('lang') || navigator.language || navigator.userLanguage || s('html').lang)
+    .slice(0, 2)
+    .toLowerCase();
+
+const main = () => {
+  const Translate = {
+    Data: {
+      ['server-maintenance']: {
+        en: "The server is under maintenance <br> we'll be back soon.",
+        es: 'El servidor está en mantenimiento <br> volveremos pronto.',
+      },
+    },
+    Render: function (id) {
+      return this.Data[id][getLang()] ? this.Data[id][getLang()] : this.Data[id]['en'];
+    },
+  };
+  const icon = html`<svg xmlns="http://www.w3.org/2000/svg" width="80" height="80" viewBox="0 0 24 24">
+    <path
+      fill="none"
+      stroke="currentColor"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      stroke-width="2"
+      d="M3 7a3 3 0 0 1 3-3h12a3 3 0 0 1 3 3v2a3 3 0 0 1-3 3H6a3 3 0 0 1-3-3zm9 13H6a3 3 0 0 1-3-3v-2a3 3 0 0 1 3-3h10.5m-.5 6a2 2 0 1 0 4 0a2 2 0 1 0-4 0m2-3.5V16m0 4v1.5m3.032-5.25l-1.299.75m-3.463 2l-1.3.75m0-3.5l1.3.75m3.463 2l1.3.75M7 8v.01M7 16v.01"
+    />
+  </svg>`;
+
+  append(
+    'body',
+    html` <style>
+        body {
+          font-family: arial;
+          font-size: 20px;
+          background-color: #d8d8d8;
+          color: #333;
+        }
+        a {
+          color: black;
+        }
+      </style>
+
+      <div class="abs center" style="top: 45%">
+        ${icon}
+        <br />
+        <br />${Translate.Render('server-maintenance')}
+      </div>`,
+  );
+};
+
+SrrComponent = () => html`<script>
+  {
+    const s = ${s};
+    const append = ${append};
+    const getLang = ${getLang};
+    const main = ${main};
+    window.onload = main;
+  }
+</script>`;

package/src/client/sw/default.sw.js

@@ -62,12 +62,38 @@ self.addEventListener('fetch', (event) => {
           if (!preCachedResponse) throw new Error(error.message);
           return preCachedResponse;
         } catch (error) {
-          console.error('Error opening cache for pre cached page', event.request.url, error);
+          console.error('Error opening cache for pre cached page', {
+            url: event.request.url,
+            error,
+            onLine: navigator.onLine,
+          });
           try {
-            const cache = await caches.open(CACHE_NAME);
-            const preCachedResponse = await cache.match(`${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`);
-            if (!preCachedResponse) throw new Error(error.message);
-            return preCachedResponse;
+            if (!navigator.onLine) {
+              if (event.request.method.toUpperCase() === 'GET') {
+                const cache = await caches.open(CACHE_NAME);
+                const preCachedResponse = await cache.match(
+                  `${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`,
+                );
+                if (!preCachedResponse) throw new Error(error.message);
+                return preCachedResponse;
+              }
+              const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+              // response.status = 200;
+              response.headers.set('Content-Type', 'application/json');
+              return response;
+            }
+            if (event.request.method.toUpperCase() === 'GET') {
+              const cache = await caches.open(CACHE_NAME);
+              const preCachedResponse = await cache.match(
+                `${PROXY_PATH === '/' ? '' : PROXY_PATH}/maintenance/index.html`,
+              );
+              if (!preCachedResponse) throw new Error(error.message);
+              return preCachedResponse;
+            }
+            const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
+            // response.status = 200;
+            response.headers.set('Content-Type', 'application/json');
+            return response;
           } catch (error) {
             console.error('Error opening cache for offline page', event.request.url, error);
             const response = new Response(JSON.stringify({ status: 'error', message: error.message }));

package/src/index.js

@@ -14,6 +14,14 @@ const logger = loggerFactory(import.meta);
  * @memberof Underpost
  */
 class Underpost {
+  /**
+   * Underpost engine version
+   * @static
+   * @type {String}
+   * @memberof Underpost
+   */
+  static version = 'v2.8.1';
+
   constructor() {}
 
   /**

package/src/server/client-build.js

@@ -465,10 +465,11 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   case 'DefaultSplashScreen':
                     if (backgroundImage) {
                       ssrHeadComponents += SrrComponent({
-                        base64BackgroundImage: `data:image/${backgroundImage.split('.').pop()};base64,${fs
-                          .readFileSync(backgroundImage)
-                          .toString('base64')}`,
+                        backgroundImage: (path === '/' ? path : `${path}/`) + backgroundImage,
                       });
+                      // `data:image/${backgroundImage.split('.').pop()};base64,${fs
+                      //     .readFileSync()
+                      //     .toString('base64')}`,
                       break;
                     } else {
                       ssrHeadComponents += SrrComponent({ metadata });
@@ -480,7 +481,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                         bgColor: metadata?.themeColor ? metadata.themeColor : '#ececec',
                       });
                       ssrHeadComponents += SrrComponent({
-                        base64BackgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
+                        backgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
                       });
                     }
 
@@ -700,28 +701,7 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
 
         await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
       }
-      if (!enableLiveRebuild && process.argv.includes('zip')) {
-        logger.warn('build zip', rootClientPath);
-
-        if (!fs.existsSync('./build')) fs.mkdirSync('./build');
-
-        const zip = new AdmZip();
-        const files = await fs.readdir(rootClientPath, { recursive: true });
-
-        for (const relativePath of files) {
-          const filePath = dir.resolve(`${rootClientPath}/${relativePath}`);
-          if (!fs.lstatSync(filePath).isDirectory()) {
-            const folder = dir.relative(`public/${host}${path}`, dir.dirname(filePath));
-            zip.addLocalFile(filePath, folder);
-          }
-        }
-
-        const buildId = `${host}-${path.replaceAll('/', '')}`;
 
-        logger.warn('write zip', `./build/${buildId}.zip`);
-
-        zip.writeZip(`./build/${buildId}.zip`);
-      }
       if (client) {
         let PRE_CACHED_RESOURCES = [];
 
@@ -792,6 +772,28 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
           );
         }
       }
+      if (!enableLiveRebuild && process.argv.includes('zip')) {
+        logger.warn('build zip', rootClientPath);
+
+        if (!fs.existsSync('./build')) fs.mkdirSync('./build');
+
+        const zip = new AdmZip();
+        const files = await fs.readdir(rootClientPath, { recursive: true });
+
+        for (const relativePath of files) {
+          const filePath = dir.resolve(`${rootClientPath}/${relativePath}`);
+          if (!fs.lstatSync(filePath).isDirectory()) {
+            const folder = dir.relative(`public/${host}${path}`, dir.dirname(filePath));
+            zip.addLocalFile(filePath, folder);
+          }
+        }
+
+        const buildId = `${host}-${path.replaceAll('/', '')}`;
+
+        logger.warn('write zip', `./build/${buildId}.zip`);
+
+        zip.writeZip(`./build/${buildId}.zip`);
+      }
     }
   }
 };

package/src/server/client-icons.js

@@ -3,8 +3,9 @@ import { favicons } from 'favicons';
 // import textToImage from 'text-to-image';
 import { loggerFactory } from './logger.js';
 import fs from 'fs-extra';
-import { png3x } from 'font-awesome-assets';
 import { getCapVariableName, s4 } from '../client/components/core/CommonJs.js';
+import { FileFactory } from '../api/file/file.service.js';
+import { svg, png, png3x } from 'font-awesome-assets';
 
 const logger = loggerFactory(import.meta);
 
@@ -140,7 +141,7 @@ const buildIcons = async ({
     for (const file of response.files)
       fs.writeFileSync(`./src/client/public/${publicClientId}/${file.name}`, file.contents, 'utf8');
 
-    const ssrPath = `./src/client/ssr/components/head/Pwa${getCapVariableName(publicClientId)}.js`;
+    const ssrPath = `./src/client/ssr/head/Pwa${getCapVariableName(publicClientId)}.js`;
     if (!fs.existsSync(ssrPath))
       fs.writeFileSync(ssrPath, 'SrrComponent = () => html`' + response.html.join(`\n`) + '`;', 'utf8');
   } catch (error) {
@@ -148,4 +149,13 @@ const buildIcons = async ({
   }
 };
 
-export { buildIcons, buildTextImg, defaultBaseTextImgOptions, faBase64Png, getBufferPngText };
+const getDefaultProfileImageId = async (File) => {
+  const faId = 'user';
+  const tmpFilePath = `./tmp/${faId}-${s4() + s4()}.svg`;
+  fs.writeFileSync(tmpFilePath, svg(faId, '#f5f5f5d1'), 'utf8');
+  const file = await new File(FileFactory.svg(fs.readFileSync(tmpFilePath), `${faId}.svg`)).save();
+  fs.removeSync(tmpFilePath);
+  return file._id;
+};
+
+export { buildIcons, buildTextImg, defaultBaseTextImgOptions, faBase64Png, getBufferPngText, getDefaultProfileImageId };

package/src/server/conf.js

@@ -253,8 +253,8 @@ const buildClientSrc = async (
   }
 
   fs.writeFileSync(
-    `./src/client/ssr/components/head/${toClientVariableName}Scripts.js`,
-    formattedSrc(fs.readFileSync(`./src/client/ssr/components/head/${fromClientVariableName}Scripts.js`, 'utf8')),
+    `./src/client/ssr/head/${toClientVariableName}Scripts.js`,
+    formattedSrc(fs.readFileSync(`./src/client/ssr/head/${fromClientVariableName}Scripts.js`, 'utf8')),
     'utf8',
   );
 
@@ -473,7 +473,7 @@ const buildProxyRouter = () => {
         title: 'Site in maintenance',
         ssrPath: '/',
         ssrHeadComponents: '',
-        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/Maintenance.js`))(),
+        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/offline/Maintenance.js`))(),
       });
     })();
 
@@ -583,7 +583,7 @@ const validateTemplatePath = (absolutePath = '') => {
   const confServer = DefaultConf.server[host][path];
   const confClient = DefaultConf.client[client];
   const confSsr = DefaultConf.ssr[ssr];
-  const clients = Object.keys(confClient).concat(['core', 'test', 'default']);
+  const clients = Object.keys(confClient).concat(['core', 'test', 'default', 'user']);
 
   if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
     return false;
@@ -935,6 +935,7 @@ const maintenanceMiddleware = (req, res, port, proxyRouter) => {
 
 const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`pm2 kill`);
+  shellExec(`node bin/deploy valkey-service`);
   const proxyDeployId = fs.readFileSync(`./engine-private/deploy/${deployGroupId}.proxy`, 'utf8').trim();
   shellExec(`node bin/deploy conf ${proxyDeployId} production`);
   shellExec(`node bin/deploy run ${proxyDeployId} maintenance`);

package/src/server/logger.js

@@ -86,6 +86,7 @@ const format = (meta) =>
  * @memberof Logger
  */
 const setUpInfo = async (logger = new winston.Logger()) => {
+  logger.info('npm_package_version', process.env.npm_package_version);
   logger.info('argv', process.argv);
   logger.info('platform', process.platform);
   logger.info('env', process.env.NODE_ENV);
@@ -179,12 +180,13 @@ const loggerMiddleware = (meta = { url: '' }) => {
 };
 
 const underpostASCI = () => `
-▗▖ ▗▖▗▖  ▗▖▗▄▄▄  ▗▄▄▄▖▗▄▄▖ ▄▄▄▄   ▄▄▄   ▄▄▄  ■  
-▐▌ ▐▌▐▛▚▖▐▌▐▌  █ ▐▌   ▐▌ ▐▌█   █ █   █ ▀▄▄▗▄▟▙▄▖
-▐▌ ▐▌▐▌ ▝▜▌▐▌  █ ▐▛▀▀▘▐▛▀▚▖█▄▄▄▀ ▀▄▄▄▀ ▄▄▄▀ ▐▌  
-▝▚▄▞▘▐▌  ▐▌▐▙▄▄▀ ▐▙▄▄▖▐▌ ▐▌█                ▐▌  
-                           ▀                ▐▌  
-                                                
+
+██╗░░░██╗███╗░░██╗██████╗░███████╗██████╗░██████╗░░█████╗░░██████╗████████╗
+██║░░░██║████╗░██║██╔══██╗██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝╚══██╔══╝
+██║░░░██║██╔██╗██║██║░░██║█████╗░░██████╔╝██████╔╝██║░░██║╚█████╗░░░░██║░░░
+██║░░░██║██║╚████║██║░░██║██╔══╝░░██╔══██╗██╔═══╝░██║░░██║░╚═══██╗░░░██║░░░
+╚██████╔╝██║░╚███║██████╔╝███████╗██║░░██║██║░░░░░╚█████╔╝██████╔╝░░░██║░░░
+░╚═════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝╚═╝░░░░░░╚════╝░╚═════╝░░░░╚═╝░░░
                                                 `;
 
 export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCI };

package/src/server/network.js

@@ -74,6 +74,10 @@ const saveRuntimeRouter = async () => {
     const host = process.env.DEFAULT_DEPLOY_HOST;
     const path = process.env.DEFAULT_DEPLOY_PATH;
     const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+    if (!deployId || !host || !path) {
+      logger.warn('default deploy instance not found');
+      return;
+    }
     const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
     const { db } = confServer[host][path];
 

package/src/server/ssl.js

@@ -50,8 +50,8 @@ const buildSSL = async (host) => {
 
           fs.writeFileSync(`./engine-private/ssl/${host}/_ca_bundle.crt`, ca, 'utf8');
           fs.writeFileSync(`./engine-private/ssl/${host}/_ca_full_bundle.crt`, caFull, 'utf8');
-
-          fs.removeSync(`${sslPath}/${folderHost}`);
+          // TODO: no repeat folderHost match
+          // fs.removeSync(`${sslPath}/${folderHost}`);
           return true;
         }
       }

package/src/server/valkey.js

@@ -0,0 +1,126 @@
+import Valkey from 'iovalkey';
+import mongoose from 'mongoose';
+import { hashPassword } from './auth.js';
+import { loggerFactory } from './logger.js';
+
+const logger = loggerFactory(import.meta);
+
+let valkeyEnabled = true;
+
+const disableValkeyErrorMessage = 'valkey is not enabled';
+
+const isValkeyEnable = () => valkeyEnabled;
+
+const selectDtoFactory = (payload, select) => {
+  const result = {};
+  for (const key of Object.keys(select)) {
+    if (select[key] === 1 && key in payload) result[key] = payload[key];
+  }
+  return result;
+};
+
+const valkeyClientFactory = async () => {
+  const valkey = new Valkey({
+    retryStrategy: (attempt) => {
+      if (attempt === 1) {
+        valkey.disconnect();
+        valkeyEnabled = false;
+        logger.warn('Valkey service not enabled', { valkeyEnabled });
+        return;
+      }
+      return 1000; // 1 second interval attempt
+    },
+  }); // Connect to 127.0.0.1:6379
+  // new Valkey(6380); // 127.0.0.1:6380
+  // new Valkey(6379, '192.168.1.1'); // 192.168.1.1:6379
+  // new Valkey('/tmp/redis.sock');
+  // new Valkey({
+  //   port: 6379, // Valkey port
+  //   host: '127.0.0.1', // Valkey host
+  //   username: 'default', // needs Valkey >= 6
+  //   password: 'my-top-secret',
+  //   db: 0, // Defaults to 0
+  // });
+  return valkey;
+};
+
+const getValkeyObject = async (key = '') => {
+  if (!valkeyEnabled) {
+    logger.warn(disableValkeyErrorMessage + ' get', key);
+    return null;
+  }
+  const object = await valkey.get(key);
+  try {
+    return JSON.parse(object);
+  } catch (error) {
+    logger.error(error);
+    return object;
+  }
+};
+
+const setValkeyObject = async (key = '', payload = {}) => {
+  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
+  return await valkey.set(key, JSON.stringify(payload));
+};
+
+const updateValkeyObject = async (key = '', payload = {}) => {
+  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
+  const object = await getValkeyObject(key, valkey);
+  object.updatedAt = new Date().toISOString();
+  return await valkey.set(key, JSON.stringify({ ...object, ...payload }));
+};
+
+const valkeyObjectFactory = async (module = '', options = { host: 'localhost', object: {} }) => {
+  if (!valkeyEnabled) throw new Error(disableValkeyErrorMessage);
+  const idoDate = new Date().toISOString();
+  options.object = options.object || {};
+  const { object } = options;
+  const _id = new mongoose.Types.ObjectId().toString();
+  object._id = _id;
+  object.createdAt = idoDate;
+  object.updatedAt = idoDate;
+  switch (module) {
+    case 'user': {
+      const role = 'guest';
+      object._id = `${role}${_id}`;
+      return {
+        ...object,
+        username: `${role}${_id.slice(-5)}`,
+        email: `${_id}@${options.host}`,
+        password: hashPassword(process.env.JWT_SECRET),
+        role,
+        failedLoginAttempts: 0,
+        phoneNumbers: [],
+        publicKey: [],
+        profileImageId: null,
+        emailConfirmed: false,
+        recoverTimeOut: null,
+        lastLoginDate: null,
+      };
+    }
+    default:
+      throw new Error(`module schema not found: ${module}`);
+  }
+};
+
+const ValkeyAPI = {
+  valkeyClientFactory,
+  selectDtoFactory,
+  getValkeyObject,
+  setValkeyObject,
+  valkeyObjectFactory,
+  updateValkeyObject,
+};
+
+const valkey = await ValkeyAPI.valkeyClientFactory();
+
+export {
+  valkeyClientFactory,
+  selectDtoFactory,
+  getValkeyObject,
+  setValkeyObject,
+  valkeyObjectFactory,
+  updateValkeyObject,
+  isValkeyEnable,
+  ValkeyAPI,
+};