underpost 2.8.883 → 2.8.885

package/src/server/client-dev-server.js

@@ -2,17 +2,26 @@ import fs from 'fs-extra';
 import nodemon from 'nodemon';
 import { shellExec } from './process.js';
 import { loggerFactory } from './logger.js';
+import { writeEnv } from './conf.js';
+import dotenv from 'dotenv';
 
 const logger = loggerFactory(import.meta);
 
-const createClientDevServer = () => {
-  // process.argv.slice(2).join(' ')
-  shellExec(`env-cmd -f .env.development node bin/deploy build-full-client ${process.argv.slice(2).join(' ')}`);
+const createClientDevServer = (
+  deployId = process.argv[2] || 'dd-default',
+  subConf = process.argv[3] || '',
+  host = process.argv[4] || 'default.net',
+  path = process.argv[5] || '/',
+) => {
   shellExec(
-    `env-cmd -f .env.development node src/api ${process.argv[2]}${process.argv[5] ? ` ${process.argv[5]}` : ''}${
-      process.argv.includes('static') ? ' static' : ''
-    }`,
-    { async: true },
+    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node bin/deploy build-full-client ${deployId} ${subConf}-dev-client ${host} ${path}`.trim(),
+  );
+
+  shellExec(
+    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node src/server ${deployId} ${subConf}-dev-client`.trim(),
+    {
+      async: true,
+    },
   );
 
   // https://github.com/remy/nodemon/blob/main/doc/events.md
@@ -28,7 +37,11 @@ const createClientDevServer = () => {
 
   let buildPathScope = [];
 
-  const nodemonOptions = { script: './src/client.build', args: process.argv.slice(2), watch: 'src/client' };
+  const nodemonOptions = {
+    script: './src/client.build',
+    args: [`${deployId}`, `${subConf}-dev-client`, `${host}`, `${path}`],
+    watch: 'src/client',
+  };
   logger.info('nodemon option', { nodemonOptions });
   nodemon(nodemonOptions)
     .on('start', function (...args) {

package/src/server/conf.js

@@ -25,13 +25,14 @@ const logger = loggerFactory(import.meta);
 const Config = {
   default: DefaultConf,
   build: async function (deployContext = 'dd-default', deployList, subConf) {
-    if (typeof process.argv[2] === 'string' && process.argv[2].startsWith('dd-')) deployContext = process.argv[2];
+    if (process.argv[2] && typeof process.argv[2] === 'string' && process.argv[2].startsWith('dd-'))
+      deployContext = process.argv[2];
+    if (!subConf && process.argv[3] && typeof process.argv[3] === 'string') subConf = process.argv[3];
     if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
     UnderpostRootEnv.API.set('await-deploy', new Date().toISOString());
-    if (fs.existsSync(`./engine-private/replica/${deployContext}`))
-      return loadConf(deployContext, process.env.NODE_ENV, subConf);
-    else if (deployContext.startsWith('dd-')) return loadConf(deployContext, process.env.NODE_ENV, subConf);
-    if (deployContext === 'proxy') Config.buildProxy(deployContext, deployList, subConf);
+    if (fs.existsSync(`./engine-private/replica/${deployContext}`)) return loadConf(deployContext, subConf);
+    else if (deployContext.startsWith('dd-')) return loadConf(deployContext, subConf);
+    if (deployContext === 'proxy') Config.buildProxy(deployList, subConf);
   },
   deployIdFactory: function (deployId = 'dd-default', options = { cluster: false }) {
     if (!deployId.startsWith('dd-')) deployId = `dd-${deployId}`;
@@ -105,7 +106,7 @@ const Config = {
     for (const confType of Object.keys(this.default))
       fs.writeFileSync(`${folder}/conf.${confType}.json`, JSON.stringify(this.default[confType], null, 4), 'utf8');
   },
-  buildProxy: function (deployContext = 'dd-default', deployList, subConf) {
+  buildProxy: function (deployList = 'dd-default', subConf = '') {
     if (!deployList) deployList = process.argv[3];
     if (!subConf) subConf = process.argv[4];
     this.default.server = {};
@@ -121,7 +122,7 @@ const Config = {
       if (process.env.NODE_ENV === 'development' && fs.existsSync(confDevPath)) confPath = confDevPath;
       const serverConf = JSON.parse(fs.readFileSync(confPath, 'utf8'));
 
-      for (const host of Object.keys(loadReplicas(serverConf, deployContext, subConf))) {
+      for (const host of Object.keys(loadReplicas(serverConf))) {
         if (serverConf[host]['/'])
           this.default.server[host] = {
             ...this.default.server[host],
@@ -138,13 +139,13 @@ const Config = {
   },
 };
 
-const loadConf = (deployId = 'dd-default', envInput, subConf) => {
+const loadConf = (deployId = 'dd-default', subConf) => {
   if (deployId === 'current') {
     console.log(process.env.DEPLOY_ID);
     return;
   }
   if (deployId === 'clean') {
-    const path = envInput ?? '.';
+    const path = '.';
     fs.removeSync(`${path}/.env`);
     shellExec(`git checkout ${path}/.env.production`);
     shellExec(`git checkout ${path}/.env.development`);
@@ -164,7 +165,6 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   for (const typeConf of Object.keys(Config.default)) {
     let srcConf = fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8');
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
-      if (!subConf) subConf = process.argv[3];
       const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
       if (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
     }
@@ -174,10 +174,13 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   fs.writeFileSync(`./.env.production`, fs.readFileSync(`${folder}/.env.production`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.development`, fs.readFileSync(`${folder}/.env.development`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.test`, fs.readFileSync(`${folder}/.env.test`, 'utf8'), 'utf8');
-  const NODE_ENV = envInput || process.env.NODE_ENV;
+  const NODE_ENV = process.env.NODE_ENV;
   if (NODE_ENV) {
-    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'), 'utf8');
-    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'));
+    const subPathEnv = fs.existsSync(`${folder}/.env.${NODE_ENV}.${subConf}`)
+      ? `${folder}/.env.${NODE_ENV}.${subConf}`
+      : `${folder}/.env.${NODE_ENV}`;
+    fs.writeFileSync(`./.env`, fs.readFileSync(subPathEnv, 'utf8'), 'utf8');
+    const env = dotenv.parse(fs.readFileSync(subPathEnv, 'utf8'));
     process.env = {
       ...process.env,
       ...env,
@@ -191,22 +194,16 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   return { folder, deployId };
 };
 
-const loadReplicas = (confServer, deployContext, subConf) => {
-  if (!deployContext) deployContext = process.argv[2];
-  if (!subConf) subConf = process.argv[3];
+const loadReplicas = (confServer) => {
   for (const host of Object.keys(confServer)) {
     for (const path of Object.keys(confServer[host])) {
       const { replicas, singleReplica } = confServer[host][path];
-      if (
-        replicas &&
-        (deployContext === 'proxy' ||
-          !singleReplica ||
-          (singleReplica && process.env.NODE_ENV === 'development' && !subConf))
-      )
+      if (replicas && !singleReplica)
         for (const replicaPath of replicas) {
-          confServer[host][replicaPath] = newInstance(confServer[host][path]);
-          delete confServer[host][replicaPath].replicas;
-          delete confServer[host][replicaPath].singleReplica;
+          {
+            confServer[host][replicaPath] = newInstance(confServer[host][path]);
+            delete confServer[host][replicaPath].replicas;
+          }
         }
     }
   }
@@ -982,6 +979,60 @@ const getInstanceContext = async (options = { singleReplica, replicas, redirect:
   return { redirectTarget };
 };
 
+const buildApiConf = async (options = { deployId: '', subConf: '', host: '', path: '', origin: '' }) => {
+  let { deployId, subConf, host, path, origin } = options;
+  if (!deployId) deployId = process.argv[2].trim();
+  if (!subConf) subConf = process.argv[3].trim();
+  if (process.argv[4]) host = process.argv[4].trim();
+  if (process.argv[5]) path = process.argv[5].trim();
+  if (process.argv[6])
+    origin = `${process.env.NODE_ENV === 'production' ? 'https' : 'http'}://${process.argv[6].trim()}`;
+
+  if (!origin) return;
+  const confServer = JSON.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`, 'utf8'),
+  );
+  const envObj = dotenv.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}`, 'utf8'),
+  );
+  if (host && path) {
+    confServer[host][path].origins = [origin];
+    logger.info('Build api conf', { host, path, origin });
+  } else return;
+  writeEnv(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-api`, envObj);
+  fs.writeFileSync(
+    `./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-api.json`,
+    JSON.stringify(confServer, null, 4),
+    'utf8',
+  );
+};
+
+const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '' }) => {
+  let { deployId, subConf, host, path } = options;
+  if (!deployId) deployId = process.argv[2].trim();
+  if (!subConf) subConf = process.argv[3].trim();
+  if (!host) host = process.argv[4].trim();
+  if (!path) path = process.argv[5].trim();
+  const confServer = JSON.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-api.json`, 'utf8'),
+  );
+  const envObj = dotenv.parse(
+    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}`;
+  confServer[host][path].apiBaseHost = apiBaseHost;
+  confServer[host][path].apiBaseProxyPath = path;
+  logger.info('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(
+    `./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-client.json`,
+    JSON.stringify(confServer, null, 4),
+    'utf8',
+  );
+};
+
 export {
   Cmd,
   Config,
@@ -1015,4 +1066,6 @@ export {
   rebuildConfFactory,
   buildCliDoc,
   getInstanceContext,
+  buildApiConf,
+  buildClientStaticConf,
 };

package/src/server/peer.js

@@ -48,7 +48,7 @@ const logger = loggerFactory(import.meta);
  */
 const createPeerServer = async ({ port, devPort, origins, host, path }) => {
   if (process.env.NODE_ENV === 'development' && devPort) {
-    logger.warn(`Adding development origin: http://localhost:${devPort}`);
+    // logger.warn(`Adding development origin: http://localhost:${devPort}`);
     origins.push(`http://localhost:${devPort}`);
   }
 
@@ -67,7 +67,7 @@ const createPeerServer = async ({ port, devPort, origins, host, path }) => {
   };
 
   // Use the framework's factory to listen on the server, ensuring graceful startup/shutdown
-  const peerServer = UnderpostStartUp.API.listenServerFactory(() => PeerServer(options));
+  const peerServer = UnderpostStartUp.API.listenServerFactory(async () => PeerServer(options));
 
   return { options, peerServer, meta: import.meta };
 };

package/src/server/runtime.js

@@ -1,31 +1,37 @@
+/**
+ * @namespace Runtime
+ * @description The main runtime orchestrator responsible for reading configuration,
+ * initializing services (Prometheus, Ports, DB, Mailer), and building the
+ * specific server runtime for each host/path (e.g., nodejs, lampp).
+ */
+
 import fs from 'fs-extra';
-import express from 'express';
 import dotenv from 'dotenv';
-import fileUpload from 'express-fileupload';
-import swaggerUi from 'swagger-ui-express';
 import * as promClient from 'prom-client';
-import compression from 'compression';
 
 import UnderpostStartUp from './start.js';
-import { createServer } from 'http';
-import { loggerFactory, loggerMiddleware } from './logger.js';
-import { getCapVariableName, newInstance } from '../client/components/core/CommonJs.js';
-import { MailerProvider } from '../mailer/MailerProvider.js';
-import { DataBaseProvider } from '../db/DataBaseProvider.js';
-import { createPeerServer } from './peer.js';
+import { loggerFactory } from './logger.js';
+import { newInstance } from '../client/components/core/CommonJs.js';
 import { Lampp } from '../runtime/lampp/Lampp.js';
-import { createValkeyConnection } from './valkey.js';
-import { applySecurity, authMiddlewareFactory } from './auth.js';
 import { getInstanceContext } from './conf.js';
-import { ssrMiddlewareFactory } from './ssr.js';
+
+import ExpressService from '../runtime/express/Express.js';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * Reads server configurations, sets up Prometheus metrics, and iterates through
+ * all defined hosts and paths to build and start the corresponding runtime instances.
+ *
+ * @memberof Runtime
+ * @returns {Promise<void>}
+ */
 const buildRuntime = async () => {
   const deployId = process.env.DEPLOY_ID;
 
+  // 1. Initialize Prometheus Metrics
   const collectDefaultMetrics = promClient.collectDefaultMetrics;
   collectDefaultMetrics();
 
@@ -38,12 +44,17 @@ const buildRuntime = async () => {
   const requestCounter = new promClient.Counter(promCounterOption);
   const initPort = parseInt(process.env.PORT) + 1;
   let currentPort = initPort;
+
+  // 2. Load Configuration
   const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
   const confSSR = JSON.parse(fs.readFileSync(`./conf/conf.ssr.json`, 'utf8'));
   const singleReplicaHosts = [];
+
+  // 3. Iterate through hosts and paths
   for (const host of Object.keys(confServer)) {
     if (singleReplicaHosts.length > 0)
       currentPort += singleReplicaHosts.reduce((accumulator, currentValue) => accumulator + currentValue.replicas, 0);
+
     const rootHostPath = `/public/${host}`;
     for (const path of Object.keys(confServer[host])) {
       confServer[host][path].port = newInstance(currentPort);
@@ -65,6 +76,7 @@ const buildRuntime = async () => {
         apiBaseHost,
       } = confServer[host][path];
 
+      // Calculate context data
       const { redirectTarget, singleReplicaHost } = await getInstanceContext({
         redirect,
         singleReplicaHosts,
@@ -91,203 +103,32 @@ const buildRuntime = async () => {
 
       switch (runtime) {
         case 'nodejs':
-          const app = express();
-
-          app.use((req, res, next) => {
-            // const info = `${req.headers.host}${req.url}`;
-            return next();
-          });
-
-          if (process.env.NODE_ENV === 'production') app.set('trust proxy', true);
-
-          app.use((req, res, next) => {
-            requestCounter.inc({
-              instance: `${host}:${port}${path}`,
-              method: req.method,
-              status_code: res.statusCode,
-            });
-            // decodeURIComponent(req.url)
-            return next();
-          });
-
-          app.get(`${path === '/' ? '' : path}/metrics`, async (req, res) => {
-            res.set('Content-Type', promClient.register.contentType);
-            return res.end(await promClient.register.metrics());
-          });
-
-          // set logger
-          app.use(loggerMiddleware(import.meta));
-
-          // js src compression
-          app.use(compression({ filter: shouldCompress }));
-          function shouldCompress(req, res) {
-            if (req.headers['x-no-compression']) {
-              // don't compress responses with this request header
-              return false;
-            }
-
-            // fallback to standard filter function
-            return compression.filter(req, res);
-          }
-
-          // parse requests of content-type - application/json
-          app.use(express.json({ limit: '100MB' }));
-
-          // parse requests of content-type - application/x-www-form-urlencoded
-          app.use(express.urlencoded({ extended: true, limit: '20MB' }));
-
-          // file upload middleware
-          app.use(fileUpload());
-
-          // json formatted response
-          if (process.env.NODE_ENV === 'development') app.set('json spaces', 2);
-
-          // lang handling middleware
-          app.use(function (req, res, next) {
-            const lang = req.headers['accept-language'] || 'en';
-            if (typeof lang === 'string' && lang.toLowerCase().match('es')) {
-              req.lang = 'es';
-            } else req.lang = 'en';
-            return next();
+          logger.info('Build nodejs server runtime', `${host}${path}:${port}`);
+
+          const { portsUsed } = await ExpressService.createApp({
+            host,
+            path,
+            port,
+            client,
+            apis,
+            origins,
+            directory,
+            ws,
+            mailer,
+            db,
+            redirect,
+            peer,
+            valkey,
+            apiBaseHost,
+            redirectTarget,
+            rootHostPath,
+            confSSR,
+            promRequestCounter: requestCounter,
+            promRegister: promClient.register,
           });
 
-          // instance public static
-          app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
-          if (process.argv.includes('static')) {
-            logger.info('Build static server runtime', `${host}${path}`);
-            currentPort += 2;
-            const staticPort = newInstance(currentPort);
-            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
-            currentPort++;
-            continue;
-          }
-
-          // Flag swagger requests before security middleware is applied
-          const swaggerJsonPath = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
-          const swaggerPath = `${path === '/' ? `/api-docs` : `${path}/api-docs`}`;
-          if (fs.existsSync(swaggerJsonPath))
-            app.use(swaggerPath, (req, res, next) => {
-              res.locals.isSwagger = true;
-              next();
-            });
-
-          // security
-          applySecurity(app, {
-            origin: origins.concat(
-              apis && process.env.NODE_ENV === 'development' ? [`http://localhost:${currentPort + 2}`] : [],
-            ),
-          });
-
-          if (redirect) {
-            app.use(function (req = express.Request, res = express.Response, next = express.NextFunction) {
-              if (process.env.NODE_ENV === 'production' && !req.url.startsWith(`/.well-known/acme-challenge`))
-                return res.status(302).redirect(redirectTarget + req.url);
-              // if (!req.url.startsWith(`/.well-known/acme-challenge`)) return res.status(302).redirect(redirect);
-              return next();
-            });
-            // app.use(
-            //   '*',
-            //   createProxyMiddleware({
-            //     target: redirect,
-            //     changeOrigin: true,
-            //   }),
-            // );
-
-            await UnderpostStartUp.API.listenPortController(app, port, runningData);
-            break;
-          }
-          // instance server
-          const server = createServer({}, app);
-          if (peer) currentPort++;
-
-          if (!apiBaseHost) {
-            if (fs.existsSync(swaggerJsonPath)) {
-              const swaggerInstance =
-                (swaggerDoc) =>
-                (...args) =>
-                  swaggerUi.setup(swaggerDoc)(...args);
-              const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
-              const swaggerPath = `${path === '/' ? `/api-docs` : `${path}/api-docs`}`;
-              app.use(swaggerPath, swaggerUi.serve, swaggerInstance(swaggerDoc));
-            }
-
-            if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
-
-            // valkey server
-            if (valkey) await createValkeyConnection({ host, path }, valkey);
-
-            if (mailer) {
-              const mailerSsrConf = confSSR[getCapVariableName(client)];
-              await MailerProvider.load({
-                id: `${host}${path}`,
-                meta: `mailer-${host}${path}`,
-                host,
-                path,
-                ...mailer,
-                templates: mailerSsrConf ? mailerSsrConf.mailer : {},
-              });
-            }
-            if (apis && apis.length > 0) {
-              const authMiddleware = authMiddlewareFactory({ host, path });
-              const apiPath = `${path === '/' ? '' : path}/${process.env.BASE_API}`;
-              for (const api of apis)
-                await (async () => {
-                  logger.info(`Build api server`, `${host}${apiPath}/${api}`);
-                  const { ApiRouter } = await import(`../api/${api}/${api}.router.js`);
-                  const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
-                  // router.use(cors({ origin: origins }));
-                  // logger.info('Load api router', { host, path: apiPath, api });
-                  app.use(`${apiPath}/${api}`, router);
-                })();
-            }
-
-            if (ws)
-              await (async () => {
-                const { createIoServer } = await import(`../ws/${ws}/${ws}.ws.server.js`);
-                // logger.info('Load socket.io ws router', { host, ws });
-                // start socket.io
-                const { options, meta } = await createIoServer(server, {
-                  host,
-                  path,
-                  db,
-                  port,
-                  origins,
-                });
-                await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), port, {
-                  runtime: 'nodejs',
-                  client: null,
-                  host,
-                  path: options.path,
-                  meta,
-                });
-              })();
-
-            if (peer) {
-              const peerPort = newInstance(currentPort);
-              const { options, meta, peerServer } = await createPeerServer({
-                port: peerPort,
-                devPort: port,
-                origins,
-                host,
-                path,
-              });
-
-              await UnderpostStartUp.API.listenPortController(peerServer, peerPort, {
-                runtime: 'nodejs',
-                client: null,
-                host,
-                path: options.path,
-                meta,
-              });
-            }
-          }
-
-          // load ssr
-          const ssr = await ssrMiddlewareFactory({ app, directory, rootHostPath, path });
-          for (const [_, ssrMiddleware] of Object.entries(ssr)) app.use(ssrMiddleware);
-
-          await UnderpostStartUp.API.listenPortController(server, port, runningData);
-
+          // Increment currentPort by any additional ports used by the service (e.g., PeerServer port)
+          currentPort += portsUsed;
           break;
 
         case 'lampp':

package/src/server/start.js

@@ -1,3 +1,9 @@
+/**
+ * Manages the startup and runtime configuration of Underpost applications.
+ * @module src/server/start.js
+ * @namespace UnderpostStartUp
+ */
+
 import UnderpostDeploy from '../cli/deploy.js';
 import fs from 'fs-extra';
 import { awaitDeployMonitor } from './conf.js';
@@ -7,8 +13,17 @@ import UnderpostRootEnv from '../cli/env.js';
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * @class UnderpostStartUp
+ * @description Manages the startup and runtime configuration of Underpost applications.
+ * @memberof UnderpostStartUp
+ */
 class UnderpostStartUp {
   static API = {
+    /**
+     * Logs the runtime network configuration.
+     * @memberof UnderpostStartUp
+     */
     logRuntimeRouter: () => {
       const displayLog = {};
 
@@ -18,6 +33,12 @@ class UnderpostStartUp {
 
       logger.info('Runtime network', displayLog);
     },
+    /**
+     * Creates a server factory.
+     * @memberof UnderpostStartUp
+     * @param {Function} logic - The logic to execute when the server is listening.
+     * @returns {Object} An object with a listen method.
+     */
     listenServerFactory: (logic = async () => {}) => {
       return {
         listen: async (...args) => {
@@ -36,6 +57,15 @@ class UnderpostStartUp {
         },
       };
     },
+
+    /**
+     * Controls the listening port for a server.
+     * @memberof UnderpostStartUp
+     * @param {Object} server - The server to listen on.
+     * @param {number|string} port - The port number or colon for all ports.
+     * @param {Object} metadata - Metadata for the server.
+     * @returns {Promise<boolean>} A promise that resolves to true if the server is listening, false otherwise.
+     */
     listenPortController: async (server, port, metadata) =>
       new Promise((resolve) => {
         try {
@@ -79,6 +109,15 @@ class UnderpostStartUp {
         }
       }),
 
+    /**
+     * Starts a deployment.
+     * @memberof UnderpostStartUp
+     * @param {string} deployId - The ID of the deployment.
+     * @param {string} env - The environment of the deployment.
+     * @param {Object} options - Options for the deployment.
+     * @param {boolean} options.build - Whether to build the deployment.
+     * @param {boolean} options.run - Whether to run the deployment.
+     */
     async callback(deployId = 'dd-default', env = 'development', options = { build: false, run: false }) {
       if (options.build === true) await UnderpostStartUp.API.build(deployId, env);
       if (options.run === true) await UnderpostStartUp.API.run(deployId, env);