underpost 2.8.1 → 2.8.6

package/src/cli/repository.js

@@ -0,0 +1,125 @@
+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);
+        }
+      });
+    },
+
+    getDeleteFiles(path = '.') {
+      const commandUntrack = `cd ${path} && git ls-files --deleted`;
+      const diffUntrackOutput = shellExec(commandUntrack, { stdout: true, silent: true });
+      return diffUntrackOutput.toString().split('\n').filter(Boolean);
+    },
+
+    getChangedFiles(path = '.', extension = '', head = false) {
+      const extensionFilter = extension ? `-- '***.${extension}'` : '';
+      const command = `cd ${path} && git diff ${head ? 'HEAD^ HEAD ' : ''}--name-only ${extensionFilter}`;
+      const commandUntrack = `cd ${path} && git ls-files --others --exclude-standard`;
+      const diffOutput = shellExec(command, { stdout: true, silent: true });
+      const diffUntrackOutput = shellExec(commandUntrack, { stdout: true, silent: true });
+      const deleteFiles = UnderpostRepository.API.getDeleteFiles(path);
+      return diffOutput
+        .toString()
+        .split('\n')
+        .filter(Boolean)
+        .concat(diffUntrackOutput.toString().split('\n').filter(Boolean))
+        .filter((f) => !deleteFiles.includes(f));
+    },
+  };
+}
+
+export default UnderpostRepository;

package/src/cli/script.js

@@ -0,0 +1,53 @@
+import { getNpmRootPath } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+import UnderpostDeploy from './deploy.js';
+
+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, value, options) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
+      if (options.itc === true) {
+        value = packageJson.scripts[key];
+        const podScriptPath = `${options.itcPath && typeof options.itcPath === 'string' ? options.itcPath : '/'}${value
+          .split('/')
+          .pop()}`;
+        const nameSpace = options.ns && typeof options.ns === 'string' ? options.ns : 'default';
+        const podMatch = options.podName && typeof options.podName === 'string' ? options.podName : key;
+
+        if (fs.existsSync(`${value}`)) {
+          for (const pod of UnderpostDeploy.API.get(podMatch)) {
+            shellExec(`sudo kubectl cp ${value} ${nameSpace}/${pod.NAME}:${podScriptPath}`);
+            const cmd = `node ${podScriptPath}`;
+            shellExec(`sudo kubectl exec -i ${pod.NAME} -- sh -c "${cmd}"`);
+          }
+        } else {
+          for (const pod of UnderpostDeploy.API.get(podMatch)) {
+            shellExec(`sudo kubectl exec -i ${pod.NAME} -- sh -c "${value}"`);
+          }
+        }
+
+        return;
+      }
+      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;

package/src/cli/test.js

@@ -0,0 +1,118 @@
+import { timer } from '../client/components/core/CommonJs.js';
+import { MariaDB } from '../db/mariadb/MariaDB.js';
+import { getNpmRootPath } from '../server/conf.js';
+import { actionInitLog, loggerFactory, setUpInfo } from '../server/logger.js';
+import { pbcopy, shellExec } from '../server/process.js';
+import UnderpostDeploy from './deploy.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostTest {
+  static API = {
+    /**
+     * Logs information about the current process environment to the console.
+     *
+     * This function is used to log details about
+     * the execution context, such as command-line arguments,
+     * environment variables, the process's administrative privileges,
+     * and the maximum available heap space size.
+     *
+     * @static
+     * @method setUpInfo
+     * @returns {Promise<void>}
+     * @memberof Underpost
+     */
+    async setUpInfo() {
+      return await setUpInfo(logger);
+    },
+    run() {
+      actionInitLog();
+      shellExec(`cd ${getNpmRootPath()}/underpost && npm run test`);
+    },
+    async callback(deployList = '', options = { itc: false, sh: false, logs: false }) {
+      if (
+        options.podName &&
+        typeof options.podName === 'string' &&
+        options.podStatus &&
+        typeof options.podStatus === 'string'
+      )
+        return await UnderpostTest.API.statusMonitor(options.podName, options.podStatus, options.kindType);
+
+      if (options.sh === true || options.logs === true) {
+        const [pod] = UnderpostDeploy.API.get(deployList);
+        if (pod) {
+          if (options.sh) return pbcopy(`sudo kubectl exec -it ${pod.NAME} -- sh`);
+          if (options.logs) return shellExec(`sudo kubectl logs -f ${pod.NAME}`);
+        }
+        return logger.warn(`Couldn't find pods in deployment`, deployList);
+      }
+      if (deployList) {
+        for (const _deployId of deployList.split(',')) {
+          const deployId = _deployId.trim();
+          if (!deployId) continue;
+          if (options.itc === true)
+            switch (deployId) {
+              case 'dd-lampp':
+                {
+                  const { MARIADB_HOST, MARIADB_USER, MARIADB_PASSWORD, DD_LAMPP_TEST_DB_0 } = process.env;
+
+                  await MariaDB.query({
+                    host: MARIADB_HOST,
+                    user: MARIADB_USER,
+                    password: MARIADB_PASSWORD,
+                    query: `SHOW TABLES FROM ${DD_LAMPP_TEST_DB_0}`,
+                  });
+                }
+                break;
+
+              default:
+                {
+                  shellExec('npm run test');
+                }
+
+                break;
+            }
+          else {
+            const pods = UnderpostDeploy.API.get(deployId);
+            if (pods.length > 0)
+              for (const deployData of pods) {
+                const { NAME } = deployData;
+                shellExec(
+                  `sudo kubectl exec -i ${NAME} -- sh -c "cd /home/dd/engine && underpost test ${deployId} --inside-container"`,
+                );
+              }
+            else logger.warn(`Couldn't find pods in deployment`, { deployId });
+          }
+        }
+      } else return UnderpostTest.API.run();
+    },
+    statusMonitor(podName, status = 'Running', kindType = '', deltaMs = 1000, maxAttempts = 60 * 5) {
+      if (!(kindType && typeof kindType === 'string')) kindType = 'pods';
+      return new Promise(async (resolve) => {
+        let index = 0;
+        logger.info(`Loading instance`, { podName, status, kindType, deltaMs, maxAttempts });
+        const _monitor = async () => {
+          await timer(deltaMs);
+          const pods = UnderpostDeploy.API.get(podName, kindType);
+          const result = pods.find((p) => p.STATUS === status);
+          logger.info(
+            `Testing pod ${podName}... ${result ? 1 : 0}/1 - elapsed time ${deltaMs * (index + 1)}s - attempt ${
+              index + 1
+            }/${maxAttempts}`,
+            pods[0] ? pods[0].STATUS : 'Not found kind object',
+          );
+          if (result) return resolve(true);
+          index++;
+          if (index === maxAttempts) {
+            logger.error(`Failed to test pod ${podName} within ${maxAttempts} attempts`);
+            return resolve(false);
+          }
+          return _monitor();
+        };
+        await _monitor();
+      });
+    },
+  };
+}
+
+export default UnderpostTest;

package/src/client/components/core/Auth.js

@@ -3,7 +3,10 @@ import { Account } from './Account.js';
 import { loggerFactory } from './Logger.js';
 import { LogIn } from './LogIn.js';
 import { LogOut } from './LogOut.js';
+import { NotificationManager } from './NotificationManager.js';
 import { SignUp } from './SignUp.js';
+import { Translate } from './Translate.js';
+import { s } from './VanillaJs.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -65,6 +68,7 @@ const Auth = {
               const _result = await UserService.get({ id: 'auth' });
               return {
                 status: _result.status,
+                message: _result.message,
                 data: {
                   user: _result.data,
                 },
@@ -77,6 +81,15 @@ const Auth = {
           await Account.updateForm(data.user);
           return { user: data.user };
         }
+        if (message && message.match('expired'))
+          setTimeout(() => {
+            s(`.main-btn-log-in`).click();
+            NotificationManager.Push({
+              html: Translate.Render(`expired-session`),
+              status: 'warning',
+            });
+          });
+        return await Auth.sessionOut();
       }
 
       // anon guest session
@@ -92,20 +105,25 @@ const Auth = {
 
       this.setGuestToken(guestToken);
       let { data, status, message } = await UserService.get({ id: 'auth' });
-      if (status === 'error') throw new Error(message);
+      if (status === 'error') {
+        if (message && message.match('expired')) {
+          localStorage.removeItem('jwt.g');
+          return await Auth.sessionOut();
+        } else throw new Error(message);
+      }
       await Account.updateForm(data);
       return { user: data };
     } catch (error) {
       logger.error(error);
-      localStorage.removeItem('jwt');
-      localStorage.removeItem('jwt.g');
       return { user: UserMock.default };
     }
   },
   sessionOut: async function () {
     this.deleteToken();
     localStorage.removeItem('jwt');
-    await LogOut.Trigger(await this.sessionIn());
+    const result = await this.sessionIn();
+    await LogOut.Trigger(result);
+    return result;
   },
 };