underpost 2.85.0 → 2.85.7

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

@@ -1,108 +1,204 @@
-const PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ? self.renderPayload.PRE_CACHED_RESOURCES : [];
-const CACHE_NAME = self.renderPayload?.CACHE_NAME ? self.renderPayload.CACHE_NAME : 'app-cache';
-const PROXY_PATH = self.renderPayload?.PROXY_PATH ? self.renderPayload.PROXY_PATH : '/';
-self.addEventListener('install', (event) => {
-  // Activate right away
-  self.skipWaiting();
-
-  event.waitUntil(
-    (async () => {
-      // Open the app's cache.
-      const cache = await caches.open(CACHE_NAME);
-      // Cache all static resources.
-      try {
-        await cache.addAll(PRE_CACHED_RESOURCES);
-      } catch (error) {
-        console.error(error);
-      }
-      // for (const cacheKey of PRE_CACHED_RESOURCES) {
-      //   try {
-      //     await cache.add(cacheKey);
-      //   } catch (error) {
-      //     console.error(error, cacheKey);
-      //   }
-      // }
-    })(),
-  );
-});
-
-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) => {
-  // Cache-First Strategy
-  event.respondWith(
-    (async () => {
-      // First, try to use the navigation preload response if it's supported.
-      try {
-        const preloadResponse = await event.preloadResponse;
-        if (preloadResponse) return preloadResponse;
-        return await fetch(event.request);
-      } catch (error) {
-        console.error('Fetch failed; returning offline page instead.', event.request.url, error);
-        // Fallback to the offline page.
-        const path = PRE_CACHED_RESOURCES.find((path) => event.request.url.match(path.replaceAll('/index.html', '')));
+/**
+ * This module provides a configurable Progressive Web App (PWA) service worker and caching strategies.
+ * It supports precaching assets, runtime caching with stale-while-revalidate strategy,
+ * and offline fallback handling.
+ * @module src/client/sw/default.sw.js
+ * @namespace PwaServiceWorker
+ */
+
+/**
+ * Class representing a Progressive Web App (PWA) Service Worker with caching strategies.
+ * @class
+ * @memberof PwaServiceWorker
+ */
+class PwaServiceWorker {
+  /**
+   * Initializes the service worker configuration by reading from self.renderPayload.
+   * If properties are not found, defaults are used.
+   * @constructor
+   * @property {Array<string>} PRE_CACHED_RESOURCES - List of resources to precache.
+   * @property {string} CACHE_NAME - Name of the cache storage.
+   * @property {string} PROXY_PATH - Base path for proxying requests.
+   */
+  constructor() {
+    // Configuration properties equivalent to the original global constants
+    this.PRE_CACHED_RESOURCES = self.renderPayload?.PRE_CACHED_RESOURCES ?? [];
+    this.CACHE_NAME = self.renderPayload?.CACHE_NAME ?? 'app-cache';
+    this.PROXY_PATH = self.renderPayload?.PROXY_PATH ?? '/';
+
+    console.log(`Service Worker Initialized. Cache: ${this.CACHE_NAME}, Proxy: ${this.PROXY_PATH}`);
+  }
 
+  /**
+   * Registers event listeners for the service worker lifecycle and requests.
+   * @method
+   * @memberof PwaServiceWorker
+   */
+  run() {
+    // Bind methods to 'this' (the instance) before attaching to self
+    self.addEventListener('install', this._onInstall.bind(this));
+    self.addEventListener('activate', this._onActivate.bind(this));
+    self.addEventListener('fetch', this._onFetch.bind(this));
+  }
+
+  /**
+   * Handles the 'install' event. Skips waiting and precaches static assets.
+   * @param {ExtendableEvent} event
+   * @memberof PwaServiceWorker
+   */
+  _onInstall(event) {
+    // Activate right away
+    self.skipWaiting();
+
+    event.waitUntil(
+      (async () => {
+        // Open the app's cache using the configured name.
+        const cache = await caches.open(this.CACHE_NAME);
+        // Cache all static resources.
         try {
-          const cachedResponse = await caches.match(event.request);
-          if (cachedResponse) return cachedResponse;
-          const cache = await caches.open(CACHE_NAME);
-          const preCachedResponse = await cache.match(path);
-          if (!preCachedResponse) throw new Error(error.message);
-          return preCachedResponse;
+          console.log(`Precaching ${this.PRE_CACHED_RESOURCES.length} resources...`);
+          await cache.addAll(this.PRE_CACHED_RESOURCES);
         } catch (error) {
-          console.error('Error opening cache for pre cached page', {
-            url: event.request.url,
-            error,
-            onLine: navigator.onLine,
-          });
-          try {
-            if (!navigator.onLine) {
-              if (event.request.method.toUpperCase() === 'GET') {
-                const cache = await caches.open(CACHE_NAME);
-                const preCachedResponse = await cache.match(
-                  `${PROXY_PATH === '/' ? '' : PROXY_PATH}/offline/index.html`,
-                );
-                if (!preCachedResponse) throw new Error(error.message);
-                return preCachedResponse;
-              }
-              const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
-              // response.status = 200;
-              response.headers.set('Content-Type', 'application/json');
-              return response;
-            }
+          console.error('Error during precaching resources:', error);
+        }
+      })(),
+    );
+  }
+
+  /**
+   * Handles the 'activate' event. Enables navigation preload and takes control
+   * of uncontrolled clients immediately.
+   * @param {ExtendableEvent} event
+   * @memberof PwaServiceWorker
+   */
+  _onActivate(event) {
+    event.waitUntil(
+      (async () => {
+        // Enable navigation preload if it's supported.
+        if ('navigationPreload' in self.registration) {
+          await self.registration.navigationPreload.enable();
+          console.log('Navigation Preload enabled.');
+        }
+      })(),
+    );
+    // Tell the active service worker to take control of the page immediately.
+    self.clients.claim();
+  }
+
+  /**
+   * Handles the 'fetch' event, implementing the Cache-First strategy with
+   * complex offline and maintenance fallbacks.
+   * @param {FetchEvent} event
+   * @memberof PwaServiceWorker
+   */
+  _onFetch(event) {
+    // Only handle HTTP/HTTPS requests that are not cross-origin (optional, but robust)
+    if (event.request.url.startsWith('http')) {
+      event.respondWith(this._handleFetchRequest(event));
+    }
+  }
+
+  /**
+   * Core logic to handle fetching, caching, and fallbacks.
+   * @param {FetchEvent} event
+   * @returns {Promise<Response>}
+   * @memberof PwaServiceWorker
+   */
+  async _handleFetchRequest(event) {
+    // 1. Try Navigation Preload (if available) or network first
+    try {
+      const preloadResponse = await event.preloadResponse;
+      if (preloadResponse) return preloadResponse;
+
+      // Fall through to network request if no preload response
+      const networkResponse = await fetch(event.request);
+
+      // OPTIONAL: If the network request is successful, cache it for future use (stale-while-revalidate logic)
+      // Omitted for strict equivalence, as original only had complex fallback, not runtime caching.
+
+      return networkResponse;
+    } catch (error) {
+      console.error('Network request failed. Attempting cache/fallback logic.', event.request.url, error);
+
+      // 2. Try to match the request in the cache
+      try {
+        const cachedResponse = await caches.match(event.request);
+        if (cachedResponse) {
+          console.log(`Cache hit for: ${event.request.url}`);
+          return cachedResponse;
+        }
+
+        // 3. Try to match a precached resource path (e.g., if requesting /page, match /page/index.html)
+        const path = this.PRE_CACHED_RESOURCES.find((p) => event.request.url.match(p.replaceAll('/index.html', '')));
+
+        if (path) {
+          const cache = await caches.open(this.CACHE_NAME);
+          const preCachedResponse = await cache.match(path);
+          if (preCachedResponse) {
+            console.log(`Matched precached resource for: ${event.request.url} via path: ${path}`);
+            return preCachedResponse;
+          }
+        }
+
+        // If neither cache match nor precache path match worked, fall through to complex fallback
+        throw new Error('Cache miss and no precache match.');
+      } catch (cacheError) {
+        console.error('Error in primary cache lookup. Falling back to offline/maintenance pages.', {
+          url: event.request.url,
+          cacheError,
+          onLine: navigator.onLine,
+        });
+
+        // 4. Complex Fallback Logic (Offline or Maintenance)
+        try {
+          const cache = await caches.open(this.CACHE_NAME);
+
+          if (!navigator.onLine) {
+            // A. OFFLINE FALLBACK
             if (event.request.method.toUpperCase() === 'GET') {
-              const cache = await caches.open(CACHE_NAME);
-              const preCachedResponse = await cache.match(
-                `${PROXY_PATH === '/' ? '' : PROXY_PATH}/maintenance/index.html`,
-              );
-              if (!preCachedResponse) throw new Error(error.message);
+              const offlinePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/offline/index.html`;
+              const preCachedResponse = await cache.match(offlinePath);
+
+              if (!preCachedResponse) throw new Error(`Offline page not found in cache: ${offlinePath}`);
+
+              console.log('Serving offline HTML page.');
               return preCachedResponse;
             }
-            const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
-            // response.status = 200;
-            response.headers.set('Content-Type', 'application/json');
-            return response;
-          } catch (error) {
-            console.error('Error opening cache for offline page', event.request.url, error);
-            const response = new Response(JSON.stringify({ status: 'error', message: error.message }));
-            // response.status = 200;
+
+            // B. OFFLINE API FALLBACK (Non-GET requests)
+            console.log('Serving offline JSON response for non-GET request.');
+            const response = new Response(JSON.stringify({ status: 'error', message: 'offline test response' }));
             response.headers.set('Content-Type', 'application/json');
             return response;
           }
+
+          // C. MAINTENANCE FALLBACK (Online, but network failed - interpreted as maintenance)
+          if (event.request.method.toUpperCase() === 'GET') {
+            const maintenancePath = `${this.PROXY_PATH === '/' ? '' : this.PROXY_PATH}/maintenance/index.html`;
+            const preCachedResponse = await cache.match(maintenancePath);
+
+            if (!preCachedResponse) throw new Error(`Maintenance page not found in cache: ${maintenancePath}`);
+
+            console.log('Serving maintenance HTML page.');
+            return preCachedResponse;
+          }
+
+          // D. MAINTENANCE API FALLBACK (Non-GET requests)
+          console.log('Serving maintenance JSON response for non-GET request.');
+          const response = new Response(JSON.stringify({ status: 'error', message: 'server in maintenance' }));
+          response.headers.set('Content-Type', 'application/json');
+          return response;
+        } catch (finalError) {
+          // 5. Final fail-safe response
+          console.error('Final fail-safe execution failed.', event.request.url, finalError);
+          const response = new Response(JSON.stringify({ status: 'error', message: finalError.message }));
+          response.headers.set('Content-Type', 'application/json');
+          return response;
         }
       }
-    })(),
-  );
-});
+    }
+  }
+}
+
+// Instantiate and run the service worker class
+new PwaServiceWorker().run();

package/src/client.dev.js

@@ -15,7 +15,7 @@ const logger = loggerFactory(import.meta);
 
 await logger.setUpInfo();
 
-await buildClientStaticConf();
+await buildClientStaticConf({ devProxy: process.argv[6] === 'proxy' });
 
 await Config.build();
 

package/src/index.js

@@ -35,7 +35,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.85.0';
+  static version = 'v2.85.7';
   /**
    * Repository cli API
    * @static

package/src/proxy.js

@@ -11,7 +11,7 @@ import { Config } from './server/conf.js';
 
 dotenv.config();
 
-await Config.build();
+await Config.build(process.argv[2], process.argv[3], process.argv[4]);
 
 const logger = loggerFactory(import.meta);
 

package/src/runtime/express/Express.js

@@ -23,6 +23,7 @@ import { applySecurity, authMiddlewareFactory } from '../../server/auth.js';
 import { ssrMiddlewareFactory } from '../../server/ssr.js';
 import { TLS } from '../../server/tls.js';
 import { shellExec } from '../../server/process.js';
+import { devProxyHostFactory, isDevProxyContext, isTlsDevProxy } from '../../server/conf.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -94,7 +95,9 @@ class ExpressService {
 
     const app = express();
 
-    if (process.env.NODE_ENV === 'production') app.set('trust proxy', true);
+    if (origins && isDevProxyContext())
+      origins.push(devProxyHostFactory({ host, includeHttp: true, tls: isTlsDevProxy() }));
+    app.set('trust proxy', true);
 
     app.use((req, res, next) => {
       res.on('finish', () => {

package/src/server/auth.js

@@ -17,6 +17,7 @@ import slowDown from 'express-slow-down';
 import cors from 'cors';
 import cookieParser from 'cookie-parser';
 import { DataBaseProvider } from '../db/DataBaseProvider.js';
+import { isDevProxyContext } from './conf.js';
 
 dotenv.config();
 const logger = loggerFactory(import.meta);
@@ -348,7 +349,7 @@ const cookieOptionsFactory = (req, host) => {
     secure,
     sameSite,
     path: '/',
-    domain: process.env.NODE_ENV === 'production' ? host : 'localhost',
+    domain: process.env.NODE_ENV === 'production' || isDevProxyContext() ? host : 'localhost',
     maxAge,
   };
 

package/src/server/conf.js

@@ -66,11 +66,11 @@ const Config = {
   /**
    * @method deployIdFactory
    * @description Creates a new deploy ID.
-   * @param {string} [deployId='dd-default'] - The deploy ID.
-   * @param {object} [options={ cluster: false }] - The options.
+   * @param {string} [deployId='dd-default
+   * @param {object} [options={ subConf: '', cluster: false }] - The options.
    * @memberof ServerConfBuilder
    */
-  deployIdFactory: function (deployId = 'dd-default', options = { cluster: false }) {
+  deployIdFactory: function (deployId = 'dd-default', options = { subConf: '', cluster: false }) {
     if (!deployId.startsWith('dd-')) deployId = `dd-${deployId}`;
 
     logger.info('Build deployId', deployId);
@@ -102,6 +102,17 @@ const Config = {
 
     this.buildTmpConf(folder);
 
+    if (options.subConf) {
+      logger.info('Creating sub conf', {
+        deployId: deployId,
+        subConf: options.subConf,
+      });
+      fs.copySync(
+        `./engine-private/conf/${deployId}/conf.server.json`,
+        `./engine-private/conf/${deployId}/conf.server.dev.${options.subConf}.json`,
+      );
+    }
+
     if (options.cluster === true) {
       fs.writeFileSync(
         `./.github/workflows/${repoName}.cd.yml`,
@@ -640,6 +651,8 @@ const buildProxyRouter = () => {
     for (const path of Object.keys(confServer[host])) {
       if (confServer[host][path].singleReplica) continue;
 
+      if (isDevProxyContext()) confServer[host][path].proxy = [isTlsDevProxy() ? 443 : 80];
+
       confServer[host][path].port = newInstance(currentPort);
       for (const port of confServer[host][path].proxy) {
         if (!(port in proxyRouter)) proxyRouter[port] = {};
@@ -784,14 +797,21 @@ const buildKindPorts = (from, to) =>
 /**
  * @method buildPortProxyRouter
  * @description Builds the port proxy router.
- * @param {number} port - The port.
- * @param {object} proxyRouter - The proxy router.
- * @param {object} [options={ orderByPathLength: false }] - The options.
+ * @param {object} options - The options.
+ * @param {number} [options.port=4000] - The port.
+ * @param {object} options.proxyRouter - The proxy router.
+ * @param {object} [options.hosts] - The hosts.
+ * @param {boolean} [options.orderByPathLength=false] - Whether to order by path length.
+ * @param {boolean} [options.devProxyContext=false] - Whether to use dev proxy context.
  * @returns {object} - The port proxy router.
  * @memberof ServerConfBuilder
  */
-const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength: false }) => {
-  const hosts = proxyRouter[port];
+const buildPortProxyRouter = (
+  options = { port: 4000, proxyRouter, hosts, orderByPathLength: false, devProxyContext: false },
+) => {
+  let { port, proxyRouter, hosts, orderByPathLength } = options;
+  hosts = hosts || proxyRouter[port] || {};
+
   const router = {};
   // build router
   Object.keys(hosts).map((hostKey) => {
@@ -804,7 +824,7 @@ const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength:
         return;
       }
     }
-
+    // ${process.env.NODE_ENV === 'development' && !isDevProxyContext() ? `:${port}` : ''}
     const absoluteHost = [80, 443].includes(port)
       ? `${host}${path === '/' ? '' : path}`
       : `${host}:${port}${path === '/' ? '' : path}`;
@@ -812,12 +832,48 @@ const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength:
     if (absoluteHost in router)
       logger.warn('Overwrite: Absolute host already exists on router', { absoluteHost, target });
 
-    router[absoluteHost] = target;
+    if (options.devProxyContext === true) {
+      const appDevPort = parseInt(target.split(':')[2]) - process.env.DEV_PROXY_PORT_OFFSET;
+      router[absoluteHost] = `http://localhost:${appDevPort}`;
+    } else router[absoluteHost] = target;
   }); // order router
 
   if (Object.keys(router).length === 0) return router;
 
-  if (options.orderByPathLength === true) {
+  if (options.devProxyContext === true && process.env.NODE_ENV === 'development') {
+    const confDevApiServer = JSON.parse(
+      fs.readFileSync(`./engine-private/conf/${process.argv[3]}/conf.server.dev.${process.argv[4]}-dev-api.json`),
+      'utf8',
+    );
+    let devApiHosts = [];
+    let origins = [];
+    for (const _host of Object.keys(confDevApiServer))
+      for (const _path of Object.keys(confDevApiServer[_host])) {
+        if (confDevApiServer[_host][_path].origins && confDevApiServer[_host][_path].origins.length) {
+          origins.push(...confDevApiServer[_host][_path].origins);
+          if (_path !== 'peer' && devApiHosts.length === 0)
+            devApiHosts.push(
+              `${_host}${[80, 443].includes(port) && isDevProxyContext() ? '' : `:${port}`}${_path == '/' ? '' : _path}`,
+            );
+        }
+      }
+    origins = Array.from(new Set(origins));
+    console.log({
+      origins,
+      devApiHosts,
+    });
+    for (const devApiHost of devApiHosts) {
+      if (devApiHost in router) {
+        const target = router[devApiHost];
+        delete router[devApiHost];
+        router[`${devApiHost}/${process.env.BASE_API}`] = target;
+        router[`${devApiHost}/socket.io`] = target;
+        for (const origin of origins) router[devApiHost] = origin;
+      }
+    }
+  }
+
+  if (orderByPathLength === true) {
     const reOrderRouter = {};
     for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
       reOrderRouter[absoluteHostKey] = router[absoluteHostKey];
@@ -1409,11 +1465,14 @@ const buildApiConf = async (options = { deployId: '', subConf: '', host: '', pat
  * @param {string} options.apiBaseHost - The API base host.
  * @param {string} options.host - The host.
  * @param {string} options.path - The path.
+ * @param {boolean} options.devProxy - The dev proxy flag.
  * @returns {void}
  * @memberof ServerConfBuilder
  */
-const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '' }) => {
-  let { deployId, subConf, host, path } = options;
+const buildClientStaticConf = async (
+  options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '', devProxy: false },
+) => {
+  let { deployId, subConf, host, path, devProxy } = options;
   if (!deployId) deployId = process.argv[2].trim();
   if (!subConf) subConf = process.argv[3].trim();
   if (!host) host = process.argv[4].trim();
@@ -1425,10 +1484,14 @@ const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiB
     fs.readFileSync(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-api`, 'utf8'),
   );
   envObj.PORT = parseInt(envObj.PORT);
-  const apiBaseHost = options?.apiBaseHost ? options.apiBaseHost : `localhost:${envObj.PORT + 1}`;
+  const apiBaseHost = devProxy
+    ? devProxyHostFactory({ host, tls: isTlsDevProxy() })
+    : options?.apiBaseHost
+      ? options.apiBaseHost
+      : `localhost:${envObj.PORT + 1}`;
   confServer[host][path].apiBaseHost = apiBaseHost;
   confServer[host][path].apiBaseProxyPath = path;
-  logger.info('Build client static conf', { host, path, apiBaseHost });
+  logger.warn('Build client static conf', { host, path, apiBaseHost });
   envObj.PORT = parseInt(confServer[host][path].origins[0].split(':')[2]) - 1;
   writeEnv(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client`, envObj);
   fs.writeFileSync(
@@ -1448,6 +1511,56 @@ const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiB
  */
 const isDeployRunnerContext = (path, options) => !options.build && path && path !== 'template-deploy';
 
+/**
+ * @method isDevProxyContext
+ * @description Checks if the dev proxy context is valid.
+ * @returns {boolean} - The dev proxy context.
+ * @memberof ServerConfBuilder
+ */
+const isDevProxyContext = () => {
+  try {
+    if (process.argv[2] === 'proxy') return true;
+    if (!process.argv[6].startsWith('localhost')) return false;
+    return new URL('http://' + process.argv[6]).hostname ? true : false;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * @method devProxyHostFactory
+ * @description Creates the dev proxy host.
+ * @param {object} options - The options.
+ * @param {string} [options.host='default.net'] - The host.
+ * @param {boolean} [options.includeHttp=false] - Whether to include HTTP.
+ * @param {number} [options.port=443] - The port.
+ * @param {boolean} [options.tls=false] - Whether to use TLS.
+ * @returns {string} - The dev proxy host.
+ * @memberof ServerConfBuilder
+ */
+const devProxyHostFactory = (options = { host: 'default.net', includeHttp: false, port: 80, tls: false }) =>
+  `${options.includeHttp ? (options.tls ? 'https://' : 'http://') : ''}${options.host ? options.host : 'localhost'}:${
+    (options.port ? options.port : options.tls ? 443 : 80) + parseInt(process.env.DEV_PROXY_PORT_OFFSET)
+  }`;
+
+/**
+ * @method isTlsDevProxy
+ * @description Checks if TLS is used in the dev proxy.
+ * @returns {boolean} - The TLS dev proxy status.
+ * @memberof ServerConfBuilder
+ */
+const isTlsDevProxy = () => process.env.NODE_ENV !== 'production' && process.argv[7] === 'tls';
+
+/**
+ * @method getTlsHosts
+ * @description Gets the TLS hosts.
+ * @param {object} confServer - The server configuration.
+ * @returns {Array} - The TLS hosts.
+ * @memberof ServerConfBuilder
+ */
+const getTlsHosts = (confServer) =>
+  Array.from(new Set(Object.keys(confServer).map((h) => new URL('https://' + h).hostname)));
+
 export {
   Cmd,
   Config,
@@ -1484,4 +1597,8 @@ export {
   buildApiConf,
   buildClientStaticConf,
   isDeployRunnerContext,
+  isDevProxyContext,
+  devProxyHostFactory,
+  isTlsDevProxy,
+  getTlsHosts,
 };