cyberia 2.8.885

package/src/server/backup.js

@@ -0,0 +1,96 @@
+/**
+ * Manages backup operations for deployments.
+ * @module src/server/backup.js
+ * @namespace BackUp
+ */
+
+import fs from 'fs-extra';
+import { loggerFactory } from './logger.js';
+import { shellExec } from './process.js';
+import { getCronBackUpFolder } from './conf.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class BackUp
+ * @description Manages backup operations for deployments.
+ * @memberof BackUp
+ */
+class BackUp {
+  /**
+   * @method callback
+   * @description Initiates a backup operation for the specified deployment list.
+   * @param {string} deployList - The list of deployments to backup.
+   * @param {Object} options - The options for the backup operation.
+   * @param {boolean} options.itc - Whether to backup inside container data.
+   * @param {boolean} options.git - Whether to backup data using Git.
+   * @memberof BackUp
+   */
+  static callback = async function (deployList, options = { itc: false, git: false }) {
+    if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
+      deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
+
+    logger.info('init backups callback', deployList);
+    await logger.setUpInfo();
+    const currentDate = new Date().getTime();
+    const maxBackupRetention = 5;
+
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
+
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
+      if (!deployId) continue;
+
+      if (!(options.itc === true)) {
+        shellExec(`node bin db ${options.git ? '--git ' : ''}--export ${deployId}`);
+        continue;
+      }
+
+      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+
+      for (const host of Object.keys(confServer))
+        for (const path of Object.keys(confServer[host])) {
+          // retention policy
+          const { db } = confServer[host][path];
+          if (!db) continue;
+          logger.info('Init backup', { host, path, db });
+
+          const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+          if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+          // .isDirectory()
+          const files = await fs.readdir(backUpPath, { withFileTypes: true });
+
+          const currentBackupsDirs = files
+            .map((fileObj) => parseInt(fileObj.name))
+            .sort((a, b) => a - b)
+            .reverse();
+
+          for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+            const removePathRetention = `${backUpPath}/${retentionPath}`;
+            logger.info('Remove backup folder', removePathRetention);
+            fs.removeSync(removePathRetention);
+          }
+
+          fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+
+          shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+        }
+      shellExec(
+        `cd ./engine-private/cron-backups` +
+          ` && underpost pull . ${process.env.GITHUB_USERNAME}/cron-backups` +
+          ` && git add .` +
+          ` && underpost cmt . backup cron-job '${new Date().toLocaleDateString()}'` +
+          ` && underpost push . ${process.env.GITHUB_USERNAME}/cron-backups`,
+        {
+          disableLog: true,
+        },
+      );
+    }
+  };
+}
+
+export default BackUp;

package/src/server/client-build-docs.js

@@ -0,0 +1,205 @@
+'use strict';
+
+import fs from 'fs-extra';
+import swaggerAutoGen from 'swagger-autogen';
+import { shellExec } from './process.js';
+import { loggerFactory } from './logger.js';
+import { JSONweb } from './client-formatted.js';
+
+/**
+ * Builds API documentation using Swagger
+ * @param {Object} options - Documentation build options
+ * @param {string} options.host - The hostname for the API
+ * @param {string} options.path - The base path for the API
+ * @param {number} options.port - The port number for the API
+ * @param {Object} options.metadata - Metadata for the API documentation
+ * @param {Array<string>} options.apis - List of API modules to document
+ * @param {string} options.publicClientId - Client ID for the public documentation
+ * @param {string} options.rootClientPath - Root path for client files
+ * @param {Object} options.packageData - Package.json data
+ */
+const buildApiDocs = async ({
+  host,
+  path,
+  port,
+  metadata = {},
+  apis = [],
+  publicClientId,
+  rootClientPath,
+  packageData,
+}) => {
+  const logger = loggerFactory(import.meta);
+  const basePath = path === '/' ? `${process.env.BASE_API}` : `/${process.env.BASE_API}`;
+
+  const doc = {
+    info: {
+      version: packageData.version,
+      title: metadata?.title ? `${metadata.title}` : 'REST API',
+      description: metadata?.description ? metadata.description : '',
+    },
+    servers: [
+      {
+        url:
+          process.env.NODE_ENV === 'development'
+            ? `http://localhost:${port}${path}${basePath}`
+            : `https://${host}${path}${basePath}`,
+        description: `${process.env.NODE_ENV} server`,
+      },
+    ],
+    tags: [
+      {
+        name: 'user',
+        description: 'User API operations',
+      },
+    ],
+    components: {
+      schemas: {
+        userRequest: {
+          username: 'user123',
+          password: 'Password123',
+          email: 'user@example.com',
+        },
+        userResponse: {
+          status: 'success',
+          data: {
+            token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjp7Il9pZCI6IjY2YzM3N2Y1N2Y5OWU1OTY5YjgxZG...',
+            user: {
+              _id: '66c377f57f99e5969b81de89',
+              email: 'user@example.com',
+              emailConfirmed: false,
+              username: 'user123',
+              role: 'user',
+              profileImageId: '66c377f57f99e5969b81de87',
+            },
+          },
+        },
+        userUpdateResponse: {
+          status: 'success',
+          data: {
+            _id: '66c377f57f99e5969b81de89',
+            email: 'user@example.com',
+            emailConfirmed: false,
+            username: 'user123222',
+            role: 'user',
+            profileImageId: '66c377f57f99e5969b81de87',
+          },
+        },
+        userGetResponse: {
+          status: 'success',
+          data: {
+            _id: '66c377f57f99e5969b81de89',
+            email: 'user@example.com',
+            emailConfirmed: false,
+            username: 'user123222',
+            role: 'user',
+            profileImageId: '66c377f57f99e5969b81de87',
+          },
+        },
+        userLogInRequest: {
+          email: 'user@example.com',
+          password: 'Password123',
+        },
+        userBadRequestResponse: {
+          status: 'error',
+          message: 'Bad request. Please check your inputs, and try again',
+        },
+      },
+      securitySchemes: {
+        bearerAuth: {
+          type: 'http',
+          scheme: 'bearer',
+        },
+      },
+    },
+  };
+
+  logger.warn('build swagger api docs', doc.info);
+
+  const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
+  const routes = [];
+  for (const api of apis) {
+    if (['user'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
+  }
+
+  await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
+};
+
+/**
+ * Builds JSDoc documentation
+ * @param {Object} options - JSDoc build options
+ * @param {string} options.host - The hostname for the documentation
+ * @param {string} options.path - The base path for the documentation
+ * @param {Object} options.metadata - Metadata for the documentation
+ */
+const buildJsDocs = async ({ host, path, metadata = {} }) => {
+  const logger = loggerFactory(import.meta);
+  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
+
+  jsDocsConfig.opts.destination = `./public/${host}${path === '/' ? path : `${path}/`}docs/`;
+  jsDocsConfig.opts.theme_opts.title = metadata?.title ? metadata.title : undefined;
+  jsDocsConfig.opts.theme_opts.favicon = `./public/${host}${path === '/' ? path : `${path}/favicon.ico`}`;
+
+  fs.writeFileSync(`./jsdoc.json`, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
+  logger.warn('build jsdoc view', jsDocsConfig.opts.destination);
+
+  shellExec(`npm run docs`, { silent: true });
+};
+
+/**
+ * Builds test coverage documentation
+ * @param {Object} options - Coverage build options
+ * @param {string} options.host - The hostname for the coverage
+ * @param {string} options.path - The base path for the coverage
+ */
+const buildCoverage = async ({ host, path }) => {
+  const logger = loggerFactory(import.meta);
+  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
+
+  if (!fs.existsSync(`./coverage`)) {
+    shellExec(`npm test`);
+  }
+
+  const coverageBuildPath = `${jsDocsConfig.opts.destination}coverage`;
+  fs.mkdirSync(coverageBuildPath, { recursive: true });
+  fs.copySync(`./coverage`, coverageBuildPath);
+
+  logger.warn('build coverage', coverageBuildPath);
+};
+
+/**
+ * Main function to build all documentation
+ * @param {Object} options - Documentation build options
+ * @param {string} options.host - The hostname
+ * @param {string} options.path - The base path
+ * @param {number} options.port - The port number
+ * @param {Object} options.metadata - Metadata for the documentation
+ * @param {Array<string>} options.apis - List of API modules to document
+ * @param {string} options.publicClientId - Client ID for the public documentation
+ * @param {string} options.rootClientPath - Root path for client files
+ * @param {Object} options.packageData - Package.json data
+ */
+const buildDocs = async ({
+  host,
+  path,
+  port,
+  metadata = {},
+  apis = [],
+  publicClientId,
+  rootClientPath,
+  packageData,
+}) => {
+  await buildJsDocs({ host, path, metadata });
+  await buildCoverage({ host, path });
+  await buildApiDocs({
+    host,
+    path,
+    port,
+    metadata,
+    apis,
+    publicClientId,
+    rootClientPath,
+    packageData,
+  });
+};
+
+export { buildDocs };

package/src/server/client-build-live.js

@@ -0,0 +1,109 @@
+/**
+ * Module for live building client-side code
+ * @module src/server/client-build-live.js
+ * @namespace clientLiveBuild
+ */
+
+import fs from 'fs-extra';
+import { Config, loadConf } from './conf.js';
+import { loggerFactory } from './logger.js';
+import { buildClient } from './client-build.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @function clientLiveBuild
+ * @description Initiates a live build of client-side code.
+ * @memberof clientLiveBuild
+ */
+const clientLiveBuild = async () => {
+  if (fs.existsSync(`./tmp/client.build.json`)) {
+    const deployId = process.argv[2];
+    const subConf = process.argv[3];
+    let clientId = 'default';
+    let host = 'default.net';
+    let path = '/';
+    let baseHost = `${host}${path === '/' ? '' : path}`;
+    let views = Config.default.client[clientId].views;
+    let apiBaseHost;
+    let apiBaseProxyPath;
+
+    if (
+      deployId &&
+      (fs.existsSync(`./engine-private/conf/${deployId}`) || fs.existsSync(`./engine-private/replica/${deployId}`))
+    ) {
+      loadConf(deployId, subConf);
+      const confClient = JSON.parse(
+        fs.readFileSync(
+          fs.existsSync(`./engine-private/replica/${deployId}`)
+            ? `./engine-private/replica/${deployId}/conf.client.json`
+            : fs.existsSync(`./engine-private/conf/${deployId}/conf.client.json`)
+            ? `./engine-private/conf/${deployId}/conf.client.json`
+            : `./conf/conf.client.json`,
+          'utf8',
+        ),
+      );
+      const confServer = JSON.parse(
+        fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`, 'utf8'),
+      );
+      host = process.argv[4];
+      path = process.argv[5];
+      clientId = confServer[host][path].client;
+      views = confClient[clientId].views;
+      baseHost = `${host}${path === '/' ? '' : path}`;
+      apiBaseHost = confServer[host][path].apiBaseHost;
+      apiBaseProxyPath = confServer[host][path].apiBaseProxyPath;
+    }
+
+    logger.info('Live build config', {
+      deployId,
+      subConf,
+      host,
+      path,
+      clientId,
+      baseHost,
+      views: views.length,
+      apiBaseHost,
+      apiBaseProxyPath,
+    });
+
+    const updates = JSON.parse(fs.readFileSync(`./tmp/client.build.json`, 'utf8'));
+    const liveClientBuildPaths = [];
+    for (let srcPath of updates) {
+      srcPath = srcPath.replaceAll('/', `\\`);
+
+      const srcBuildPath = `./src${srcPath.split('src')[1].replace(/\\/g, '/')}`;
+      if (
+        srcPath.split('src')[1].startsWith(`\\client\\components`) ||
+        srcPath.split('src')[1].startsWith(`\\client\\services`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/${srcPath.split('src')[1].slice(8)}`.replace(/\\/g, '/');
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (srcPath.split('src')[1].startsWith(`\\client\\sw`)) {
+        const publicBuildPath = `./public/${baseHost}/sw.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (
+        srcPath.split('src')[1].startsWith(`\\client\\offline`) &&
+        srcPath.split('src')[1].startsWith(`index.js`)
+      ) {
+        const publicBuildPath = `./public/${baseHost}/offline.js`;
+        liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+      } else if (srcPath.split('src')[1].startsWith(`\\client`) && srcPath.slice(-9) === '.index.js') {
+        for (const view of views) {
+          const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/${clientId}.index.js`;
+          liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+        }
+      } else if (srcPath.split('src')[1].startsWith(`\\client\\ssr`)) {
+        for (const view of views) {
+          const publicBuildPath = `./public/${baseHost}${view.path === '/' ? '' : view.path}/index.html`;
+          liveClientBuildPaths.push({ srcBuildPath, publicBuildPath });
+        }
+      }
+    }
+    logger.info('liveClientBuildPaths', liveClientBuildPaths);
+    await buildClient({ liveClientBuildPaths, instances: [{ host, path }] });
+    fs.removeSync(`./tmp/client.build.json`);
+  }
+};
+
+export { clientLiveBuild };