underpost 2.85.1 → 2.85.7

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,
 };

package/src/server/proxy.js

@@ -11,9 +11,12 @@ import dotenv from 'dotenv';
 
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
-import { TLS } from './tls.js';
-import { buildPortProxyRouter, buildProxyRouter } from './conf.js';
+import { buildPortProxyRouter, buildProxyRouter, getTlsHosts, isDevProxyContext, isTlsDevProxy } from './conf.js';
 import UnderpostStartUp from './start.js';
+import UnderpostDeploy from '../cli/deploy.js';
+import { SSL_BASE, TLS } from './tls.js';
+import { shellExec } from './process.js';
+import fs from 'fs-extra';
 
 dotenv.config();
 
@@ -22,28 +25,27 @@ const logger = loggerFactory(import.meta);
 /**
  * Main class for building and running the proxy server.
  * All utility methods are implemented as static to serve as a namespace container.
- * @class Proxy
- * @augments Proxy
+ * @class ProxyService
  * @memberof ProxyService
  */
-class Proxy {
+class ProxyService {
   /**
-   * Initializes and starts the reverse proxy server for all configured ports and hosts.
-   * @async
+   * Builds and starts the proxy server with appropriate routing and SSL configuration.
    * @static
-   * @memberof ProxyService
-   * @returns {Promise<void>}
-   * @memberof ProxyService
+   * @returns {Promise<void>} Resolves when the server is successfully started.
    */
-  static async buildProxy() {
+  static async build() {
+    if (process.env.NODE_ENV === 'production') process.env.DEV_PROXY_PORT_OFFSET = 0;
+
     // Start a default Express listener on process.env.PORT (potentially unused, but ensures Express is initialized)
+    process.env.PORT = parseInt(process.env.PORT) + parseInt(process.env.DEV_PROXY_PORT_OFFSET);
     express().listen(process.env.PORT);
 
     const proxyRouter = buildProxyRouter();
 
     for (let port of Object.keys(proxyRouter)) {
-      port = parseInt(port);
       const hosts = proxyRouter[port];
+      port = parseInt(port) + parseInt(process.env.DEV_PROXY_PORT_OFFSET);
       const proxyPath = '/';
       const proxyHost = 'localhost';
       const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
@@ -56,19 +58,22 @@ class Proxy {
       /** @type {import('http-proxy-middleware/dist/types').Options} */
       const options = {
         ws: true, // Enable websocket proxying
-        target: `http://localhost:${process.env.PORT}`, // Default target (should be overridden by router)
+        target: `http://localhost:${parseInt(process.env.PORT - 1)}`, // Default target (should be overridden by router)
         router: {},
+        // changeOrigin: true,
+        logLevel: 'debug',
         xfwd: true, // Adds x-forward headers (Host, Proto, etc.)
-        onProxyReq: (proxyReq, req, res, options) => {
-          // Use the static method from the TLS class for redirection logic
-          TLS.sslRedirectMiddleware(req, res, port, proxyRouter);
-        },
-        pathRewrite: {
-          // Add path rewrite rules here if necessary
-        },
+        onProxyReq: (proxyReq, req, res, options) => {},
+        pathRewrite: {},
       };
 
-      options.router = buildPortProxyRouter(port, proxyRouter, { orderByPathLength: true });
+      options.router = buildPortProxyRouter({
+        port,
+        proxyRouter,
+        hosts,
+        orderByPathLength: true,
+        devProxyContext: process.env.NODE_ENV !== 'production',
+      });
 
       const filter = proxyPath; // Use '/' as the general filter
       app.use(proxyPath, createProxyMiddleware(filter, options));
@@ -91,11 +96,33 @@ class Proxy {
           break;
 
         default:
-          // In non-production, always use standard HTTP listener
-          await UnderpostStartUp.API.listenPortController(app, port, runningData);
-          break;
+          switch (port) {
+            case 443: {
+              let tlsHosts = hosts;
+              if (isDevProxyContext() && isTlsDevProxy()) {
+                tlsHosts = {};
+                for (const tlsHost of getTlsHosts(hosts)) {
+                  if (fs.existsSync(SSL_BASE(tlsHost))) fs.removeSync(SSL_BASE(tlsHost));
+                  if (!TLS.validateSecureContext(tlsHost)) shellExec(`node bin/deploy tls "${tlsHost}"`);
+                  tlsHosts[tlsHost] = {};
+                }
+              }
+              const { ServerSSL } = await TLS.createSslServer(app, tlsHosts);
+              await UnderpostStartUp.API.listenPortController(ServerSSL, port, runningData);
+              break;
+            }
+            default: // In non-production, always use standard HTTP listener
+              await UnderpostStartUp.API.listenPortController(app, port, runningData);
+              break;
+          }
       }
       logger.info('Proxy running', { port, options });
+      if (process.env.NODE_ENV === 'development')
+        logger.info(
+          UnderpostDeploy.API.etcHostFactory(Object.keys(options.router), {
+            append: true,
+          }).renderHosts,
+        );
     }
   }
 }
@@ -105,6 +132,6 @@ class Proxy {
  * @type {function(): Promise<void>}
  * @memberof ProxyService
  */
-const buildProxy = Proxy.buildProxy;
+const buildProxy = ProxyService.build;
 
-export { Proxy, buildProxy };
+export { ProxyService, buildProxy };

package/src/server/start.js

@@ -53,7 +53,7 @@ class UnderpostStartUp {
               throw new Error(message);
             }
           }, msDelta);
-          return logic ? await logic(...args) : undefined, args[1]();
+          return (logic ? await logic(...args) : undefined, args[1]());
         },
       };
     },
@@ -95,8 +95,8 @@ class UnderpostStartUp {
                 port === 80
                   ? `http://${host}${path}`
                   : port === 443
-                  ? `https://${host}${path}`
-                  : `http://${host}:${port}${path}`,
+                    ? `https://${host}${path}`
+                    : `http://${host}:${port}${path}`,
               local: `http://localhost:${port}${path}`,
               apis: metadata.apis,
             };
@@ -158,4 +158,14 @@ class UnderpostStartUp {
   };
 }
 
+/**
+ * Creates a keep-alive process to maintain server activity.
+ * @memberof UnderpostStartUp
+ * @returns
+ */
+const createKeepAliveProcess = async () =>
+  await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), ':');
+
 export default UnderpostStartUp;
+
+export { createKeepAliveProcess, UnderpostStartUp };

package/src/server/tls.js

@@ -248,4 +248,4 @@ const validateSecureContext = TLS.validateSecureContext;
 const createSslServer = TLS.createSslServer;
 const sslRedirectMiddleware = TLS.sslRedirectMiddleware;
 
-export { TLS, buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };
+export { TLS, SSL_BASE, buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };