underpost 2.8.877 → 2.8.881

package/src/index.js

@@ -35,7 +35,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.877';
+  static version = 'v2.8.881';
   /**
    * Repository cli API
    * @static

package/src/mailer/EmailRender.js

@@ -1,4 +1,4 @@
-import { ssrFactory } from '../server/client-formatted.js';
+import { ssrFactory } from '../server/ssr.js';
 
 const EmailRender = {
   style: {

package/src/server/auth.js

@@ -523,6 +523,7 @@ function applySecurity(app, opts = {}) {
 
   // Content-Security-Policy: include nonce from res.locals
   // Note: We avoid 'unsafe-inline' on script/style. Use nonces or hashes.
+  const httpDirective = process.env.NODE_ENV === 'production' ? 'https:' : 'http:';
   app.use(
     helmet.contentSecurityPolicy({
       useDefaults: true,
@@ -530,16 +531,16 @@ function applySecurity(app, opts = {}) {
         defaultSrc: ["'self'"],
         baseUri: ["'self'"],
         blockAllMixedContent: [],
-        fontSrc: ["'self'", 'https:', 'data:'],
+        fontSrc: ["'self'", httpDirective, 'data:'],
         frameAncestors: frameAncestors,
-        imgSrc: ["'self'", 'data:', 'https:'],
+        imgSrc: ["'self'", 'data:', httpDirective],
         objectSrc: ["'none'"],
         // script-src and script-src-elem include dynamic nonce
         scriptSrc: ["'self'", (req, res) => `'nonce-${res.locals.nonce}'`],
         scriptSrcElem: ["'self'", (req, res) => `'nonce-${res.locals.nonce}'`],
         // style-src: avoid 'unsafe-inline' when possible; if you must inline styles,
         // use a nonce for them too (or hash).
-        styleSrc: ["'self'", 'https:', (req, res) => `'nonce-${res.locals.nonce}'`],
+        styleSrc: ["'self'", httpDirective, (req, res) => `'nonce-${res.locals.nonce}'`],
         // deny plugins
         objectSrc: ["'none'"],
       },

package/src/server/client-build.js

@@ -1,14 +1,12 @@
 'use strict';
 
 import fs from 'fs-extra';
-import { srcFormatted, componentFormatted, viewFormatted, ssrFactory, JSONweb } from './client-formatted.js';
+import { srcFormatted, componentFormatted, viewFormatted, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
 import {
-  cap,
   getCapVariableName,
   newInstance,
   orderArrayFromAttrInt,
-  titleFormatted,
   uniqueArray,
 } from '../client/components/core/CommonJs.js';
 import UglifyJS from 'uglify-js';
@@ -22,6 +20,7 @@ import { Readable } from 'stream';
 import { buildIcons } from './client-icons.js';
 import Underpost from '../index.js';
 import { buildDocs } from './client-build-docs.js';
+import { ssrFactory } from './ssr.js';
 
 dotenv.config();
 

package/src/server/client-formatted.js

@@ -1,9 +1,17 @@
-'use strict';
+/**
+ * Module for formatting client-side code
+ * @module src/server/client-formatted.js
+ * @namespace clientFormatted
+ */
 
-import fs from 'fs-extra';
-import vm from 'node:vm';
-import Underpost from '../index.js';
+'use strict';
 
+/**
+ * Formats a source code string by removing 'html`' and 'css`' tags from template literals.
+ * @param {string} src - The source code string.
+ * @returns {string} The formatted source code.
+ * @memberof clientFormatted
+ */
 const srcFormatted = (src) =>
   src
     .replaceAll(' html`', '`')
@@ -15,8 +23,26 @@ const srcFormatted = (src) =>
     .replaceAll('[html`', '[`')
     .replaceAll('[css`', '[`');
 
+/**
+ * Converts a JavaScript object into a string that can be embedded in client-side code
+ * and parsed back into an object (e.g., 'JSON.parse(`{...}`)').
+ * @param {*} data - The data to be stringified.
+ * @returns {string} A string representing the code to parse the JSON data.
+ * @memberof clientFormatted
+ */
 const JSONweb = (data) => 'JSON.parse(`' + JSON.stringify(data) + '`)';
 
+/**
+ * Formats a component's source code by rewriting its import paths to be absolute for browser consumption.
+ * @param {string} src - The source code of the component.
+ * @param {string} module - The name of the module/component.
+ * @param {Array<object>} dists - An array of distribution objects with import names.
+ * @param {string} proxyPath - The proxy path for the application.
+ * @param {string} [componentBasePath=''] - The base path for components.
+ * @param {string} [baseHost=''] - The base host URL.
+ * @returns {string} The formatted source code with updated import paths.
+ * @memberof clientFormatted
+ */
 const componentFormatted = (src, module, dists, proxyPath, componentBasePath = '', baseHost = '') => {
   dists.map(
     (dist) =>
@@ -40,6 +66,15 @@ const componentFormatted = (src, module, dists, proxyPath, componentBasePath = '
     );
 };
 
+/**
+ * Formats a view's source code by rewriting its import paths.
+ * @param {string} src - The source code of the view.
+ * @param {Array<object>} dists - An array of distribution objects with import names.
+ * @param {string} proxyPath - The proxy path for the application.
+ * @param {string} [baseHost=''] - The base host URL.
+ * @returns {string} The formatted source code with updated import paths.
+ * @memberof clientFormatted
+ */
 const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
   dists.map(
     (dist) =>
@@ -49,11 +84,4 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
   return src.replaceAll(`from './`, componentFromFormatted).replaceAll(`from '../`, componentFromFormatted);
 };
 
-const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
-  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
-  vm.createContext(context);
-  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
-  return context.SrrComponent;
-};
-
-export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };
+export { srcFormatted, JSONweb, componentFormatted, viewFormatted };

package/src/server/conf.js

@@ -33,12 +33,13 @@ const Config = {
     else if (deployContext.startsWith('dd-')) return loadConf(deployContext, process.env.NODE_ENV, subConf);
     if (deployContext === 'proxy') Config.buildProxy(deployContext, deployList, subConf);
   },
-  deployIdFactory: function (deployId = 'dd-default') {
+  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(
@@ -56,10 +57,48 @@ const Config = {
       fs.readFileSync('./.env.test', 'utf8').replaceAll('dd-default', deployId),
       'utf8',
     );
-    fs.writeFileSync(`${folder}/package.json`, fs.readFileSync('./package.json', 'utf8'), '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') {
@@ -657,7 +696,7 @@ const validateTemplatePath = (absolutePath = '') => {
   const confServer = DefaultConf.server[host][path];
   const confClient = DefaultConf.client[client];
   const confSsr = DefaultConf.ssr[ssr];
-  const clients = Object.keys(confClient).concat(['core', 'test', 'default', 'user']);
+  const clients = DefaultConf.client.default.services;
 
   if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
     return false;

package/src/server/object-layer.js

@@ -0,0 +1,196 @@
+import dotenv from 'dotenv';
+
+import fs from 'fs-extra';
+import { PNG } from 'pngjs';
+import sharp from 'sharp';
+import Jimp from 'jimp';
+
+import { range } from '../client/components/core/CommonJs.js';
+import { random } from '../client/components/core/CommonJs.js';
+
+dotenv.config({ path: `./engine-private/conf/dd-cyberia/.env.production`, override: true });
+
+const pngDirectoryIteratorByObjectLayerType = async (
+  objectLayerType = 'skin',
+  callback = ({ path, objectLayerType, objectLayerId, direction, frame }) => {},
+) => {
+  for (const objectLayerId of await fs.readdir(`./src/client/public/cyberia/assets/${objectLayerType}`)) {
+    for (const direction of await fs.readdir(
+      `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}`,
+    )) {
+      const dirFolder = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/${direction}`;
+      if (!fs.statSync(dirFolder).isDirectory()) continue;
+      for (const frame of await fs.readdir(dirFolder)) {
+        const imageFilePath = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/${direction}/${frame}`;
+        await callback({ path: imageFilePath, objectLayerType, objectLayerId, direction, frame });
+      }
+    }
+  }
+};
+
+const readPngAsync = (filePath) => {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(filePath)
+      .pipe(new PNG())
+      .on('parsed', function () {
+        resolve({
+          width: this.width,
+          height: this.height,
+          data: Buffer.from(this.data),
+        });
+      })
+      .on('error', (err) => {
+        reject(err);
+      });
+  });
+};
+
+const frameFactory = async (path, colors = []) => {
+  const frame = [];
+  try {
+    let image;
+
+    if (path.endsWith('.gif')) {
+      image = await Jimp.read(path);
+      // remove gif file
+      fs.removeSync(path);
+      // save image replacing gif for png
+      const pngPath = path.replace('.gif', '.png');
+      await image.writeAsync(pngPath);
+    } else {
+      const png = await readPngAsync(path);
+      image = new Jimp(png.width, png.height);
+      image.bitmap = png;
+    }
+
+    const mazeFactor = parseInt(image.bitmap.height / 24);
+    let _y = -1;
+    for (const y of range(0, image.bitmap.height - 1)) {
+      if (y % mazeFactor === 0) {
+        _y++;
+        if (!frame[_y]) frame[_y] = [];
+      }
+      let _x = -1;
+      for (const x of range(0, image.bitmap.width - 1)) {
+        const rgba = Object.values(Jimp.intToRGBA(image.getPixelColor(x, y)));
+        if (y % mazeFactor === 0 && x % mazeFactor === 0) {
+          _x++;
+          const indexColor = colors.findIndex(
+            (c) => c[0] === rgba[0] && c[1] === rgba[1] && c[2] === rgba[2] && c[3] === rgba[3],
+          );
+          if (indexColor === -1) {
+            colors.push(rgba);
+            frame[_y][_x] = colors.length - 1;
+          } else {
+            frame[_y][_x] = indexColor;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.error(`Failed to process image ${path}:`, error);
+  }
+  return { frame, colors };
+};
+
+const getKeyFramesDirectionsFromNumberFolderDirection = (direction) => {
+  let objectLayerFrameDirections = [];
+
+  switch (direction) {
+    case '08':
+      objectLayerFrameDirections = ['down_idle', 'none_idle', 'default_idle'];
+      break;
+    case '18':
+      objectLayerFrameDirections = ['down_walking'];
+      break;
+    case '02':
+      objectLayerFrameDirections = ['up_idle'];
+      break;
+    case '12':
+      objectLayerFrameDirections = ['up_walking'];
+      break;
+    case '04':
+      objectLayerFrameDirections = ['left_idle', 'up_left_idle', 'down_left_idle'];
+      break;
+    case '14':
+      objectLayerFrameDirections = ['left_walking', 'up_left_walking', 'down_left_walking'];
+      break;
+    case '06':
+      objectLayerFrameDirections = ['right_idle', 'up_right_idle', 'down_right_idle'];
+      break;
+    case '16':
+      objectLayerFrameDirections = ['right_walking', 'up_right_walking', 'down_right_walking'];
+      break;
+  }
+
+  return objectLayerFrameDirections;
+};
+
+const buildImgFromTile = async (
+  options = {
+    tile: { map_color: null, frame_matrix: null },
+    imagePath: '',
+    cellPixelDim: 20,
+    opacityFilter: (x, y, color) => 255,
+  },
+) => {
+  const { tile, imagePath, cellPixelDim, opacityFilter } = options;
+  const mainMatrix = tile.frame_matrix;
+  const sharpOptions = {
+    create: {
+      width: cellPixelDim * mainMatrix[0].length,
+      height: cellPixelDim * mainMatrix.length,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }, // transparent background
+    },
+  };
+
+  let image = await sharp(sharpOptions).png().toBuffer();
+  fs.writeFileSync(imagePath, image);
+  image = await Jimp.read(imagePath);
+
+  for (let y = 0; y < mainMatrix.length; y++) {
+    for (let x = 0; x < mainMatrix[y].length; x++) {
+      const colorIndex = mainMatrix[y][x];
+      if (colorIndex === null || colorIndex === undefined) continue;
+
+      const color = tile.map_color[colorIndex];
+      if (!color) continue;
+
+      const rgbaColor = color.length === 4 ? color : [...color, 255]; // Ensure alpha channel
+
+      for (let dy = 0; dy < cellPixelDim; dy++) {
+        for (let dx = 0; dx < cellPixelDim; dx++) {
+          const pixelX = x * cellPixelDim + dx;
+          const pixelY = y * cellPixelDim + dy;
+          image.setPixelColor(Jimp.rgbaToInt(...rgbaColor), pixelX, pixelY);
+        }
+      }
+    }
+  }
+
+  await image.writeAsync(imagePath);
+};
+
+const generateRandomStats = () => {
+  return {
+    effect: random(0, 10),
+    resistance: random(0, 10),
+    agility: random(0, 10),
+    range: random(0, 10),
+    intelligence: random(0, 10),
+    utility: random(0, 10),
+  };
+};
+
+const zIndexPriority = { floor: 0, skin: 1, weapon: 2, skill: 3, coin: 4 };
+
+export {
+  pngDirectoryIteratorByObjectLayerType,
+  readPngAsync,
+  frameFactory,
+  getKeyFramesDirectionsFromNumberFolderDirection,
+  buildImgFromTile,
+  generateRandomStats,
+  zIndexPriority,
+};

package/src/server/runtime.js

@@ -117,9 +117,6 @@ const buildRuntime = async () => {
           // set logger
           app.use(loggerMiddleware(import.meta));
 
-          // instance public static
-          app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
-
           // js src compression
           app.use(compression({ filter: shouldCompress }));
           function shouldCompress(req, res) {
@@ -132,17 +129,6 @@ const buildRuntime = async () => {
             return compression.filter(req, res);
           }
 
-          if (process.argv.includes('static')) {
-            logger.info('Build static server runtime', `${host}${path}`);
-            currentPort += 2;
-            const staticPort = newInstance(currentPort);
-
-            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
-            currentPort++;
-            continue;
-          }
-          logger.info('Build api server runtime', `${host}${path}`);
-
           // parse requests of content-type - application/json
           app.use(express.json({ limit: '100MB' }));
 
@@ -164,6 +150,17 @@ const buildRuntime = async () => {
             return next();
           });
 
+          // instance public static
+          app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
+          if (process.argv.includes('static')) {
+            logger.info('Build static server runtime', `${host}${path}`);
+            currentPort += 2;
+            const staticPort = newInstance(currentPort);
+            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
+            currentPort++;
+            continue;
+          }
+
           // security
           applySecurity(app, {
             origin: origins.concat(
@@ -228,24 +225,20 @@ const buildRuntime = async () => {
                 templates: mailerSsrConf ? mailerSsrConf.mailer : {},
               });
             }
-            if (apis) {
+            if (apis && apis.length > 0) {
               const authMiddleware = authMiddlewareFactory({ host, path });
-
               const apiPath = `${path === '/' ? '' : path}/${process.env.BASE_API}`;
               for (const api of apis)
                 await (async () => {
+                  logger.info(`Build api server`, `${host}${apiPath}/${api}`);
                   const { ApiRouter } = await import(`../api/${api}/${api}.router.js`);
-                  const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware });
+                  const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
                   // router.use(cors({ origin: origins }));
                   // logger.info('Load api router', { host, path: apiPath, api });
                   app.use(`${apiPath}/${api}`, router);
                 })();
             }
 
-            // load ssr
-            const ssr = await ssrMiddlewareFactory({ app, directory, rootHostPath, path });
-            for (const [_, ssrMiddleware] of Object.entries(ssr)) app.use(ssrMiddleware);
-
             if (ws)
               await (async () => {
                 const { createIoServer } = await import(`../ws/${ws}/${ws}.ws.server.js`);
@@ -287,6 +280,10 @@ const buildRuntime = async () => {
             }
           }
 
+          // load ssr
+          const ssr = await ssrMiddlewareFactory({ app, directory, rootHostPath, path });
+          for (const [_, ssrMiddleware] of Object.entries(ssr)) app.use(ssrMiddleware);
+
           await UnderpostStartUp.API.listenPortController(server, port, runningData);
 
           break;

package/src/server/ssr.js

@@ -1,8 +1,16 @@
+/**
+ * Module for managing server side rendering
+ * @module src/server/ssr.js
+ * @namespace SSR
+ */
+
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
+import vm from 'node:vm';
+
 import Underpost from '../index.js';
 
-import { ssrFactory, JSONweb } from './client-formatted.js';
+import { srcFormatted, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
 import { getRootDirectory } from './process.js';
 
@@ -10,6 +18,48 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * Creates a server-side rendering component function from a given file path.
+ * It reads the component file, formats it, and executes it in a sandboxed Node.js VM context to extract the component.
+ * @param {string} [componentPath='./src/client/ssr/Render.js'] - The path to the SSR component file.
+ * @returns {Promise<Function>} A promise that resolves to the SSR component function.
+ * @memberof SSR
+ */
+const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
+  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
+};
+
+/**
+ * Sanitizes an HTML string by adding a nonce to all script and style tags for Content Security Policy (CSP).
+ * The nonce is retrieved from `res.locals.nonce`.
+ * @param {object} res - The Express response object.
+ * @param {object} req - The Express request object.
+ * @param {string} html - The HTML string to sanitize.
+ * @returns {string} The sanitized HTML string with nonces.
+ * @memberof SSR
+ */
+const sanitizeHtml = (res, req, html) => {
+  const nonce = res.locals.nonce;
+
+  return html
+    .replace(/<script(?=\s|>)/gi, `<script nonce="${nonce}"`)
+    .replace(/<style(?=\s|>)/gi, `<style nonce="${nonce}"`);
+};
+
+/**
+ * Factory function to create Express middleware for handling 404 and 500 errors.
+ * It generates server-side rendered HTML for these error pages. If static error pages exist, it redirects to them.
+ * @param {object} options - The options for creating the middleware.
+ * @param {object} options.app - The Express app instance.
+ * @param {string} options.directory - The directory for the instance's static files.
+ * @param {string} options.rootHostPath - The root path for the host's public files.
+ * @param {string} options.path - The base path for the instance.
+ * @returns {Promise<{error500: Function, error400: Function}>} A promise that resolves to an object containing the 500 and 404 error handling middleware.
+ * @memberof SSR
+ */
 const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   const Render = await ssrFactory();
   const ssrPath = path === '/' ? path : `${path}/`;
@@ -48,14 +98,6 @@ const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   const path500 = `${directory ? directory : `${getRootDirectory()}${rootHostPath}`}/500/index.html`;
   const page500 = fs.existsSync(path500) ? `${path === '/' ? '' : path}/500` : undefined;
 
-  const sanitizeHtml = (res, req, html) => {
-    const nonce = res.locals.nonce;
-
-    return html
-      .replace(/<script(?=\s|>)/gi, `<script nonce="${nonce}"`)
-      .replace(/<style(?=\s|>)/gi, `<style nonce="${nonce}"`);
-  };
-
   return {
     error500: function (err, req, res, next) {
       logger.error(err, err.stack);
@@ -82,4 +124,4 @@ const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   };
 };
 
-export { ssrMiddlewareFactory };
+export { ssrMiddlewareFactory, ssrFactory, sanitizeHtml };