underpost 2.7.83 → 2.7.92

package/src/server/backup.js

@@ -9,100 +9,112 @@ dotenv.config();
 const logger = loggerFactory(import.meta);
 
 const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${process.env.GITHUB_BACKUP_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function () {
-    await this.Callback();
-    return this.Callback;
-  },
-  Callback: async function () {
-    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+  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`;
 
-    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
 
-    const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
 
-    if (!backups) return;
+      if (!backups) return;
 
-    const currentDate = new Date().getTime();
+      logger.info('init backups callback');
+      await logger.setUpInfo();
 
-    if (!fs.existsSync('./engine-private/cron-backups'))
-      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
+      const currentDate = new Date().getTime();
 
-    for (const deployGroupData of backups) {
-      const { deployGroupId } = deployGroupData;
-      const dataDeploy = getDataDeploy({ deployGroupId });
+      if (!fs.existsSync('./engine-private/cron-backups'))
+        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      for (const deployObj of dataDeploy) {
-        const { deployId, replicaHost } = deployObj;
+      for (const deployGroupData of backups) {
+        const { deployGroupId } = deployGroupData;
+        const dataDeploy = getDataDeploy({ deployGroupId });
 
-        if (replicaHost) continue;
+        for (const deployObj of dataDeploy) {
+          const { deployId, replicaHost } = deployObj;
 
-        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'),
-        );
+          if (replicaHost) continue;
 
-        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];
+          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'),
+          );
 
-            if (!db || singleReplica) continue;
+          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 (!backupFrequency) backupFrequency = 'daily';
-            if (!maxBackupRetention) maxBackupRetention = 5;
+              if (!db || singleReplica) continue;
 
-            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 });
+              if (!backupFrequency) backupFrequency = 'daily';
+              if (!maxBackupRetention) maxBackupRetention = 5;
 
-            const currentBackupsDirs = files
-              .map((fileObj) => parseInt(fileObj.name))
-              .sort((a, b) => a - b)
-              .reverse();
+              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 });
 
-            switch (backupFrequency) {
-              case 'daily':
+              const currentBackupsDirs = files
+                .map((fileObj) => parseInt(fileObj.name))
+                .sort((a, b) => a - b)
+                .reverse();
 
-              default:
-                // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                break;
-            }
+              switch (backupFrequency) {
+                case 'daily':
 
-            for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-              const removePathRetention = `${backUpPath}/${retentionPath}`;
-              logger.info('Remove backup folder', removePathRetention);
-              fs.removeSync(removePathRetention);
-            }
+                default:
+                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
+                  break;
+              }
+
+              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+                const removePathRetention = `${backUpPath}/${retentionPath}`;
+                logger.info('Remove backup folder', removePathRetention);
+                fs.removeSync(removePathRetention);
+              }
 
-            fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-            shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
 
-            if (wp) {
-              const repoUrl = `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${
-                process.env.GITHUB_BACKUP_USERNAME
-              }/${git.split('/').pop()}.git`;
+              if (wp) {
+                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
+                  .split('/')
+                  .pop()}.git`;
 
-              shellExec(
-                `cd ${directory}` +
-                  ` && git pull ${repoUrl}` +
-                  ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                  ` && git push ${repoUrl}`,
-              );
+                shellExec(
+                  `cd ${directory}` +
+                    ` && git pull ${repoUrl}` +
+                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+                    ` && git push ${repoUrl}`,
+                  {
+                    disableLog: true,
+                  },
+                );
+              }
             }
-          }
+        }
       }
-    }
-    shellExec(
-      `cd ./engine-private/cron-backups` +
-        ` && git pull ${BackUpManagement.repoUrl}` +
-        ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-        ` && git push ${BackUpManagement.repoUrl}`,
-    );
+      shellExec(
+        `cd ./engine-private/cron-backups` +
+          ` && git pull ${BackUpManagement.repoUrl}` +
+          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+          ` && git push ${BackUpManagement.repoUrl}`,
+        {
+          disableLog: true,
+        },
+      );
+    };
+    await Callback();
+    BackUpManagement.Callback = Callback;
+    return Callback;
   },
+  Callback: async function (params) {},
 };
 
 export { BackUpManagement };

package/src/server/client-build.js

@@ -1,9 +1,16 @@
 'use strict';
 
 import fs from 'fs-extra';
-import { srcFormatted, componentFormatted, viewFormatted, ssrFactory } from './client-formatted.js';
+import { srcFormatted, componentFormatted, viewFormatted, ssrFactory, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
-import { cap, newInstance, orderArrayFromAttrInt, titleFormatted } from '../client/components/core/CommonJs.js';
+import {
+  cap,
+  getCapVariableName,
+  newInstance,
+  orderArrayFromAttrInt,
+  titleFormatted,
+  uniqueArray,
+} from '../client/components/core/CommonJs.js';
 import UglifyJS from 'uglify-js';
 import { minify } from 'html-minifier-terser';
 import dotenv from 'dotenv';
@@ -40,10 +47,22 @@ const fullBuild = async ({
 }) => {
   logger.warn('Full build', rootClientPath);
 
-  fs.removeSync(rootClientPath);
-
   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(`${rootClientPath}/index.php`)) {
+      fs.copySync(`/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');
+    }
+    return;
+  }
+
+  fs.removeSync(rootClientPath);
+
   if (fs.existsSync(`./src/client/public/${publicClientId}`)) {
     if (iconsBuild) {
       const defaultBaseIconFolderPath = `src/client/public/${publicClientId}/assets/logo`;
@@ -52,7 +71,7 @@ const fullBuild = async ({
       if (!fs.existsSync(defaultBaseIconPath))
         await buildTextImg(metadata.title, { debugFilename: defaultBaseIconPath });
 
-      if (path === '/' && !fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
+      if (!fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
         await buildIcons({ publicClientId, metadata });
     }
     fs.copySync(
@@ -89,8 +108,15 @@ const fullBuild = async ({
   if (dists)
     for (const dist of dists) {
       if ('folder' in dist) {
-        fs.mkdirSync(`${rootClientPath}${dist.public_folder}`, { recursive: true });
-        fs.copySync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        if (fs.statSync(dist.folder).isDirectory()) {
+          fs.mkdirSync(`${rootClientPath}${dist.public_folder}`, { recursive: true });
+          fs.copySync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        } else {
+          const folder = dist.public_folder.split('/');
+          folder.pop();
+          fs.mkdirSync(`${rootClientPath}${folder.join('/')}`, { recursive: true });
+          fs.copyFileSync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        }
       }
       if ('styles' in dist) {
         fs.mkdirSync(`${rootClientPath}${dist.public_styles_folder}`, { recursive: true });
@@ -112,16 +138,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
   const enableLiveRebuild =
     options && options.liveClientBuildPaths && options.liveClientBuildPaths.length > 0 ? true : false;
 
-  // common ssr components
-  let jsSsrCommonComponents = '';
-  {
-    const files = await fs.readdir(`./src/client/ssr/common`);
-    for (const relativePath of files)
-      jsSsrCommonComponents += await srcFormatted(
-        fs.readFileSync(`./src/client/ssr/common/${relativePath}`, 'utf8').split('export')[0],
-      );
-  }
-
   let currentPort = parseInt(process.env.PORT) + 1;
   for (const host of Object.keys(confServer)) {
     const paths = orderArrayFromAttrInt(Object.keys(confServer[host]), 'length', 'asc');
@@ -148,6 +164,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
         apiBaseHost,
         ttiLoadTimeLimit,
         singleReplica,
+        offlineBuild,
       } = confServer[host][path];
       if (singleReplica) continue;
       if (!confClient[client]) confClient[client] = {};
@@ -188,7 +205,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis)
+        if (apis && false)
           for (const apiBuildScript of apis) {
             const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
             if (fs.existsSync(`./${scriptPath}`)) {
@@ -248,8 +265,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   'const getBaseHost = () => location.host;',
                   `const getBaseHost = () => '${apiBaseHost}';`,
                 );
-              if (apiBaseProxyPath)
+              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,
@@ -284,87 +306,22 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       const buildId = `${client}.index`;
       const siteMapLinks = [];
-      let Render = () => '';
-      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/Render.js`, 'utf8')));
+      const ssrPath = path === '/' ? path : `${path}/`;
+      const Render = await ssrFactory();
 
       if (views) {
-        const buildJsSrcPage = async (jsSrcPath, jsPublicPath) => {
-          if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
-            let jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
-            if (jsSrc.split('/*imports*/')[1]) jsSrc = jsSrc.split('/*imports*/')[1];
+        const jsSrcPath = fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
+          ? `./src/client/sw/${publicClientId}.sw.js`
+          : `./src/client/sw/default.sw.js`;
 
-            fs.writeFileSync(
-              jsPublicPath,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
-          }
-        };
+        const jsPublicPath = `${rootClientPath}/sw.js`;
 
-        if (path === '/') {
-          // service woker
-          await buildJsSrcPage(
-            fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
-              ? `./src/client/sw/${publicClientId}.sw.js`
-              : `./src/client/sw/default.sw.js`,
-            `${rootClientPath}/sw.js`,
-          );
-        }
-
-        // offline html
-        {
-          await buildJsSrcPage(
-            fs.existsSync(`./src/client/ssr/offline/${publicClientId}.index.js`)
-              ? `./src/client/ssr/offline/${publicClientId}.index.js`
-              : `./src/client/ssr/offline/default.index.js`,
-            `${rootClientPath}/offline.js`,
-          );
-
-          const htmlSrc = Render({
-            title: metadata?.title ? metadata.title : cap(client),
-            ssrPath: '/',
-            ssrHeadComponents: '',
-            ssrBodyComponents: '',
-            baseSsrLib: jsSsrCommonComponents + fs.readFileSync(`${rootClientPath}/offline.js`, 'utf8'),
-          });
+        if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
+          const jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
 
           fs.writeFileSync(
-            `${rootClientPath}offline.html`,
-            minifyBuild || process.env.NODE_ENV === 'production'
-              ? await minify(htmlSrc, {
-                  minifyCSS: true,
-                  minifyJS: true,
-                  collapseBooleanAttributes: true,
-                  collapseInlineTagWhitespace: true,
-                  collapseWhitespace: true,
-                })
-              : htmlSrc,
-            'utf8',
-          );
-        }
-        // ssr pages
-        for (const page of await fs.readdir('./src/client/ssr/pages')) {
-          await buildJsSrcPage(`./src/client/ssr/pages/${page}`, `${rootClientPath}/${page}`);
-
-          const htmlSrc = Render({
-            title: metadata?.title ? metadata.title : cap(client),
-            ssrPath: '/',
-            ssrHeadComponents: '',
-            ssrBodyComponents: '',
-            baseSsrLib: jsSsrCommonComponents + fs.readFileSync(`${rootClientPath}/${page}`, 'utf8'),
-          });
-
-          fs.writeFileSync(
-            `${rootClientPath}${page.slice(0, -3)}.html`,
-            minifyBuild || process.env.NODE_ENV === 'production'
-              ? await minify(htmlSrc, {
-                  minifyCSS: true,
-                  minifyJS: true,
-                  collapseBooleanAttributes: true,
-                  collapseInlineTagWhitespace: true,
-                  collapseWhitespace: true,
-                })
-              : htmlSrc,
+            jsPublicPath,
+            minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
             'utf8',
           );
         }
@@ -410,7 +367,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
             const canonicalURL = `https://${host}${path}${
               view.path === '/' ? (path === '/' ? '' : '/') : path === '/' ? `${view.path.slice(1)}/` : `${view.path}/`
             }`;
-            const ssrPath = path === '/' ? path : `${path}/`;
 
             let ssrHeadComponents = ``;
             let ssrBodyComponents = ``;
@@ -420,10 +376,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 confSSR[view.ssr].head.unshift('Production');
 
               for (const ssrHeadComponent of confSSR[view.ssr].head) {
-                const SrrComponent = await ssrFactory(
-                  `./src/client/ssr/components/head/${ssrHeadComponent}.js`,
-                  jsSsrCommonComponents,
-                );
+                const SrrComponent = await ssrFactory(`./src/client/ssr/head/${ssrHeadComponent}.js`);
 
                 switch (ssrHeadComponent) {
                   case 'Pwa':
@@ -432,7 +385,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       fs.existsSync(`./src/client/public/${publicClientId}/browserconfig.xml`) &&
                       fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`);
 
-                    if (view.path === '/' && validPwaBuild) {
+                    if (validPwaBuild) {
                       // build webmanifest
                       const webmanifestJson = JSON.parse(
                         fs.readFileSync(`./src/client/public/${publicClientId}/site.webmanifest`, 'utf8'),
@@ -504,10 +457,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               }
 
               for (const ssrBodyComponent of confSSR[view.ssr].body) {
-                const SrrComponent = await ssrFactory(
-                  `./src/client/ssr/components/body/${ssrBodyComponent}.js`,
-                  jsSsrCommonComponents,
-                );
+                const SrrComponent = await ssrFactory(`./src/client/ssr/body/${ssrBodyComponent}.js`);
                 switch (ssrBodyComponent) {
                   case 'UnderpostDefaultSplashScreen':
                   case 'CyberiaDefaultSplashScreen':
@@ -540,48 +490,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       host,
                       path,
                       ttiLoadTimeLimit,
-                      storage: {
-                        // 'space-background': fs.readFileSync('./src/client/public/cyberia/space-background', 'utf8'),
-                        lore0: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore0.jpeg')
-                          .toString('base64')}`,
-                        lore1: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore1.jpeg')
-                          .toString('base64')}`,
-                        lore2: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore2.jpeg')
-                          .toString('base64')}`,
-                        lore3: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore3.jpeg')
-                          .toString('base64')}`,
-                        lore4: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore4.jpeg')
-                          .toString('base64')}`,
-                        lore5: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore5.jpeg')
-                          .toString('base64')}`,
-                        lore6: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore6.jpeg')
-                          .toString('base64')}`,
-                        lore7: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore7.jpeg')
-                          .toString('base64')}`,
-                        lore8: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore8.jpeg')
-                          .toString('base64')}`,
-                        ['arrow-left']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-left.png')
-                          .toString('base64')}`,
-                        ['arrow-right']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-right.png')
-                          .toString('base64')}`,
-                        ['fullscreen']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/fullscreen.png')
-                          .toString('base64')}`,
-                        ['cyberia-logo']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/util/cyberia-retro-banner.png')
-                          .toString('base64')}`,
-                      },
                     });
                     break;
                   }
@@ -592,14 +500,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 }
               }
             }
-            const htmlSrc = Render({
-              title,
-              buildId,
-              ssrPath,
-              ssrHeadComponents,
-              ssrBodyComponents,
-              baseSsrLib: jsSsrCommonComponents,
-            });
 
             /** @type {import('sitemap').SitemapItem} */
             const siteMapLink = {
@@ -609,6 +509,14 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
             };
             siteMapLinks.push(siteMapLink);
 
+            const htmlSrc = Render({
+              title,
+              buildId,
+              ssrPath,
+              ssrHeadComponents,
+              ssrBodyComponents,
+            });
+
             fs.writeFileSync(
               `${buildPath}index.html`,
               minifyBuild || process.env.NODE_ENV === 'production'
@@ -686,7 +594,7 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
         fs.copySync(`./coverage`, coverageBuildPath);
 
         // uml
-        shellExec(`node bin/deploy uml ${host} ${path}`);
+        // shellExec(`node bin/deploy uml ${host} ${path}`);
 
         // https://swagger-autogen.github.io/docs/
 
@@ -814,6 +722,76 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
 
         zip.writeZip(`./build/${buildId}.zip`);
       }
+      if (client) {
+        let PRE_CACHED_RESOURCES = [];
+
+        if (views && offlineBuild && fs.existsSync(`${rootClientPath}/sw.js`)) {
+          PRE_CACHED_RESOURCES = await fs.readdir(rootClientPath, { recursive: true });
+          PRE_CACHED_RESOURCES = views
+            .map((view) => `${path === '/' ? '' : path}${view.path}`)
+            .concat(
+              PRE_CACHED_RESOURCES.map((p) => `/${p}`).filter(
+                (p) => p[1] !== '.' && !fs.statSync(`${rootClientPath}${p}`).isDirectory(),
+              ),
+            );
+        }
+
+        for (const pageType of ['offline', 'pages']) {
+          if (confSSR[getCapVariableName(client)] && confSSR[getCapVariableName(client)][pageType]) {
+            for (const page of confSSR[getCapVariableName(client)][pageType]) {
+              const SsrComponent = await ssrFactory(`./src/client/ssr/${pageType}/${page.client}.js`);
+
+              const htmlSrc = Render({
+                title: page.title,
+                ssrPath,
+                ssrHeadComponents: '',
+                ssrBodyComponents: SsrComponent(),
+              });
+
+              const buildPath = `${
+                rootClientPath[rootClientPath.length - 1] === '/' ? rootClientPath.slice(0, -1) : rootClientPath
+              }${page.path === '/' ? page.path : `${page.path}/`}`;
+
+              PRE_CACHED_RESOURCES.push(`${path === '/' ? '' : path}${page.path === '/' ? '' : page.path}/index.html`);
+
+              if (!fs.existsSync(buildPath)) fs.mkdirSync(buildPath, { recursive: true });
+
+              const buildHtmlPath = `${buildPath}index.html`;
+
+              logger.info('ssr page build', buildHtmlPath);
+
+              fs.writeFileSync(
+                buildHtmlPath,
+                minifyBuild || process.env.NODE_ENV === 'production'
+                  ? await minify(htmlSrc, {
+                      minifyCSS: true,
+                      minifyJS: true,
+                      collapseBooleanAttributes: true,
+                      collapseInlineTagWhitespace: true,
+                      collapseWhitespace: true,
+                    })
+                  : htmlSrc,
+                'utf8',
+              );
+            }
+          }
+        }
+
+        {
+          const PRE_CACHED_JSON = `PRE_CACHED_RESOURCES = ${JSONweb(uniqueArray(PRE_CACHED_RESOURCES))}`;
+          const PROXY_PATH = `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),
+            'utf8',
+          );
+        }
+      }
     }
   }
 };

package/src/server/client-formatted.js

@@ -47,11 +47,9 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
   return src.replaceAll(`from './`, componentFromFormatted).replaceAll(`from '../`, componentFromFormatted);
 };
 
-const ssrFactory = async (componentPath = '', jsSsrCommonComponents) => {
+const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
   let SrrComponent = () => {};
-  let render = await srcFormatted(fs.readFileSync(componentPath, 'utf8'));
-  if (render.split('/*imports*/')[1]) render = render.split('/*imports*/')[1];
-  eval(jsSsrCommonComponents + render);
+  eval(await srcFormatted(fs.readFileSync(componentPath, 'utf8')));
   return SrrComponent;
 };