underpost 2.7.6 → 2.7.8

package/src/client/ssr/common/SsrCore.js

@@ -0,0 +1,91 @@
+const s = (el) => document.querySelector(el);
+
+const append = (el, html) => s(el).insertAdjacentHTML('beforeend', html);
+
+const htmls = (el, html) => (s(el).innerHTML = html);
+
+const s4 = () => (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+
+const range = (start, end) => {
+  return end < start
+    ? range(end, start).reverse()
+    : Array.apply(0, Array(end - start + 1)).map((element, index) => index + start);
+};
+
+const timer = (ms) => new Promise((res) => setTimeout(res, ms));
+
+const newInstance = (obj) => {
+  // structuredClone() 2022 ES6 feature
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (error) {
+    return { error: error.message };
+  }
+};
+
+const fullScreenIn = () => {
+  const elem = document.documentElement;
+  if (elem.requestFullscreen) {
+    elem.requestFullscreen();
+  } else if (elem.mozRequestFullScreen) {
+    /* Firefox */
+    elem.mozRequestFullScreen();
+  } else if (elem.webkitRequestFullscreen) {
+    /* Chrome, Safari & Opera */
+    elem.webkitRequestFullscreen();
+  } else if (elem.msRequestFullscreen) {
+    /* IE/Edge */
+    elem = window.top.document.body; //To break out of frame in IE
+    elem.msRequestFullscreen();
+  }
+};
+
+const borderChar = (px, color, selectors) => {
+  if (selectors) {
+    return selectors
+      .map(
+        (selector) => html`
+          <style>
+            ${selector} {
+              text-shadow: ${px}px -${px}px ${px}px ${color}, -${px}px ${px}px ${px}px ${color},
+                -${px}px -${px}px ${px}px ${color}, ${px}px ${px}px ${px}px ${color};
+            }
+          </style>
+        `,
+      )
+      .join('');
+  }
+  return html`
+    text-shadow: ${px}px -${px}px ${px}px ${color}, -${px}px ${px}px ${px}px ${color}, -${px}px -${px}px ${px}px
+    ${color}, ${px}px ${px}px ${px}px ${color};
+  `;
+};
+const getLang = () =>
+  localStorage.getItem('lang') ? localStorage.getItem('lang') : navigator.language || navigator.userLanguage;
+
+const loggerFactory = (meta) => {
+  meta = meta.url.split('/').pop();
+  const types = ['error', 'warn', 'info', 'debug'];
+  const logger = {
+    log: function (type, args) {
+      if (location.hostname !== 'localhost' && console.log() !== null) {
+        console.log = () => null;
+        console.error = () => null;
+        console.info = () => null;
+        console.warn = () => null;
+      }
+      return location.hostname === 'localhost'
+        ? console[type](`[${meta}] ${new Date().toISOString()} ${type}:`, ...args)
+        : null;
+    },
+  };
+  types.map(
+    (type) =>
+      (logger[type] = function (...args) {
+        return this.log(type, args);
+      }),
+  );
+  return logger;
+};
+
+export { getLang, s, append, s4, range, timer, htmls, newInstance, fullScreenIn, borderChar, loggerFactory };

package/src/client/ssr/common/Translate.js

@@ -0,0 +1,26 @@
+const TranslateCore = {
+  ['server-maintenance']: {
+    en: "The server is under maintenance <br> we'll be back soon.",
+    es: 'El servidor está en mantenimiento <br> volveremos pronto.',
+  },
+  ['no-internet-connection']: {
+    en: 'No internet connection <br> verify your network',
+    es: 'Sin conexión a internet <br> verifica tu red',
+  },
+  ['page-not-found']: {
+    en: 'Page not found',
+    es: 'Página no encontrada',
+  },
+  ['page-broken']: {
+    es: 'Algo salio mal',
+    en: 'Something went wrong',
+  },
+  ['back']: {
+    en: 'Back to <br>  homepage',
+    es: 'Volver a  <br> la pagina principal',
+  },
+};
+
+const Translate = (key) => TranslateCore[key][getLang().match('es') ? 'es' : 'en'];
+
+export { Translate };

package/src/client/ssr/common/Worker.js

@@ -0,0 +1,28 @@
+const Worker = {
+  instance: async function (options = { render: async () => {} }) {
+    window.serviceWorkerReady = true;
+    append(
+      'body',
+      html`
+        <style>
+          body {
+            background-color: #dcdcdc;
+            color: #303030;
+            font-family: arial;
+            font-size: 16px;
+          }
+          .page-render {
+            min-height: 100vh;
+          }
+          a {
+            color: #000000;
+          }
+        </style>
+        <div class="in page-render"></div>
+      `,
+    );
+    await options.render();
+  },
+};
+
+export { Worker };

package/src/client/ssr/{body-components → components/body}/CacheControl.js

@@ -109,6 +109,6 @@ SrrComponent = ({ ttiLoadTimeLimit }) => {
       const CacheControl = ${CacheControl};
       CacheControl({ ttiLoadTimeLimit: ${ttiLoadTimeLimit ? ttiLoadTimeLimit : 1000 * 70 * 1} });
     </script>
-    <div class="clean-cache-container">v2.7.6</div>
+    <div class="clean-cache-container">v2.7.8</div>
   `;
 };

package/src/client/ssr/{body-components → components/body}/DefaultSplashScreen.js

@@ -1,8 +1,19 @@
-SrrComponent = ({ base64BackgroundImage }) => html`
+SrrComponent = ({ base64BackgroundImage, metadata }) => html`
+  ${base64BackgroundImage
+    ? html`<style>
+        .ssr-background-image {
+          background-image: url('${base64BackgroundImage}');
+        }
+      </style>`
+    : metadata?.themeColor
+    ? html`<style>
+        .ssr-background-image {
+          background: ${metadata.themeColor};
+        }
+      </style>`
+    : ''}
+
   <style>
-    .ssr-background-image {
-      background-image: url('${base64BackgroundImage}');
-    }
     .ssr-top-bar {
       background: #ffffff;
       height: 100px;

package/src/client/ssr/offline/default.index.js

@@ -0,0 +1,31 @@
+import { htmls, loggerFactory } from '../common/SsrCore.js';
+import { Alert } from '../common/Alert.js';
+import { Translate } from '../common/Translate.js';
+import { Worker } from '../common/Worker.js';
+/*imports*/
+
+const logger = loggerFactory({ url: '/offline.js' });
+
+window.onload = () =>
+  Worker.instance({
+    render: async () => {
+      window.ononline = async () => {
+        location.href = '/';
+      };
+      window.onoffline = async () => {
+        htmls(`.page-render`, html`${await Alert.noInternet({ Translate })}`);
+      };
+      try {
+        if (navigator.onLine) {
+          const maintenance = await fetch(location.origin + '/favicon.ico');
+          if (maintenance.status !== 200) {
+            htmls(`.page-render`, html`${await Alert.maintenance({ Translate })}`);
+          } else window.ononline();
+        }
+        throw new Error(`no internet connection`);
+      } catch (error) {
+        logger.error(error);
+        window.onoffline();
+      }
+    },
+  });

package/src/client/ssr/pages/404.js

@@ -0,0 +1,12 @@
+import { e404 } from '../common/Alert.js';
+import { append } from '../common/SsrCore.js';
+import { Translate } from '../common/Translate.js';
+import { Worker } from '../common/Worker.js';
+/*imports*/
+
+window.onload = () =>
+  Worker.instance({
+    render: async () => {
+      append('.page-render', await e404({ Translate }));
+    },
+  });

package/src/client/ssr/pages/500.js

@@ -0,0 +1,12 @@
+import { e500 } from '../common/Alert.js';
+import { append } from '../common/SsrCore.js';
+import { Translate } from '../common/Translate.js';
+import { Worker } from '../common/Worker.js';
+/*imports*/
+
+window.onload = () =>
+  Worker.instance({
+    render: async () => {
+      append('.page-render', await e500({ Translate }));
+    },
+  });

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

@@ -179,15 +179,17 @@ self.addEventListener('fetch', (event) => {
           }
 
           logger.error('Fetch failed; returning offline page instead.', { error, path });
-
-          // const cache = await caches.open(CACHE_NAME);
-          // const cachedResponse = await cache.match(OFFLINE_URL);
-          // return cachedResponse;
-
-          const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
-          // response.status = 200;
-          response.headers.set('Content-Type', 'application/json');
-          return response;
+          try {
+            const cache = await caches.open('/offline.html');
+            const cachedResponse = await cache.match('/offline.html');
+            return cachedResponse;
+          } catch (error) {
+            logger.error('Error opening cache for offline page', { error, path });
+            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
+            // response.status = 200;
+            response.headers.set('Content-Type', 'application/json');
+            return response;
+          }
         }
       })(),
     );

package/src/cron.js

@@ -9,6 +9,7 @@ import { Dns } from './server/dns.js';
 import { ProcessController } from './server/process.js';
 import { Config } from './server/conf.js';
 import { BackUpManagement } from './server/backup.js';
+import { CronManagement } from './server/cron.js';
 
 dotenv.config();
 
@@ -18,8 +19,12 @@ const logger = loggerFactory(import.meta);
 
 await logger.setUpInfo();
 
-await Dns.InitIpDaemon();
+// every minutes
+CronManagement.add('ip', '* * * * *', await Dns.InitIpDaemon());
 
-await BackUpManagement.Init();
+// every day at 1 am
+CronManagement.add('backup', '0 1 * * *', await BackUpManagement.Init());
+
+await CronManagement.init();
 
 ProcessController.init(logger);

package/src/db/mongo/MongooseDB.js

@@ -114,18 +114,6 @@ const MongooseDB = {
           };
 
           checkStatus();
-          break;
-          // every 30 minute
-          cron.schedule(
-            '0 */30 * * * *',
-            async () => {
-              checkStatus();
-            },
-            {
-              scheduled: true,
-              timezone: process.env.TIME_ZONE || 'America/New_York',
-            },
-          );
         }
         break;
       default:

package/src/mailer/EmailRender.js

@@ -59,7 +59,7 @@ const EmailRender = {
     for (const templateKey of Object.keys(options.templates)) {
       const ssrEmailComponent = options.templates[templateKey];
       let SrrComponent;
-      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/email-components/${ssrEmailComponent}.js`, 'utf8')));
+      eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/components/email/${ssrEmailComponent}.js`, 'utf8')));
       templates[templateKey] = SrrComponent(this, options);
     }
     return templates;

package/src/server/backup.js

@@ -2,25 +2,17 @@ import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
 import { shellCd, shellExec } from './process.js';
 import { getCronBackUpFolder, getDataDeploy } from './conf.js';
-import cron from 'node-cron';
+import dotenv from 'dotenv';
+
+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 BackUpManagement.Callback();
-
-    // Schedule the sending process to run every day at 1 am
-    cron.schedule(
-      '0 1 * * *',
-      async () => {
-        await BackUpManagement.Callback();
-      },
-      {
-        scheduled: true,
-        timezone: process.env.TIME_ZONE || 'America/New_York',
-      },
-    );
+    await this.Callback();
+    return this.Callback;
   },
   Callback: async function () {
     const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
@@ -54,7 +46,7 @@ const BackUpManagement = {
         for (const host of Object.keys(confServer))
           for (const path of Object.keys(confServer[host])) {
             // retention policy
-            let { db, backupFrequency, maxBackupRetention, singleReplica } = confServer[host][path];
+            let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } = confServer[host][path];
 
             if (!db || singleReplica) continue;
 
@@ -75,26 +67,41 @@ const BackUpManagement = {
               case 'daily':
 
               default:
-                if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] <= 1000 * 60 * 60 * 24) continue;
+                // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
                 break;
             }
 
-            for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention + 1)) {
+            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 });
 
             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`;
+
+              shellExec(
+                `cd ${directory}` +
+                  ` && git pull ${repoUrl}` +
+                  ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+                  ` && git push ${repoUrl}`,
+              );
+            }
           }
       }
     }
-    shellCd(`./engine-private`);
-    shellExec(`git pull origin master`);
-    shellExec(`git add . && git commit -m "backup ${new Date().toLocaleDateString()}"`);
-    shellExec(`git push origin master`);
-    shellCd(`..`);
+    shellExec(
+      `cd ./engine-private/cron-backups` +
+        ` && git pull ${BackUpManagement.repoUrl}` +
+        ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+        ` && git push ${BackUpManagement.repoUrl}`,
+    );
   },
 };
 

package/src/server/client-build-live.js

@@ -20,8 +20,26 @@ const clientLiveBuild = async () => {
       (fs.existsSync(`./engine-private/conf/${deployId}`) || fs.existsSync(`./engine-private/replica/${deployId}`))
     ) {
       loadConf(deployId);
-      const confClient = JSON.parse(fs.readFileSync(`./conf/conf.client.json`, 'utf8'));
-      const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+      const confClient = JSON.parse(
+        fs.readFileSync(
+          fs.existsSync(`./engine-private/replica/${deployId}`)
+            ? `./engine-private/replica/${deployId}/conf.client.json`
+            : fs.existsSync(`./engine-private/conf/${deployId}/conf.client.json`)
+            ? `./engine-private/conf/${deployId}/conf.client.json`
+            : `./conf/conf.client.json`,
+          'utf8',
+        ),
+      );
+      const confServer = JSON.parse(
+        fs.readFileSync(
+          fs.existsSync(`./engine-private/replica/${deployId}`)
+            ? `./engine-private/replica/${deployId}/conf.server.json`
+            : fs.existsSync(`./engine-private/conf/${deployId}/conf.server.json`)
+            ? `./engine-private/conf/${deployId}/conf.server.json`
+            : `./conf/conf.server.json`,
+          'utf8',
+        ),
+      );
       host = process.argv[3];
       path = process.argv[4];
       clientId = confServer[host][path].client;
@@ -41,6 +59,8 @@ const clientLiveBuild = async () => {
     const updates = JSON.parse(fs.readFileSync(`./tmp/client.build.json`, 'utf8'));
     const liveClientBuildPaths = [];
     for (let srcPath of updates) {
+      srcPath = srcPath.replaceAll('/', `\\`); // linux case
+
       const srcBuildPath = `./src${srcPath.split('src')[1].replace(/\\/g, '/')}`;
       if (
         srcPath.split('src')[1].startsWith(`\\client\\components`) ||
@@ -51,6 +71,12 @@ const clientLiveBuild = async () => {
       } else if (srcPath.split('src')[1].startsWith(`\\client\\sw`)) {
         const publicBuildPath = `./public/${baseHost}/sw.js`;
         liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (
+        srcPath.split('src')[1].startsWith(`\\client\\offline`) &&
+        srcPath.split('src')[1].startsWith(`index.js`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/offline.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
       } else if (srcPath.split('src')[1].startsWith(`\\client`) && srcPath.slice(-9) === '.index.js') {
         for (const view of views) {
           const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/${clientId}.index.js`;