underpost 2.7.83 → 2.7.92

package/src/server/conf.js

@@ -1,19 +1,20 @@
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
-import { cap, capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
+import { capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
 import * as dir from 'path';
 import cliProgress from 'cli-progress';
 import cliSpinners from 'cli-spinners';
 import logUpdate from 'log-update';
 import colors from 'colors';
 import { loggerFactory } from './logger.js';
-import { shellExec, shellCd } from './process.js';
+import { shellExec } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import ncp from 'copy-paste';
 import read from 'read';
 import splitFile from 'split-file';
 import axios from 'axios';
 import https from 'https';
+import { ssrFactory } from './client-formatted.js';
 
 // axios.defaults.baseURL = BASE_URL;
 
@@ -44,7 +45,9 @@ const Config = {
       this.default.server = {};
       for (const deployId of process.argv[3].split(',')) {
         let confPath = `./engine-private/conf/${deployId}/conf.server.json`;
-        const privateConfDevPath = `./engine-private/conf/${deployId}/conf.server.dev.${process.argv[4]}.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`;
         const confDevPath = fs.existsSync(privateConfDevPath)
           ? privateConfDevPath
           : `./engine-private/conf/${deployId}/conf.server.dev.json`;
@@ -89,6 +92,11 @@ const loadConf = (deployId) => {
   if (!fs.existsSync(`./conf`)) fs.mkdirSync(`./conf`);
   if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
   const isValidDeployId = fs.existsSync(`${folder}`);
+  if (!isValidDeployId) {
+    logger.info(`Save new deploy conf: '${deployId}'`);
+    shellExec(`node bin/deploy save ${deployId}`);
+    return loadConf(deployId);
+  }
   for (const typeConf of Object.keys(Config.default)) {
     let srcConf = isValidDeployId
       ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
@@ -100,7 +108,6 @@ const loadConf = (deployId) => {
     if (typeConf === 'server') srcConf = JSON.stringify(loadReplicas(JSON.parse(srcConf)), null, 4);
     fs.writeFileSync(`./conf/conf.${typeConf}.json`, srcConf, 'utf8');
   }
-  if (!isValidDeployId) return {};
   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');
@@ -120,10 +127,16 @@ 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 && (process.argv[2] === 'proxy' || !singleReplica))
+      if (
+        replicas &&
+        (process.argv[2] === 'proxy' ||
+          !singleReplica ||
+          (singleReplica && process.env.NODE_ENV === 'development' && !process.argv[3]))
+      )
         for (const replicaPath of replicas) {
           confServer[host][replicaPath] = newInstance(confServer[host][path]);
           delete confServer[host][replicaPath].replicas;
+          delete confServer[host][replicaPath].singleReplica;
         }
     }
   }
@@ -246,8 +259,8 @@ const buildClientSrc = async (
   );
 
   fs.writeFileSync(
-    `./src/client/${toClientVariableName}.js`,
-    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.js`, 'utf8')),
+    `./src/client/${toClientVariableName}.index.js`,
+    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.index.js`, 'utf8')),
     'utf8',
   );
 
@@ -454,6 +467,16 @@ const buildProxyRouter = () => {
       }
     }
   }
+  if (process.argv.includes('maintenance'))
+    (async () => {
+      globalThis.defaultHtmlSrcMaintenance = (await ssrFactory())({
+        title: 'Site in maintenance',
+        ssrPath: '/',
+        ssrHeadComponents: '',
+        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/Maintenance.js`))(),
+      });
+    })();
+
   return proxyRouter;
 };
 
@@ -584,14 +607,32 @@ const validateTemplatePath = (absolutePath = '') => {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/components/body') &&
-    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/components/body/${p}.js`))
+    absolutePath.match('src/client/ssr/body') &&
+    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/body/${p}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/head') &&
+    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/head/${p}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/mailer') &&
+    !Object.keys(confSsr.mailer).find((p) => absolutePath.match(`src/client/ssr/mailer/${confSsr.mailer[p]}.js`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/offline') &&
+    !confSsr.offline.find((p) => absolutePath.match(`src/client/ssr/offline/${p.client}.js`))
   ) {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/components/head') &&
-    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/components/head/${p}.js`))
+    absolutePath.match('src/client/ssr/pages') &&
+    !confSsr.pages.find((p) => absolutePath.match(`src/client/ssr/pages/${p.client}.js`))
   ) {
     return false;
   }
@@ -624,7 +665,7 @@ const deployTest = async (dataDeploy) => {
         if (singleReplica) continue;
         const urlTest = `https://${host}${path}`;
         try {
-          const result = await axios.get(urlTest);
+          const result = await axios.get(urlTest, { timeout: 10000 });
           const test = result.data.split('<title>');
           if (test[1])
             logger.info('Success deploy', {
@@ -660,19 +701,29 @@ const getDeployGroupId = () => {
   return 'dd';
 };
 
+const getDeployId = () => {
+  const deployIndexArg = process.argv.findIndex((a) => a.match(`deploy-id:`));
+  if (deployIndexArg > -1) return process.argv[deployIndexArg].split(':')[1].trim();
+  for (const deployId of process.argv) {
+    if (fs.existsSync(`./engine-private/conf/${deployId}`)) return deployId;
+    else if (fs.existsSync(`./engine-private/replica/${deployId}`)) return deployId;
+  }
+  return 'default';
+};
+
 const getCronBackUpFolder = (host = '', path = '') => {
   return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
 };
 
-const execDeploy = async (options = { deployId: 'default' }) => {
+const execDeploy = async (options = { deployId: 'default' }, currentAttempt = 1) => {
   const { deployId } = options;
   shellExec(Cmd.delete(deployId));
   shellExec(Cmd.conf(deployId));
   shellExec(Cmd.run(deployId));
+  const maxTime = 1000 * 60;
+  const minTime = 20 * 1000;
+  const intervalTime = 1000;
   return await new Promise(async (resolve) => {
-    const maxTime = 1000 * 60 * 5;
-    const minTime = 10000 * 2;
-    const intervalTime = 1000;
     let currentTime = 0;
     const attempt = () => {
       if (currentTime >= minTime && !fs.existsSync(`./tmp/await-deploy`)) {
@@ -682,27 +733,40 @@ const execDeploy = async (options = { deployId: 'default' }) => {
       cliSpinner(
         intervalTime,
         `[deploy.js] `,
-        ` Load instance | elapsed time ${currentTime / 1000}s / ${maxTime / 1000}s`,
+        ` Load instance | attempt:${currentAttempt} | elapsed time ${currentTime / 1000}s / ${maxTime / 1000}s`,
         'yellow',
         'material',
       );
       currentTime += intervalTime;
-      if (currentTime >= maxTime) return resolve(false);
+      if (currentTime >= maxTime) {
+        clearInterval(processMonitor);
+        return resolve(false);
+      }
     };
     const processMonitor = setInterval(attempt, intervalTime);
   });
 };
 
-const deployRun = async (dataDeploy, reset) => {
+const deployRun = async (dataDeploy, currentAttempt = 1) => {
   if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
-  if (reset) fs.writeFileSync(`./tmp/runtime-router.json`, '{}', 'utf8');
   await fixDependencies();
-  for (const deploy of dataDeploy) await execDeploy(deploy);
+  const maxAttempts = 3;
+  for (const deploy of dataDeploy) {
+    let currentAttempt = 1;
+    const attempt = async () => {
+      const success = await execDeploy(deploy, currentAttempt);
+      currentAttempt++;
+      if (!success && currentAttempt <= maxAttempts) await attempt();
+    };
+    await attempt();
+  }
   const { failed } = await deployTest(dataDeploy);
   if (failed.length > 0) {
     for (const deploy of failed) logger.error(deploy.deployId, Cmd.run(deploy.deployId));
-    await read({ prompt: 'Press enter to retry failed processes\n' });
-    await deployRun(failed);
+    if (currentAttempt === maxAttempts) return logger.error(`max deploy attempts exceeded`);
+    if (process.argv.includes('manual')) await read({ prompt: 'Press enter to retry failed processes\n' });
+    currentAttempt++;
+    await deployRun(failed, currentAttempt);
   } else logger.info(`Deploy process successfully`);
 };
 
@@ -833,6 +897,10 @@ const Cmd = {
   conf: (deployId, env) => `node bin/deploy conf ${deployId} ${env ? env : 'production'}`,
   replica: (deployId, host, path) => `node bin/deploy build-single-replica ${deployId} ${host} ${path}`,
   syncPorts: (deployGroupId) => `node bin/deploy sync-env-port ${deployGroupId}`,
+  cron: (deployId, job, expression) => {
+    shellExec(Cmd.delete(`${deployId}-${job}`));
+    return `env-cmd -f .env.production pm2 start bin/cron.js --no-autorestart --instances 1 --cron "${expression}" --name ${deployId}-${job} -- ${job} ${deployId}`;
+  },
 };
 
 const fixDependencies = async () => {
@@ -852,6 +920,26 @@ const fixDependencies = async () => {
   );
 };
 
+const maintenanceMiddleware = (req, res, port, proxyRouter) => {
+  if (process.argv.includes('maintenance') && globalThis.defaultHtmlSrcMaintenance) {
+    if (req.method.toUpperCase() === 'GET') {
+      res.set('Content-Type', 'text/html');
+      return res.status(503).send(globalThis.defaultHtmlSrcMaintenance);
+    }
+    return res.status(503).json({
+      status: 'error',
+      message: 'Server is under maintenance',
+    });
+  }
+};
+
+const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
+  shellExec(`pm2 kill`);
+  const proxyDeployId = fs.readFileSync(`./engine-private/deploy/${deployGroupId}.proxy`, 'utf8').trim();
+  shellExec(`node bin/deploy conf ${proxyDeployId} production`);
+  shellExec(`node bin/deploy run ${proxyDeployId} maintenance`);
+};
+
 export {
   Cmd,
   Config,
@@ -880,4 +968,7 @@ export {
   getRestoreCronCmd,
   mergeBackUp,
   fixDependencies,
+  getDeployId,
+  maintenanceMiddleware,
+  setUpProxyMaintenanceServer,
 };

package/src/server/crypto.js

@@ -0,0 +1,91 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+
+const CryptoBuilder = {
+  symmetric: {
+    instance: function (options = { iv: '', encryptionKey: '' }) {
+      // Generate a random 32-byte encryption key
+      const encryptionKey = option?.encryptionKey ? options.encryptionKey : crypto.randomBytes(32);
+      const iv = option?.iv ? options.iv : crypto.randomBytes(16); // Generate a new Initialization Vector (IV) for each encryption
+
+      // Function to encrypt data
+      function encryptData(plaintext = '') {
+        const cipher = crypto.createCipheriv('aes-256-cbc', encryptionKey, iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return `${iv.toString('hex')}:${encrypted}`;
+      }
+
+      // Function to decrypt data
+      function decryptData(ciphertext = '') {
+        const [ivHex, encrypted] = ciphertext.split(':');
+        const _iv = Buffer.from(ivHex, 'hex');
+        const decipher = crypto.createDecipheriv('aes-256-cbc', encryptionKey, _iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+      }
+
+      return {
+        encryptionKey,
+        iv,
+        encryptData,
+        decryptData,
+      };
+    },
+  },
+  asymmetric: {
+    instance: function (
+      options = {
+        publicKey: '', // fs.readFileSync('./key.pem', 'utf8')
+        privateKey: '', // fs.readFileSync('./key.pem', 'utf8')
+      },
+    ) {
+      // Generate a new key pair
+      const { privateKey, publicKey } = options
+        ? options
+        : crypto.generateKeyPairSync('rsa', {
+            modulusLength: 2048, // Key size in bits
+            publicKeyEncoding: {
+              type: 'spki',
+              format: 'pem',
+            },
+            privateKeyEncoding: {
+              type: 'pkcs8',
+              format: 'pem',
+            },
+          });
+
+      // Function to encrypt data
+      function encryptData(plaintext) {
+        const buffer = Buffer.from(plaintext, 'utf8');
+        const encrypted = crypto.publicEncrypt(publicKey, buffer);
+        return encrypted.toString('hex');
+      }
+
+      // Function to decrypt data
+      function decryptData(ciphertext) {
+        const buffer = Buffer.from(ciphertext, 'hex');
+        const decrypted = crypto.privateDecrypt(privateKey, buffer);
+        return decrypted.toString('utf8');
+      }
+
+      fs.writeFileSync('./public.pem', publicKey);
+      fs.writeFileSync('./private.pem', privateKey);
+
+      const result = {
+        privateKey: fs.readFileSync('./public.pem', 'utf8'),
+        publicKey: fs.readFileSync('./private.pem', 'utf8'),
+        encryptData,
+        decryptData,
+      };
+
+      fs.removeSync('./public.pem');
+      fs.removeSync('./private.pem');
+
+      return result;
+    },
+  },
+};
+
+export { CryptoBuilder };

package/src/server/dns.js

@@ -1,38 +1,47 @@
 import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
-import cron from 'node-cron';
+import https from 'https';
 
 import { ip } from './network.js';
 import { loggerFactory } from './logger.js';
 import { isIPv4 } from 'is-ip';
+import { shellExec } from './process.js';
+
+const httpsAgent = new https.Agent({
+  rejectUnauthorized: false,
+});
+
+axios.defaults.httpsAgent = httpsAgent;
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
 const Dns = {
-  ip: null,
-  ipDaemon: null,
+  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_DNS_REPO}.git`,
   callback: () => null,
-  InitIpDaemon: async function () {
-    // WAN | NAT-VPS | LAN
+  InitIpDaemon: async function ({ deployId }) {
+    // NAT-VPS modem/router device configuration:
+    // LAN --> [NAT-VPS] --> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
-    // LAN server or device's local servers port ->  3000-3100 (2999-3101)
-    // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [ip]
+    // disabled local red DHCP
+    // verify inet ip proxy server address
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
+    // LAN server or device's local servers port ->  3000-3100 (2999-3101)
+    // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [public-ip]
     // Forward the router's TCP/UDP ports to the LAN device's IP address
 
-    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+    const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
 
     const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-
     let confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
     if (confCronData.ipDaemon.disabled) return;
     Dns.ip = confCronData.ipDaemon.ip;
     logger.info(`Current ip`, Dns.ip);
-    if (Dns.ipDaemon) clearInterval(Dns.ipDaemon);
     const callback = async () => {
+      logger.info('init dns ip callback');
+      await logger.setUpInfo();
       let testIp;
       try {
         testIp = await ip.public.ipv4();
@@ -41,15 +50,12 @@ const Dns = {
       }
       if (testIp && typeof testIp === 'string' && isIPv4(testIp) && Dns.ip !== testIp) {
         logger.info(`New ip`, testIp);
-        Dns.ip = testIp;
-        confCronData.ipDaemon.ip = Dns.ip;
-        fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {
             case 'A':
               for (const dnsProvider of confCronData.records[recordType]) {
                 if (typeof Dns.services.updateIp[dnsProvider.dns] === 'function')
-                  await Dns.services.updateIp[dnsProvider.dns](dnsProvider);
+                  await Dns.services.updateIp[dnsProvider.dns]({ ...dnsProvider, ip: testIp });
               }
               break;
 
@@ -57,16 +63,28 @@ const Dns = {
               break;
           }
         }
+        try {
+          const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
+          const response = await axios.get(ipUrlTest);
+          const verifyIp = response.request.socket.remoteAddress;
+          logger.info(ipUrlTest + ' IP', verifyIp);
+          if (verifyIp === testIp) {
+            await this.saveIp(confCronPath, confCronData, testIp);
+          } else logger.error('ip not updated');
+        } catch (error) {
+          logger.error(error), 'ip not updated';
+        }
       }
     };
+    await callback();
     this.callback = callback;
     return callback;
   },
   services: {
     updateIp: {
       dondominio: (options) => {
-        const { user, api_key, host, dns } = options;
-        const url = `https://dondns.dondominio.com/json/?user=${user}&password=${api_key}&host=${host}&ip=${Dns.ip}`;
+        const { user, api_key, host, dns, ip } = options;
+        const url = `https://dondns.dondominio.com/json/?user=${user}&password=${api_key}&host=${host}&ip=${ip}`;
         logger.info(`${dns} update ip url`, url);
         if (process.env.NODE_ENV !== 'production') return false;
         return new Promise((resolve) => {
@@ -84,6 +102,20 @@ const Dns = {
       },
     },
   },
+  saveIp: async (confCronPath, confCronData, ip) => {
+    Dns.ip = ip;
+    confCronData.ipDaemon.ip = ip;
+    fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
+    shellExec(
+      `cd ./engine-private` +
+        ` && git pull ${Dns.repoUrl}` +
+        ` && git add . && git commit -m "update ip ${new Date().toLocaleDateString()}"` +
+        ` && git push ${Dns.repoUrl}`,
+      {
+        disableLog: true,
+      },
+    );
+  },
 };
 
 export { Dns };

package/src/server/network.js

@@ -5,6 +5,8 @@ import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
 import { killPortProcess } from 'kill-port-process';
 import { loggerFactory } from './logger.js';
 import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
+import { DataBaseProvider } from '../db/DataBaseProvider.js';
+import { getDeployId } from './conf.js';
 
 // Network Address Translation Management
 
@@ -66,12 +68,86 @@ const logRuntimeRouter = () => {
   logger.info('Runtime network', displayLog);
 };
 
-const saveRuntimeRouter = () =>
-  fs.writeFileSync(
-    `./tmp/runtime-router.${process.argv[3] ? process.argv[3] : 'default'}.json`,
-    JSON.stringify(networkRouter, null, 4),
-    'utf-8',
-  );
+const saveRuntimeRouter = async () => {
+  try {
+    const deployId = process.env.DEFAULT_DEPLOY_ID;
+    const host = process.env.DEFAULT_DEPLOY_HOST;
+    const path = process.env.DEFAULT_DEPLOY_PATH;
+    const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+    const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+    const { db } = confServer[host][path];
+
+    let closeConn;
+    if (!DataBaseProvider.instance[`${host}${path}`]) {
+      await DataBaseProvider.load({ apis: ['instance'], host, path, db });
+      closeConn = true;
+    }
+
+    /** @type {import('../api/instance/instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Instance;
+
+    for (const _host of Object.keys(networkRouter)) {
+      for (const _path of Object.keys(networkRouter[_host])) {
+        const body = {
+          host: _host,
+          path: _path,
+          deployId: getDeployId(),
+          client: networkRouter[_host][_path].client,
+          runtime: networkRouter[_host][_path].runtime,
+          port: networkRouter[_host][_path].port,
+          apis: networkRouter[_host][_path].apis,
+        };
+        const instance = await Instance.findOne({ deployId: body.deployId, port: body.port });
+        if (instance) {
+          await Instance.findByIdAndUpdate(instance._id, body);
+        } else {
+          await new Instance(body).save();
+        }
+      }
+    }
+
+    if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+const netWorkCron = [];
+
+const saveRuntimeCron = async () => {
+  try {
+    const deployId = process.env.DEFAULT_DEPLOY_ID;
+    const host = process.env.DEFAULT_DEPLOY_HOST;
+    const path = process.env.DEFAULT_DEPLOY_PATH;
+    const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+    const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+    const { db } = confServer[host][path];
+
+    let closeConn;
+    if (!DataBaseProvider.instance[`${host}${path}`]) {
+      await DataBaseProvider.load({ apis: ['cron'], host, path, db });
+      closeConn = true;
+    }
+
+    /** @type {import('../api/cron/cron.model.js').CronModel} */
+    const Cron = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Cron;
+
+    // await Cron.insertMany(netWorkCron);
+
+    for (const cronInstance of netWorkCron) {
+      const cron = await Cron.findOne({ deployId: cronInstance.deployId, jobId: cronInstance.jobId });
+      if (cron) {
+        await Cron.findByIdAndUpdate(cron._id, cronInstance);
+      } else {
+        await new Cron(cronInstance).save();
+      }
+    }
+
+    if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  } catch (error) {
+    logger.error(error);
+  }
+};
 
 const listenServerFactory = (logic = async () => {}) => {
   return {
@@ -109,6 +185,7 @@ const listenPortController = async (server, port, metadata) =>
               ? `https://${host}${path}`
               : `http://${host}:${port}${path}`,
           local: `http://localhost:${port}${path}`,
+          apis: metadata.apis,
         };
 
         return resolve(true);
@@ -119,4 +196,14 @@ const listenPortController = async (server, port, metadata) =>
     }
   });
 
-export { ip, network, listenPortController, networkRouter, saveRuntimeRouter, logRuntimeRouter, listenServerFactory };
+export {
+  ip,
+  network,
+  listenPortController,
+  networkRouter,
+  netWorkCron,
+  saveRuntimeRouter,
+  logRuntimeRouter,
+  listenServerFactory,
+  saveRuntimeCron,
+};