underpost 2.6.2

package/src/server/conf.js

@@ -0,0 +1,611 @@
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import { cap, capFirst, 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 } from './process.js';
+import { DefaultConf } from '../../conf.js';
+
+colors.enable();
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+// monitoring: https://app.pm2.io/
+
+const Config = {
+  default: DefaultConf,
+  build: async function (options = { folder: '' }) {
+    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 (process.argv[2] === 'deploy') return;
+
+    if (process.argv[2] === 'proxy') {
+      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 confDevPath = fs.existsSync(privateConfDevPath)
+          ? privateConfDevPath
+          : `./engine-private/conf/${deployId}/conf.server.dev.json`;
+
+        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))) {
+          if (serverConf[host]['/'])
+            this.default.server[host] = {
+              ...this.default.server[host],
+              ...serverConf[host],
+            };
+          else
+            this.default.server[host] = {
+              ...serverConf[host],
+              ...this.default.server[host],
+            };
+        }
+      }
+    }
+    if (!options || !options.folder)
+      options = {
+        ...options,
+        folder: `./conf`,
+      };
+    if (!fs.existsSync(options.folder)) fs.mkdirSync(options.folder, { recursive: true });
+    for (const confType of Object.keys(this.default)) {
+      fs.writeFileSync(
+        `${options.folder}/conf.${confType}.json`,
+        JSON.stringify(this.default[confType], null, 4),
+        'utf8',
+      );
+    }
+  },
+};
+
+const loadConf = (deployId) => {
+  const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
+    ? `./engine-private/replica/${deployId}`
+    : `./engine-private/conf/${deployId}`;
+  if (!fs.existsSync(`./conf`)) fs.mkdirSync(`./conf`);
+  const isValidDeployId = fs.existsSync(`${folder}`);
+  for (const typeConf of Object.keys(Config.default)) {
+    let srcConf = isValidDeployId
+      ? 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 (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
+    }
+    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');
+  if (process.env.NODE_ENV) {
+    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'), 'utf8');
+    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'));
+    process.env = {
+      ...process.env,
+      ...env,
+    };
+  }
+  fs.writeFileSync(`./package.json`, fs.readFileSync(`${folder}/package.json`, 'utf8'), 'utf8');
+  return { folder, deployId };
+};
+
+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))
+        for (const replicaPath of replicas) {
+          confServer[host][replicaPath] = newInstance(confServer[host][path]);
+          delete confServer[host][replicaPath].replicas;
+        }
+    }
+  }
+  return confServer;
+};
+
+const getCapVariableName = (value = 'default') => cap(value.replaceAll('-', ' ')).replaceAll(' ', '');
+
+const cloneConf = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { deployId: 'dd-default', clientId: 'default' },
+) => {
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.clientId) fromOptions.clientId = fromDefaultOptions.clientId;
+
+  const confFromFolder = `./engine-private/conf/${fromOptions.deployId}`;
+  const confToFolder = `./engine-private/conf/${toOptions.deployId}`;
+
+  const toClientVariableName = getCapVariableName(toOptions.clientId);
+  const fromClientVariableName = getCapVariableName(fromOptions.clientId);
+
+  const formattedSrc = (dataConf) =>
+    JSON.stringify(dataConf, null, 4)
+      .replaceAll(fromClientVariableName, toClientVariableName)
+      .replaceAll(fromOptions.clientId, toOptions.clientId);
+
+  const isMergeConf = fs.existsSync(confToFolder);
+  if (!isMergeConf) fs.mkdirSync(confToFolder, { recursive: true });
+
+  fs.writeFileSync(
+    `${confToFolder}/.env.production`,
+    fs.readFileSync(`${confFromFolder}/.env.production`, 'utf8'),
+    'utf8',
+  );
+  fs.writeFileSync(
+    `${confToFolder}/.env.development`,
+    fs.readFileSync(`${confFromFolder}/.env.development`, 'utf8'),
+    'utf8',
+  );
+  fs.writeFileSync(`${confToFolder}/.env.test`, fs.readFileSync(`${confFromFolder}/.env.test`, 'utf8'), 'utf8');
+
+  for (const confTypeId of ['server', 'client', 'cron', 'ssr']) {
+    const confFromData = JSON.parse(fs.readFileSync(`${confFromFolder}/conf.${confTypeId}.json`, 'utf8'));
+    fs.writeFileSync(`${confToFolder}/conf.${confTypeId}.json`, formattedSrc(confFromData), 'utf8');
+  }
+
+  const packageData = JSON.parse(fs.readFileSync(`${confFromFolder}/package.json`, 'utf8'));
+  packageData.scripts.start = packageData.scripts.start.replaceAll(fromOptions.deployId, toOptions.deployId);
+  fs.writeFileSync(`${confToFolder}/package.json`, JSON.stringify(packageData, null, 4), 'utf8');
+};
+
+const addClientConf = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { deployId: 'dd-default', clientId: 'default' },
+) => {
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.clientId) fromOptions.clientId = fromDefaultOptions.clientId;
+
+  const confFromFolder = `./engine-private/conf/${fromOptions.deployId}`;
+  const confToFolder = `./engine-private/conf/${toOptions.deployId}`;
+
+  const toClientConf = JSON.parse(fs.readFileSync(`${confToFolder}/conf.client.json`, 'utf8'));
+  const fromClientConf = JSON.parse(fs.readFileSync(`${confFromFolder}/conf.client.json`, 'utf8'));
+
+  const toClientVariableName = getCapVariableName(toOptions.clientId);
+  const fromClientVariableName = getCapVariableName(fromOptions.clientId);
+
+  const { host, path } = toOptions;
+
+  toClientConf[fromOptions.clientId] = fromClientConf[fromOptions.clientId];
+
+  fs.writeFileSync(`${confToFolder}/conf.client.json`, JSON.stringify(toClientConf, null, 4), 'utf8');
+
+  const toServerConf = JSON.parse(fs.readFileSync(`${confToFolder}/conf.server.json`, 'utf8'));
+  const fromServerConf = JSON.parse(fs.readFileSync(`${confToFolder}/conf.server.json`, 'utf8'));
+
+  toServerConf[host][path].client = fromOptions.clientId;
+  toServerConf[host][path].runtime = 'nodejs';
+  toServerConf[host][path].apis = fromClientConf[fromOptions.clientId].services;
+
+  fs.writeFileSync(`${confToFolder}/conf.server.json`, JSON.stringify(toServerConf, null, 4), 'utf8');
+
+  const fromSsrConf = JSON.parse(fs.readFileSync(`${confFromFolder}/conf.ssr.json`, 'utf8'));
+  const toSsrConf = JSON.parse(fs.readFileSync(`${confToFolder}/conf.ssr.json`, 'utf8'));
+
+  toSsrConf[fromClientVariableName] = fromSsrConf[fromClientVariableName];
+
+  fs.writeFileSync(`${confToFolder}/conf.ssr.json`, JSON.stringify(toSsrConf, null, 4), 'utf8');
+};
+
+const buildClientSrc = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { deployId: 'dd-default', clientId: 'default' },
+) => {
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.clientId) fromOptions.clientId = fromDefaultOptions.clientId;
+
+  const confFromFolder = `./src/client/components/${fromOptions.clientId}`;
+  const confToFolder = `./src/client/components/${toOptions.clientId}`;
+
+  const toClientVariableName = getCapVariableName(toOptions.clientId);
+  const fromClientVariableName = getCapVariableName(fromOptions.clientId);
+
+  const formattedSrc = (src) =>
+    src.replaceAll(fromClientVariableName, toClientVariableName).replaceAll(fromOptions.clientId, toOptions.clientId);
+
+  const isMergeConf = fs.existsSync(confToFolder);
+  if (!isMergeConf) fs.mkdirSync(confToFolder, { recursive: true });
+
+  const files = await fs.readdir(confFromFolder, { recursive: true });
+  for (const relativePath of files) {
+    const fromFilePath = dir.resolve(`${confFromFolder}/${relativePath}`);
+    const toFilePath = dir.resolve(`${confToFolder}/${relativePath}`);
+
+    fs.writeFileSync(formattedSrc(toFilePath), formattedSrc(fs.readFileSync(fromFilePath, 'utf8')), 'utf8');
+  }
+
+  fs.writeFileSync(
+    `./src/client/ssr/head-components/${toClientVariableName}Scripts.js`,
+    formattedSrc(fs.readFileSync(`./src/client/ssr/head-components/${fromClientVariableName}Scripts.js`, 'utf8')),
+    'utf8',
+  );
+
+  fs.writeFileSync(
+    `./src/client/${toClientVariableName}.js`,
+    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.js`, 'utf8')),
+    'utf8',
+  );
+
+  fs.copySync(`./src/client/public/${fromOptions.clientId}`, `./src/client/public/${toOptions.clientId}`);
+};
+
+const buildApiSrc = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { apiId: 'default', deployId: 'dd-default', clientId: 'default' },
+) => {
+  if (!fromOptions.apiId) fromOptions.apiId = fromDefaultOptions.apiId;
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.clientId) fromOptions.clientId = fromDefaultOptions.clientId;
+
+  const toClientVariableName = getCapVariableName(toOptions.apiId);
+  const fromClientVariableName = getCapVariableName(fromOptions.apiId);
+
+  const formattedSrc = (src) =>
+    src.replaceAll(fromClientVariableName, toClientVariableName).replaceAll(fromOptions.apiId, toOptions.apiId);
+
+  const apiToFolder = `./src/api/${toOptions.apiId}`;
+  const apiFromFolder = `./src/api/${fromOptions.apiId}`;
+
+  const isMergeConf = fs.existsSync(apiToFolder);
+  if (!isMergeConf) fs.mkdirSync(apiToFolder, { recursive: true });
+
+  for (const srcApiType of ['model', 'controller', 'service', 'router']) {
+    fs.writeFileSync(
+      `${apiToFolder}/${toOptions.apiId}.${srcApiType}.js`,
+      formattedSrc(fs.readFileSync(`${apiFromFolder}/${fromOptions.apiId}.${srcApiType}.js`, 'utf8')),
+      'utf8',
+    );
+  }
+
+  fs.mkdirSync(`./src/client/services/${toOptions.apiId}`, { recursive: true });
+  if (fs.existsSync(`./src/client/services/${fromOptions.apiId}/${fromOptions.apiId}.service.js`))
+    fs.writeFileSync(
+      `./src/client/services/${toOptions.apiId}/${toOptions.apiId}.service.js`,
+      formattedSrc(
+        fs.readFileSync(`./src/client/services/${fromOptions.apiId}/${fromOptions.apiId}.service.js`, 'utf8'),
+      ),
+      'utf8',
+    );
+  return;
+  if (fs.existsSync(`./src/client/services/${fromOptions.apiId}/${fromOptions.apiId}.management.js`))
+    fs.writeFileSync(
+      `./src/client/services/${toOptions.apiId}/${toOptions.apiId}.management.js`,
+      formattedSrc(
+        fs.readFileSync(`./src/client/services/${fromOptions.apiId}/${fromOptions.apiId}.management.js`, 'utf8'),
+      ),
+      'utf8',
+    );
+};
+
+const addApiConf = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { apiId: 'default', deployId: 'dd-default', clientId: 'default' },
+) => {
+  if (!fromOptions.apiId) fromOptions.apiId = fromDefaultOptions.apiId;
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.clientId) fromOptions.clientId = fromDefaultOptions.clientId;
+
+  const toClientVariableName = getCapVariableName(toOptions.apiId);
+  const fromClientVariableName = getCapVariableName(fromOptions.apiId);
+
+  const confFromFolder = `./engine-private/conf/${fromOptions.deployId}`;
+  const confToFolder = `./engine-private/conf/${toOptions.deployId}`;
+
+  const confServer = JSON.parse(fs.readFileSync(`${confToFolder}/conf.server.json`, 'utf8'));
+  for (const host of Object.keys(confServer))
+    for (const path of Object.keys(confServer[host]))
+      if (confServer[host][path].apis) confServer[host][path].apis.push(toOptions.apiId);
+  fs.writeFileSync(`${confToFolder}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+
+  const confClient = JSON.parse(fs.readFileSync(`${confToFolder}/conf.client.json`, 'utf8'));
+  confClient[toOptions.clientId].services.push(toOptions.apiId);
+  fs.writeFileSync(`${confToFolder}/conf.client.json`, JSON.stringify(confClient, null, 4), 'utf8');
+};
+
+const addWsConf = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { wsId: 'default', deployId: 'dd-default', host: 'default.net', paths: '/' },
+) => {
+  if (!fromOptions.wsId) fromOptions.wsId = fromDefaultOptions.wsId;
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.host) fromOptions.host = fromDefaultOptions.host;
+  if (!fromOptions.paths) fromOptions.paths = fromDefaultOptions.paths;
+
+  const toClientVariableName = getCapVariableName(toOptions.apiId);
+  const fromClientVariableName = getCapVariableName(fromOptions.apiId);
+
+  const confFromFolder = `./engine-private/conf/${fromOptions.deployId}`;
+  const confToFolder = `./engine-private/conf/${toOptions.deployId}`;
+
+  const paths = toOptions.paths.split(',');
+
+  const confServer = JSON.parse(fs.readFileSync(`${confToFolder}/conf.server.json`, 'utf8'));
+  for (const host of Object.keys(confServer))
+    for (const path of Object.keys(confServer[host]))
+      if (host === toOptions.host && paths.includes(path) && confServer[host][path])
+        confServer[host][path].ws = toOptions.wsId;
+  fs.writeFileSync(`${confToFolder}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+};
+
+const buildWsSrc = async (
+  { toOptions, fromOptions },
+  fromDefaultOptions = { wsId: 'default', deployId: 'dd-default', host: 'default.net', paths: '/' },
+) => {
+  if (!fromOptions.wsId) fromOptions.wsId = fromDefaultOptions.wsId;
+  if (!fromOptions.deployId) fromOptions.deployId = fromDefaultOptions.deployId;
+  if (!fromOptions.host) fromOptions.host = fromDefaultOptions.host;
+  if (!fromOptions.paths) fromOptions.paths = fromDefaultOptions.paths;
+
+  const toClientVariableName = getCapVariableName(toOptions.wsId);
+  const fromClientVariableName = getCapVariableName(fromOptions.wsId);
+
+  const confFromFolder = `./src/ws/${fromOptions.wsId}`;
+  const confToFolder = `./src/ws/${toOptions.wsId}`;
+
+  const paths = toOptions.paths.split(',');
+
+  const formattedSrc = (src) =>
+    src.replaceAll(fromClientVariableName, toClientVariableName).replaceAll(fromOptions.wsId, toOptions.wsId);
+
+  const files = await fs.readdir(confFromFolder, { recursive: true });
+  for (const relativePath of files) {
+    const fromFilePath = dir.resolve(`${confFromFolder}/${relativePath}`);
+    const toFilePath = dir.resolve(`${confToFolder}/${relativePath}`);
+
+    if (fs.lstatSync(fromFilePath).isDirectory() && !fs.existsSync(formattedSrc(toFilePath)))
+      fs.mkdirSync(formattedSrc(toFilePath), { recursive: true });
+
+    if (fs.lstatSync(fromFilePath).isFile() && !fs.existsSync(formattedSrc(toFilePath))) {
+      fs.writeFileSync(formattedSrc(toFilePath), formattedSrc(fs.readFileSync(fromFilePath, 'utf8')), 'utf8');
+    }
+  }
+};
+
+const cloneSrcComponents = async ({ toOptions, fromOptions }) => {
+  const toClientVariableName = getCapVariableName(toOptions.componentsFolder);
+  const fromClientVariableName = getCapVariableName(fromOptions.componentsFolder);
+
+  const formattedSrc = (src) =>
+    src
+      .replaceAll(fromClientVariableName, toClientVariableName)
+      .replaceAll(fromOptions.componentsFolder, toOptions.componentsFolder);
+
+  const confFromFolder = `./src/client/components/${fromOptions.componentsFolder}`;
+  const confToFolder = `./src/client/components/${toOptions.componentsFolder}`;
+
+  fs.mkdirSync(confToFolder, { recursive: true });
+
+  const files = await fs.readdir(confFromFolder);
+  for (const relativePath of files) {
+    const fromFilePath = dir.resolve(`${confFromFolder}/${relativePath}`);
+    const toFilePath = dir.resolve(`${confToFolder}/${relativePath}`);
+
+    fs.writeFileSync(formattedSrc(toFilePath), formattedSrc(fs.readFileSync(fromFilePath, 'utf8')), 'utf8');
+  }
+};
+
+const buildProxyRouter = () => {
+  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+  let currentPort = parseInt(process.env.PORT) + 1;
+  const proxyRouter = {};
+  const singleReplicaHosts = [];
+  for (const host of Object.keys(confServer)) {
+    for (const path of Object.keys(confServer[host])) {
+      if (confServer[host][path].singleReplica && !singleReplicaHosts.includes(host)) {
+        singleReplicaHosts.push(host);
+        currentPort++;
+        continue;
+      }
+      confServer[host][path].port = newInstance(currentPort);
+      for (const port of confServer[host][path].proxy) {
+        if (!(port in proxyRouter)) proxyRouter[port] = {};
+        proxyRouter[port][`${host}${path}`] = {
+          // target: `http://${host}:${confServer[host][path].port}${path}`,
+          target: `http://localhost:${confServer[host][path].port - singleReplicaHosts.length}`,
+          // target: `http://127.0.0.1:${confServer[host][path].port}`,
+          proxy: confServer[host][path].proxy,
+          redirect: confServer[host][path].redirect,
+          host,
+          path,
+        };
+      }
+      currentPort++;
+      if (confServer[host][path].peer) {
+        const peerPath = path === '/' ? `/peer` : `${path}/peer`;
+        confServer[host][peerPath] = newInstance(confServer[host][path]);
+        confServer[host][peerPath].port = newInstance(currentPort);
+        for (const port of confServer[host][path].proxy) {
+          if (!(port in proxyRouter)) proxyRouter[port] = {};
+          proxyRouter[port][`${host}${peerPath}`] = {
+            // target: `http://${host}:${confServer[host][peerPath].port}${peerPath}`,
+            target: `http://localhost:${confServer[host][peerPath].port - singleReplicaHosts.length}`,
+            // target: `http://127.0.0.1:${confServer[host][peerPath].port}`,
+            proxy: confServer[host][peerPath].proxy,
+            host,
+            path: peerPath,
+          };
+        }
+        currentPort++;
+      }
+    }
+  }
+  return proxyRouter;
+};
+
+const cliBar = async (time = 5000) => {
+  // create new progress bar
+  const b = new cliProgress.SingleBar({
+    format: 'Delay | {bar} | {percentage}% || {value}/{total} Chunks || Speed: {speed}',
+    barCompleteChar: '\u2588',
+    barIncompleteChar: '\u2591',
+    hideCursor: true,
+  });
+
+  const maxValueDisplay = 200;
+  const minValueDisplay = 0;
+  const steps = 10;
+  const incrementValue = 200 / steps;
+  const delayTime = time / steps;
+  // initialize the bar - defining payload token "speed" with the default value "N/A"
+  b.start(maxValueDisplay, minValueDisplay, {
+    speed: 'N/A',
+  });
+
+  // update values
+  // b1.increment();
+  // b1.update(20);
+
+  for (const step of range(1, steps)) {
+    b.increment(incrementValue);
+    await timer(delayTime);
+  }
+
+  // stop the bar
+  b.stop();
+};
+
+const cliSpinner = async (time = 5000, message0, message1, color, type = 'dots') => {
+  const { frames, interval } = cliSpinners[type];
+  const steps = parseInt(time / interval);
+  let index = 0;
+  for (const step of range(1, steps)) {
+    const msg = `${message0 ? message0 : ''}${frames[index]}${message1 ? message1 : ''}`;
+    logUpdate(color ? msg[color] : msg);
+    await timer(interval);
+    index++;
+    if (index === frames.length) index = 0;
+  }
+};
+
+const getDataDeploy = (options = { buildSingleReplica: false, deployGroupId: '' }) => {
+  let dataDeploy = JSON.parse(
+    fs.readFileSync(
+      `./engine-private/deploy/${options?.deployGroupId ? options.deployGroupId : process.argv[3]}.json`,
+      'utf8',
+    ),
+  ).map((deployId) => {
+    return {
+      deployId,
+    };
+  });
+
+  if (options && options.buildSingleReplica && fs.existsSync(`./engine-private/replica`))
+    fs.removeSync(`./engine-private/replica`);
+
+  let buildDataDeploy = [];
+  for (const deployObj of dataDeploy) {
+    const serverConf = loadReplicas(
+      JSON.parse(fs.readFileSync(`./engine-private/conf/${deployObj.deployId}/conf.server.json`, 'utf8')),
+    );
+    let replicaDataDeploy = [];
+    for (const host of Object.keys(serverConf))
+      for (const path of Object.keys(serverConf[host])) {
+        if (serverConf[host][path].replicas && serverConf[host][path].singleReplica) {
+          if (options && options.buildSingleReplica)
+            shellExec(`node bin/deploy build-single-replica ${deployObj.deployId} ${host} ${path}`);
+          replicaDataDeploy = replicaDataDeploy.concat(
+            serverConf[host][path].replicas.map((r) => {
+              return {
+                deployId: `${deployObj.deployId}-${r.slice(1)}`,
+                replicaHost: host,
+              };
+            }),
+          );
+        }
+      }
+    buildDataDeploy.push(deployObj);
+    if (replicaDataDeploy.length > 0) buildDataDeploy = buildDataDeploy.concat(replicaDataDeploy);
+  }
+
+  logger.info('buildDataDeploy', buildDataDeploy);
+  return buildDataDeploy;
+};
+
+const validateTemplatePath = (absolutePath = '') => {
+  const host = 'default.net';
+  const path = '/';
+  const client = 'default';
+  const ssr = 'Default';
+  const confServer = DefaultConf.server[host][path];
+  const confClient = DefaultConf.client[client];
+  const confSsr = DefaultConf.ssr[ssr];
+  const clients = Object.keys(confClient).concat(['core', 'test']);
+
+  if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/services/') &&
+    !clients.find((p) => absolutePath.match(`src/client/services/${p}/`))
+  ) {
+    return false;
+  }
+  if (absolutePath.match('src/client/public/') && !clients.find((p) => absolutePath.match(`src/client/public/${p}/`))) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/components/') &&
+    !clients.find((p) => absolutePath.match(`src/client/components/${p}/`))
+  ) {
+    return false;
+  }
+  if (absolutePath.match('src/client/sw/') && !clients.find((p) => absolutePath.match(`src/client/sw/${p}.sw.js`))) {
+    return false;
+  }
+  if (
+    absolutePath.match('src/client/ssr/body-components') &&
+    !confSsr.body.find((p) => absolutePath.match(`src/client/ssr/body-components/${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`))
+  ) {
+    return false;
+  }
+  if (
+    absolutePath.match('/client') &&
+    absolutePath.match('.index.js') &&
+    !clients.find((p) => absolutePath.match(`src/client/${capFirst(p)}.index.js`))
+  ) {
+    return false;
+  }
+  if (absolutePath.match('src/ws/') && !clients.find((p) => absolutePath.match(`src/ws/${p}/`))) {
+    return false;
+  }
+  return true;
+};
+
+export {
+  Config,
+  loadConf,
+  loadReplicas,
+  cloneConf,
+  getCapVariableName,
+  buildClientSrc,
+  buildApiSrc,
+  addApiConf,
+  addClientConf,
+  addWsConf,
+  buildWsSrc,
+  cloneSrcComponents,
+  buildProxyRouter,
+  cliBar,
+  cliSpinner,
+  getDataDeploy,
+  validateTemplatePath,
+};

package/src/server/dns.js

@@ -0,0 +1,87 @@
+import axios from 'axios';
+import dotenv from 'dotenv';
+import fs from 'fs';
+
+import { ip } from './network.js';
+import { loggerFactory } from './logger.js';
+import { isIPv4 } from 'is-ip';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const Dns = {
+  ip: null,
+  ipDaemon: null,
+  InitIpDaemon: async function () {
+    // 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)
+    // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [ip]
+    // 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 confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+
+    let confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    if (confCronData.ipDaemon.disabled) return;
+    this.ip = confCronData.ipDaemon.ip;
+    logger.info(`Current ip`, this.ip);
+    if (this.ipDaemon) clearInterval(this.ipDaemon);
+    const callback = async () => {
+      let testIp;
+      try {
+        testIp = await ip.public.ipv4();
+      } catch (error) {
+        logger.error(error, { testIp, stack: error.stack });
+      }
+      if (testIp && typeof testIp === 'string' && isIPv4(testIp) && this.ip !== testIp) {
+        logger.info(`New ip`, testIp);
+        this.ip = testIp;
+        confCronData.ipDaemon.ip = this.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 this.services.updateIp[dnsProvider.dns] === 'function')
+                  await this.services.updateIp[dnsProvider.dns](dnsProvider);
+              }
+              break;
+
+            default:
+              break;
+          }
+        }
+      }
+    };
+    await callback();
+    this.ipDaemon = setInterval(async () => await callback(), confCronData.ipDaemon.minutesTimeInterval * 1000 * 60);
+  },
+  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}`;
+        logger.info(`${dns} update ip url`, url);
+        if (process.env.NODE_ENV !== 'production') return false;
+        return new Promise((resolve) => {
+          axios
+            .get(url)
+            .then((response) => {
+              logger.info(`${dns} update ip success`, response.data);
+              return resolve(true);
+            })
+            .catch((error) => {
+              logger.error(error, `${dns} update ip error`);
+              return resolve(false);
+            });
+        });
+      },
+    },
+  },
+};
+
+export { Dns };