@underpostnet/underpost 2.7.82

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

@@ -0,0 +1,203 @@
+import { loggerFactory } from '../components/core/Logger.js';
+
+// https://googlechrome.github.io/samples/service-worker/custom-offline-page/
+
+/*
+Copyright 2015, 2019 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+// https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+// https://web.dev/cache-api-quick-guide/
+// https://developer.mozilla.org/en-US/docs/Web/API
+// https://developer.mozilla.org/es/docs/Web/Progressive_web_apps/Re-engageable_Notifications_Push
+// https://developer.mozilla.org/en-US/docs/Web/API/Notification/Notification
+// https://github.com/GoogleChrome/samples/blob/9e4b3b77b091268d28e5438bb2fe8829091e9540/service-worker/basic/service-worker.js#L59
+// https://developer.mozilla.org/en-US/docs/Web/API/Geolocation_API
+
+/*
+
+ 4 different ways to store data on client-side without using cookies:
+
+- Local Storage (Session and Local key/value pairs)
+- Web SQL (my favorite, it's a whole SQL Database, and it's NOT obsolete)
+- IndexedDB (another Database with different structure and acceptance)
+- Service Workers (Persistent background processing,
+even while offline, can asynchronously save files and many other things)
+
+*/
+
+const logger = loggerFactory(import.meta);
+
+self.addEventListener('install', (event) => {
+  // Activate right away
+  self.skipWaiting();
+
+  event.waitUntil(
+    (async () => {
+      // const cache = await caches.open(CACHE_NAME);
+      // Setting {cache: 'reload'} in the new request will ensure that the response
+      // isn't fulfilled from the HTTP cache; i.e., it will be from the network.
+      // await cache.add(new Request(OFFLINE_URL, { cache: 'reload' }));
+      // Open the app's cache.
+      // const cache = await caches.open(CACHE_NAME);
+      // Cache all static resources.
+      // await cache.addAll(PRE_CACHED_RESOURCES);
+    })(),
+  );
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    (async () => {
+      // Enable navigation preload if it's supported.
+      // See https://developers.google.com/web/updates/2017/02/navigation-preload
+      if ('navigationPreload' in self.registration) {
+        await self.registration.navigationPreload.enable();
+      }
+    })(),
+  );
+
+  // Tell the active service worker to take control of the page immediately.
+  self.clients.claim();
+
+  // event message
+  self.addEventListener('message', (event) => {
+    logger.info('Received event message', event.data);
+
+    switch (event.data.status) {
+      case 'skipWaiting':
+        return self.skipWaiting();
+        break;
+
+      default:
+        break;
+    }
+
+    clients.matchAll().then((clientList) => {
+      for (const client of clientList) {
+        logger.info('client', client);
+        client.postMessage({
+          title: 'Hello from SW event message',
+        });
+        // client -> document.visibilityState
+        //           client.visibilityState
+      }
+    });
+  });
+  // broadcast message
+  const channel = new BroadcastChannel('sw-messages');
+  channel.addEventListener('message', (event) => {
+    logger.info('Received broadcast message', event.data);
+    channel.postMessage({ title: 'Hello from SW broadcast message' });
+  });
+});
+
+self.addEventListener('fetch', (event) => {
+  let path;
+
+  if (event.request.url.match(location.origin)) path = event.request.url.slice(location.origin.length);
+  const preload = path && !path.match('/api');
+
+  logger.info(`On fetch`, {
+    mode: event.request.mode,
+    url: event.request.url,
+    referrer: event.request.referrer,
+    method: event.request.method,
+    path,
+    preload,
+  });
+
+  (async () => {
+    // Get the client.
+    const client = await clients.get(event.clientId);
+    if (client)
+      client.postMessage({
+        status: 'loader',
+        path,
+      });
+    else logger.warn('client not found');
+  })();
+
+  // We only want to call event.respondWith() if this is a navigation request
+  // for an HTML page.
+  if (path !== undefined || event.request.mode === 'navigate') {
+    event.respondWith(
+      (async () => {
+        try {
+          // First, try to use the navigation preload response if it's supported.
+          const preloadResponse = await event.preloadResponse;
+          if (preloadResponse) {
+            return preloadResponse;
+          }
+
+          if (preload) {
+            const preloadCache = await caches.has(path);
+            const cache = await caches.open(path);
+            const cacheResponse = await cache.match(path);
+            if (!preloadCache || !cacheResponse || cacheResponse.status !== 200) {
+              logger.warn('install', path);
+              // await cache.add(new Request(event.request.url, { cache: 'reload' }));
+
+              // Other option:
+              // The resource wasn't found in the cache, so fetch it from the network.
+              const fetchResponse = await fetch(event.request.url);
+
+              if (fetchResponse.status === 200) {
+                // Put the response in cache.
+                await cache.put(event.request.url, fetchResponse.clone());
+                // And return the response.
+                return fetchResponse;
+              } else {
+                await caches.delete(path);
+                throw new Error(await fetchResponse.text());
+              }
+            }
+            // logger.info('cache response', path);
+            return cacheResponse;
+          }
+
+          const networkResponse = await fetch(event.request);
+          logger.warn('fetch response', event.request.url);
+          return networkResponse;
+        } catch (error) {
+          // catch is only triggered if an exception is thrown, which is likely
+          // due to a network error.
+          // If fetch() returns a valid HTTP response with a response code in
+          // the 4xx or 5xx range, the catch() will NOT be called.
+          if (path) {
+            const preloadCache = await caches.has(path);
+            if (preloadCache) await caches.delete(path);
+          }
+
+          logger.error('Fetch failed; returning offline page instead.', { error, path });
+          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;
+          }
+        }
+      })(),
+    );
+  }
+
+  // If our if() condition is false, then this fetch handler won't intercept the
+  // request. If there are any other fetch handlers registered, they will get a
+  // chance to call event.respondWith(). If no fetch handlers call
+  // event.respondWith(), the request will be handled by the browser as if there
+  // were no service worker involvement.
+});

package/src/client/sw/template.sw.js

@@ -0,0 +1,84 @@
+// https://googlechrome.github.io/samples/service-worker/custom-offline-page/
+
+/*
+Copyright 2015, 2019 Google Inc. All Rights Reserved.
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+// Incrementing OFFLINE_VERSION will kick off the install event and force
+// previously cached resources to be updated from the network.
+const OFFLINE_VERSION = 1;
+const CACHE_NAME = 'offline';
+// Customize this with a different URL if needed.
+const OFFLINE_URL = 'offline.html';
+
+self.addEventListener('install', (event) => {
+  event.waitUntil(
+    (async () => {
+      const cache = await caches.open(CACHE_NAME);
+      // Setting {cache: 'reload'} in the new request will ensure that the response
+      // isn't fulfilled from the HTTP cache; i.e., it will be from the network.
+      await cache.add(new Request(OFFLINE_URL, { cache: 'reload' }));
+    })(),
+  );
+});
+
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    (async () => {
+      // Enable navigation preload if it's supported.
+      // See https://developers.google.com/web/updates/2017/02/navigation-preload
+      if ('navigationPreload' in self.registration) {
+        await self.registration.navigationPreload.enable();
+      }
+    })(),
+  );
+
+  // Tell the active service worker to take control of the page immediately.
+  self.clients.claim();
+});
+
+self.addEventListener('fetch', (event) => {
+  // We only want to call event.respondWith() if this is a navigation request
+  // for an HTML page.
+  if (event.request.mode === 'navigate') {
+    event.respondWith(
+      (async () => {
+        try {
+          // First, try to use the navigation preload response if it's supported.
+          const preloadResponse = await event.preloadResponse;
+          if (preloadResponse) {
+            return preloadResponse;
+          }
+
+          const networkResponse = await fetch(event.request);
+          return networkResponse;
+        } catch (error) {
+          // catch is only triggered if an exception is thrown, which is likely
+          // due to a network error.
+          // If fetch() returns a valid HTTP response with a response code in
+          // the 4xx or 5xx range, the catch() will NOT be called.
+          console.log('Fetch failed; returning offline page instead.', error);
+
+          const cache = await caches.open(CACHE_NAME);
+          const cachedResponse = await cache.match(OFFLINE_URL);
+          return cachedResponse;
+        }
+      })(),
+    );
+  }
+
+  // If our if() condition is false, then this fetch handler won't intercept the
+  // request. If there are any other fetch handlers registered, they will get a
+  // chance to call event.respondWith(). If no fetch handlers call
+  // event.respondWith(), the request will be handled by the browser as if there
+  // were no service worker involvement.
+});

package/src/client.build.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { Config } from './server/conf.js';
+import { ProcessController } from './server/process.js';
+import { clientLiveBuild } from './server/client-build-live.js';
+
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await clientLiveBuild();
+
+// ProcessController.init(logger);

package/src/client.dev.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { ProcessController } from './server/process.js';
+import { Config } from './server/conf.js';
+import { createClientDevServer } from './server/client-dev-server.js';
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await createClientDevServer();
+
+ProcessController.init(logger);

package/src/cron.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+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();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+// every minutes
+CronManagement.add('ip', '* * * * *', await Dns.InitIpDaemon());
+
+// every day at 1 am
+CronManagement.add('backup', '0 1 * * *', await BackUpManagement.Init());
+
+await CronManagement.init();
+
+ProcessController.init(logger);

package/src/db/DataBaseProvider.js

@@ -0,0 +1,34 @@
+import { MongooseDB } from './mongo/MongooseDB.js';
+import { loggerFactory } from '../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const DataBaseProvider = {
+  instance: {},
+  load: async function (options = { apis: [], host: '', path: '', db: {} }) {
+    try {
+      const { apis, host, path, db } = options;
+
+      if (!this.instance[`${host}${path}`]) this.instance[`${host}${path}`] = {};
+
+      if (!db || this.instance[`${host}${path}`][db.provider]) return;
+
+      // logger.info(`Load ${db.provider} provider`, `${host}${path}`);
+      switch (db.provider) {
+        case 'mongoose':
+          {
+            const conn = await MongooseDB.connect(db.host, db.name);
+            this.instance[`${host}${path}`][db.provider] = await MongooseDB.loadModels({ conn, apis });
+          }
+          break;
+        default:
+          break;
+      }
+      return this.instance[`${host}${path}`][db.provider];
+    } catch (error) {
+      logger.error(error, { error: error.stack, options });
+      return undefined;
+    }
+  },
+};
+export { DataBaseProvider };

package/src/db/mariadb/MariaDB.js

@@ -0,0 +1,33 @@
+import mariadb from 'mariadb';
+
+import { loggerFactory } from '../../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const MariaDB = {
+  query: async (options) => {
+    const { host, port, user, password, query } = options;
+    const pool = mariadb.createPool({
+      host: 'host' in options ? host : '127.0.0.1',
+      port: 'port' in options ? port : 3306,
+      user: 'user' in options ? user : 'root',
+      password: 'password' in options ? password : '',
+    });
+    let conn, result;
+    try {
+      conn = await pool.getConnection();
+      result = await conn.query(query, { supportBigNumbers: true, bigNumberStrings: true });
+      logger.info(query, result);
+    } catch (error) {
+      if (error.stack.startsWith('TypeError: Do not know how to serialize a BigInt')) return;
+      logger.error(error, error.stack);
+    } finally {
+      if (conn) conn.release(); //release to pool
+      await pool.end();
+    }
+
+    return result;
+  },
+};
+
+export { MariaDB };

package/src/db/mongo/MongooseDB.js

@@ -0,0 +1,125 @@
+import mongoose from 'mongoose';
+import cron from 'node-cron';
+import { loggerFactory } from '../../server/logger.js';
+import { getCapVariableName } from '../../client/components/core/CommonJs.js';
+import { shellCd, shellExec } from '../../server/process.js';
+
+const logger = loggerFactory(import.meta);
+
+const MongooseDB = {
+  connect: async (host, name) => {
+    const uri = `${host}/${name}`;
+    // logger.info('MongooseDB connect', { host, name, uri });
+    return await mongoose.createConnection(uri).asPromise();
+    return new Promise((resolve, reject) =>
+      mongoose
+        .connect(
+          uri,
+          // ,{
+          //   useNewUrlParser: true,
+          //   useUnifiedTopology: true,
+          // }
+        )
+        .then((db) => {
+          logger.info(`db connected`, uri);
+          return resolve(db);
+        })
+        .catch((err) => {
+          logger.error(err, { host, name, error: err.stack });
+          // return reject(err);
+          return resolve(undefined);
+        }),
+    );
+  },
+  loadModels: async function (options = { apis: ['test'], conn: new mongoose.Connection() }) {
+    const { conn, apis } = options;
+    const models = {};
+    for (const api of apis) {
+      const { ProviderSchema } = await import(`../../api/${api}/${api}.model.js`);
+      const keyModel = getCapVariableName(api);
+      models[keyModel] = conn.model(keyModel, ProviderSchema);
+    }
+
+    return models;
+  },
+  server: async function () {
+    logger.info('platform', process.platform);
+    switch (process.platform) {
+      case 'win32':
+        {
+          // https://www.mongodb.com/docs/v7.0/tutorial/install-mongodb-on-windows-unattended/
+
+          // C:\Program Files\MongoDB\Tools\100\bin
+
+          const urlDownload = `https://fastdl.mongodb.org/windows/mongodb-windows-x86_64-7.0.14-signed.msi`;
+          const folderPath = `./engine-private/setup`;
+          if (!fs.existsSync(folderPath)) fs.mkdirSync(folderPath, { recursive: true });
+          const fullPath = `${folderPath}/${urlDownload.split('/').pop()}`;
+          logger.info('destination', fullPath);
+          shellCd(folderPath);
+        }
+        break;
+      case 'linux':
+        {
+          if (!process.argv.includes('server')) {
+            logger.info('remove');
+            shellExec(`sudo apt-get purge mongodb-org*`);
+            shellExec(`sudo rm -r /var/log/mongodb`);
+            shellExec(`sudo rm -r /var/lib/mongodb`);
+            // restore lib
+            // shellExec(`sudo chown -R mongodb:mongodb /var/lib/mongodb/*`);
+
+            if (process.argv.includes('legacy')) {
+              logger.info('install legacy 4.4');
+              shellExec(`wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -`);
+
+              shellExec(
+                `echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list`,
+              );
+
+              shellExec(`sudo apt-get update`);
+
+              shellExec(
+                `sudo apt-get install mongodb-org=4.4.8 mongodb-org-server=4.4.8 mongodb-org-shell=4.4.8 mongodb-org-mongos=4.4.8 mongodb-org-tools=4.4.8`,
+              );
+            } else {
+              logger.info('install 7.0');
+              shellExec(`curl -fsSL https://www.mongodb.org/static/pgp/server-7.0.asc | \
+   sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg \
+   --dearmor`);
+              shellExec(
+                `echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list`,
+              );
+
+              shellExec(`sudo apt-get update`);
+
+              shellExec(`sudo apt-get install -y mongodb-org`);
+            }
+          }
+          logger.info('clean server environment');
+          shellExec(`sudo service mongod stop`);
+          shellExec(`sudo systemctl unmask mongod`);
+          shellExec(`sudo pkill -f mongod`);
+          shellExec(`sudo systemctl enable mongod.service`);
+          shellExec(`sudo chown -R mongodb:mongodb /var/lib/mongodb`);
+          shellExec(`sudo chown mongodb:mongodb /tmp/mongodb-27017.sock`);
+
+          logger.info('run server');
+          shellExec(`sudo service mongod restart`);
+
+          const checkStatus = () => {
+            logger.info('check status');
+            shellExec(`sudo systemctl status mongod`);
+            shellExec(`sudo systemctl --type=service | grep mongod`);
+          };
+
+          checkStatus();
+        }
+        break;
+      default:
+        break;
+    }
+  },
+};
+
+export { MongooseDB };

package/src/dns.js

@@ -0,0 +1,22 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { Dns } from './server/dns.js';
+import { ProcessController } from './server/process.js';
+import { Config } from './server/conf.js';
+
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await Dns.InitIpDaemon();
+
+ProcessController.init(logger);

package/src/index.js

@@ -0,0 +1,43 @@
+/**
+ * Underpost index npm package
+ * @module src/index.js
+ * @namespace Underpost
+ */
+
+import { loggerFactory, setUpInfo } from './server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * Underpost main module methods
+ * @class
+ * @memberof Underpost
+ */
+class Underpost {
+  constructor() {}
+
+  /**
+   * 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.
+   *
+   * @static
+   * @method setUpInfo
+   * @returns {Promise<void>}
+   * @memberof Underpost
+   */
+  static async setUpInfo() {
+    return await setUpInfo(logger);
+  }
+}
+
+const up = Underpost;
+
+const underpost = Underpost;
+
+export { underpost, up, Underpost };
+
+export default Underpost;