underpost 2.8.64 → 2.8.67

package/src/client/components/core/RichText.js

@@ -7,28 +7,18 @@ const RichText = {
   Render: async function (options = { id: '', parentIdModal: '' }) {
     const id = options?.id ? options.id : getId(this.Tokens, 'rich-text-');
     this.Tokens[id] = {};
-    let top, height;
     setTimeout(() => {
       const easyMDE = new EasyMDE({
         element: s(`.${id}`),
+        hideIcons: ['fullscreen', 'side-by-side'],
         onToggleFullScreen: (onFs) => {
           if (onFs) {
             if (options.parentIdModal) {
-              s(`.btn-bar-modal-container-${options.parentIdModal}`).classList.add('hide');
-              top = newInstance(s(`.${options.parentIdModal}`).style.top);
-              height = newInstance(s(`.${options.parentIdModal}`).style.height);
-              s(`.${options.parentIdModal}`).style.top = '0px';
-              s(`.${options.parentIdModal}`).style.height = `${window.innerHeight}px`;
             }
             // Modal.cleanUI();
-            if (s(`.slide-menu-top-bar`)) s(`.slide-menu-top-bar`).classList.add('hide');
           } else {
             if (options.parentIdModal) {
-              s(`.btn-bar-modal-container-${options.parentIdModal}`).classList.remove('hide');
-              s(`.${options.parentIdModal}`).style.top = top;
-              s(`.${options.parentIdModal}`).style.height = height;
             }
-            if (s(`.slide-menu-top-bar`)) s(`.slide-menu-top-bar`).classList.add('remove');
             // Modal.restoreUI();
           }
         },

package/src/index.js

@@ -16,6 +16,7 @@ import UnderpostRepository from './cli/repository.js';
 import UnderpostScript from './cli/script.js';
 import UnderpostSecret from './cli/secrets.js';
 import UnderpostTest from './cli/test.js';
+import UnderpostStartUp from './server/start.js';
 
 /**
  * Underpost main module methods
@@ -29,7 +30,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.64';
+  static version = 'v2.8.67';
   /**
    * Repository cli API
    * @static
@@ -51,6 +52,13 @@ class Underpost {
    * @memberof Underpost
    */
   static test = UnderpostTest.API;
+  /**
+   * Underpost Start Up cli API
+   * @static
+   * @type {UnderpostStartUp.API}
+   * @memberof Underpost
+   */
+  static start = UnderpostStartUp.API;
   /**
    * Cluster cli API
    * @static
@@ -93,13 +101,6 @@ class Underpost {
    * @memberof Underpost
    */
   static deploy = UnderpostDeploy.API;
-  /**
-   * Deployment cli NETWORK
-   * @static
-   * @type {UnderpostDeploy.NETWORK}
-   * @memberof Underpost
-   */
-  static deployNetwork = UnderpostDeploy.NETWORK;
   /**
    * Cron cli API
    * @static

package/src/mailer/MailerProvider.js

@@ -32,6 +32,9 @@ const MailerProvider = {
     },
   ) {
     try {
+      options.transport.tls = {
+        rejectUnauthorized: false,
+      };
       const { id } = options;
       // Generate test SMTP service account from ethereal.email
       // Only needed if you don't have a real mail account for testing

package/src/server/client-build.js

@@ -683,6 +683,19 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
 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',
+            );
+          }
+        }
       }
 
       if (client) {

package/src/server/conf.js

@@ -923,6 +923,53 @@ const mergeFile = async (parts = [], outputFilePath) => {
   });
 };
 
+const rebuildConfFactory = ({ deployId, valkey, mongo }) => {
+  const confServer = loadReplicas(
+    JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+  );
+  const hosts = {};
+  for (const host of Object.keys(confServer)) {
+    hosts[host] = {};
+    for (const path of Object.keys(confServer[host])) {
+      if (!confServer[host][path].db) continue;
+      const { singleReplica, replicas, db } = confServer[host][path];
+      const { provider } = db;
+      if (singleReplica) {
+        for (const replica of replicas) {
+          const deployIdReplica = buildReplicaId({ replica, deployId });
+          const confServerReplica = JSON.parse(
+            fs.readFileSync(`./engine-private/replica/${deployIdReplica}/conf.server.json`, 'utf8'),
+          );
+          for (const _host of Object.keys(confServerReplica)) {
+            for (const _path of Object.keys(confServerReplica[_host])) {
+              hosts[host][_path] = { replica: { host, path } };
+              confServerReplica[_host][_path].valkey = valkey;
+              switch (provider) {
+                case 'mongoose':
+                  confServerReplica[_host][_path].db.host = mongo.host;
+                  break;
+              }
+            }
+          }
+          fs.writeFileSync(
+            `./engine-private/replica/${deployIdReplica}/conf.server.json`,
+            JSON.stringify(confServerReplica, null, 4),
+            'utf8',
+          );
+        }
+      } else hosts[host][path] = {};
+      confServer[host][path].valkey = valkey;
+      switch (provider) {
+        case 'mongoose':
+          confServer[host][path].db.host = mongo.host;
+          break;
+      }
+    }
+  }
+  fs.writeFileSync(`./engine-private/conf/${deployId}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+  return { hosts };
+};
+
 const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deployId: '' }) => {
   const { host, path, conf, deployId } = options;
   const { runtime, db, git, directory } = conf[host][path];
@@ -1166,4 +1213,5 @@ export {
   pathPortAssignmentFactory,
   deployRangePortFactory,
   awaitDeployMonitor,
+  rebuildConfFactory,
 };

package/src/server/dns.js

@@ -5,6 +5,9 @@ import validator from 'validator';
 import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
 import { loggerFactory } from './logger.js';
 import UnderpostRootEnv from '../cli/env.js';
+import dns from 'node:dns';
+import os from 'node:os';
+import { shellExec } from './process.js';
 
 dotenv.config();
 
@@ -18,35 +21,59 @@ const ip = {
   },
 };
 
+const isInternetConnection = (domain = 'google.com') =>
+  new Promise((resolve) => dns.lookup(domain, {}, (err) => resolve(err ? false : true)));
+
+// export INTERFACE=$(ip route | grep default | cut -d ' ' -f 5)
+// export IP_ADDRESS=$(ip -4 addr show dev $INTERFACE | grep -oP '(?<=inet\s)\d+(\.\d+){3}')
+const getLocalIPv4Address = () =>
+  os.networkInterfaces()[
+    shellExec(`ip route | grep default | cut -d ' ' -f 5`, {
+      stdout: true,
+      silent: true,
+      disableLog: true,
+    }).trim()
+  ].find((i) => i.family === 'IPv4').address;
+
 class Dns {
   static callback = async function (deployList) {
     // Network topology configuration:
     // LAN -> [NAT-VPS](modem/router device) -> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
-    // disabled local red DHCP
+
+    // Enabling DHCP
+    // Navigate to Subnets > VLAN > Configure DHCP.
+    // Select the appropriate DHCP options (Managed or Relay).
+    // Save and apply changes.
+
     // verify inet ip proxy server address
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
     // LAN server or device's local servers port ->  3000-3100 (2999-3101)
     // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [public-ip]
     // Forward the router's TCP/UDP ports to the LAN device's IP address
-    for (const _deployId of deployList.split(',')) {
-      const deployId = _deployId.trim();
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-      const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
-
-      let testIp;
-
-      try {
-        testIp = await ip.public.ipv4();
-      } catch (error) {
-        logger.error(error, { testIp, stack: error.stack });
-      }
+    const isOnline = await isInternetConnection();
+
+    if (!isOnline) return;
 
-      const currentIp = UnderpostRootEnv.API.get('ip');
+    let testIp;
 
-      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && currentIp !== testIp) {
-        logger.info(`new ip`, testIp);
+    try {
+      testIp = await ip.public.ipv4();
+    } catch (error) {
+      logger.error(error, { testIp, stack: error.stack });
+    }
+
+    const currentIp = UnderpostRootEnv.API.get('ip');
+
+    if (validator.isIP(testIp) && currentIp !== testIp) {
+      logger.info(`new ip`, testIp);
+      UnderpostRootEnv.API.set('monitor-input', 'pause');
+
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+        const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+        const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {
             case 'A':
@@ -68,6 +95,7 @@ class Dns {
           if (verifyIp === testIp) {
             logger.info('ip updated successfully', testIp);
             UnderpostRootEnv.API.set('ip', testIp);
+            UnderpostRootEnv.API.delete('monitor-input');
           } else logger.error('ip not updated', testIp);
         } catch (error) {
           logger.error(error, error.stack);
@@ -102,3 +130,5 @@ class Dns {
 }
 
 export default Dns;
+
+export { Dns, ip, isInternetConnection, getLocalIPv4Address };

package/src/server/json-schema.js

@@ -0,0 +1,77 @@
+function isPlainObject(obj) {
+  return obj ? typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype : false;
+}
+
+const supportType = ['string', 'number', 'array', 'object', 'boolean', 'integer'];
+
+function getType(type) {
+  if (!type) type = 'string';
+  if (supportType.indexOf(type) !== -1) {
+    return type;
+  }
+  return typeof type;
+}
+
+function isSchema(object) {
+  if (supportType.indexOf(object.type) !== -1) {
+    return true;
+  }
+  return false;
+}
+
+function handleSchema(json, schema) {
+  Object.assign(schema, json);
+  if (schema.type === 'object') {
+    delete schema.properties;
+    parse(json.properties, schema);
+  }
+  if (schema.type === 'array') {
+    delete schema.items;
+    schema.items = {};
+    parse(json.items, schema.items);
+  }
+}
+
+function handleArray(arr, schema) {
+  schema.type = 'array';
+  let props = (schema.items = {});
+  parse(arr[0], props);
+}
+
+function handleObject(json, schema) {
+  if (isSchema(json)) {
+    return handleSchema(json, schema);
+  }
+  schema.type = 'object';
+  schema.required = [];
+  let props = (schema.properties = {});
+  for (let key in json) {
+    let item = json[key];
+    let curSchema = (props[key] = {});
+    if (key[0] === '*') {
+      delete props[key];
+      key = key.substr(1);
+      schema.required.push(key);
+      curSchema = props[key] = {};
+    }
+    parse(item, curSchema);
+  }
+}
+
+function parse(json, schema) {
+  if (Array.isArray(json)) {
+    handleArray(json, schema);
+  } else if (isPlainObject(json)) {
+    handleObject(json, schema);
+  } else {
+    schema.type = getType(json);
+  }
+}
+
+function ejs(data) {
+  let JsonSchema = {};
+  parse(data, JsonSchema);
+  return JsonSchema;
+}
+
+export { ejs };

package/src/server/peer.js

@@ -2,7 +2,7 @@ import { PeerServer } from 'peer';
 import dotenv from 'dotenv';
 import { loggerFactory } from './logger.js';
 import fs from 'fs-extra';
-import { listenServerFactory } from './network.js';
+import UnderpostStartUp from './start.js';
 
 dotenv.config();
 
@@ -25,7 +25,7 @@ const createPeerServer = async ({ port, devPort, origins, host, path }) => {
     // cert: fs.readFileSync(''),
     // ca: fs.readFileSync(''),
   };
-  const peerServer = listenServerFactory(() => PeerServer(options));
+  const peerServer = UnderpostStartUp.API.listenServerFactory(() => PeerServer(options));
 
   return { options, peerServer, meta: import.meta };
 };

package/src/server/proxy.js

@@ -5,9 +5,9 @@ import dotenv from 'dotenv';
 
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
-import { listenPortController } from './network.js';
 import { createSslServer, sslRedirectMiddleware } from './ssl.js';
 import { buildPortProxyRouter, buildProxyRouter, maintenanceMiddleware } from './conf.js';
+import UnderpostStartUp from './start.js';
 
 dotenv.config();
 
@@ -71,11 +71,11 @@ const buildProxy = async () => {
         switch (port) {
           case 443:
             const { ServerSSL } = await createSslServer(app, hosts);
-            await listenPortController(ServerSSL, port, runningData);
+            await UnderpostStartUp.API.listenPortController(ServerSSL, port, runningData);
             break;
 
           default:
-            await listenPortController(app, port, runningData);
+            await UnderpostStartUp.API.listenPortController(app, port, runningData);
 
             break;
         }
@@ -83,7 +83,7 @@ const buildProxy = async () => {
         break;
 
       default:
-        await listenPortController(app, port, runningData);
+        await UnderpostStartUp.API.listenPortController(app, port, runningData);
 
         break;
     }

package/src/server/runtime.js

@@ -9,7 +9,7 @@ import compression from 'compression';
 
 import { createServer } from 'http';
 import { getRootDirectory } from './process.js';
-import { listenPortController, logRuntimeRouter, listenServerFactory } from './network.js';
+import UnderpostStartUp from './start.js';
 import { loggerFactory, loggerMiddleware } from './logger.js';
 import { getCapVariableName, newInstance } from '../client/components/core/CommonJs.js';
 import { Xampp } from '../runtime/xampp/Xampp.js';
@@ -21,6 +21,7 @@ import { Lampp } from '../runtime/lampp/Lampp.js';
 import { getDeployId } from './conf.js';
 import { JSONweb, ssrFactory } from './client-formatted.js';
 import Underpost from '../index.js';
+import { createValkeyConnection } from './valkey.js';
 
 dotenv.config();
 
@@ -67,6 +68,7 @@ const buildRuntime = async () => {
         peer,
         singleReplica,
         replicas,
+        valkey,
       } = confServer[host][path];
 
       if (singleReplica && replicas && replicas.length > 0 && !singleReplicaHosts.includes(host)) {
@@ -140,6 +142,8 @@ const buildRuntime = async () => {
           // if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
           //   $_SERVER['HTTPS'] = 'on';
           // }
+          // For plugins:
+          // define( 'FS_METHOD', 'direct' );
 
           // ErrorDocument 404 /custom_404.html
           // ErrorDocument 500 /custom_50x.html
@@ -182,7 +186,11 @@ const buildRuntime = async () => {
           // RewriteCond %{HTTP_HOST} ^(?:www\.)?(.+)$ [NC]
           // RewriteRule ^ https://%1%{REQUEST_URI} [L,NE,R=301]
 
-          await listenPortController(listenServerFactory(), port, runningData);
+          await UnderpostStartUp.API.listenPortController(
+            UnderpostStartUp.API.listenServerFactory(),
+            port,
+            runningData,
+          );
           break;
         case 'xampp':
           if (!Xampp.enabled()) continue;
@@ -229,7 +237,11 @@ const buildRuntime = async () => {
           // if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && $_SERVER['HTTP_X_FORWARDED_PROTO'] === 'https') {
           //   $_SERVER['HTTPS'] = 'on';
           // }
-          await listenPortController(listenServerFactory(), port, runningData);
+          await UnderpostStartUp.API.listenPortController(
+            UnderpostStartUp.API.listenServerFactory(),
+            port,
+            runningData,
+          );
           break;
         case 'nodejs':
           const app = express();
@@ -282,7 +294,7 @@ const buildRuntime = async () => {
             currentPort += 2;
             const staticPort = newInstance(currentPort);
 
-            await listenPortController(app, staticPort, runningData);
+            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
             currentPort++;
             continue;
           }
@@ -333,7 +345,7 @@ const buildRuntime = async () => {
             //   }),
             // );
 
-            await listenPortController(app, port, runningData);
+            await UnderpostStartUp.API.listenPortController(app, port, runningData);
             break;
           }
 
@@ -353,6 +365,9 @@ const buildRuntime = async () => {
 
           if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
 
+          // valkey server
+          await createValkeyConnection({ host, path }, valkey);
+
           if (mailer) {
             const mailerSsrConf = confSSR[getCapVariableName(client)];
             await MailerProvider.load({
@@ -441,7 +456,7 @@ const buildRuntime = async () => {
                 port,
                 origins,
               });
-              await listenPortController(listenServerFactory(), port, {
+              await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), port, {
                 runtime: 'nodejs',
                 client: null,
                 host,
@@ -461,7 +476,7 @@ const buildRuntime = async () => {
               path,
             });
 
-            await listenPortController(peerServer, peerPort, {
+            await UnderpostStartUp.API.listenPortController(peerServer, peerPort, {
               runtime: 'nodejs',
               client: null,
               host,
@@ -470,7 +485,7 @@ const buildRuntime = async () => {
             });
           }
 
-          await listenPortController(server, port, runningData);
+          await UnderpostStartUp.API.listenPortController(server, port, runningData);
 
           break;
         default:
@@ -483,7 +498,7 @@ const buildRuntime = async () => {
   if (Xampp.enabled() && Xampp.router) Xampp.initService();
   if (Lampp.enabled() && Lampp.router) Lampp.initService();
 
-  logRuntimeRouter();
+  UnderpostStartUp.API.logRuntimeRouter();
 };
 
 export { buildRuntime };

package/src/server/start.js

@@ -0,0 +1,122 @@
+import UnderpostDeploy from '../cli/deploy.js';
+import fs from 'fs-extra';
+import { awaitDeployMonitor } from './conf.js';
+import { actionInitLog, loggerFactory } from './logger.js';
+import { shellCd, shellExec } from './process.js';
+import UnderpostRootEnv from '../cli/env.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostStartUp {
+  static API = {
+    logRuntimeRouter: () => {
+      const displayLog = {};
+
+      for (const host of Object.keys(UnderpostDeploy.NETWORK))
+        for (const path of Object.keys(UnderpostDeploy.NETWORK[host]))
+          displayLog[UnderpostDeploy.NETWORK[host][path].publicHost] = UnderpostDeploy.NETWORK[host][path].local;
+
+      logger.info('Runtime network', displayLog);
+    },
+    listenServerFactory: (logic = async () => {}) => {
+      return {
+        listen: async (...args) => {
+          const msDelta = 1000;
+          const msMax = 30 * 24 * 60 * 60 * 1000; // ~ 1 month
+          let msCount = 0;
+          setInterval(() => {
+            msCount += msDelta;
+            if (msCount >= msMax) {
+              const message = 'Listen server factory timeout';
+              logger.error(message);
+              throw new Error(message);
+            }
+          }, msDelta);
+          return logic ? await logic(...args) : undefined, args[1]();
+        },
+      };
+    },
+    listenPortController: async (server, port, metadata) =>
+      new Promise((resolve) => {
+        try {
+          if (port === ':') {
+            server.listen(port, actionInitLog);
+            return resolve(true);
+          }
+
+          const { host, path, client, runtime, meta } = metadata;
+          const error = [];
+          if (port === undefined) error.push(`port`);
+          if (host === undefined) error.push(`host`);
+          if (path === undefined) error.push(`path`);
+          if (client === undefined) error.push(`client`);
+          if (runtime === undefined) error.push(`runtime`);
+          if (meta === undefined) error.push(`meta`);
+          if (error.length > 0) throw new Error('Listen port controller requires values: ' + error.join(', '));
+
+          server.listen(port, () => {
+            if (!UnderpostDeploy.NETWORK[host]) UnderpostDeploy.NETWORK[host] = {};
+            UnderpostDeploy.NETWORK[host][path] = {
+              meta,
+              client,
+              runtime,
+              port,
+              publicHost:
+                port === 80
+                  ? `http://${host}${path}`
+                  : port === 443
+                  ? `https://${host}${path}`
+                  : `http://${host}:${port}${path}`,
+              local: `http://localhost:${port}${path}`,
+              apis: metadata.apis,
+            };
+
+            return resolve(true);
+          });
+        } catch (error) {
+          logger.error(error, { metadata, port, stack: error.stack });
+          resolve(false);
+        }
+      }),
+
+    async callback(deployId = 'default', env = 'development', options = { build: false, run: false }) {
+      if (options.build === true) await UnderpostStartUp.API.build(deployId, env);
+      if (options.run === true) await UnderpostStartUp.API.run(deployId, env);
+    },
+    async build(deployId = 'default', env = 'development') {
+      const buildBasePath = `/home/dd`;
+      const repoName = `engine-${deployId.split('-')[1]}`;
+      shellExec(`cd ${buildBasePath} && underpost clone underpostnet/${repoName}`);
+      shellExec(`cd ${buildBasePath} && sudo mv ./${repoName} ./engine`);
+      shellExec(`cd ${buildBasePath}/engine && underpost clone underpostnet/${repoName}-private`);
+      shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      shellCd(`${buildBasePath}/engine`);
+      shellExec(`npm install`);
+      shellExec(`node bin/deploy conf ${deployId} ${env}`);
+      if (fs.existsSync('./engine-private/itc-scripts')) {
+        const itcScripts = await fs.readdir('./engine-private/itc-scripts');
+        for (const itcScript of itcScripts)
+          if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
+      }
+      shellExec(`node bin/deploy build-full-client ${deployId}`);
+    },
+    async run(deployId = 'default', env = 'development') {
+      const runCmd = env === 'production' ? 'run prod-img' : 'run dev-img';
+      if (fs.existsSync(`./engine-private/replica`)) {
+        const replicas = await fs.readdir(`./engine-private/replica`);
+        for (const replica of replicas) {
+          if (!replica.match(deployId)) continue;
+          shellExec(`node bin/deploy conf ${replica} ${env}`);
+          shellExec(`npm ${runCmd} deploy deploy-id:${replica}`, { async: true });
+          await awaitDeployMonitor(true);
+        }
+      }
+      shellExec(`node bin/deploy conf ${deployId} ${env}`);
+      shellExec(`npm ${runCmd} deploy deploy-id:${deployId}`, { async: true });
+      await awaitDeployMonitor(true);
+      UnderpostRootEnv.API.set('container-status', `${deployId}-${env}-running-deployment`);
+    },
+  };
+}
+
+export default UnderpostStartUp;