cyberia 2.8.885

package/src/ws/core/core.ws.connection.js

@@ -0,0 +1,62 @@
+/**
+ * Module for handling new WebSocket connections and setting up channel listeners.
+ * @module ws/core.ws.connection
+ * @namespace CoreWsConnection
+ */
+
+import { loggerFactory } from '../../server/logger.js';
+import { CoreWsChatChannel } from './channels/core.ws.chat.js';
+import { CoreWsMailerChannel } from './channels/core.ws.mailer.js';
+import { CoreWsStreamChannel } from './channels/core.ws.stream.js';
+import { Socket } from 'socket.io'; // Added for JSDoc type hinting
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class CoreWsConnectionManager
+ * @alias CoreWsConnectionManager
+ * @memberof CoreWsConnection
+ * @classdesc Manages the lifecycle of a new WebSocket connection, setting up listeners for
+ * all registered channels (Chat, Mailer, Stream) and handling disconnection by delegating to channel handlers.
+ */
+class CoreWsConnectionManager {
+  /**
+   * Handles a new WebSocket connection by subscribing it to all active channels
+   * and setting up the disconnect listener.
+   *
+   * @static
+   * @param {Socket} socket - The Socket.IO socket object representing the client connection.
+   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @returns {void}
+   */
+  static handleConnection(socket, wsManagementId) {
+    logger.info(`New connection established. Socket ID: ${socket.id}`);
+
+    // Subscribe socket to all channel connection handlers (assuming these channels are IoChannel instances)
+    CoreWsChatChannel.connection(socket, wsManagementId);
+    CoreWsMailerChannel.connection(socket, wsManagementId);
+    CoreWsStreamChannel.connection(socket, wsManagementId);
+
+    // Set up the disconnect listener
+    socket.on('disconnect', (reason) => {
+      logger.info(`Connection disconnected. Socket ID: ${socket.id} due to reason: ${reason}`);
+
+      // Notify all channels of the disconnection
+      CoreWsChatChannel.disconnect(socket, reason, wsManagementId);
+      CoreWsMailerChannel.disconnect(socket, reason, wsManagementId);
+      CoreWsStreamChannel.disconnect(socket, reason, wsManagementId);
+    });
+  }
+}
+
+/**
+ * Backward compatibility export for the connection handler function.
+ * @memberof CoreWsConnection
+ * @function CoreWsConnection
+ * @param {Socket} socket - The Socket.IO socket object.
+ * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+ * @returns {void}
+ */
+const CoreWsConnection = CoreWsConnectionManager.handleConnection;
+
+export { CoreWsConnectionManager, CoreWsConnection };

package/src/ws/core/core.ws.emit.js

@@ -0,0 +1,53 @@
+/**
+ * Module for standardized WebSocket message emission (sending).
+ * @module ws/core.ws.emit
+ * @namespace CoreWsEmitter
+ */
+
+import { loggerFactory } from '../../server/logger.js';
+import { Socket } from 'socket.io';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * @class CoreWsEmitter
+ * @alias CoreWsEmitter
+ * @memberof CoreWsEmitter
+ * @classdesc Provides a static utility method for safely emitting messages over a WebSocket connection.
+ */
+class CoreWsEmitter {
+  /**
+   * Emits a payload to a specific client over a given channel.
+   * The payload is automatically JSON stringified.
+   *
+   * @static
+   * @param {string} [channel=''] - The name of the channel/event to emit on.
+   * @param {Socket | Object} [client={}] - The Socket.IO client/socket object. Must have an `emit` method.
+   * @param {Object} [payload={}] - The data object to send.
+   * @returns {void}
+   */
+  static emit(channel = '', client = {}, payload = {}) {
+    try {
+      if (client && typeof client.emit === 'function') {
+        client.emit(channel, JSON.stringify(payload));
+      } else {
+        logger.error('Invalid client: Cannot emit message.', { channel, client, payload });
+      }
+    } catch (error) {
+      logger.error(error, { channel, client, payload, stack: error.stack });
+    }
+  }
+}
+
+/**
+ * Backward compatibility export for the `emit` function.
+ * @memberof CoreWsEmitter
+ * @function CoreWsEmit
+ * @param {string} [channel=''] - The name of the channel/event to emit on.
+ * @param {Socket | Object} [client={}] - The Socket.IO client/socket object.
+ * @param {Object} [payload={}] - The data object to send.
+ * @returns {void}
+ */
+const CoreWsEmit = CoreWsEmitter.emit;
+
+export { CoreWsEmitter, CoreWsEmit };

package/src/ws/core/core.ws.server.js

@@ -0,0 +1,76 @@
+/**
+ * Module for creating and initializing the main WebSocket server instance.
+ * @module ws/core.ws.server
+ * @namespace CoreWsServer
+ */
+
+'use strict';
+
+import { IoServerClass } from '../IoServer.js';
+import { CoreWsConnection } from './core.ws.connection.js';
+import { CoreWsChatManagement } from './management/core.ws.chat.js';
+import { CoreWsMailerManagement } from './management/core.ws.mailer.js';
+import { CoreWsStreamManagement } from './management/core.ws.stream.js';
+import http from 'http'; // Added for JSDoc type hinting
+
+// https://socket.io/docs/v3/
+
+/**
+ * @class CoreWsServerClass
+ * @alias CoreWsServerClass
+ * @memberof CoreWsServer
+ * @classdesc Manages the creation and initialization of the main WebSocket server,
+ * including setting up the management instances for all channels.
+ */
+class CoreWsServerClass {
+  /**
+   * Initializes channel management instances and creates the Socket.IO server.
+   *
+   * @static
+   * @async
+   * @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.host - The host address.
+   * @param {string} options.path - The base path for the API.
+   * @returns {Promise<Object>} The result object from IoServer creation.
+   */
+  static async create(httpServer, options) {
+    const { host, path } = options;
+    if (!host || !path) {
+      throw new Error('Host and path must be provided in server options.');
+    }
+
+    // Create a unique identifier for this server instance's management context
+    const wsManagementId = `${host}${path}`;
+
+    // Initialize/Retrieve singleton management instances for all channels
+    CoreWsChatManagement.instance(wsManagementId);
+    CoreWsMailerManagement.instance(wsManagementId);
+    CoreWsStreamManagement.instance(wsManagementId);
+
+    // Use the IoServerClass factory to create the server, passing the connection handler
+    return IoServerClass.create(httpServer, options, (socket) => CoreWsConnection(socket, wsManagementId));
+  }
+}
+
+/**
+ * Backward compatibility export for the server creation function.
+ * @memberof CoreWsServer
+ * @function createIoServer
+ * @param {http.Server} httpServer - The HTTP server instance.
+ * @param {Object} options - Configuration options.
+ * @returns {Promise<Object>} The server creation result.
+ */
+const createIoServer = CoreWsServerClass.create;
+
+/**
+ * Backward compatibility alias.
+ * @memberof CoreWsServer
+ * @function CoreWsServer
+ * @param {import('http').Server} httpServer - The HTTP server instance.
+ * @param {Object} options - Configuration options.
+ * @returns {Promise<Object>} The server creation result.
+ */
+const CoreWsServer = createIoServer;
+
+export { CoreWsServerClass, createIoServer, CoreWsServer };

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

@@ -0,0 +1,8 @@
+const CoreWsChatManagement = {
+  element: {},
+  instance: function (wsManagementId = '') {
+    this.element[wsManagementId] = {};
+  },
+};
+
+export { CoreWsChatManagement };

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

@@ -0,0 +1,16 @@
+const CoreWsMailerManagement = {
+  element: {},
+  instance: function (wsManagementId = '') {
+    this.element[wsManagementId] = {};
+  },
+  getUserWsId: function (wsManagementId = '', id = '') {
+    for (const userWsId of Object.keys(this.element[wsManagementId])) {
+      if (this.element[wsManagementId][userWsId].model.user._id === id) {
+        return userWsId;
+      }
+    }
+    return undefined;
+  },
+};
+
+export { CoreWsMailerManagement };

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

@@ -0,0 +1,8 @@
+const CoreWsStreamManagement = {
+  element: {},
+  instance: function (wsManagementId = '') {
+    this.element[wsManagementId] = {};
+  },
+};
+
+export { CoreWsStreamManagement };

package/src/ws/cyberia/channels/cyberia.ws.bot.js

@@ -0,0 +1,56 @@
+import { objectEquals } from '../../../client/components/core/CommonJs.js';
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CyberiaWsEmit } from '../cyberia.ws.emit.js';
+import { CyberiaWsBotManagement } from '../management/cyberia.ws.bot.js';
+import { CyberiaWsUserManagement } from '../management/cyberia.ws.user.js';
+
+const channel = 'bot';
+const logger = loggerFactory(import.meta);
+
+const CyberiaWsBotController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    const { status, element } = payload;
+    switch (status) {
+      case 'update-world-face':
+        for (const botId of Object.keys(CyberiaWsBotManagement.element[wsManagementId])) {
+          if (
+            !CyberiaWsBotManagement.localElementScope[wsManagementId][botId].disabled &&
+            objectEquals(CyberiaWsBotManagement.element[wsManagementId][botId].model.world, element.model.world)
+          ) {
+            CyberiaWsEmit(channel, client[socket.id], {
+              status: 'connection',
+              id: botId,
+              element: CyberiaWsBotManagement.element[wsManagementId][botId],
+            });
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  },
+  connection: function (socket, client, wsManagementId) {
+    for (const botId of Object.keys(CyberiaWsBotManagement.element[wsManagementId])) {
+      if (
+        !CyberiaWsBotManagement.localElementScope[wsManagementId][botId].disabled &&
+        objectEquals(
+          CyberiaWsBotManagement.element[wsManagementId][botId].model.world,
+          CyberiaWsUserManagement.element[wsManagementId][socket.id].model.world,
+        )
+      ) {
+        CyberiaWsEmit(channel, client[socket.id], {
+          status: 'connection',
+          id: botId,
+          element: CyberiaWsBotManagement.element[wsManagementId][botId],
+        });
+      }
+    }
+  },
+  disconnect: function (socket, client, reason, wsManagementId) {},
+};
+
+const CyberiaWsBotChannel = IoCreateChannel(CyberiaWsBotController);
+
+export { CyberiaWsBotChannel, CyberiaWsBotController };

package/src/ws/cyberia/channels/cyberia.ws.skill.js

@@ -0,0 +1,51 @@
+import { objectEquals } from '../../../client/components/core/CommonJs.js';
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CyberiaWsEmit } from '../cyberia.ws.emit.js';
+import { CyberiaWsInstanceScope } from '../cyberia.ws.server.js';
+import { CyberiaWsSkillManagement } from '../management/cyberia.ws.skill.js';
+import { CyberiaWsUserManagement } from '../management/cyberia.ws.user.js';
+
+const channel = 'skill';
+const logger = loggerFactory(import.meta);
+
+const CyberiaWsSkillController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    switch (payload.status) {
+      case 'create':
+        if (!CyberiaWsUserManagement.localElementScope[wsManagementId][socket.id].immunityQuestModalDialog)
+          CyberiaWsSkillManagement.createSkill(
+            wsManagementId,
+            { id: socket.id, type: 'user' },
+            payload.skillKey,
+            CyberiaWsInstanceScope[wsManagementId].biome.instance,
+          );
+        break;
+
+      default:
+        break;
+    }
+  },
+  connection: function (socket, client, wsManagementId) {
+    for (const skillId of Object.keys(CyberiaWsSkillManagement.element[wsManagementId])) {
+      if (
+        objectEquals(
+          CyberiaWsSkillManagement.element[wsManagementId][skillId].model.world,
+          CyberiaWsUserManagement.element[wsManagementId][socket.id].model.world,
+        )
+      ) {
+        CyberiaWsEmit(channel, client[skillId], {
+          status: 'connection',
+          id: skillId,
+          element: CyberiaWsSkillManagement.element[wsManagementId][skillId],
+        });
+      }
+    }
+  },
+  disconnect: function (socket, client, reason, wsManagementId) {},
+};
+
+const CyberiaWsSkillChannel = IoCreateChannel(CyberiaWsSkillController);
+
+export { CyberiaWsSkillChannel, CyberiaWsSkillController };