underpost 2.8.1 → 2.8.7

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 = { itc: false, git: 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.itc === true)) {
+        shellExec(`node bin db ${options.git ? '--git ' : ''}--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

@@ -21,6 +21,7 @@ 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';
 
 dotenv.config();
 
@@ -50,10 +51,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 +192,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 +205,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)) {
@@ -259,20 +251,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               'services',
               baseHost,
             );
-            if (module === 'core' && (process.env.NODE_ENV === 'production' || process.argv.includes('static'))) {
-              if (apiBaseHost)
-                jsSrc = jsSrc.replace(
-                  'const getBaseHost = () => location.host;',
-                  `const getBaseHost = () => '${apiBaseHost}';`,
-                );
-              if (apiBaseProxyPath) {
-                jsSrc = jsSrc.replace('${getProxyPath()}api/', `${apiBaseProxyPath}${process.env.BASE_API}/`);
-                jsSrc = jsSrc.replace(
-                  "const getWsBasePath = () => (getProxyPath() !== '/' ? `${getProxyPath()}socket.io/` : undefined);",
-                  `const getWsBasePath = () => '${apiBaseProxyPath}socket.io/';`,
-                );
-              }
-            }
             fs.writeFileSync(
               jsPublicPath,
               minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
@@ -496,7 +474,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   }
 
                   default:
-                    ssrBodyComponents += SrrComponent({ ssrPath, host, path, ttiLoadTimeLimit });
+                    ssrBodyComponents += SrrComponent({
+                      ssrPath,
+                      host,
+                      path,
+                      ttiLoadTimeLimit,
+                      version: Underpost.version,
+                    });
                     break;
                 }
               }
@@ -516,6 +500,15 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               ssrPath,
               ssrHeadComponents,
               ssrBodyComponents,
+              renderPayload: {
+                apiBaseProxyPath,
+                apiBaseHost,
+                apiBasePath: process.env.BASE_API,
+                version: Underpost.version,
+              },
+              renderApi: {
+                JSONweb,
+              },
             });
 
             fs.writeFileSync(
@@ -545,17 +538,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)
@@ -700,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) {
@@ -726,6 +722,15 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
                 ssrPath,
                 ssrHeadComponents: '',
                 ssrBodyComponents: SsrComponent(),
+                renderPayload: {
+                  apiBaseProxyPath,
+                  apiBaseHost,
+                  apiBasePath: process.env.BASE_API,
+                  version: Underpost.version,
+                },
+                renderApi: {
+                  JSONweb,
+                },
               });
 
               const buildPath = `${
@@ -758,16 +763,14 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
         }
 
         {
-          const PRE_CACHED_JSON = `PRE_CACHED_RESOURCES = ${JSONweb(uniqueArray(PRE_CACHED_RESOURCES))}`;
-          const PROXY_PATH = `PROXY_PATH = '${path}'`;
+          const renderPayload = {
+            PRE_CACHED_RESOURCES: uniqueArray(PRE_CACHED_RESOURCES),
+            PROXY_PATH: path,
+          };
           fs.writeFileSync(
             `${rootClientPath}/sw.js`,
-            fs
-              .readFileSync(`${rootClientPath}/sw.js`, 'utf8')
-              .replaceAll(`PRE_CACHED_RESOURCES = []`, PRE_CACHED_JSON)
-              .replaceAll(`PRE_CACHED_RESOURCES=[]`, PRE_CACHED_JSON)
-              .replaceAll(`PROXY_PATH = '/'`, PROXY_PATH)
-              .replaceAll(`PROXY_PATH='/'`, PROXY_PATH),
+            `self.renderPayload = ${JSONweb(renderPayload)};
+${fs.readFileSync(`${rootClientPath}/sw.js`, 'utf8')}`,
             'utf8',
           );
         }

package/src/server/client-formatted.js

@@ -1,6 +1,8 @@
 'use strict';
 
 import fs from 'fs-extra';
+import vm from 'node:vm';
+import Underpost from '../index.js';
 
 const srcFormatted = (src) =>
   src
@@ -48,9 +50,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: Underpost.version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
 };
 
 export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };