@underpostnet/underpost 2.8.4 → 2.8.5

package/src/cli/deploy.js

@@ -0,0 +1,277 @@
+import {
+  buildKindPorts,
+  buildPortProxyRouter,
+  buildProxyRouter,
+  Config,
+  getDataDeploy,
+  loadReplicas,
+} from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import Underpost from '../index.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostDeploy {
+  static API = {
+    sync(deployList) {
+      const deployGroupId = 'dd.tmp';
+      fs.writeFileSync(`./engine-private/deploy/${deployGroupId}`, deployList, 'utf8');
+      return getDataDeploy({
+        buildSingleReplica: true,
+        deployGroupId,
+      });
+    },
+    async routerFactory(deployList, env) {
+      const initEnvPath = `./engine-private/conf/${deployList.split(',')[0]}/.env.${env}`;
+      const initEnvObj = dotenv.parse(fs.readFileSync(initEnvPath, 'utf8'));
+      process.env.PORT = initEnvObj.PORT;
+      process.env.NODE_ENV = env;
+      await Config.build(undefined, 'proxy', deployList);
+      return buildPortProxyRouter(env === 'development' ? 80 : 443, buildProxyRouter());
+    },
+    async buildManifest(deployList, env) {
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        if (!deployId) continue;
+
+        const router = await UnderpostDeploy.API.routerFactory(deployId, env);
+        const ports = Object.values(router).map((p) => parseInt(p.split(':')[2]));
+        const fromPort = Math.min(...ports);
+        const toPort = Math.max(...ports);
+        const confServer = loadReplicas(
+          JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+          'proxy',
+        );
+
+        fs.mkdirSync(`./engine-private/conf/${deployId}/build/${env}`, { recursive: true });
+        if (env === 'development') fs.mkdirSync(`./manifests/deployment/${deployId}-${env}`, { recursive: true });
+
+        logger.info('port range', { deployId, fromPort, toPort });
+
+        const deploymentYamlParts = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${deployId}-${env}
+  labels:
+    app: ${deployId}-${env}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${deployId}-${env}
+  template:
+    metadata:
+      labels:
+        app: ${deployId}-${env}
+    spec:
+      containers:
+        - name: ${deployId}-${env}
+          image: localhost/${deployId}-${env}:${Underpost.version}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${deployId}-${env}-service
+spec:
+  selector:
+    app: ${deployId}-${env}
+  ports:
+  type: LoadBalancer`.split('ports:');
+        deploymentYamlParts[1] =
+          buildKindPorts(fromPort, toPort) +
+          `  type: LoadBalancer
+`;
+
+        fs.writeFileSync(
+          `./engine-private/conf/${deployId}/build/${env}/deployment.yaml`,
+          deploymentYamlParts.join(`ports:
+`),
+        );
+
+        let proxyYaml = '';
+        let secretYaml = '';
+
+        for (const host of Object.keys(confServer)) {
+          if (env === 'production')
+            secretYaml += `
+---
+apiVersion: cert-manager.io/v1
+kind: Certificate
+metadata:
+  name: ${host}
+spec:
+  commonName: ${host}
+  dnsNames:
+    - ${host}
+  issuerRef:
+    name: letsencrypt-prod
+    kind: ClusterIssuer
+  secretName: ${host}`;
+
+          const pathPortConditions = [];
+          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 });
+            pathPortConditions.push({
+              port,
+              path,
+            });
+
+            if (peer) {
+              //  logger.info('', { host, port: port + 1, path: '/peer' });
+              pathPortConditions.push({
+                port: port + 1,
+                path: '/peer',
+              });
+            }
+          }
+
+          // logger.info('', { host, pathPortConditions });
+          proxyYaml += `
+---
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: ${host}
+spec:
+  virtualhost:
+    fqdn: ${host}${
+            env === 'development'
+              ? ''
+              : `
+    tls:
+      secretName: ${host}`
+          }
+  routes:`;
+          for (const conditionObj of pathPortConditions) {
+            const { path, port } = conditionObj;
+            proxyYaml += `
+    - conditions:
+        - prefix: ${path}
+      enableWebsockets: true
+      services:
+        - name: ${deployId}-${env}-service
+          port: ${port}`;
+          }
+        }
+        const yamlPath = `./engine-private/conf/${deployId}/build/${env}/proxy.yaml`;
+        fs.writeFileSync(yamlPath, proxyYaml, 'utf8');
+        if (env === 'production') {
+          const yamlPath = `./engine-private/conf/${deployId}/build/${env}/secret.yaml`;
+          fs.writeFileSync(yamlPath, secretYaml, 'utf8');
+        } else {
+          const deploymentsFiles = ['Dockerfile', 'proxy.yaml', 'deployment.yaml'];
+          for (const file of deploymentsFiles) {
+            if (fs.existsSync(`./engine-private/conf/${deployId}/build/${env}/${file}`)) {
+              fs.copyFileSync(
+                `./engine-private/conf/${deployId}/build/${env}/${file}`,
+                `./manifests/deployment/${deployId}-${env}/${file}`,
+              );
+            }
+          }
+        }
+      }
+    },
+    async callback(
+      deployList = 'default',
+      env = 'development',
+      options = { remove: false, infoRouter: false, sync: false, buildManifest: false },
+    ) {
+      if (deployList === 'dd' && fs.existsSync(`./engine-private/deploy/dd.router`))
+        deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
+      if (options.sync) UnderpostDeploy.API.sync(deployList);
+      if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env);
+      if (options.infoRouter === true)
+        return logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
+
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        if (!deployId) continue;
+
+        shellExec(`sudo kubectl delete svc ${deployId}-${env}-service`);
+        shellExec(`sudo kubectl delete deployment ${deployId}-${env}`);
+
+        const etcHost = (
+          concat,
+        ) => `127.0.0.1  ${concat} localhost localhost.localdomain localhost4 localhost4.localdomain4
+::1         localhost localhost.localdomain localhost6 localhost6.localdomain6`;
+        let concatHots = '';
+
+        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+        for (const host of Object.keys(confServer)) {
+          shellExec(`sudo kubectl delete HTTPProxy ${host}`);
+          if (!options.remove === true && env === 'development') concatHots += ` ${host}`;
+        }
+
+        if (!options.remove === true) {
+          shellExec(`sudo kubectl apply -f ./manifests/deployment/${deployId}-${env}/deployment.yaml`);
+          shellExec(`sudo kubectl apply -f ./manifests/deployment/${deployId}-${env}/proxy.yaml`);
+        }
+
+        let renderHosts;
+
+        switch (process.platform) {
+          case 'linux':
+            {
+              switch (env) {
+                case 'development':
+                  renderHosts = etcHost(concatHots);
+                  fs.writeFileSync(`/etc/hosts`, renderHosts, 'utf8');
+
+                  break;
+
+                default:
+                  break;
+              }
+            }
+            break;
+
+          default:
+            break;
+        }
+        logger.info(
+          `
+` + renderHosts,
+        );
+      }
+    },
+    getPods(deployId) {
+      const raw = shellExec(`sudo kubectl get pods --all-namespaces -o wide`, {
+        stdout: true,
+        disableLog: false,
+        silent: true,
+      });
+
+      const heads = raw
+        .split(`\n`)[0]
+        .split(' ')
+        .filter((_r) => _r.trim());
+
+      const pods = raw
+        .split(`\n`)
+        .filter((r) => (deployId ? r.match(deployId) : r.trim() && !r.match('NAME')))
+        .map((r) => r.split(' ').filter((_r) => _r.trim()));
+
+      const result = [];
+
+      for (const row of pods) {
+        const pod = {};
+        let index = -1;
+        for (const head of heads) {
+          index++;
+          pod[head] = row[index];
+        }
+        result.push(pod);
+      }
+
+      return result;
+    },
+  };
+}
+
+export default UnderpostDeploy;

package/src/cli/env.js

@@ -0,0 +1,52 @@
+import { getNpmRootPath, writeEnv } from '../server/conf.js';
+import fs from 'fs-extra';
+import { loggerFactory } from '../server/logger.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostRootEnv {
+  static API = {
+    set(key, value) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      let env = {};
+      if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      env[key] = value;
+      writeEnv(envPath, env);
+    },
+    delete(key) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      let env = {};
+      if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      delete env[key];
+      writeEnv(envPath, env);
+    },
+    get(key) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      logger.info('underpost root', { [key]: env[key] });
+      return env[key];
+    },
+    list() {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      logger.info('underpost root', env);
+      return env;
+    },
+    clean() {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      fs.removeSync(envPath);
+    },
+  };
+}
+
+export default UnderpostRootEnv;

package/src/cli/image.js

@@ -0,0 +1,125 @@
+import fs from 'fs-extra';
+import Underpost from '../index.js';
+import { shellExec } from '../server/process.js';
+import dotenv from 'dotenv';
+import { getNpmRootPath } from '../server/conf.js';
+import { timer } from '../client/components/core/CommonJs.js';
+
+dotenv.config();
+
+class UnderpostImage {
+  static API = {
+    dockerfile: {
+      pullBaseImages() {
+        shellExec(`sudo podman pull docker.io/library/debian:buster`);
+      },
+      build(deployId = 'default', env = 'development', path = '.', options = { imageArchive: false }) {
+        const imgName = `${deployId}-${env}:${Underpost.version}`;
+        const podManImg = `localhost/${imgName}`;
+        const imagesStoragePath = `./images`;
+        const tarFile = `${imagesStoragePath}/${imgName.replace(':', '_')}.tar`;
+
+        let secrets = ' ';
+        let secretDockerInput = '';
+
+        const envObj = dotenv.parse(fs.readFileSync(`${getNpmRootPath()}/underpost/.env`, 'utf8'));
+
+        for (const key of Object.keys(envObj)) {
+          continue;
+          secrets += ` && export ${key}="${envObj[key]}" `; // $(cat gitlab-token.txt)
+          secretDockerInput += ` --secret id=${key},env=${key} \ `;
+        }
+        // --rm --no-cache
+        if (options.imageArchive !== true) {
+          fs.copyFile(`${getNpmRootPath()}/underpost/.env`, `${path}/.env.underpost`);
+          shellExec(
+            `cd ${path}${secrets}&& sudo podman build -f ./Dockerfile -t ${imgName} --pull=never --cap-add=CAP_AUDIT_WRITE${secretDockerInput}`,
+          );
+          fs.removeSync(`${path}/.env.underpost`);
+          shellExec(`cd ${path} && podman save -o ${tarFile} ${podManImg}`);
+        }
+        shellExec(`cd ${path} && sudo kind load image-archive ${tarFile}`);
+      },
+      async script(deployId = 'default', env = 'development', options = { run: false }) {
+        switch (deployId) {
+          case 'dd-lampp':
+            {
+              const lamppPublicPath = '/xampp/htdocs/online';
+              shellExec(`sudo mkdir -p ${lamppPublicPath}`);
+
+              {
+                shellExec(
+                  `cd ${lamppPublicPath} && git clone https://${process.env.GITHUB_TOKEN}@github.com/${process.env.DD_LAMPP_REPO_0}`,
+                );
+
+                shellExec(`cd ${lamppPublicPath} && sudo ${process.env.DD_LAMPP_SCRIPT_0}`);
+
+                shellExec(
+                  `sudo sed -i -e "s@define( 'DB_HOST', 'localhost' );@define( 'DB_HOST', '${process.env.MARIADB_HOST}' );@g" ${lamppPublicPath}/${process.env.DD_LAMPP_REPO_0_FOLDER}/wp-config.php`,
+                );
+              }
+              {
+                shellExec(
+                  `cd ${lamppPublicPath} && git clone https://${process.env.GITHUB_TOKEN}@github.com/${process.env.DD_LAMPP_REPO_1}`,
+                );
+              }
+            }
+            break;
+
+          default:
+            {
+              {
+                const originPath = `./src/db/mongo/MongooseDB.js`;
+                fs.writeFileSync(
+                  originPath,
+                  fs.readFileSync(originPath, 'utf8').replaceAll(
+                    `connect: async (host, name) => {`,
+                    `connect: async (host, name) => {
+    host = 'mongodb://mongodb-0.mongodb-service:27017';
+        `,
+                  ),
+                  'utf8',
+                );
+              }
+
+              {
+                const originPath = `./src/server/valkey.js`;
+                fs.writeFileSync(
+                  originPath,
+                  fs.readFileSync(originPath, 'utf8').replaceAll(
+                    `    // port: 6379,
+    // host: 'service-valkey.default.svc.cluster.local',`,
+                    `     port: 6379,
+    host: 'service-valkey.default.svc.cluster.local',`,
+                  ),
+                  'utf8',
+                );
+              }
+            }
+            break;
+        }
+        shellExec(`node bin/deploy conf ${deployId} ${env}`);
+        shellExec(`node bin/deploy build-full-client ${deployId}`);
+        if (options.run === true) {
+          const runCmd = env === 'production' ? 'prod-img' : 'dev-img';
+          if (fs.existsSync(`./engine-private/replica`)) {
+            const replicas = await fs.readdir(`./engine-private/replica`);
+            for (const replica of replicas) {
+              shellExec(`node bin/deploy conf ${replica} ${env}`);
+              shellExec(`npm run ${runCmd} ${replica} deploy`, { async: true });
+              fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
+              const monitor = async () => {
+                await timer(1000);
+                if (fs.existsSync(`./tmp/await-deploy`)) return await monitor();
+              };
+              await monitor();
+            }
+            shellExec(`node bin/deploy conf ${deployId} ${env}`);
+          }
+          shellExec(`npm run ${runCmd} ${deployId} deploy`);
+        }
+      },
+    },
+  };
+}
+export default UnderpostImage;

package/src/cli/repository.js

@@ -0,0 +1,104 @@
+import { commitData } from '../client/components/core/CommonJs.js';
+import dotenv from 'dotenv';
+import { pbcopy, shellExec } from '../server/process.js';
+import { actionInitLog, loggerFactory } from '../server/logger.js';
+import fs from 'fs-extra';
+import { getNpmRootPath } from '../server/conf.js';
+import { listenPortController, listenServerFactory } from '../server/network.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostRepository {
+  static API = {
+    clone(gitUri = 'underpostnet/pwa-microservices-template', options = { bare: false }) {
+      const repoName = gitUri.split('/').pop();
+      if (fs.existsSync(`./${repoName}`)) fs.removeSync(`./${repoName}`);
+      shellExec(
+        `git clone ${options?.bare === true ? ` --bare ` : ''}https://${
+          process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
+        }github.com/${gitUri}.git`,
+        {
+          disableLog: true,
+        },
+      );
+    },
+    pull(repoPath = './', gitUri = 'underpostnet/pwa-microservices-template') {
+      shellExec(
+        `cd ${repoPath} && git pull https://${
+          process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
+        }github.com/${gitUri}.git`,
+        {
+          disableLog: true,
+        },
+      );
+    },
+    commit(
+      repoPath = './',
+      commitType = 'feat',
+      subModule = '',
+      message = '',
+      options = {
+        copy: false,
+        info: false,
+        empty: false,
+      },
+    ) {
+      if (commitType === 'reset') {
+        shellExec(`cd ${repoPath} && git reset --soft HEAD~${isNaN(parseInt(subModule)) ? 1 : parseInt(subModule)}`);
+        return;
+      }
+      if (options.info) return logger.info('', commitData);
+      const _message = `${commitType}${subModule ? `(${subModule})` : ''}${process.argv.includes('!') ? '!' : ''}: ${
+        commitData[commitType].emoji
+      } ${message ? message : commitData[commitType].description}`;
+      if (options.copy) return pbcopy(_message);
+      shellExec(`cd ${repoPath} && git commit ${options?.empty ? `--allow-empty ` : ''}-m "${_message}"`);
+    },
+
+    push(repoPath = './', gitUri = 'underpostnet/pwa-microservices-template', options = { f: false }) {
+      shellExec(
+        `cd ${repoPath} && git push https://${process.env.GITHUB_TOKEN}@github.com/${gitUri}.git${
+          options?.f === true ? ' --force' : ''
+        }`,
+        {
+          disableLog: true,
+        },
+      );
+      logger.info(
+        'commit url',
+        `http://github.com/${gitUri}/commit/${shellExec(`cd ${repoPath} && git rev-parse --verify HEAD`, {
+          stdout: true,
+        }).trim()}`,
+      );
+    },
+
+    new(repositoryName) {
+      return new Promise(async (resolve, reject) => {
+        try {
+          await logger.setUpInfo();
+          if (repositoryName === 'service') return resolve(await listenPortController(listenServerFactory(), ':'));
+          else actionInitLog();
+          const exeRootPath = `${getNpmRootPath()}/underpost`;
+          const destFolder = `./${repositoryName}`;
+          logger.info('Note: This process may take several minutes to complete');
+          logger.info('build app', { destFolder });
+          if (fs.existsSync(destFolder)) fs.removeSync(destFolder);
+          fs.mkdirSync(destFolder, { recursive: true });
+          fs.copySync(exeRootPath, destFolder);
+          fs.writeFileSync(`${destFolder}/.gitignore`, fs.readFileSync(`${exeRootPath}/.dockerignore`, 'utf8'), 'utf8');
+          shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+          shellExec(`cd ${destFolder} && npm run build`);
+          shellExec(`cd ${destFolder} && npm run dev`);
+          return resolve();
+        } catch (error) {
+          logger.error(error, error.stack);
+          return reject(error.message);
+        }
+      });
+    },
+  };
+}
+
+export default UnderpostRepository;

package/src/cli/script.js

@@ -0,0 +1,29 @@
+import { getNpmRootPath } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostScript {
+  static API = {
+    set(key, value) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
+      packageJson.scripts[key] = value;
+      fs.writeFileSync(`${npmRoot}/package.json`, JSON.stringify(packageJson, null, 4));
+    },
+    run(key) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      shellExec(`cd ${npmRoot} && npm run ${key}`);
+    },
+    get(key) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
+      logger.info('[get] ' + key, packageJson.scripts[key]);
+      return packageJson.scripts[key];
+    },
+  };
+}
+
+export default UnderpostScript;

package/src/cli/secrets.js

@@ -0,0 +1,37 @@
+import dotenv from 'dotenv';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+import UnderpostRootEnv from './env.js';
+
+class UnderpostSecret {
+  static API = {
+    docker: {
+      init() {
+        shellExec(`docker swarm init`);
+      },
+      createFromEnvFile(envPath) {
+        const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+        for (const key of Object.keys(envObj)) {
+          UnderpostSecret.API.docker.set(key, envObj[key]);
+        }
+      },
+      set(key, value) {
+        shellExec(`docker secret rm ${key}`);
+        shellExec(`echo "${value}" | docker secret create ${key} -`);
+      },
+      list() {
+        shellExec(`docker secret ls`);
+      },
+    },
+    underpost: {
+      createFromEnvFile(envPath) {
+        const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+        for (const key of Object.keys(envObj)) {
+          UnderpostRootEnv.API.set(key, envObj[key]);
+        }
+      },
+    },
+  };
+}
+
+export default UnderpostSecret;