underpost 2.8.878 → 2.8.881

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/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

@@ -77,6 +77,10 @@ const Config = {
         '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}`,
@@ -692,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

@@ -129,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' }));
 
@@ -163,6 +152,14 @@ const buildRuntime = async () => {
 
           // 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, {
@@ -228,12 +225,12 @@ 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, origins });
                   // router.use(cors({ origin: origins }));

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 };

package/src/server/valkey.js

@@ -1,3 +1,9 @@
+/**
+ * Module for managing Valkey
+ * @module src/server/valkey.js
+ * @namespace Valkey
+ */
+
 import Valkey from 'iovalkey';
 import mongoose from 'mongoose';
 import { hashPassword } from './auth.js';
@@ -10,11 +16,35 @@ const ValkeyInstances = {};
 const DummyStores = {}; // in-memory Maps per instance
 const ValkeyStatus = {}; // 'connected' | 'dummy' | 'error' | undefined
 
-// Backward-compatible overall flag: true if any instance is connected
+/**
+ * Checks if any Valkey instance is connected.
+ * This is a backward-compatible overall flag.
+ * @returns {boolean} True if any instance has a 'connected' status.
+ * @memberof Valkey
+ */
 const isValkeyEnable = () => Object.values(ValkeyStatus).some((s) => s === 'connected');
 
+/**
+ * Generates a unique key for a Valkey instance based on its host and path.
+ * @param {object} [opts={ host: '', path: '' }] - The instance options.
+ * @param {string} [opts.host=''] - The host of the instance.
+ * @param {string} [opts.path=''] - The path of the instance.
+ * @returns {string} The instance key.
+ * @private
+ * @memberof Valkey
+ */
 const _instanceKey = (opts = { host: '', path: '' }) => `${opts.host || ''}${opts.path || ''}`;
 
+/**
+ * Creates and manages a connection to a Valkey server for a given instance.
+ * It sets up a client, attaches event listeners for connection status, and implements a fallback to an in-memory dummy store if the connection fails.
+ * @param {object} [instance={ host: '', path: '' }] - The instance identifier.
+ * @param {string} [instance.host=''] - The host of the instance.
+ * @param {string} [instance.path=''] - The path of the instance.
+ * @param {object} [valkeyServerConnectionOptions={ host: '', path: '' }] - Connection options for the iovalkey client.
+ * @returns {Promise<Valkey|undefined>} A promise that resolves to the Valkey client instance, or undefined if creation fails.
+ * @memberof Valkey
+ */
 const createValkeyConnection = async (
   instance = { host: '', path: '' },
   valkeyServerConnectionOptions = { host: '', path: '' },
@@ -72,6 +102,14 @@ const createValkeyConnection = async (
   return ValkeyInstances[key];
 };
 
+/**
+ * Factory function to create a Data Transfer Object (DTO) from a payload.
+ * It filters the payload to include only the keys specified in the `select` object.
+ * @param {object} payload - The source object.
+ * @param {object} select - An object where keys are field names and values are 1 to include them.
+ * @returns {object} A new object containing only the selected fields from the payload.
+ * @memberof Valkey
+ */
 const selectDtoFactory = (payload, select) => {
   const result = {};
   for (const key of Object.keys(select)) {
@@ -80,6 +118,12 @@ const selectDtoFactory = (payload, select) => {
   return result;
 };
 
+/**
+ * Factory function to create a new Valkey client instance.
+ * @param {object} options - Connection options for the iovalkey client.
+ * @returns {Promise<Valkey>} A promise that resolves to a new Valkey client.
+ * @memberof Valkey
+ */
 const valkeyClientFactory = async (options) => {
   const valkey = new Valkey({
     port: options?.port ? options.port : undefined,
@@ -103,6 +147,15 @@ const valkeyClientFactory = async (options) => {
   return valkey;
 };
 
+/**
+ * Retrieves an object from Valkey by key for a specific instance.
+ * If the Valkey client is not connected or an error occurs, it falls back to the dummy in-memory store.
+ * It automatically parses JSON strings.
+ * @param {object} [options={ host: '', path: '' }] - The instance identifier.
+ * @param {string} [key=''] - The key of the object to retrieve.
+ * @returns {Promise<object|string|null>} A promise that resolves to the retrieved object, string, or null if not found.
+ * @memberof Valkey
+ */
 const getValkeyObject = async (options = { host: '', path: '' }, key = '') => {
   const k = _instanceKey(options);
   const status = ValkeyStatus[k];
@@ -124,6 +177,16 @@ const getValkeyObject = async (options = { host: '', path: '' }, key = '') => {
   return DummyStores[k]?.get(key) ?? null;
 };
 
+/**
+ * Sets an object or string in Valkey for a specific instance.
+ * If the Valkey client is not connected, it writes to the in-memory dummy store instead.
+ * Objects are automatically stringified.
+ * @param {object} [options={ host: '', path: '' }] - The instance identifier.
+ * @param {string} [key=''] - The key under which to store the payload.
+ * @param {object|string} [payload={}] - The data to store.
+ * @returns {Promise<string>} A promise that resolves to 'OK' on success.
+ * @memberof Valkey
+ */
 const setValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
   const k = _instanceKey(options);
   const isString = typeof payload === 'string';
@@ -141,6 +204,16 @@ const setValkeyObject = async (options = { host: '', path: '' }, key = '', paylo
   return 'OK';
 };
 
+/**
+ * Updates an existing object in Valkey by merging it with a new payload.
+ * It retrieves the current object, merges it with the new payload, and sets the updated object back.
+ * It also updates the `updatedAt` timestamp.
+ * @param {object} [options={ host: '', path: '' }] - The instance identifier.
+ * @param {string} [key=''] - The key of the object to update.
+ * @param {object} [payload={}] - The new data to merge into the object.
+ * @returns {Promise<string>} A promise that resolves to the result of the set operation.
+ * @memberof Valkey
+ */
 const updateValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
   let base = await getValkeyObject(options, key);
   if (typeof base !== 'object' || base === null) base = {};
@@ -148,6 +221,17 @@ const updateValkeyObject = async (options = { host: '', path: '' }, key = '', pa
   return await setValkeyObject(options, key, { ...base, ...payload });
 };
 
+/**
+ * Factory function to create a new object based on a model schema.
+ * It generates a new object with default properties like `_id`, `createdAt`, and `updatedAt`,
+ * and model-specific properties.
+ * @param {object} [options={ host: 'localhost', path: '', object: {} }] - Options for object creation.
+ * @param {string} [options.host='localhost'] - The host context for the object.
+ * @param {object} [options.object={}] - An initial object to extend.
+ * @param {string} [model=''] - The name of the model schema to use (e.g., 'user').
+ * @returns {Promise<object>} A promise that resolves to the newly created object.
+ * @memberof Valkey
+ */
 const valkeyObjectFactory = async (options = { host: 'localhost', path: '', object: {} }, model = '') => {
   const idoDate = new Date().toISOString();
   options.object = options.object || {};
@@ -181,6 +265,10 @@ const valkeyObjectFactory = async (options = { host: 'localhost', path: '', obje
   }
 };
 
+/**
+ * A collection of Valkey-related API functions.
+ * @type {object}
+ */
 const ValkeyAPI = {
   valkeyClientFactory,
   selectDtoFactory,