underpost 2.85.0 → 2.85.7

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