@underpostnet/underpost 2.8.1 → 2.8.5

package/src/index.js

@@ -4,9 +4,16 @@
  * @namespace Underpost
  */
 
-import { loggerFactory, setUpInfo } from './server/logger.js';
-
-const logger = loggerFactory(import.meta);
+import UnderpostCluster from './cli/cluster.js';
+import UnderpostCron from './cli/cron.js';
+import UnderpostDB from './cli/db.js';
+import UnderpostDeploy from './cli/deploy.js';
+import UnderpostRootEnv from './cli/env.js';
+import UnderpostImage from './cli/image.js';
+import UnderpostRepository from './cli/repository.js';
+import UnderpostScript from './cli/script.js';
+import UnderpostSecret from './cli/secrets.js';
+import UnderpostTest from './cli/test.js';
 
 /**
  * Underpost main module methods
@@ -20,26 +27,77 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.1';
-
-  constructor() {}
-
+  static version = 'v2.8.5';
+  /**
+   * Repository cli API
+   * @static
+   * @type {UnderpostRepository.API}
+   * @memberof Underpost
+   */
+  static repo = UnderpostRepository.API;
+  /**
+   * Root Env cli API
+   * @static
+   * @type {UnderpostRootEnv.API}
+   * @memberof Underpost
+   */
+  static env = UnderpostRootEnv.API;
+  /**
+   * Test cli API
+   * @static
+   * @type {UnderpostTest.API}
+   * @memberof Underpost
+   */
+  static test = UnderpostTest.API;
+  /**
+   * Cluster cli API
+   * @static
+   * @type {UnderpostCluster.API}
+   * @memberof Underpost
+   */
+  static cluster = UnderpostCluster.API;
+  /**
+   * Image cli API
+   * @static
+   * @type {UnderpostImage.API}
+   * @memberof Underpost
+   */
+  static image = UnderpostImage.API;
+  /**
+   * Secrets cli API
+   * @static
+   * @type {UnderpostSecret.API}
+   * @memberof Underpost
+   */
+  static secret = UnderpostSecret.API;
+  /**
+   * Scripts cli API
+   * @static
+   * @type {UnderpostScript.API}
+   * @memberof Underpost
+   */
+  static script = UnderpostScript.API;
+  /**
+   * Database cli API
+   * @static
+   * @type {UnderpostDB.API}
+   * @memberof Underpost
+   */
+  static db = UnderpostDB.API;
+  /**
+   * Deployment cli API
+   * @static
+   * @type {UnderpostDeploy.API}
+   * @memberof Underpost
+   */
+  static deploy = UnderpostDeploy.API;
   /**
-   * Logs information about the current process environment to the console.
-   *
-   * This function is used to log details about
-   * the execution context, such as command-line arguments,
-   * environment variables, the process's administrative privileges,
-   * and the maximum available heap space size.
-   *
+   * Cron cli API
    * @static
-   * @method setUpInfo
-   * @returns {Promise<void>}
+   * @type {UnderpostCron.API}
    * @memberof Underpost
    */
-  static async setUpInfo() {
-    return await setUpInfo(logger);
-  }
+  static cron = UnderpostCron.API;
 }
 
 const up = Underpost;

package/src/runtime/lampp/Lampp.js

@@ -1,5 +1,4 @@
 import fs from 'fs-extra';
-import { network } from '../../server/network.js';
 import { shellCd, shellExec } from '../../server/process.js';
 import { timer } from '../../client/components/core/CommonJs.js';
 import { loggerFactory } from '../../server/logger.js';
@@ -39,20 +38,9 @@ const Lampp = {
       );
 
     shellExec(cmd);
-    await network.port.portClean(3306);
-    for (const port of this.ports) await network.port.portClean(port);
     cmd = `sudo /opt/lampp/lampp start`;
     if (this.router) fs.writeFileSync(`./tmp/lampp-router.conf`, this.router, 'utf-8');
-    shellExec(cmd, { async: true });
-    if (options && options.daemon) this.daemon();
-  },
-  daemon: async function () {
-    await timer(1000 * 60 * 2); // 2 minutes
-    for (const port of this.ports) {
-      const [portStatus] = await network.port.status([port]);
-      if (!portStatus.open) return await this.initService();
-    }
-    this.daemon();
+    shellExec(cmd);
   },
   enabled: () => fs.existsSync(`/opt/lampp/apache2/conf/httpd.conf`),
   appendRouter: function (render) {

package/src/runtime/xampp/Xampp.js

@@ -1,7 +1,5 @@
 import fs from 'fs-extra';
-import { network } from '../../server/network.js';
 import { shellExec } from '../../server/process.js';
-import { timer } from '../../client/components/core/CommonJs.js';
 
 const Xampp = {
   ports: [],
@@ -16,20 +14,9 @@ const Xampp = {
     fs.writeFileSync(`C:/xampp/apache/conf/extra/httpd-ssl.conf`, this.router || '', 'utf8');
     cmd = `C:/xampp/xampp_stop.exe`;
     shellExec(cmd);
-    await network.port.portClean(3306);
-    for (const port of this.ports) await network.port.portClean(port);
     cmd = `C:/xampp/xampp_start.exe`;
     if (this.router) fs.writeFileSync(`./tmp/xampp-router.conf`, this.router, 'utf-8');
     shellExec(cmd);
-    if (options && options.daemon) this.daemon();
-  },
-  daemon: async function () {
-    await timer(1000 * 60 * 2); // 2 minutes
-    for (const port of this.ports) {
-      const [portStatus] = await network.port.status([port]);
-      if (!portStatus.open) return await this.initService();
-    }
-    this.daemon();
   },
   enabled: () => fs.existsSync(`C:/xampp/apache/conf/httpd.conf`),
   appendRouter: function (render) {

package/src/server/auth.js

@@ -9,7 +9,7 @@ import jwt from 'jsonwebtoken';
 import { loggerFactory } from './logger.js';
 import crypto from 'crypto';
 import { userRoleEnum } from '../api/user/user.model.js';
-import { validatePassword } from '../client/components/core/CommonJs.js';
+import { commonAdminGuard, commonModeratorGuard, validatePassword } from '../client/components/core/CommonJs.js';
 
 dotenv.config();
 
@@ -162,7 +162,7 @@ const authMiddleware = (req, res, next) => {
  */
 const adminGuard = (req, res, next) => {
   try {
-    if (!(userRoleEnum.indexOf(req.auth.user.role) === userRoleEnum.indexOf('admin')))
+    if (!commonAdminGuard(req.auth.user.role))
       return res.status(403).json({ status: 'error', message: 'Insufficient permission' });
     return next();
   } catch (error) {
@@ -194,7 +194,7 @@ const adminGuard = (req, res, next) => {
  */
 const moderatorGuard = (req, res, next) => {
   try {
-    if (!(userRoleEnum.indexOf(req.auth.user.role) <= userRoleEnum.indexOf('moderator')))
+    if (!commonModeratorGuard(req.auth.user.role))
       return res.status(403).json({ status: 'error', message: 'Insufficient permission' });
     return next();
   } catch (error) {

package/src/server/backup.js

@@ -1,120 +1,76 @@
 import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
-import { shellCd, shellExec } from './process.js';
-import { getCronBackUpFolder, getDataDeploy } from './conf.js';
+import { shellExec } from './process.js';
+import { getCronBackUpFolder } from './conf.js';
 import dotenv from 'dotenv';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function ({ deployId }) {
-    const Callback = async function () {
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+class BackUp {
+  static callback = async function (deployList, options = { disableKindCluster: false }) {
+    if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
+      deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
 
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+    logger.info('init backups callback', deployList);
+    await logger.setUpInfo();
+    const currentDate = new Date().getTime();
+    const maxBackupRetention = 5;
 
-      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      if (!backups) return;
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
+      if (!deployId) continue;
 
-      logger.info('init backups callback');
-      await logger.setUpInfo();
-
-      const currentDate = new Date().getTime();
-
-      if (!fs.existsSync('./engine-private/cron-backups'))
-        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
-
-      for (const deployGroupData of backups) {
-        const { deployGroupId } = deployGroupData;
-        const dataDeploy = getDataDeploy({ deployGroupId });
-
-        for (const deployObj of dataDeploy) {
-          const { deployId, replicaHost } = deployObj;
-
-          if (replicaHost) continue;
-
-          const confServer = JSON.parse(
-            fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
-              ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
-              : fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
-          );
-
-          for (const host of Object.keys(confServer))
-            for (const path of Object.keys(confServer[host])) {
-              // retention policy
-              let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } =
-                confServer[host][path];
-
-              if (!db || singleReplica) continue;
-
-              if (!backupFrequency) backupFrequency = 'daily';
-              if (!maxBackupRetention) maxBackupRetention = 5;
-
-              const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
-              if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
-              // .isDirectory()
-              const files = await fs.readdir(backUpPath, { withFileTypes: true });
-
-              const currentBackupsDirs = files
-                .map((fileObj) => parseInt(fileObj.name))
-                .sort((a, b) => a - b)
-                .reverse();
+      if (options.disableKindCluster !== true) {
+        shellExec(`underpost db --export ${deployId}`);
+        continue;
+      }
 
-              switch (backupFrequency) {
-                case 'daily':
+      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
 
-                default:
-                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                  break;
-              }
+      for (const host of Object.keys(confServer))
+        for (const path of Object.keys(confServer[host])) {
+          // retention policy
+          const { db } = confServer[host][path];
+          if (!db) continue;
+          logger.info('Init backup', { host, path, db });
 
-              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-                const removePathRetention = `${backUpPath}/${retentionPath}`;
-                logger.info('Remove backup folder', removePathRetention);
-                fs.removeSync(removePathRetention);
-              }
+          const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+          if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+          // .isDirectory()
+          const files = await fs.readdir(backUpPath, { withFileTypes: true });
 
-              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+          const currentBackupsDirs = files
+            .map((fileObj) => parseInt(fileObj.name))
+            .sort((a, b) => a - b)
+            .reverse();
 
-              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+          for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+            const removePathRetention = `${backUpPath}/${retentionPath}`;
+            logger.info('Remove backup folder', removePathRetention);
+            fs.removeSync(removePathRetention);
+          }
 
-              if (wp) {
-                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
-                  .split('/')
-                  .pop()}.git`;
+          fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-                shellExec(
-                  `cd ${directory}` +
-                    ` && git pull ${repoUrl}` +
-                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                    ` && git push ${repoUrl}`,
-                  {
-                    disableLog: true,
-                  },
-                );
-              }
-            }
+          shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
         }
-      }
       shellExec(
         `cd ./engine-private/cron-backups` +
-          ` && git pull ${BackUpManagement.repoUrl}` +
-          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-          ` && git push ${BackUpManagement.repoUrl}`,
+          ` && underpost pull . underpostnet/cron-backups` +
+          ` && git add .` +
+          ` && underpost cmt . backup cron-job '${new Date().toLocaleDateString()}'` +
+          ` && underpost push . underpostnet/cron-backups`,
         {
           disableLog: true,
         },
       );
-    };
-    await Callback();
-    BackUpManagement.Callback = Callback;
-    return Callback;
-  },
-  Callback: async function (params) {},
-};
+    }
+  };
+}
 
-export { BackUpManagement };
+export default BackUp;

package/src/server/client-build.js

@@ -50,10 +50,10 @@ const fullBuild = async ({
   buildAcmeChallengePath(acmeChallengeFullPath);
 
   if (publicClientId && publicClientId.startsWith('html-website-templates')) {
-    if (!fs.existsSync(`/dd/html-website-templates/`))
-      shellExec(`cd /dd && git clone https://github.com/designmodo/html-website-templates.git`);
+    if (!fs.existsSync(`/home/dd/html-website-templates/`))
+      shellExec(`cd /home/dd && git clone https://github.com/designmodo/html-website-templates.git`);
     if (!fs.existsSync(`${rootClientPath}/index.php`)) {
-      fs.copySync(`/dd/html-website-templates/${publicClientId.split('-publicClientId-')[1]}`, rootClientPath);
+      fs.copySync(`/home/dd/html-website-templates/${publicClientId.split('-publicClientId-')[1]}`, rootClientPath);
       shellExec(`cd ${rootClientPath} && git init && git add . && git commit -m "Base template implementation"`);
       // git remote add origin git@github.com:<username>/<repo>.git
       fs.writeFileSync(`${rootClientPath}/.git/.htaccess`, `Deny from all`, 'utf8');
@@ -191,8 +191,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       if (redirect || disabledRebuild) continue;
 
-      if (fullBuildEnabled) {
-        //  !(confServer[host]['/'] && confServer[host]['/'].liteBuild)
+      if (fullBuildEnabled)
         await fullBuild({
           path,
           logger,
@@ -205,14 +204,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis && false)
-          for (const apiBuildScript of apis) {
-            const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
-            if (fs.existsSync(`./${scriptPath}`)) {
-              shellExec(`node ${scriptPath}`);
-            }
-          }
-      }
 
       if (components)
         for (const module of Object.keys(components)) {
@@ -545,17 +536,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
         let siteMapSrc = await new Promise((resolve) =>
           streamToPromise(Readable.from(siteMapLinks).pipe(siteMapStream)).then((data) => resolve(data.toString())),
         );
-        switch (publicClientId) {
-          case 'underpost':
-            siteMapSrc = siteMapSrc.replaceAll(
-              `</urlset>`,
-              `${fs.readFileSync(`./src/client/public/underpost/sitemap-template.txt`, 'utf8')} </urlset>`,
-            );
-            break;
 
-          default:
-            break;
-        }
         // Return a promise that resolves with your XML string
         fs.writeFileSync(`${rootClientPath}/sitemap.xml`, siteMapSrc, 'utf8');
         if (xslUrl)

package/src/server/client-formatted.js

@@ -1,6 +1,7 @@
 'use strict';
 
 import fs from 'fs-extra';
+import vm from 'node:vm';
 
 const srcFormatted = (src) =>
   src
@@ -48,9 +49,10 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
 };
 
 const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
-  let SrrComponent = () => {};
-  eval(await srcFormatted(fs.readFileSync(componentPath, 'utf8')));
-  return SrrComponent;
+  const context = { SrrComponent: () => {}, npm_package_version: process.env.npm_package_version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
 };
 
 export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };