cyberia 2.8.885

package/src/server/conf.js

@@ -0,0 +1,1071 @@
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import {
+  capFirst,
+  getCapVariableName,
+  newInstance,
+  orderArrayFromAttrInt,
+  range,
+  timer,
+} from '../client/components/core/CommonJs.js';
+import * as dir from 'path';
+import colors from 'colors';
+import { loggerFactory } from './logger.js';
+import { shellExec } from './process.js';
+import { DefaultConf } from '../../conf.js';
+import splitFile from 'split-file';
+import UnderpostRootEnv from '../cli/env.js';
+
+colors.enable();
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const Config = {
+  default: DefaultConf,
+  build: async function (deployContext = 'dd-default', deployList, subConf) {
+    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, 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}`;
+
+    logger.info('Build deployId', deployId);
+
+    const folder = `./engine-private/conf/${deployId}`;
+    const repoName = `engine-${deployId.split('dd-')[1]}`;
+
+    if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+    fs.writeFileSync(
+      `${folder}/.env.production`,
+      fs.readFileSync('./.env.production', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(
+      `${folder}/.env.development`,
+      fs.readFileSync('./.env.development', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(
+      `${folder}/.env.test`,
+      fs.readFileSync('./.env.test', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(
+      `${folder}/package.json`,
+      fs.readFileSync('./package.json', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+
+    this.buildTmpConf(folder);
+
+    if (options.cluster === true) {
+      fs.writeFileSync(
+        `./.github/workflows/${repoName}.cd.yml`,
+        fs.readFileSync(`./.github/workflows/engine-test.cd.yml`, 'utf8').replaceAll('test', deployId.split('dd-')[1]),
+        'utf8',
+      );
+      fs.writeFileSync(
+        `./.github/workflows/${repoName}.ci.yml`,
+        fs.readFileSync(`./.github/workflows/engine-test.ci.yml`, 'utf8').replaceAll('test', deployId.split('dd-')[1]),
+        'utf8',
+      );
+      shellExec(`node bin/deploy update-default-conf ${deployId}`);
+
+      if (!fs.existsSync(`./engine-private/deploy/dd.router`))
+        fs.writeFileSync(`./engine-private/deploy/dd.router`, '', 'utf8');
+
+      fs.writeFileSync(
+        `./engine-private/deploy/dd.router`,
+        fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').trim() + `,${deployId}`,
+        'utf8',
+      );
+      const updateRepo = (stage = 1) => {
+        shellExec(`git add . && git commit -m "Add base deployId ${deployId} cluster files stage:${stage}"`);
+        shellExec(
+          `cd engine-private && git add . && git commit -m "Add base deployId ${deployId} cluster files stage:${stage}"`,
+        );
+      };
+      updateRepo(1);
+      shellExec(`node bin run --build --dev sync`);
+      updateRepo(2);
+      shellExec(`node bin run --build sync`);
+      updateRepo(3);
+    }
+
+    return { deployIdFolder: folder, deployId };
+  },
+  buildTmpConf: function (folder = './conf') {
+    for (const confType of Object.keys(this.default))
+      fs.writeFileSync(`${folder}/conf.${confType}.json`, JSON.stringify(this.default[confType], null, 4), 'utf8');
+  },
+  buildProxy: function (deployList = 'dd-default', subConf = '') {
+    if (!deployList) deployList = process.argv[3];
+    if (!subConf) subConf = process.argv[4];
+    this.default.server = {};
+    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.${subConf}.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],
+          };
+      }
+    }
+    this.buildTmpConf();
+  },
+};
+
+const loadConf = (deployId = 'dd-default', subConf) => {
+  if (deployId === 'current') {
+    console.log(process.env.DEPLOY_ID);
+    return;
+  }
+  if (deployId === 'clean') {
+    const path = '.';
+    fs.removeSync(`${path}/.env`);
+    shellExec(`git checkout ${path}/.env.production`);
+    shellExec(`git checkout ${path}/.env.development`);
+    shellExec(`git checkout ${path}/.env.test`);
+    if (fs.existsSync(`${path}/jsdoc.json`)) shellExec(`git checkout ${path}/jsdoc.json`);
+    shellExec(`git checkout ${path}/package.json`);
+    shellExec(`git checkout ${path}/package-lock.json`);
+    return;
+  }
+  const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
+    ? `./engine-private/replica/${deployId}`
+    : `./engine-private/conf/${deployId}`;
+  if (!fs.existsSync(folder)) Config.deployIdFactory(deployId);
+  if (!fs.existsSync(`./conf`)) fs.mkdirSync(`./conf`);
+  if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`);
+
+  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') {
+      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);
+    fs.writeFileSync(`./conf/conf.${typeConf}.json`, srcConf, 'utf8');
+  }
+  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 = process.env.NODE_ENV;
+  if (NODE_ENV) {
+    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,
+    };
+  }
+  const originPackageJson = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
+  const packageJson = JSON.parse(fs.readFileSync(`${folder}/package.json`, 'utf8'));
+  originPackageJson.scripts.start = packageJson.scripts.start;
+  packageJson.scripts = originPackageJson.scripts;
+  fs.writeFileSync(`./package.json`, JSON.stringify(packageJson, null, 4), '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 && !singleReplica)
+        for (const replicaPath of replicas) {
+          {
+            confServer[host][replicaPath] = newInstance(confServer[host][path]);
+            delete confServer[host][replicaPath].replicas;
+          }
+        }
+    }
+  }
+  return confServer;
+};
+
+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/${toClientVariableName}Scripts.js`,
+    formattedSrc(fs.readFileSync(`./src/client/ssr/head/${fromClientVariableName}Scripts.js`, 'utf8')),
+    'utf8',
+  );
+
+  fs.writeFileSync(
+    `./src/client/${toClientVariableName}.index.js`,
+    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.index.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 pathPortAssignmentFactory = (router, confServer) => {
+  const pathPortAssignmentData = {};
+  for (const host of Object.keys(confServer)) {
+    const pathPortAssignment = [];
+    for (const path of Object.keys(confServer[host])) {
+      const { peer } = confServer[host][path];
+      if (!router[`${host}${path === '/' ? '' : path}`]) continue;
+      const port = parseInt(router[`${host}${path === '/' ? '' : path}`].split(':')[2]);
+      // logger.info('', { host, port, path });
+      pathPortAssignment.push({
+        port,
+        path,
+      });
+
+      if (peer) {
+        //  logger.info('', { host, port: port + 1, path: '/peer' });
+        pathPortAssignment.push({
+          port: port + 1,
+          path: '/peer',
+        });
+      }
+    }
+    pathPortAssignmentData[host] = pathPortAssignment;
+  }
+  return pathPortAssignmentData;
+};
+
+const deployRangePortFactory = (router) => {
+  const ports = Object.values(router).map((p) => parseInt(p.split(':')[2]));
+  const fromPort = Math.min(...ports);
+  const toPort = Math.max(...ports);
+  return { ports, fromPort, toPort };
+};
+
+const buildKindPorts = (from, to) =>
+  range(parseInt(from), parseInt(to))
+    .map(
+      (port) => `    - name: 'tcp-${port}'
+      protocol: TCP
+      port: ${port}
+      targetPort: ${port}
+    - name: 'udp-${port}'
+      protocol: UDP
+      port: ${port}
+      targetPort: ${port}
+`,
+    )
+    .join('\n');
+
+const buildPortProxyRouter = (port, proxyRouter) => {
+  const hosts = proxyRouter[port];
+  const router = {};
+  // build router
+  Object.keys(hosts).map((hostKey) => {
+    let { host, path, target, proxy, peer } = hosts[hostKey];
+    if (process.env.NODE_ENV === 'development' && process.argv.includes('localhost')) host = `localhost`;
+
+    if (!proxy.includes(port)) {
+      logger.warn('Proxy port not set on conf', { port, host, path, proxy, target });
+      if (process.env.NODE_ENV === 'production') {
+        logger.warn('Omitting host', { host, path, target });
+        return;
+      }
+    }
+
+    const absoluteHost = [80, 443].includes(port)
+      ? `${host}${path === '/' ? '' : path}`
+      : `${host}:${port}${path === '/' ? '' : path}`;
+
+    if (absoluteHost in router)
+      logger.warn('Overwrite: Absolute host already exists on router', { absoluteHost, target });
+
+    router[absoluteHost] = target;
+  }); // order router
+
+  if (Object.keys(router).length === 0) return router;
+
+  const reOrderRouter = {};
+  for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
+    reOrderRouter[absoluteHostKey] = router[absoluteHostKey];
+
+  return reOrderRouter;
+};
+
+const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1)}`;
+
+const getDataDeploy = (
+  options = {
+    buildSingleReplica: false,
+    deployGroupId: '',
+    deployId: '',
+    disableSyncEnvPort: false,
+  },
+) => {
+  let dataDeploy =
+    options.deployGroupId === 'dd'
+      ? fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.router`, 'utf8')
+      : fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}`, 'utf8');
+
+  dataDeploy = dataDeploy
+    .split(',')
+    .map((deployId) => deployId.trim())
+    .filter((deployId) => deployId);
+
+  if (options.deployId) dataDeploy = dataDeploy.filter((d) => d === options.deployId);
+
+  dataDeploy = dataDeploy.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(Cmd.replica(deployObj.deployId, host, path));
+          replicaDataDeploy = replicaDataDeploy.concat(
+            serverConf[host][path].replicas.map((r) => {
+              return {
+                deployId: buildReplicaId({ deployId: deployObj.deployId, replica: r }),
+                replicaHost: host,
+              };
+            }),
+          );
+        }
+      }
+    buildDataDeploy.push(deployObj);
+    if (replicaDataDeploy.length > 0) buildDataDeploy = buildDataDeploy.concat(replicaDataDeploy);
+  }
+
+  const enableSyncEnvPort = !options.disableSyncEnvPort && options.buildSingleReplica;
+  if (enableSyncEnvPort) shellExec(Cmd.syncPorts(options.deployGroupId));
+
+  logger.info('buildDataDeploy', { buildDataDeploy, enableSyncEnvPort });
+
+  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 = DefaultConf.client.default.services;
+
+  if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
+    return false;
+  }
+  if (absolutePath.match('conf.dd-') && absolutePath.match('.js')) 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') &&
+    !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/pages') &&
+    !confSsr.pages.find((p) => absolutePath.match(`src/client/ssr/pages/${p.client}.js`))
+  ) {
+    return false;
+  }
+  if (absolutePath.match('hardhat/')) return false;
+  if (
+    absolutePath.match('/client') &&
+    absolutePath.match('.index.js') &&
+    !absolutePath.match('/offline') &&
+    !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;
+};
+
+const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
+  if (init) UnderpostRootEnv.API.set('await-deploy', new Date().toISOString());
+  await timer(deltaMs);
+  if (UnderpostRootEnv.API.get('await-deploy')) return await awaitDeployMonitor();
+};
+
+const getCronBackUpFolder = (host = '', path = '') => {
+  return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
+};
+
+const mergeFile = async (parts = [], outputFilePath) => {
+  await new Promise((resolve) => {
+    splitFile
+      .mergeFiles(parts, outputFilePath)
+      .then(() => {
+        resolve();
+      })
+      .catch((err) => {
+        console.log('Error: ', err);
+        resolve();
+      });
+  });
+};
+
+const rebuildConfFactory = ({ deployId, valkey, mongo }) => {
+  const confServer = loadReplicas(
+    JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+  );
+  const hosts = {};
+  for (const host of Object.keys(confServer)) {
+    hosts[host] = {};
+    for (const path of Object.keys(confServer[host])) {
+      if (!confServer[host][path].db) continue;
+      const { singleReplica, replicas, db } = confServer[host][path];
+      const { provider } = db;
+      if (singleReplica) {
+        for (const replica of replicas) {
+          const deployIdReplica = buildReplicaId({ replica, deployId });
+          const confServerReplica = JSON.parse(
+            fs.readFileSync(`./engine-private/replica/${deployIdReplica}/conf.server.json`, 'utf8'),
+          );
+          for (const _host of Object.keys(confServerReplica)) {
+            for (const _path of Object.keys(confServerReplica[_host])) {
+              hosts[host][_path] = { replica: { host, path } };
+              confServerReplica[_host][_path].valkey = valkey;
+              switch (provider) {
+                case 'mongoose':
+                  confServerReplica[_host][_path].db.host = mongo.host;
+                  break;
+              }
+            }
+          }
+          fs.writeFileSync(
+            `./engine-private/replica/${deployIdReplica}/conf.server.json`,
+            JSON.stringify(confServerReplica, null, 4),
+            'utf8',
+          );
+        }
+      } else hosts[host][path] = {};
+      confServer[host][path].valkey = valkey;
+      switch (provider) {
+        case 'mongoose':
+          confServer[host][path].db.host = mongo.host;
+          break;
+      }
+    }
+  }
+  fs.writeFileSync(`./engine-private/conf/${deployId}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+  return { hosts };
+};
+
+const getPathsSSR = (conf) => {
+  const paths = ['src/client/ssr/Render.js'];
+  for (const o of conf.head) paths.push(`src/client/ssr/head/${o}.js`);
+  for (const o of conf.body) paths.push(`src/client/ssr/body/${o}.js`);
+  for (const o of Object.keys(conf.mailer)) paths.push(`src/client/ssr/mailer/${conf.mailer[o]}.js`);
+  for (const o of conf.offline) paths.push(`src/client/ssr/mailer/${o.client}.js`);
+  for (const o of conf.pages) paths.push(`src/client/ssr/pages/${o.client}.js`);
+  return paths;
+};
+
+const Cmd = {
+  delete: (deployId) => `pm2 delete ${deployId}`,
+  run: () => `npm start`,
+  build: (deployId) => `node bin/deploy build-full-client ${deployId}${process.argv.includes('l') ? ' l' : ''}`,
+  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: (deployList, jobList, name, expression, options) =>
+    `pm2 start ./bin/index.js --no-autorestart --instances 1 --cron "${expression}" --name ${name} -- cron ${
+      options?.itc ? `--itc ` : ''
+    }${options?.git ? `--git ` : ''}${deployList} ${jobList}`,
+};
+
+const splitFileFactory = async (name, _path) => {
+  const stats = fs.statSync(_path);
+  const maxSizeInBytes = 1024 * 1024 * 50; // 50 mb
+  const fileSizeInBytes = stats.size;
+  if (fileSizeInBytes > maxSizeInBytes) {
+    logger.info('splitFileFactory input', { name, from: _path });
+    return await new Promise((resolve) => {
+      splitFile
+        .splitFileBySize(_path, maxSizeInBytes) // 50 mb
+        .then((names) => {
+          logger.info('splitFileFactory output', { parts: names });
+          fs.writeFileSync(
+            `${_path.split('/').slice(0, -1).join('/')}/${name}-parths.json`,
+            JSON.stringify(names, null, 4),
+            'utf8',
+          );
+          fs.removeSync(_path);
+          return resolve(true);
+        })
+        .catch((err) => {
+          console.log('Error: ', err);
+          return resolve(false);
+        });
+    });
+  }
+  return false;
+};
+
+const getNpmRootPath = () =>
+  shellExec(`npm root -g`, {
+    stdout: true,
+    disableLog: true,
+    silent: true,
+  }).trim();
+
+const getUnderpostRootPath = () => `${getNpmRootPath()}/underpost`;
+
+const writeEnv = (envPath, envObj) =>
+  fs.writeFileSync(
+    envPath,
+    Object.keys(envObj)
+      .map((key) => `${key}=${envObj[key]}`)
+      .join(`\n`),
+    'utf8',
+  );
+
+const buildCliDoc = (program, oldVersion, newVersion) => {
+  let md = shellExec(`node bin help`, { silent: true, stdout: true }).split('Options:');
+  const baseOptions =
+    `## ${md[0].split(`\n`)[2]}
+
+### Usage: ` +
+    '`' +
+    md[0].split(`\n`)[0].split('Usage: ')[1] +
+    '`' +
+    `
+  ` +
+    '```\n Options:' +
+    md[1] +
+    ' \n```';
+  md =
+    baseOptions +
+    `
+
+## Commands:
+    `;
+  program.commands.map((o) => {
+    md +=
+      `
+
+` +
+      '### `' +
+      o._name +
+      '` :' +
+      `
+` +
+      '```\n ' +
+      shellExec(`node bin help ${o._name}`, { silent: true, stdout: true }) +
+      ' \n```' +
+      `
+  `;
+  });
+  md = md.replaceAll(oldVersion, newVersion);
+  fs.writeFileSync(`./src/client/public/nexodev/docs/references/Command Line Interface.md`, md, 'utf8');
+  fs.writeFileSync(`./cli.md`, md, 'utf8');
+  const readmeSplit = `pwa-microservices-template</a>`;
+  const readme = fs.readFileSync(`./README.md`, 'utf8').split(readmeSplit);
+  fs.writeFileSync(
+    './README.md',
+    (
+      readme[0] +
+      readmeSplit +
+      `
+
+` +
+      baseOptions +
+      `
+      
+<a target="_top" href="https://github.com/${process.env.GITHUB_USERNAME}/pwa-microservices-template/blob/master/cli.md">See complete CLI Docs here.</a>
+      
+`
+    ).replaceAll(oldVersion, newVersion),
+    'utf8',
+  );
+};
+
+const getInstanceContext = async (options = { singleReplica, replicas, redirect: '' }) => {
+  const { singleReplica, replicas, redirect } = options;
+
+  if (singleReplica && replicas && replicas.length > 0)
+    return {
+      singleReplicaHost: true,
+    };
+
+  const redirectTarget = redirect
+    ? redirect[redirect.length - 1] === '/'
+      ? redirect.slice(0, -1)
+      : redirect
+    : undefined;
+
+  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,
+  loadConf,
+  loadReplicas,
+  cloneConf,
+  getCapVariableName,
+  buildClientSrc,
+  buildApiSrc,
+  addApiConf,
+  addClientConf,
+  addWsConf,
+  buildWsSrc,
+  cloneSrcComponents,
+  buildProxyRouter,
+  getDataDeploy,
+  validateTemplatePath,
+  buildReplicaId,
+  getCronBackUpFolder,
+  mergeFile,
+  getPathsSSR,
+  buildKindPorts,
+  buildPortProxyRouter,
+  splitFileFactory,
+  getNpmRootPath,
+  getUnderpostRootPath,
+  writeEnv,
+  pathPortAssignmentFactory,
+  deployRangePortFactory,
+  awaitDeployMonitor,
+  rebuildConfFactory,
+  buildCliDoc,
+  getInstanceContext,
+  buildApiConf,
+  buildClientStaticConf,
+};