underpost 2.8.884 → 2.8.885

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

@@ -8,18 +8,20 @@ const logger = loggerFactory(import.meta);
 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);
+      loadConf(deployId, subConf);
       const confClient = JSON.parse(
         fs.readFileSync(
           fs.existsSync(`./engine-private/replica/${deployId}`)
@@ -32,7 +34,9 @@ const clientLiveBuild = async () => {
       );
       const confServer = JSON.parse(
         fs.readFileSync(
-          fs.existsSync(`./engine-private/replica/${deployId}`)
+          fs.existsSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`)
+            ? `./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`
+            : fs.existsSync(`./engine-private/replica/${deployId}`)
             ? `./engine-private/replica/${deployId}/conf.server.json`
             : fs.existsSync(`./engine-private/conf/${deployId}/conf.server.json`)
             ? `./engine-private/conf/${deployId}/conf.server.json`
@@ -40,20 +44,25 @@ const clientLiveBuild = async () => {
           'utf8',
         ),
       );
-      host = process.argv[3];
-      path = process.argv[4];
+      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'));

package/src/server/client-dev-server.js

@@ -2,17 +2,26 @@ import fs from 'fs-extra';
 import nodemon from 'nodemon';
 import { shellExec } from './process.js';
 import { loggerFactory } from './logger.js';
+import { writeEnv } from './conf.js';
+import dotenv from 'dotenv';
 
 const logger = loggerFactory(import.meta);
 
-const createClientDevServer = () => {
-  // process.argv.slice(2).join(' ')
-  shellExec(`env-cmd -f .env.development node bin/deploy build-full-client ${process.argv.slice(2).join(' ')}`);
+const createClientDevServer = (
+  deployId = process.argv[2] || 'dd-default',
+  subConf = process.argv[3] || '',
+  host = process.argv[4] || 'default.net',
+  path = process.argv[5] || '/',
+) => {
   shellExec(
-    `env-cmd -f .env.development node src/api ${process.argv[2]}${process.argv[5] ? ` ${process.argv[5]}` : ''}${
-      process.argv.includes('static') ? ' static' : ''
-    }`,
-    { async: true },
+    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node bin/deploy build-full-client ${deployId} ${subConf}-dev-client ${host} ${path}`.trim(),
+  );
+
+  shellExec(
+    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node src/server ${deployId} ${subConf}-dev-client`.trim(),
+    {
+      async: true,
+    },
   );
 
   // https://github.com/remy/nodemon/blob/main/doc/events.md
@@ -28,7 +37,11 @@ const createClientDevServer = () => {
 
   let buildPathScope = [];
 
-  const nodemonOptions = { script: './src/client.build', args: process.argv.slice(2), watch: 'src/client' };
+  const nodemonOptions = {
+    script: './src/client.build',
+    args: [`${deployId}`, `${subConf}-dev-client`, `${host}`, `${path}`],
+    watch: 'src/client',
+  };
   logger.info('nodemon option', { nodemonOptions });
   nodemon(nodemonOptions)
     .on('start', function (...args) {

package/src/server/conf.js

@@ -25,13 +25,14 @@ const logger = loggerFactory(import.meta);
 const Config = {
   default: DefaultConf,
   build: async function (deployContext = 'dd-default', deployList, subConf) {
-    if (typeof process.argv[2] === 'string' && process.argv[2].startsWith('dd-')) deployContext = process.argv[2];
+    if (process.argv[2] && typeof process.argv[2] === 'string' && process.argv[2].startsWith('dd-'))
+      deployContext = process.argv[2];
+    if (!subConf && process.argv[3] && typeof process.argv[3] === 'string') subConf = process.argv[3];
     if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
     UnderpostRootEnv.API.set('await-deploy', new Date().toISOString());
-    if (fs.existsSync(`./engine-private/replica/${deployContext}`))
-      return loadConf(deployContext, process.env.NODE_ENV, subConf);
-    else if (deployContext.startsWith('dd-')) return loadConf(deployContext, process.env.NODE_ENV, subConf);
-    if (deployContext === 'proxy') Config.buildProxy(deployContext, deployList, subConf);
+    if (fs.existsSync(`./engine-private/replica/${deployContext}`)) return loadConf(deployContext, subConf);
+    else if (deployContext.startsWith('dd-')) return loadConf(deployContext, subConf);
+    if (deployContext === 'proxy') Config.buildProxy(deployList, subConf);
   },
   deployIdFactory: function (deployId = 'dd-default', options = { cluster: false }) {
     if (!deployId.startsWith('dd-')) deployId = `dd-${deployId}`;
@@ -105,7 +106,7 @@ const Config = {
     for (const confType of Object.keys(this.default))
       fs.writeFileSync(`${folder}/conf.${confType}.json`, JSON.stringify(this.default[confType], null, 4), 'utf8');
   },
-  buildProxy: function (deployContext = 'dd-default', deployList, subConf) {
+  buildProxy: function (deployList = 'dd-default', subConf = '') {
     if (!deployList) deployList = process.argv[3];
     if (!subConf) subConf = process.argv[4];
     this.default.server = {};
@@ -121,7 +122,7 @@ const Config = {
       if (process.env.NODE_ENV === 'development' && fs.existsSync(confDevPath)) confPath = confDevPath;
       const serverConf = JSON.parse(fs.readFileSync(confPath, 'utf8'));
 
-      for (const host of Object.keys(loadReplicas(serverConf, deployContext, subConf))) {
+      for (const host of Object.keys(loadReplicas(serverConf))) {
         if (serverConf[host]['/'])
           this.default.server[host] = {
             ...this.default.server[host],
@@ -138,13 +139,13 @@ const Config = {
   },
 };
 
-const loadConf = (deployId = 'dd-default', envInput, subConf) => {
+const loadConf = (deployId = 'dd-default', subConf) => {
   if (deployId === 'current') {
     console.log(process.env.DEPLOY_ID);
     return;
   }
   if (deployId === 'clean') {
-    const path = envInput ?? '.';
+    const path = '.';
     fs.removeSync(`${path}/.env`);
     shellExec(`git checkout ${path}/.env.production`);
     shellExec(`git checkout ${path}/.env.development`);
@@ -164,7 +165,6 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   for (const typeConf of Object.keys(Config.default)) {
     let srcConf = fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8');
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
-      if (!subConf) subConf = process.argv[3];
       const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
       if (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
     }
@@ -174,10 +174,13 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   fs.writeFileSync(`./.env.production`, fs.readFileSync(`${folder}/.env.production`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.development`, fs.readFileSync(`${folder}/.env.development`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.test`, fs.readFileSync(`${folder}/.env.test`, 'utf8'), 'utf8');
-  const NODE_ENV = envInput || process.env.NODE_ENV;
+  const NODE_ENV = process.env.NODE_ENV;
   if (NODE_ENV) {
-    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'), 'utf8');
-    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'));
+    const subPathEnv = fs.existsSync(`${folder}/.env.${NODE_ENV}.${subConf}`)
+      ? `${folder}/.env.${NODE_ENV}.${subConf}`
+      : `${folder}/.env.${NODE_ENV}`;
+    fs.writeFileSync(`./.env`, fs.readFileSync(subPathEnv, 'utf8'), 'utf8');
+    const env = dotenv.parse(fs.readFileSync(subPathEnv, 'utf8'));
     process.env = {
       ...process.env,
       ...env,
@@ -191,22 +194,16 @@ const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   return { folder, deployId };
 };
 
-const loadReplicas = (confServer, deployContext, subConf) => {
-  if (!deployContext) deployContext = process.argv[2];
-  if (!subConf) subConf = process.argv[3];
+const loadReplicas = (confServer) => {
   for (const host of Object.keys(confServer)) {
     for (const path of Object.keys(confServer[host])) {
       const { replicas, singleReplica } = confServer[host][path];
-      if (
-        replicas &&
-        (deployContext === 'proxy' ||
-          !singleReplica ||
-          (singleReplica && process.env.NODE_ENV === 'development' && !subConf))
-      )
+      if (replicas && !singleReplica)
         for (const replicaPath of replicas) {
-          confServer[host][replicaPath] = newInstance(confServer[host][path]);
-          delete confServer[host][replicaPath].replicas;
-          delete confServer[host][replicaPath].singleReplica;
+          {
+            confServer[host][replicaPath] = newInstance(confServer[host][path]);
+            delete confServer[host][replicaPath].replicas;
+          }
         }
     }
   }
@@ -982,6 +979,60 @@ const getInstanceContext = async (options = { singleReplica, replicas, redirect:
   return { redirectTarget };
 };
 
+const buildApiConf = async (options = { deployId: '', subConf: '', host: '', path: '', origin: '' }) => {
+  let { deployId, subConf, host, path, origin } = options;
+  if (!deployId) deployId = process.argv[2].trim();
+  if (!subConf) subConf = process.argv[3].trim();
+  if (process.argv[4]) host = process.argv[4].trim();
+  if (process.argv[5]) path = process.argv[5].trim();
+  if (process.argv[6])
+    origin = `${process.env.NODE_ENV === 'production' ? 'https' : 'http'}://${process.argv[6].trim()}`;
+
+  if (!origin) return;
+  const confServer = JSON.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`, 'utf8'),
+  );
+  const envObj = dotenv.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}`, 'utf8'),
+  );
+  if (host && path) {
+    confServer[host][path].origins = [origin];
+    logger.info('Build api conf', { host, path, origin });
+  } else return;
+  writeEnv(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-api`, envObj);
+  fs.writeFileSync(
+    `./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-api.json`,
+    JSON.stringify(confServer, null, 4),
+    'utf8',
+  );
+};
+
+const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '' }) => {
+  let { deployId, subConf, host, path } = options;
+  if (!deployId) deployId = process.argv[2].trim();
+  if (!subConf) subConf = process.argv[3].trim();
+  if (!host) host = process.argv[4].trim();
+  if (!path) path = process.argv[5].trim();
+  const confServer = JSON.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-api.json`, 'utf8'),
+  );
+  const envObj = dotenv.parse(
+    fs.readFileSync(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-api`, 'utf8'),
+  );
+  envObj.PORT = parseInt(envObj.PORT);
+  const apiBaseHost = options?.apiBaseHost ? options.apiBaseHost : `localhost:${envObj.PORT + 1}`;
+  confServer[host][path].apiBaseHost = apiBaseHost;
+  confServer[host][path].apiBaseProxyPath = path;
+  logger.info('Build client static conf', { host, path, apiBaseHost });
+  envObj.PORT = parseInt(confServer[host][path].origins[0].split(':')[2]) - 1;
+  writeEnv(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client`, envObj);
+  fs.writeFileSync(
+    `./engine-private/conf/${deployId}/conf.server.dev.${subConf}-dev-client.json`,
+    JSON.stringify(confServer, null, 4),
+    'utf8',
+  );
+};
+
 export {
   Cmd,
   Config,
@@ -1015,4 +1066,6 @@ export {
   rebuildConfFactory,
   buildCliDoc,
   getInstanceContext,
+  buildApiConf,
+  buildClientStaticConf,
 };

package/src/server/peer.js

@@ -48,7 +48,7 @@ const logger = loggerFactory(import.meta);
  */
 const createPeerServer = async ({ port, devPort, origins, host, path }) => {
   if (process.env.NODE_ENV === 'development' && devPort) {
-    logger.warn(`Adding development origin: http://localhost:${devPort}`);
+    // logger.warn(`Adding development origin: http://localhost:${devPort}`);
     origins.push(`http://localhost:${devPort}`);
   }
 
@@ -67,7 +67,7 @@ const createPeerServer = async ({ port, devPort, origins, host, path }) => {
   };
 
   // Use the framework's factory to listen on the server, ensuring graceful startup/shutdown
-  const peerServer = UnderpostStartUp.API.listenServerFactory(() => PeerServer(options));
+  const peerServer = UnderpostStartUp.API.listenServerFactory(async () => PeerServer(options));
 
   return { options, peerServer, meta: import.meta };
 };

package/src/server/runtime.js

@@ -103,10 +103,6 @@ const buildRuntime = async () => {
 
       switch (runtime) {
         case 'nodejs':
-          // The devApiPort is used for development CORS origin calculation
-          // It needs to account for the current port and potential peer server increment
-          const devApiPort = currentPort + (peer ? 2 : 1);
-
           logger.info('Build nodejs server runtime', `${host}${path}:${port}`);
 
           const { portsUsed } = await ExpressService.createApp({
@@ -124,7 +120,6 @@ const buildRuntime = async () => {
             peer,
             valkey,
             apiBaseHost,
-            devApiPort, // Pass the dynamically calculated dev API port
             redirectTarget,
             rootHostPath,
             confSSR,

package/src/server/start.js

@@ -1,3 +1,9 @@
+/**
+ * Manages the startup and runtime configuration of Underpost applications.
+ * @module src/server/start.js
+ * @namespace UnderpostStartUp
+ */
+
 import UnderpostDeploy from '../cli/deploy.js';
 import fs from 'fs-extra';
 import { awaitDeployMonitor } from './conf.js';
@@ -7,8 +13,17 @@ import UnderpostRootEnv from '../cli/env.js';
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * @class UnderpostStartUp
+ * @description Manages the startup and runtime configuration of Underpost applications.
+ * @memberof UnderpostStartUp
+ */
 class UnderpostStartUp {
   static API = {
+    /**
+     * Logs the runtime network configuration.
+     * @memberof UnderpostStartUp
+     */
     logRuntimeRouter: () => {
       const displayLog = {};
 
@@ -18,6 +33,12 @@ class UnderpostStartUp {
 
       logger.info('Runtime network', displayLog);
     },
+    /**
+     * Creates a server factory.
+     * @memberof UnderpostStartUp
+     * @param {Function} logic - The logic to execute when the server is listening.
+     * @returns {Object} An object with a listen method.
+     */
     listenServerFactory: (logic = async () => {}) => {
       return {
         listen: async (...args) => {
@@ -36,6 +57,15 @@ class UnderpostStartUp {
         },
       };
     },
+
+    /**
+     * Controls the listening port for a server.
+     * @memberof UnderpostStartUp
+     * @param {Object} server - The server to listen on.
+     * @param {number|string} port - The port number or colon for all ports.
+     * @param {Object} metadata - Metadata for the server.
+     * @returns {Promise<boolean>} A promise that resolves to true if the server is listening, false otherwise.
+     */
     listenPortController: async (server, port, metadata) =>
       new Promise((resolve) => {
         try {
@@ -79,6 +109,15 @@ class UnderpostStartUp {
         }
       }),
 
+    /**
+     * Starts a deployment.
+     * @memberof UnderpostStartUp
+     * @param {string} deployId - The ID of the deployment.
+     * @param {string} env - The environment of the deployment.
+     * @param {Object} options - Options for the deployment.
+     * @param {boolean} options.build - Whether to build the deployment.
+     * @param {boolean} options.run - Whether to run the deployment.
+     */
     async callback(deployId = 'dd-default', env = 'development', options = { build: false, run: false }) {
       if (options.build === true) await UnderpostStartUp.API.build(deployId, env);
       if (options.run === true) await UnderpostStartUp.API.run(deployId, env);

package/src/ws/IoInterface.js

@@ -1,45 +1,138 @@
+/**
+ * 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);
 
-const IoCreateChannel = (
-  IoInterface = {
-    channel: '',
-    connection: (socket = {}, client = {}, wsManagementId = '') => {},
-    controller: (socket = {}, client = {}, args = '', wsManagementId = '') => {},
-    disconnect: (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
-    stream: false,
-  },
-) => {
-  return {
-    channel: IoInterface.channel,
-    client: {},
-    connection: async function (socket, wsManagementId) {
-      try {
-        this.client[socket.id] = socket;
-        socket.on(IoInterface.channel, (...args) => this.controller(socket, args, wsManagementId));
-        await IoInterface.connection(socket, this.client, wsManagementId);
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, stack: error.stack });
-      }
-    },
-    controller: async function (socket, args, wsManagementId) {
-      try {
-        const payload = IoInterface.stream ? args[0] : JSON.parse(args[0]);
-        await IoInterface.controller(socket, this.client, payload, wsManagementId, args);
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, args, stack: error.stack });
-      }
-    },
-    disconnect: async function (socket, reason, wsManagementId) {
-      try {
-        await IoInterface.disconnect(socket, this.client, reason, wsManagementId);
-        delete this.client[socket.id];
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, reason, stack: error.stack });
+/**
+ * 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).
+ */
+
+/**
+ * @class
+ * @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 { IoCreateChannel };
+export { IoChannel, IoCreateChannel };