underpost 2.7.7 → 2.7.9

package/src/server/conf.js

@@ -7,7 +7,7 @@ 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, shellCd, getRootDirectory } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import ncp from 'copy-paste';
 import read from 'read';
@@ -44,7 +44,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 +91,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')
@@ -240,14 +247,14 @@ const buildClientSrc = async (
   }
 
   fs.writeFileSync(
-    `./src/client/ssr/head-components/${toClientVariableName}Scripts.js`,
-    formattedSrc(fs.readFileSync(`./src/client/ssr/head-components/${fromClientVariableName}Scripts.js`, 'utf8')),
+    `./src/client/ssr/components/head/${toClientVariableName}Scripts.js`,
+    formattedSrc(fs.readFileSync(`./src/client/ssr/components/head/${fromClientVariableName}Scripts.js`, 'utf8')),
     'utf8',
   );
 
   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',
   );
 
@@ -560,7 +567,7 @@ const validateTemplatePath = (absolutePath = '') => {
   const confServer = DefaultConf.server[host][path];
   const confClient = DefaultConf.client[client];
   const confSsr = DefaultConf.ssr[ssr];
-  const clients = Object.keys(confClient).concat(['core', 'test']);
+  const clients = Object.keys(confClient).concat(['core', 'test', 'default']);
 
   if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
     return false;
@@ -584,14 +591,14 @@ const validateTemplatePath = (absolutePath = '') => {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/body-components') &&
-    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/body-components/${p}.js`))
+    absolutePath.match('src/client/ssr/components/body') &&
+    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/components/body/${p}.js`))
   ) {
     return false;
   }
   if (
-    absolutePath.match('src/client/ssr/head-components') &&
-    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/head-components/${p}.js`))
+    absolutePath.match('src/client/ssr/components/head') &&
+    !confSsr.head.find((p) => absolutePath.match(`src/client/ssr/components/head/${p}.js`))
   ) {
     return false;
   }
@@ -599,6 +606,7 @@ const validateTemplatePath = (absolutePath = '') => {
   if (
     absolutePath.match('/client') &&
     absolutePath.match('.index.js') &&
+    !absolutePath.match('/offline') &&
     !clients.find((p) => absolutePath.match(`src/client/${capFirst(p)}.index.js`))
   ) {
     return false;
@@ -659,6 +667,16 @@ 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(`/`, '-')}`;
 };
@@ -670,7 +688,7 @@ const execDeploy = async (options = { deployId: 'default' }) => {
   shellExec(Cmd.run(deployId));
   return await new Promise(async (resolve) => {
     const maxTime = 1000 * 60 * 5;
-    const minTime = 10000 * 2;
+    const minTime = 7 * 1000;
     const intervalTime = 1000;
     let currentTime = 0;
     const attempt = () => {
@@ -695,6 +713,7 @@ const execDeploy = async (options = { deployId: 'default' }) => {
 const deployRun = async (dataDeploy, reset) => {
   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 { failed } = await deployTest(dataDeploy);
   if (failed.length > 0) {
@@ -831,6 +850,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 () => {
@@ -850,6 +873,27 @@ const fixDependencies = async () => {
   );
 };
 
+const maintenancePath = `${getRootDirectory()}/public/${process.env.DEFAULT_DEPLOY_HOST}${
+  process.env.DEFAULT_DEPLOY_PATH
+}/maintenance.html`;
+
+const maintenanceMiddleware = (req, res, port, proxyRouter) => {
+  if (process.argv.includes('maintenance') && fs.existsSync(maintenancePath)) {
+    if (req.method.toUpperCase() === 'GET') return res.status(503).sendFile(maintenancePath);
+    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,
@@ -878,4 +922,8 @@ export {
   getRestoreCronCmd,
   mergeBackUp,
   fixDependencies,
+  getDeployId,
+  maintenancePath,
+  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,21 +1,27 @@
 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 () {
+  InitIpDaemon: async function ({ deployId }) {
     // WAN | NAT-VPS | LAN
     // 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)
@@ -23,16 +29,16 @@ const Dns = {
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
     // 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 +47,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 +60,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 +99,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,
+};

package/src/server/proxy.js

@@ -9,7 +9,8 @@ import { loggerFactory, loggerMiddleware } from './logger.js';
 import { listenPortController, network } from './network.js';
 import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
 import { createSslServer, sslRedirectMiddleware } from './ssl.js';
-import { buildProxyRouter } from './conf.js';
+import { buildProxyRouter, maintenanceMiddleware } from './conf.js';
+import { getRootDirectory } from './process.js';
 
 dotenv.config();
 
@@ -25,6 +26,9 @@ const buildProxy = async () => {
   for (let port of Object.keys(proxyRouter)) {
     port = parseInt(port);
     const hosts = proxyRouter[port];
+    const proxyPath = '/';
+    const proxyHost = 'localhost';
+    const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
     const app = express();
 
     // set logger
@@ -47,6 +51,7 @@ const buildProxy = async () => {
       onProxyReq: (proxyReq, req, res, options) => {
         // https://wtools.io/check-http-status-code
         // http://nexodev.org
+        maintenanceMiddleware(req, res, port, proxyRouter);
         sslRedirectMiddleware(req, res, port, proxyRouter);
       },
       pathRewrite: {
@@ -54,30 +59,27 @@ const buildProxy = async () => {
         // '^/target-path': '/',
       },
     };
-
-    // build router
-    Object.keys(hosts).map((hostKey) => {
-      let { host, path, target, proxy, peer } = hosts[hostKey];
-      if (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 options.router)) options.router[absoluteHost] = target;
-    });
-    if (Object.keys(options.router).length === 0) continue;
-
-    // order router
-    const router = {};
-    for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(options.router), 'length'))
-      router[absoluteHostKey] = options.router[absoluteHostKey];
-    options.router = router;
-
-    // instance proxy server
-    const proxyPath = '/';
-    const proxyHost = 'localhost';
+    if (!process.argv.includes('maintenance')) {
+      // build router
+      Object.keys(hosts).map((hostKey) => {
+        let { host, path, target, proxy, peer } = hosts[hostKey];
+        if (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 options.router)) options.router[absoluteHost] = target;
+      });
+      if (Object.keys(options.router).length === 0) continue;
+
+      // order router
+      const router = {};
+      for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(options.router), 'length'))
+        router[absoluteHostKey] = options.router[absoluteHostKey];
+      options.router = router;
+    }
 
     const filter = false
       ? (pathname, req) => {
@@ -88,8 +90,6 @@ const buildProxy = async () => {
     app.use(proxyPath, createProxyMiddleware(filter, options));
     await network.port.portClean(port);
 
-    const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
-
     switch (process.env.NODE_ENV) {
       case 'production':
         switch (port) {