underpost 2.8.453 → 2.8.481

package/src/index.js

@@ -5,6 +5,8 @@
  */
 
 import UnderpostCluster from './cli/cluster.js';
+import UnderpostDB from './cli/db.js';
+import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
 import UnderpostImage from './cli/image.js';
 import UnderpostRepository from './cli/repository.js';
@@ -24,7 +26,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.453';
+  static version = 'v2.8.481';
   /**
    * Repository cli API
    * @static
@@ -74,6 +76,20 @@ class Underpost {
    * @memberof Underpost
    */
   static script = UnderpostScript.API;
+  /**
+   * Database cli API
+   * @static
+   * @type {UnderpostDB.API}
+   * @memberof Underpost
+   */
+  static db = UnderpostDB.API;
+  /**
+   * Deployment cli API
+   * @static
+   * @type {UnderpostDeploy.API}
+   * @memberof Underpost
+   */
+  static deploy = UnderpostDeploy.API;
 }
 
 const up = Underpost;

package/src/server/conf.js

@@ -40,21 +40,26 @@ const logger = loggerFactory(import.meta);
 
 const Config = {
   default: DefaultConf,
-  build: async function (options = { folder: '' }) {
+  build: async function (options = { folder: '' }, deployContext, deployList, subConf) {
+    if (!deployContext) deployContext = process.argv[2];
     if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
     fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
-    if (fs.existsSync(`./engine-private/conf/${process.argv[2]}`)) return loadConf(process.argv[2]);
-    if (fs.existsSync(`./engine-private/replica/${process.argv[2]}`)) return loadConf(process.argv[2]);
+    if (fs.existsSync(`./engine-private/conf/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
+    if (fs.existsSync(`./engine-private/replica/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
 
-    if (process.argv[2] === 'deploy') return;
+    if (deployContext === 'deploy') return;
 
-    if (process.argv[2] === 'proxy') {
+    if (deployContext === 'proxy') {
+      if (!deployList) deployList = process.argv[3];
+      if (!subConf) subConf = process.argv[4];
       this.default.server = {};
-      for (const deployId of process.argv[3].split(',')) {
+      for (const deployId of deployList.split(',')) {
         let confPath = `./engine-private/conf/${deployId}/conf.server.json`;
         const privateConfDevPath = fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
           ? `./engine-private/replica/${deployId}/conf.server.json`
-          : `./engine-private/conf/${deployId}/conf.server.dev.${process.argv[4]}.json`;
+          : `./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`;
         const confDevPath = fs.existsSync(privateConfDevPath)
           ? privateConfDevPath
           : `./engine-private/conf/${deployId}/conf.server.dev.json`;
@@ -62,7 +67,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))) {
+        for (const host of Object.keys(loadReplicas(serverConf, deployContext, subConf))) {
           if (serverConf[host]['/'])
             this.default.server[host] = {
               ...this.default.server[host],
@@ -92,7 +97,7 @@ const Config = {
   },
 };
 
-const loadConf = (deployId, envInput) => {
+const loadConf = (deployId, envInput, subConf) => {
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -109,7 +114,8 @@ const loadConf = (deployId, envInput) => {
       ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
       : JSON.stringify(Config.default[typeConf]);
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
-      const devConfPath = `${folder}/conf.${typeConf}.dev${process.argv[3] ? `.${process.argv[3]}` : ''}.json`;
+      if (!subConf) subConf = process.argv[3];
+      const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
       if (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
     }
     if (typeConf === 'server') srcConf = JSON.stringify(loadReplicas(JSON.parse(srcConf)), null, 4);
@@ -135,15 +141,17 @@ const loadConf = (deployId, envInput) => {
   return { folder, deployId };
 };
 
-const loadReplicas = (confServer) => {
+const loadReplicas = (confServer, deployContext, subConf) => {
+  if (!deployContext) deployContext = process.argv[2];
+  if (!subConf) subConf = process.argv[3];
   for (const host of Object.keys(confServer)) {
     for (const path of Object.keys(confServer[host])) {
       const { replicas, singleReplica } = confServer[host][path];
       if (
         replicas &&
-        (process.argv[2] === 'proxy' ||
+        (deployContext === 'proxy' ||
           !singleReplica ||
-          (singleReplica && process.env.NODE_ENV === 'development' && !process.argv[3]))
+          (singleReplica && process.env.NODE_ENV === 'development' && !subConf))
       )
         for (const replicaPath of replicas) {
           confServer[host][replicaPath] = newInstance(confServer[host][path]);
@@ -513,14 +521,16 @@ const buildPortProxyRouter = (port, proxyRouter) => {
   // build router
   Object.keys(hosts).map((hostKey) => {
     let { host, path, target, proxy, peer } = hosts[hostKey];
-    if (process.env.NODE_ENV === 'development') host = `localhost`;
+    if (process.argv.includes('localhost') && process.env.NODE_ENV === 'development') host = `localhost`;
 
     if (!proxy.includes(port)) return;
     const absoluteHost = [80, 443].includes(port)
       ? `${host}${path === '/' ? '' : path}`
       : `${host}:${port}${path === '/' ? '' : path}`;
 
-    if (!(absoluteHost in router)) router[absoluteHost] = target;
+    if (process.argv.includes('localhost')) {
+      if (!(absoluteHost in router)) router[absoluteHost] = target;
+    } else router[absoluteHost] = target;
   }); // order router
 
   if (Object.keys(router).length === 0) return router;

package/src/server/logger.js

@@ -85,6 +85,7 @@ const format = (meta) =>
  */
 const setUpInfo = async (logger = new winston.Logger()) => {
   logger.info('argv', process.argv);
+  logger.info('cwd', process.cwd());
   logger.info('platform', process.platform);
   logger.info('env', process.env.NODE_ENV);
   logger.info('--max-old-space-size', {

package/src/server/network.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 
 import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
-import { loggerFactory } from './logger.js';
+import { actionInitLog, loggerFactory } from './logger.js';
 import { DataBaseProvider } from '../db/DataBaseProvider.js';
 import { getDeployId } from './conf.js';
 
@@ -39,7 +39,7 @@ const saveRuntimeRouter = async () => {
     const host = process.env.DEFAULT_DEPLOY_HOST;
     const path = process.env.DEFAULT_DEPLOY_PATH;
     const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
-    if (!deployId || !host || !path) {
+    if (!deployId || !host || !path || !fs.existsSync(confServerPath)) {
       // logger.warn('default deploy instance not found');
       return;
     }
@@ -77,7 +77,7 @@ const saveRuntimeRouter = async () => {
 
     if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
   } catch (error) {
-    logger.error(error);
+    logger.error(error, error.stack);
   }
 };
 
@@ -114,20 +114,30 @@ const saveRuntimeCron = async () => {
 
     if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
   } catch (error) {
-    logger.error(error);
+    logger.error(error, error.stack);
   }
 };
 
 const listenServerFactory = (logic = async () => {}) => {
   return {
-    listen: async (...args) => (logic ? await logic(...args) : undefined, args[1]()),
+    listen: async (...args) => (
+      setTimeout(() => {
+        const message = 'Listen server factory timeout';
+        logger.error(message);
+        throw new Error(message);
+      }, 80000000), // ~ 55 days
+      (logic ? await logic(...args) : undefined, args[1]())
+    ),
   };
 };
 
 const listenPortController = async (server, port, metadata) =>
   new Promise((resolve) => {
     try {
-      if (!server) server = listenServerFactory();
+      if (port === ':') {
+        server.listen(port, actionInitLog);
+        return resolve(true);
+      }
 
       const { host, path, client, runtime, meta } = metadata;
       const error = [];