cyberia 2.8.885

package/src/server/valkey.js

@@ -0,0 +1,293 @@
+/**
+ * Module for managing Valkey
+ * @module src/server/valkey.js
+ * @namespace ValkeyService
+ */
+
+import Valkey from 'iovalkey';
+import mongoose from 'mongoose';
+import { hashPassword } from './auth.js';
+import { loggerFactory } from './logger.js';
+
+const logger = loggerFactory(import.meta);
+
+// Per-instance registries keyed by `${host}${path}`
+const ValkeyInstances = {};
+const DummyStores = {}; // in-memory Maps per instance
+const ValkeyStatus = {}; // 'connected' | 'dummy' | 'error' | undefined
+
+/**
+ * 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 ValkeyService
+ */
+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 ValkeyService
+ */
+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 ValkeyService
+ */
+const createValkeyConnection = async (
+  instance = { host: '', path: '' },
+  valkeyServerConnectionOptions = { host: '', path: '' },
+) => {
+  const key = _instanceKey(instance);
+  // Initialize dummy store for the instance
+  if (!DummyStores[key]) DummyStores[key] = new Map();
+
+  try {
+    const client = await ValkeyAPI.valkeyClientFactory(valkeyServerConnectionOptions);
+
+    // Attach listeners for visibility
+    client.on?.('ready', () => {
+      ValkeyStatus[key] = 'connected';
+      logger.info('Valkey connected', { instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('error', (err) => {
+      // Switch to dummy if not yet connected
+      if (ValkeyStatus[key] !== 'connected') {
+        ValkeyStatus[key] = 'dummy';
+      } else {
+        ValkeyStatus[key] = 'error';
+      }
+      logger.warn('Valkey error', { err: err?.message, instance, status: ValkeyStatus[key] });
+    });
+    client.on?.('end', () => {
+      if (ValkeyStatus[key] !== 'dummy') ValkeyStatus[key] = 'error';
+      logger.warn('Valkey connection ended', { instance, status: ValkeyStatus[key] });
+    });
+
+    // Probe connectivity with a short timeout
+    const probe = async () => {
+      try {
+        // basic ping via SET/GET roundtrip
+        const probeKey = `__vk_probe_${Date.now()}`;
+        await client.set(probeKey, '1');
+        await client.get(probeKey);
+        ValkeyStatus[key] = 'connected';
+      } catch (e) {
+        ValkeyStatus[key] = 'dummy';
+        logger.warn('Valkey probe failed, falling back to dummy', { instance, error: e?.message });
+      }
+    };
+
+    // Race with timeout to avoid hanging
+    await Promise.race([probe(), new Promise((resolve) => setTimeout(resolve, 1000))]);
+
+    ValkeyInstances[key] = client;
+    if (!ValkeyStatus[key]) ValkeyStatus[key] = 'dummy';
+  } catch (err) {
+    ValkeyStatus[key] = 'dummy';
+    logger.warn('Valkey client creation failed, using dummy', { instance, error: err?.message });
+  }
+
+  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 ValkeyService
+ */
+const selectDtoFactory = (payload, select) => {
+  const result = {};
+  for (const key of Object.keys(select)) {
+    if (select[key] === 1 && key in payload) result[key] = payload[key];
+  }
+  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 ValkeyService
+ */
+const valkeyClientFactory = async (options) => {
+  const valkey = new Valkey({
+    port: options?.port ? options.port : undefined,
+    host: options?.host ? options.host : undefined,
+    // Keep retry strategy minimal; state handled in createValkeyConnection
+    retryStrategy: (attempt) => {
+      if (attempt === 1) return undefined; // stop aggressive retries early
+      return 1000; // retry interval if library continues
+    },
+  }); // Connect to 127.0.0.1:6379
+  // new Valkey(6380); // 127.0.0.1:6380
+  // new Valkey(6379, '192.168.1.1'); // 192.168.1.1:6379
+  // new Valkey('/tmp/redis.sock');
+  // new Valkey({
+  //   port: 6379, // Valkey port
+  //   host: '127.0.0.1', // Valkey host
+  //   username: 'default', // needs Valkey >= 6
+  //   password: 'my-top-secret',
+  //   db: 0, // Defaults to 0
+  // });
+  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 ValkeyService
+ */
+const getValkeyObject = async (options = { host: '', path: '' }, key = '') => {
+  const k = _instanceKey(options);
+  const status = ValkeyStatus[k];
+  try {
+    if (status === 'connected' && ValkeyInstances[k]) {
+      const value = await ValkeyInstances[k].get(key);
+      if (value == null) return null;
+      try {
+        return JSON.parse(value);
+      } catch {
+        // not JSON, return raw string
+        return value;
+      }
+    }
+  } catch (err) {
+    logger.warn('Valkey get failed, using dummy', { key, err: err?.message });
+  }
+  // Dummy fallback returns stored value as-is (string or object)
+  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 ValkeyService
+ */
+const setValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  const k = _instanceKey(options);
+  const isString = typeof payload === 'string';
+  const value = isString ? payload : JSON.stringify(payload);
+  try {
+    if (ValkeyStatus[k] === 'connected' && ValkeyInstances[k]) {
+      return await ValkeyInstances[k].set(key, value);
+    }
+  } catch (err) {
+    logger.warn('Valkey set failed, writing to dummy', { key, err: err?.message });
+  }
+  if (!DummyStores[k]) DummyStores[k] = new Map();
+  // Store raw string or object accordingly
+  DummyStores[k].set(key, isString ? payload : payload);
+  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 ValkeyService
+ */
+const updateValkeyObject = async (options = { host: '', path: '' }, key = '', payload = {}) => {
+  let base = await getValkeyObject(options, key);
+  if (typeof base !== 'object' || base === null) base = {};
+  base.updatedAt = new Date().toISOString();
+  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 ValkeyService
+ */
+const valkeyObjectFactory = async (options = { host: 'localhost', path: '', object: {} }, model = '') => {
+  const idoDate = new Date().toISOString();
+  options.object = options.object || {};
+  const { object } = options;
+  const _id = new mongoose.Types.ObjectId().toString();
+  object._id = _id;
+  object.createdAt = idoDate;
+  object.updatedAt = idoDate;
+  switch (model) {
+    case 'user': {
+      const role = 'guest';
+      object._id = `${role}${_id}`;
+      return {
+        ...object,
+        username: `${role}${_id.slice(-5)}`,
+        email: `${_id}@${options.host}`,
+        password: hashPassword(process.env.JWT_SECRET),
+        role,
+        failedLoginAttempts: 0,
+        phoneNumbers: [],
+        publicKey: [],
+        profileImageId: null,
+        emailConfirmed: false,
+        recoverTimeOut: null,
+        lastLoginDate: null,
+        activeSessions: [],
+      };
+    }
+    default:
+      throw new Error(`model schema not found: ${model}`);
+  }
+};
+
+/**
+ * A collection of Valkey-related API functions.
+ * @type {object}
+ * @memberof ValkeyServiceService
+ */
+const ValkeyAPI = {
+  valkeyClientFactory,
+  selectDtoFactory,
+  getValkeyObject,
+  setValkeyObject,
+  valkeyObjectFactory,
+  updateValkeyObject,
+  createValkeyConnection,
+};
+
+export {
+  valkeyClientFactory,
+  selectDtoFactory,
+  getValkeyObject,
+  setValkeyObject,
+  valkeyObjectFactory,
+  updateValkeyObject,
+  isValkeyEnable,
+  createValkeyConnection,
+  ValkeyAPI,
+};

package/src/server.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { buildClient } from './server/client-build.js';
+import { buildRuntime } from './server/runtime.js';
+import { ProcessController } from './server/process.js';
+import { Config } from './server/conf.js';
+
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await buildClient();
+
+await buildRuntime();
+
+ProcessController.init(logger);

package/src/ws/IoInterface.js

@@ -0,0 +1,139 @@
+/**
+ * Module for creating and managing WebSocket channels.
+ * @module src/ws/IoInterface.js
+ * @namespace SocketIoInterface
+ */
+
+import { loggerFactory } from '../server/logger.js';
+import { Socket } from 'socket.io';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * Defines the structure for a WebSocket channel's behavior functions.
+ * @typedef {Object} ChannelInterface
+ * @property {string} channel - The name of the channel.
+ * @property {function(Socket, Object.<string, Socket>, string): Promise<void>} [connection] - Handler on client connection.
+ * @property {function(Socket, Object.<string, Socket>, any, string, any[]): Promise<void>} [controller] - Handler for incoming channel messages.
+ * @property {function(Socket, Object.<string, Socket>, string, string): Promise<void>} [disconnect] - Handler on client disconnection.
+ * @property {boolean} [stream=false] - Whether the channel should treat the message as a raw stream (no JSON parsing).
+ * @memberof SocketIoInterface
+ */
+
+/**
+ * @class IoChannel
+ * @alias IoChannel
+ * @memberof SocketIoInterface
+ * @classdesc Manages the logic, client map, and event listeners for a specific WebSocket channel,
+ * ensuring robust message handling and lifecycle management.
+ */
+class IoChannel {
+  /**
+   * @private
+   * @type {ChannelInterface}
+   */
+  #IoInterface;
+
+  /**
+   * Map of connected sockets for this channel, keyed by socket ID.
+   * @type {Object.<string, Socket>}
+   */
+  client = {};
+
+  /**
+   * Creates an instance of IoChannel.
+   * @param {ChannelInterface} IoInterface - The interface object defining the channel's behavior.
+   */
+  constructor(IoInterface) {
+    this.#IoInterface = {
+      channel: '',
+      connection: async (socket = {}, client = {}, wsManagementId = '') => {},
+      controller: async (socket = {}, client = {}, payload = {}, wsManagementId = '', args = []) => {},
+      disconnect: async (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
+      stream: false,
+      ...IoInterface,
+    };
+    logger.debug(`Channel instance created for: ${this.channel}`);
+  }
+
+  /**
+   * Gets the name of the channel.
+   * @returns {string} The channel name.
+   */
+  get channel() {
+    return this.#IoInterface.channel;
+  }
+
+  /**
+   * Handles a new socket connection for this channel.
+   * Sets up the listener for the channel message.
+   *
+   * @param {Socket} socket - The Socket.IO socket object.
+   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @returns {Promise<void>}
+   */
+  async connection(socket, wsManagementId) {
+    try {
+      this.client[socket.id] = socket;
+      // Use bind/arrow function to maintain 'this' context for the controller
+      socket.on(this.channel, (...args) => this.controller(socket, args, wsManagementId));
+      await this.#IoInterface.connection(socket, this.client, wsManagementId);
+      logger.debug(`Socket ${socket.id} connected to channel ${this.channel}`);
+    } catch (error) {
+      logger.error(error, { channel: this.channel, wsManagementId, stack: error.stack });
+    }
+  }
+
+  /**
+   * Handles incoming messages on the channel.
+   *
+   * @private
+   * @param {Socket} socket - The Socket.IO socket object.
+   * @param {any[]} args - The raw arguments received from the socket event.
+   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @returns {Promise<void>}
+   */
+  async controller(socket, args, wsManagementId) {
+    try {
+      if (!args || args.length === 0) {
+        logger.warn(`No arguments received for channel: ${this.channel}`, { socketId: socket.id });
+        return;
+      }
+      // Determine if JSON parsing is needed based on the stream flag
+      const payload = this.#IoInterface.stream ? args[0] : JSON.parse(args[0]);
+
+      await this.#IoInterface.controller(socket, this.client, payload, wsManagementId, args);
+    } catch (error) {
+      logger.error(error, { channel: this.channel, wsManagementId, socketId: socket.id, args, stack: error.stack });
+    }
+  }
+
+  /**
+   * Handles a socket disconnection for this channel.
+   *
+   * @param {Socket} socket - The Socket.IO socket object.
+   * @param {string} reason - The reason for disconnection (e.g., 'client namespace disconnect').
+   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @returns {Promise<void>}
+   */
+  async disconnect(socket, reason, wsManagementId) {
+    try {
+      await this.#IoInterface.disconnect(socket, this.client, reason, wsManagementId);
+      delete this.client[socket.id];
+      logger.debug(`Socket ${socket.id} disconnected from channel ${this.channel}. Reason: ${reason}`);
+    } catch (error) {
+      logger.error(error, { channel: this.channel, wsManagementId, reason, socketId: socket.id, stack: error.stack });
+    }
+  }
+}
+
+/**
+ * Backward compatibility function to create a new channel instance.
+ * @memberof SocketIoInterface
+ * @function IoCreateChannel
+ * @param {ChannelInterface} IoInterface - The interface object defining the channel's behavior.
+ * @returns {IoChannel} An instance of the IoChannel class.
+ */
+const IoCreateChannel = (IoInterface) => new IoChannel(IoInterface);
+
+export { IoChannel, IoCreateChannel };

package/src/ws/IoServer.js

@@ -0,0 +1,88 @@
+/**
+ * Module for creating and managing WebSocket servers.
+ * @module src/ws/IoServer
+ * @namespace SocketIoServer
+ */
+
+'use strict';
+
+import { Server } from 'socket.io';
+import { loggerFactory } from '../server/logger.js';
+import UnderpostStartUp from '../server/start.js';
+
+import http from 'http';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class IoServerClass
+ * @alias IoServerClass
+ * @memberof SocketIoServer
+ * @classdesc Provides a static factory method to create and configure a Socket.IO server,
+ * encapsulating WebSocket server initialization logic and CORS configuration.
+ */
+class IoServerClass {
+  /**
+   * Creates a new WebSocket server instance attached to an HTTP server.
+   *
+   * @static
+   * @param {http.Server} httpServer - The HTTP server instance to attach the WebSocket server to.
+   * @param {Object} options - Configuration options for the WebSocket server.
+   * @param {string[]} options.origins - List of allowed origins for Cross-Origin Resource Sharing (CORS).
+   * @param {string} options.path - The base path for the API. The WebSocket path ('/socket.io') will be appended to this.
+   * @param {function(import('socket.io').Socket): void} ConnectionHandler - The connection handler function to be executed on a new connection.
+   * @returns {Object} An object containing the final options and the server instance.
+   * @returns {import('socket.io').ServerOptions} return.options - The final options object used to create the WebSocket server.
+   * @returns {import('socket.io').Server} return.ioServer - The created and listening WebSocket server instance.
+   * @returns {object} return.meta - The module's import meta object (`import.meta`).
+   */
+  static create(httpServer, options = {}, ConnectionHandler = () => {}) {
+    logger.info('origins', options.origins);
+    const wsOptions = {
+      cors: {
+        origins: options.origins,
+        methods: ['GET', 'POST', 'DELETE', 'PUT'],
+        allowedHeaders: [
+          'Access-Control-Allow-Headers',
+          'Access-Control-Allow-Origin',
+          'X-Requested-With',
+          'X-Access-Token',
+          'Content-Type',
+          'Host',
+          'Accept',
+          'Connection',
+          'Cache-Control',
+          'Authorization',
+        ],
+        credentials: true,
+      },
+      // Ensure the path ends correctly, appending '/socket.io/'
+      path: options.path !== '/' ? `${options.path}/socket.io/` : '/socket.io/',
+    };
+
+    const ioServerInstance = UnderpostStartUp.API.listenServerFactory(() =>
+      new Server(httpServer, wsOptions).on('connection', ConnectionHandler),
+    );
+
+    logger.info('Socket.IO Server created and listening', { path: wsOptions.path });
+
+    return {
+      options: wsOptions,
+      meta: import.meta,
+      ioServer: ioServerInstance,
+    };
+  }
+}
+
+/**
+ * Backward compatibility export for the server creation function.
+ * @memberof SocketIoServer
+ * @function IoServer
+ * @param {http.Server} httpServer - The HTTP server instance.
+ * @param {Object} options - Configuration options.
+ * @param {function(import('socket.io').Socket): void} ConnectionHandler - The connection handler function.
+ * @returns {Object} The server configuration object.
+ */
+const IoServer = IoServerClass.create;
+
+export { IoServerClass, IoServer };

package/src/ws/core/channels/core.ws.chat.js

@@ -0,0 +1,23 @@
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsEmit } from '../core.ws.emit.js';
+
+const channel = 'chat';
+const logger = loggerFactory(import.meta);
+
+const CoreWsChatController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    for (const socketId of Object.keys(client)) {
+      if (socketId !== socket.id) {
+        CoreWsEmit(channel, client[socketId], { id: socket.id, ...payload });
+      }
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {},
+};
+
+const CoreWsChatChannel = IoCreateChannel(CoreWsChatController);
+
+export { CoreWsChatChannel, CoreWsChatController };

package/src/ws/core/channels/core.ws.mailer.js

@@ -0,0 +1,35 @@
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsMailerManagement } from '../management/core.ws.mailer.js';
+
+const channel = 'mailer';
+const logger = loggerFactory(import.meta);
+
+const CoreWsMailerController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    switch (payload.status) {
+      case 'register-user':
+        CoreWsMailerManagement.element[wsManagementId][socket.id] = {
+          model: {
+            user: payload.user,
+          },
+        };
+        break;
+      case 'unregister-user':
+        delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+        break;
+
+      default:
+        break;
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {
+    delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+  },
+};
+
+const CoreWsMailerChannel = IoCreateChannel(CoreWsMailerController);
+
+export { CoreWsMailerChannel, CoreWsMailerController };

package/src/ws/core/channels/core.ws.stream.js

@@ -0,0 +1,31 @@
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsStreamManagement } from '../management/core.ws.stream.js';
+
+const channel = 'stream';
+const logger = loggerFactory(import.meta);
+
+const CoreWsStreamController = {
+  channel,
+  stream: true,
+  controller: function (socket, client, payload, wsManagementId, args) {
+    const [roomId, userId] = args;
+    CoreWsStreamManagement.element[wsManagementId][socket.id] = args;
+
+    socket.join(roomId); // Join the room
+    socket.broadcast.emit(`${channel}-user-connected`, userId); // Tell everyone else in the room that we joined
+  },
+  connection: function (socket, client, wsManagementId) {
+    CoreWsStreamManagement.element[wsManagementId][socket.id] = [];
+  },
+  disconnect: function (socket, client, reason, wsManagementId) {
+    // Communicate the disconnection
+    const [roomId, userId] = CoreWsStreamManagement.element[wsManagementId][socket.id];
+    socket.broadcast.emit(`${channel}-user-disconnected`, userId);
+    delete CoreWsStreamManagement.element[wsManagementId][socket.id];
+  },
+};
+
+const CoreWsStreamChannel = IoCreateChannel(CoreWsStreamController);
+
+export { CoreWsStreamChannel, CoreWsStreamController };