@wabot-dev/framework 0.2.0-beta.7 → 0.2.0-beta.9

package/dist/src/addon/auth/api-key/@apiKeyHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { ApiKeyHandshakeGuardMiddleware } from './ApiKeyHandshakeGuardMiddleware.js';
+
+function apiKeyHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([ApiKeyHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { apiKeyHandshakeGuard };

package/dist/src/addon/auth/api-key/ApiKey.js

@@ -13,6 +13,9 @@ class ApiKey extends Entity {
     get metadata() {
         return this.data.metadata ?? {};
     }
+    get name() {
+        return this.data.name;
+    }
     setAuthInfo(authInfo) {
         this.data.authInfo = authInfo;
     }

package/dist/src/addon/auth/api-key/{ApiKeyConnectionGuardMiddleware.js → ApiKeyHandshakeGuardMiddleware.js}

@@ -4,7 +4,7 @@ import { CustomError } from '../../../core/error/CustomError.js';
 import { injectable } from '../../../core/injection/index.js';
 import { ApiKeyRepository } from './ApiKeyRepository.js';
 
-let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
+let ApiKeyHandshakeGuardMiddleware = class ApiKeyHandshakeGuardMiddleware {
     apiKeyRepository;
     auth;
     constructor(apiKeyRepository, auth) {
@@ -45,10 +45,10 @@ let ApiKeyConnectionGuardMiddleware = class ApiKeyConnectionGuardMiddleware {
         }
     }
 };
-ApiKeyConnectionGuardMiddleware = __decorate([
+ApiKeyHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [ApiKeyRepository,
         Auth])
-], ApiKeyConnectionGuardMiddleware);
+], ApiKeyHandshakeGuardMiddleware);
 
-export { ApiKeyConnectionGuardMiddleware };
+export { ApiKeyHandshakeGuardMiddleware };

package/dist/src/addon/auth/jwt/@jwtHandshakeGuard.js

@@ -0,0 +1,16 @@
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import '../../../core/injection/index.js';
+import 'debug';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import 'socket.io';
+import '../../../feature/socket/SocketServerProvider.js';
+import { JwtHandshakeGuardMiddleware } from './JwtHandshakeGuardMiddleware.js';
+
+function jwtHandshakeGuard() {
+    return function (target) {
+        handshakeMiddlewares([JwtHandshakeGuardMiddleware])(target);
+    };
+}
+
+export { jwtHandshakeGuard };

package/dist/src/addon/auth/jwt/{JwtConnectionGuardMiddleware.js → JwtHandshakeGuardMiddleware.js}

@@ -5,7 +5,7 @@ import { Auth } from '../../../core/auth/Auth.js';
 import { CustomError } from '../../../core/error/CustomError.js';
 import { JwtConfig } from './JwtConfig.js';
 
-let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
+let JwtHandshakeGuardMiddleware = class JwtHandshakeGuardMiddleware {
     config;
     auth;
     constructor(config, auth) {
@@ -48,10 +48,10 @@ let JwtConnectionGuardMiddleware = class JwtConnectionGuardMiddleware {
         }
     }
 };
-JwtConnectionGuardMiddleware = __decorate([
+JwtHandshakeGuardMiddleware = __decorate([
     injectable(),
     __metadata("design:paramtypes", [JwtConfig,
         Auth])
-], JwtConnectionGuardMiddleware);
+], JwtHandshakeGuardMiddleware);
 
-export { JwtConnectionGuardMiddleware };
+export { JwtHandshakeGuardMiddleware };

package/dist/src/addon/chat-controller/socket/@socket.js

@@ -18,7 +18,7 @@ function socket(config) {
             channelConstructor: SocketChannel,
             functionName: propertyKey.toString(),
             controllerConstructor: target.constructor,
-            channelConfig: new SocketChannelConfig(config.channel),
+            channelConfig: new SocketChannelConfig(config.namespace, config.handshakeMidlewares),
         });
     };
 }

package/dist/src/addon/chat-controller/socket/SocketChannel.js

@@ -1,65 +1,77 @@
 import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
-import { SocketServerProvider } from '../../../feature/socket/SocketServerProvider.js';
+import { handshakeMiddlewares } from '../../../feature/socket-controller/metadata/@handshakeMiddlewares.js';
+import { socketController } from '../../../feature/socket-controller/metadata/@socketController.js';
+import { onSocketEvent } from '../../../feature/socket-controller/metadata/@onSocketEvent.js';
+import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
+import { runSocketControllers } from '../../../feature/socket-controller/runSocketControllers.js';
+import { Socket } from 'socket.io';
 import { SocketChannelConfig } from './SocketChannelConfig.js';
 
 var SocketChannel_1;
 let SocketChannel = SocketChannel_1 = class SocketChannel {
     config;
-    socketServerProvider;
     callBack = null;
-    server;
-    constructor(config, socketServerProvider) {
+    controller = null;
+    constructor(config) {
         this.config = config;
-        this.socketServerProvider = socketServerProvider;
-        this.server = this.socketServerProvider.getSocketServer();
+        this.configController();
     }
-    listen(callback) {
-        this.callBack = callback;
-    }
-    connect() {
-        this.server.on('connection', (socket) => {
-            socket.on(this.config.channel, async (message) => {
+    configController() {
+        const channel = this;
+        let SocketChannelController = class SocketChannelController {
+            onMessage(message, socket) {
+                if (!channel.callBack)
+                    return;
                 const trimmedInput = message.text.trim();
                 if (!trimmedInput) {
                     return;
                 }
-                if (!message.chatId || !message.userId || !message.senderName) {
-                    socket.emit(this.config.channel, {
-                        error: 'Invalid message format. chatId, userId, and senderName are required.',
-                    });
-                    return;
-                }
                 const chatConnection = {
                     id: message.chatId,
                     chatType: 'PRIVATE',
                     channelName: SocketChannel_1.name,
                 };
-                if (!this.callBack)
-                    return;
-                this.callBack({
+                channel.callBack({
                     chatConnection,
                     message: {
-                        text: trimmedInput,
+                        text: message.text,
                         senderName: message.senderName,
                     },
                     reply: (message) => {
-                        socket.emit(this.config.channel, message);
+                        socket.emit('message', message);
                     },
                     authInfo: socket.data.authInfo,
                     setAuthInfo: (authInfo) => {
                         socket.data.authInfo = authInfo;
                     },
                 });
-            });
-        });
-        this.socketServerProvider.listen();
+            }
+        };
+        __decorate([
+            onSocketEvent('message'),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object, Socket]),
+            __metadata("design:returntype", void 0)
+        ], SocketChannelController.prototype, "onMessage", null);
+        SocketChannelController = __decorate([
+            socketController(channel.config.namespace),
+            handshakeMiddlewares(channel.config.handshakeMidlewares ?? [])
+        ], SocketChannelController);
+        this.controller = SocketChannelController;
+    }
+    listen(callback) {
+        this.callBack = callback;
+    }
+    connect() {
+        if (!this.controller)
+            return;
+        runSocketControllers([this.controller]);
     }
 };
 SocketChannel = SocketChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [SocketChannelConfig,
-        SocketServerProvider])
+    __metadata("design:paramtypes", [SocketChannelConfig])
 ], SocketChannel);
 
 export { SocketChannel };

package/dist/src/addon/chat-controller/socket/SocketChannelConfig.js

@@ -2,14 +2,16 @@ import { __decorate, __metadata } from 'tslib';
 import { injectable } from '../../../core/injection/index.js';
 
 let SocketChannelConfig = class SocketChannelConfig {
-    channel;
-    constructor(channel) {
-        this.channel = channel;
+    namespace;
+    handshakeMidlewares;
+    constructor(namespace, handshakeMidlewares) {
+        this.namespace = namespace;
+        this.handshakeMidlewares = handshakeMidlewares;
     }
 };
 SocketChannelConfig = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [String])
+    __metadata("design:paramtypes", [String, Array])
 ], SocketChannelConfig);
 
 export { SocketChannelConfig };

package/dist/src/core/auth/Auth.js

@@ -4,6 +4,7 @@ import { scoped, Lifecycle } from '../injection/index.js';
 
 let Auth = class Auth {
     authInfo = null;
+    overrided = false;
     require() {
         if (!this.authInfo) {
             throw new CustomError({ message: 'Unauthorized', httpCode: 401 });
@@ -18,13 +19,18 @@ let Auth = class Auth {
     }
     override(authInfo) {
         this.authInfo = authInfo;
+        this.overrided = true;
     }
     clear() {
         this.authInfo = null;
+        this.overrided = true;
     }
     isAssigned() {
         return this.authInfo !== null;
     }
+    wasOverrided() {
+        return this.overrided;
+    }
 };
 Auth = __decorate([
     scoped(Lifecycle.ContainerScoped)

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -69,7 +69,9 @@ function runChatControllers(controllers) {
                         channelMessage.reply(message);
                         if (channelMessage.setAuthInfo) {
                             const auth = chatContainer.resolve(Auth);
-                            channelMessage.setAuthInfo(auth['authInfo'] || undefined);
+                            if (auth.wasOverrided()) {
+                                channelMessage.setAuthInfo(auth['authInfo'] || undefined);
+                            }
                         }
                     },
                 };

package/dist/src/feature/socket-controller/metadata/@handshakeMiddlewares.js

@@ -0,0 +1,16 @@
+import { SocketControllerMetadataStore } from './SocketControllerMetadataStore.js';
+import { container } from '../../../core/injection/index.js';
+
+function handshakeMiddlewares(middlewares) {
+    return function (target) {
+        const store = container.resolve(SocketControllerMetadataStore);
+        for (const mw of middlewares) {
+            store.saveHandshakeMiddlewareMetadata({
+                controllerConstructor: target.constructor,
+                middlewareConstructor: mw,
+            });
+        }
+    };
+}
+
+export { handshakeMiddlewares };

package/dist/src/feature/socket-controller/metadata/{@socketEvent.js → @onSocketEvent.js}

@@ -1,7 +1,7 @@
 import { container } from '../../../core/injection/index.js';
 import { SocketControllerMetadataStore } from './SocketControllerMetadataStore.js';
 
-function socketEvent(config) {
+function onSocketEvent(config) {
     return function (target, propertyKey) {
         const functionName = propertyKey.toString();
         const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
@@ -15,4 +15,4 @@ function socketEvent(config) {
     };
 }
 
-export { socketEvent };
+export { onSocketEvent };

package/dist/src/feature/socket-controller/metadata/SocketControllerMetadataStore.js

@@ -3,19 +3,11 @@ import { singleton } from '../../../core/injection/index.js';
 
 let SocketControllerMetadataStore = class SocketControllerMetadataStore {
     socketControllers = new Map();
-    socketConnections = new Map();
     socketEvents = new Map();
-    connectionMiddlewares = new Map();
+    handshakeMiddlewares = new Map();
     saveControllerMetadata(controllerMetadata) {
         this.socketControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
     }
-    saveSocketConnectionMetadata(socketConnectionMetadata) {
-        let controllerConnections = this.socketConnections.get(socketConnectionMetadata.controllerConstructor);
-        if (!controllerConnections) {
-            this.socketConnections.set(socketConnectionMetadata.controllerConstructor, (controllerConnections = new Map()));
-        }
-        controllerConnections.set(socketConnectionMetadata.functionName, socketConnectionMetadata);
-    }
     saveSocketEventMetadata(socketEventMetadata) {
         let controllerEvents = this.socketEvents.get(socketEventMetadata.controllerConstructor);
         if (!controllerEvents) {
@@ -23,39 +15,25 @@ let SocketControllerMetadataStore = class SocketControllerMetadataStore {
         }
         controllerEvents.set(socketEventMetadata.functionName, socketEventMetadata);
     }
-    saveConnectionMiddlewareMetadata(middlewareMetadata) {
-        let controllerMiddlewares = this.connectionMiddlewares.get(middlewareMetadata.controllerConstructor);
+    saveHandshakeMiddlewareMetadata(handshakeMetadata) {
+        let controllerMiddlewares = this.handshakeMiddlewares.get(handshakeMetadata.controllerConstructor);
         if (!controllerMiddlewares) {
-            this.connectionMiddlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+            this.handshakeMiddlewares.set(handshakeMetadata.controllerConstructor, (controllerMiddlewares = []));
         }
-        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
-        if (!methodMiddlewares) {
-            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
-        }
-        methodMiddlewares.unshift(middlewareMetadata);
+        controllerMiddlewares.unshift(handshakeMetadata);
     }
-    getControllerSockerConnectionsInfo(controllerConstructor) {
+    getSocketControllerInfo(controllerConstructor) {
         const controller = this.socketControllers.get(controllerConstructor);
         if (!controller) {
             throw new Error(`${controllerConstructor.name} should be decorated with @socketController`);
         }
-        const connections = this.socketConnections.get(controllerConstructor);
+        const handShakeMiddlewares = this.handshakeMiddlewares.get(controllerConstructor);
         const events = this.socketEvents.get(controllerConstructor) ?? new Map();
-        if (!connections?.size) {
-            // TODO: Warning
-            return [];
-        }
-        return [...connections.values()].map((connection) => ({
-            ...connection,
-            events: (() => {
-                const connectionNamespace = connection.config?.namespace;
-                return [...events.values()].filter((x) => x.config?.namespace === connectionNamespace);
-            })(),
-            connectionMiddlewares: this.connectionMiddlewares
-                .get(connection.controllerConstructor)
-                ?.get(connection.functionName) ?? [],
-            controller: this.socketControllers.get(connection.controllerConstructor),
-        }));
+        return {
+            controller,
+            events,
+            handShakeMiddlewares,
+        };
     }
 };
 SocketControllerMetadataStore = __decorate([

package/dist/src/feature/socket-controller/runSocketControllers.js

@@ -1,11 +1,11 @@
-import { SocketControllerMetadataStore } from './metadata/SocketControllerMetadataStore.js';
+import { CustomError } from '../../core/error/CustomError.js';
 import { container } from '../../core/injection/index.js';
-import path__default from 'path';
 import { Logger } from '../../core/logger/Logger.js';
-import { SocketServerProvider } from '../socket/SocketServerProvider.js';
-import { CustomError } from '../../core/error/CustomError.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
 import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
+import { Socket } from 'socket.io';
+import { SocketServerProvider } from '../socket/SocketServerProvider.js';
+import { SocketControllerMetadataStore } from './metadata/SocketControllerMetadataStore.js';
 
 function runSocketControllers(controllers) {
     const logger = new Logger('wabot:socket');
@@ -13,84 +13,102 @@ function runSocketControllers(controllers) {
     const socketServerProvider = container.resolve(SocketServerProvider);
     const socketServer = socketServerProvider.getSocketServer();
     controllers.forEach((controller) => {
-        const connections = metadataStore.getControllerSockerConnectionsInfo(controller);
-        connections.forEach((connection) => {
-            const namespace = path__default
-                .join(connection.controller.config?.namespace ?? '/', connection.config?.namespace ?? '')
-                .replaceAll('\\', '/');
-            logger.info(`config connection to ${namespace}`);
-            const namespaceServer = socketServer.of(namespace);
-            namespaceServer.use(async (socket, next) => {
-                const connectionContainer = container.createChildContainer();
-                try {
-                    const middlewares = connection.connectionMiddlewares.map((x) => connectionContainer.resolve(x.middlewareConstructor));
-                    for (const middleware of middlewares) {
-                        await middleware.handle(socket, connectionContainer);
-                    }
-                    socket.data.connectionContainer = connectionContainer;
-                    next();
+        const controllerInfo = metadataStore.getSocketControllerInfo(controller);
+        const namespace = `/${controllerInfo.controller.config?.namespace ?? ''}`;
+        logger.info(`config connection to ${namespace}`);
+        const namespaceServer = socketServer.of(namespace);
+        namespaceServer.use(async (socket, next) => {
+            const connectionContainer = container.createChildContainer();
+            try {
+                const middlewares = controllerInfo.handShakeMiddlewares?.map((x) => connectionContainer.resolve(x.middlewareConstructor)) ?? [];
+                for (const middleware of middlewares) {
+                    await middleware.handle(socket, connectionContainer);
                 }
-                catch (err) {
-                    next(err);
-                    connectionContainer.dispose();
+                socket.data.connectionContainer = connectionContainer;
+                next();
+            }
+            catch (err) {
+                next(err);
+                connectionContainer.dispose();
+            }
+        });
+        const eventListener = async (controllerInstance, socket, event, req, callback) => {
+            logger.trace(`received '${event.config.event}' event on '${namespace}'`);
+            const paramsValues = [];
+            try {
+                if (event.paramsTypes.length > 2) {
+                    throw new CustomError({
+                        httpCode: 400,
+                        message: 'the socket event handler should have max 2 parameters: (req, socket)',
+                    });
                 }
-            });
-            namespaceServer.on('connection', async (socket) => {
-                logger.trace(`connection on '${namespace}'`);
-                const connectionContainer = socket.data.connectionContainer;
-                try {
-                    const controllerInstance = connectionContainer.resolve(connection.controllerConstructor);
-                    connection.events.forEach((event) => {
-                        logger.trace(`config listener to '${event.config.event}' event on '${namespace}'`);
-                        socket.on(event.config.event, async (req, callback) => {
-                            logger.trace(`received '${event.config.event}' event on '${namespace}'`);
-                            try {
-                                const reqType = event.paramsTypes[0];
-                                if (typeof reqType !== 'function') {
-                                    throw new CustomError({
-                                        httpCode: 400,
-                                        message: 'Unable to validate request',
-                                    });
-                                }
-                                const { value, error } = validateAndTransform(req, reqType);
-                                if (error) {
-                                    throw new CustomError({
-                                        httpCode: 400,
-                                        message: error.description,
-                                        info: error,
-                                    });
-                                }
-                                const out = await controllerInstance[event.functionName].apply(controllerInstance, [value, socket]);
-                                callback(out);
-                            }
-                            catch (err) {
-                                logger.error(err);
-                                if (err instanceof Error) {
-                                    const keys = Object.keys(err).filter((key) => !['message', 'stack'].includes(key));
-                                    const { httpCode, ...info } = keys.reduce((acc, key) => {
-                                        acc[key] = err[key];
-                                        return acc;
-                                    }, {});
-                                    if (typeof callback === 'function') {
-                                        callback({ error: { ...info, message: err.message, stack: err.stack } });
-                                    }
-                                }
-                                else {
-                                    if (typeof callback === 'function') {
-                                        callback({ error: { message: 'Unspected error' } });
-                                    }
-                                }
-                            }
+                if (event.paramsTypes[0] !== Socket) {
+                    const reqType = event.paramsTypes[0];
+                    if (typeof reqType !== 'function') {
+                        throw new CustomError({
+                            httpCode: 400,
+                            message: 'Unable to validate request',
                         });
-                    });
-                    await controllerInstance[connection.functionName].apply(controllerInstance, [socket]);
+                    }
+                    const { value, error } = validateAndTransform(req, reqType);
+                    if (error) {
+                        throw new CustomError({
+                            httpCode: 400,
+                            message: error.description,
+                            info: error,
+                        });
+                    }
+                    paramsValues.push(value);
+                }
+                paramsValues.push(socket);
+                const out = await controllerInstance[event.functionName].apply(controllerInstance, paramsValues);
+                if (typeof callback === 'function') {
+                    callback(out);
+                }
+            }
+            catch (err) {
+                logger.error(err);
+                if (err instanceof Error) {
+                    const keys = Object.keys(err).filter((key) => !['message', 'stack'].includes(key));
+                    const { httpCode, ...info } = keys.reduce((acc, key) => {
+                        acc[key] = err[key];
+                        return acc;
+                    }, {});
+                    if (typeof callback === 'function') {
+                        callback({ error: { ...info, message: err.message, stack: err.stack } });
+                    }
+                }
+                else {
+                    if (typeof callback === 'function') {
+                        callback({ error: { message: 'Unspected error' } });
+                    }
                 }
-                catch (err) {
-                    logger.error(err);
-                    socket.disconnect();
-                    connectionContainer.dispose();
+            }
+        };
+        namespaceServer.on('connection', async (socket) => {
+            logger.trace(`connection on '${namespace}'`);
+            const connectionContainer = socket.data.connectionContainer;
+            try {
+                const controllerInstance = connectionContainer.resolve(controllerInfo.controller.controllerConstructor);
+                controllerInfo.events.forEach((event) => {
+                    logger.trace(`config listener to '${event.config.event}' event on '${namespace}'`);
+                    if (event.config.event === 'connection') {
+                        return;
+                    }
+                    socket.on(event.config.event, async (req, callback) => {
+                        await eventListener(controllerInstance, socket, event, req, callback);
+                    });
+                });
+                const connectionEvent = controllerInfo.events.get('connection');
+                if (connectionEvent) {
+                    await eventListener(controllerInstance, socket, connectionEvent, null, null);
                 }
-            });
+            }
+            catch (err) {
+                logger.error(err);
+                socket.disconnect();
+                connectionContainer.dispose();
+            }
         });
     });
     socketServerProvider.listen();

package/dist/src/index.d.ts

@@ -23,11 +23,13 @@ declare class Storable<D extends IStorableData> {
 
 declare class Auth<D extends IStorableData> {
     private authInfo;
+    private overrided;
     require(): D;
     assign(authInfo: D): void;
     override(authInfo: D): void;
     clear(): void;
     isAssigned(): boolean;
+    wasOverrided(): boolean;
 }
 
 interface IEntityData extends IStorableData {
@@ -924,17 +926,11 @@ declare class SocketServerProvider {
     private createSocketServer;
 }
 
-interface IConnectionMiddleware {
+interface IHandshakeMiddleware {
     handle(socket: Socket, container: DependencyContainer$1): Promise<void>;
 }
 
-declare function connectionMiddleware(middlewareConstructor: IConstructor<IConnectionMiddleware>): (target: object, propertyKey: string | symbol) => void;
-
-interface ISocketConnectionConfig {
-    namespace: string;
-}
-
-declare function socketConnection(config?: string | ISocketConnectionConfig): (target: object, propertyKey: string | symbol) => void;
+declare function handshakeMiddlewares(middlewares: IConstructor<IHandshakeMiddleware>[]): (target: IConstructor<any>) => void;
 
 interface ISocketControllerConfig {
     namespace: string;
@@ -943,23 +939,14 @@ interface ISocketControllerConfig {
 declare function socketController(config?: string | ISocketControllerConfig): (target: IConstructor<any>) => void;
 
 interface ISocketEventConfig {
-    namespace?: string;
     event: string;
 }
 
-declare function socketEvent(config: string | ISocketEventConfig): (target: object, propertyKey: string | symbol) => void;
+declare function onSocketEvent(config: string | ISocketEventConfig): (target: object, propertyKey: string | symbol) => void;
 
-interface IConnectionMiddlewareMetadata {
+interface IHandshakeMiddlewareMetadata {
     controllerConstructor: IConstructor<any>;
-    functionName: string;
-    middlewareConstructor: IConstructor<IConnectionMiddleware>;
-}
-
-interface ISocketConnectionMetadata {
-    config?: ISocketConnectionConfig;
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    paramsTypes: any[];
+    middlewareConstructor: IConstructor<IHandshakeMiddleware>;
 }
 
 interface ISocketControllerMetadata {
@@ -976,22 +963,16 @@ interface ISocketEventMetadata {
 
 declare class SocketControllerMetadataStore {
     private socketControllers;
-    private socketConnections;
     private socketEvents;
-    private connectionMiddlewares;
+    private handshakeMiddlewares;
     saveControllerMetadata(controllerMetadata: ISocketControllerMetadata): void;
-    saveSocketConnectionMetadata(socketConnectionMetadata: ISocketConnectionMetadata): void;
     saveSocketEventMetadata(socketEventMetadata: ISocketEventMetadata): void;
-    saveConnectionMiddlewareMetadata(middlewareMetadata: IConnectionMiddlewareMetadata): void;
-    getControllerSockerConnectionsInfo(controllerConstructor: IConstructor<any>): {
-        events: ISocketEventMetadata[];
-        connectionMiddlewares: IConnectionMiddlewareMetadata[];
+    saveHandshakeMiddlewareMetadata(handshakeMetadata: IHandshakeMiddlewareMetadata): void;
+    getSocketControllerInfo(controllerConstructor: IConstructor<any>): {
         controller: ISocketControllerMetadata;
-        config?: ISocketConnectionConfig;
-        controllerConstructor: IConstructor<any>;
-        functionName: string;
-        paramsTypes: any[];
-    }[];
+        events: Map<string, ISocketEventMetadata>;
+        handShakeMiddlewares: IHandshakeMiddlewareMetadata[] | undefined;
+    };
 }
 
 declare function runSocketControllers(controllers: IConstructor<any>[]): void;
@@ -1000,7 +981,7 @@ declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepos
     constructor(pool: Pool);
 }
 
-declare function apiKeyConnectionGuard(): (target: object, propertyKey: string | symbol) => void;
+declare function apiKeyHandshakeGuard(): (target: IConstructor<any>) => void;
 
 declare function apiKeyGuard(): (target: object, propertyKey: string | symbol) => void;
 
@@ -1015,6 +996,7 @@ declare class ApiKey<A extends IStorableData> extends Entity<IApiKeyData<A>> {
     static hashSecret(secret: string): string;
     get authInfo(): A;
     get metadata(): Record<string, string>;
+    get name(): string;
     setAuthInfo(authInfo: A): void;
     generateSecret(): string;
     isValidSecret(secret: string): boolean;
@@ -1050,7 +1032,7 @@ declare class ApiKeyRepository<A extends IStorableData> implements IApiKeyReposi
     findAndValidate(secret: string): Promise<A>;
 }
 
-declare class ApiKeyConnectionGuardMiddleware implements IConnectionMiddleware {
+declare class ApiKeyHandshakeGuardMiddleware implements IHandshakeMiddleware {
     private apiKeyRepository;
     private auth;
     constructor(apiKeyRepository: ApiKeyRepository<any>, auth: Auth<any>);
@@ -1089,7 +1071,7 @@ declare class RemoteApiKeyRepository<A extends IStorableData> implements IApiKey
     generate(req: IGenerateApiKeyReq<A>): Promise<IGenerateApiKeyRes<A>>;
 }
 
-declare function jwtConnectionGuard(): (target: object, propertyKey: string | symbol) => void;
+declare function jwtHandshakeGuard(): (target: IConstructor<any>) => void;
 
 declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
 
@@ -1168,7 +1150,7 @@ declare class Jwt {
     findRefreshTokenAuthInfo(secret: string): Promise<any>;
 }
 
-declare class JwtConnectionGuardMiddleware implements IConnectionMiddleware {
+declare class JwtHandshakeGuardMiddleware implements IHandshakeMiddleware {
     private config;
     private auth;
     constructor(config: JwtConfig, auth: Auth<any>);
@@ -1292,28 +1274,29 @@ declare function writeJsonToFile<T>(filename: string, data: T): void;
 declare function readJsonFromFile<T>(filename: string): T | null;
 
 interface ISocketChannelConfig {
-    channel: string;
+    namespace: string;
+    handshakeMidlewares?: IConstructor<IHandshakeMiddleware>[];
 }
 
 declare class SocketChannelConfig implements ISocketChannelConfig {
-    channel: string;
-    constructor(channel: string);
+    namespace: string;
+    handshakeMidlewares?: IConstructor<IHandshakeMiddleware>[] | undefined;
+    constructor(namespace: string, handshakeMidlewares?: IConstructor<IHandshakeMiddleware>[] | undefined);
 }
 
 declare function socket(config: SocketChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
 interface ISocketChannelReceivedMessage {
     chatId: string;
-    userId: string;
     senderName: string;
     text: string;
 }
 declare class SocketChannel implements IChatChannel {
     private config;
-    private socketServerProvider;
     private callBack;
-    private server;
-    constructor(config: SocketChannelConfig, socketServerProvider: SocketServerProvider);
+    private controller;
+    constructor(config: SocketChannelConfig);
+    private configController;
     listen(callback: (message: IChannelMessage) => void): void;
     connect(): void;
 }
@@ -1635,4 +1618,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyConnectionGuardMiddleware, ApiKeyGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatAdapterNextItemRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConnectionMiddleware, type IConnectionMiddlewareMetadata, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketConnectionConfig, type ISocketConnectionMetadata, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtConnectionGuardMiddleware, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyConnectionGuard, apiKeyGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, connectionMiddleware, container, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtConnectionGuard, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, param, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketConnection, socketController, socketEvent, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemReq, type IChatAdapterNextItemRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobEvent, type IJobEventListener, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, SocketChannel, SocketChannelConfig, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, param, readJsonFromFile, restController, runAsyncCommandHandlers, runChatControllers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsApp, writeJsonToFile };

package/dist/src/index.js

@@ -84,27 +84,26 @@ export { RestControllerMetadataStore } from './feature/rest-controller/metadata/
 export { runRestControllers } from './feature/rest-controller/runRestControllers.js';
 export { EXPRESS_REQ, EXPRESS_RES } from './feature/rest-controller/injection-tokens.js';
 export { SocketServerProvider } from './feature/socket/SocketServerProvider.js';
-export { connectionMiddleware } from './feature/socket-controller/metadata/@connectionMiddleware.js';
-export { socketConnection } from './feature/socket-controller/metadata/@socketConnection.js';
+export { handshakeMiddlewares } from './feature/socket-controller/metadata/@handshakeMiddlewares.js';
 export { socketController } from './feature/socket-controller/metadata/@socketController.js';
-export { socketEvent } from './feature/socket-controller/metadata/@socketEvent.js';
+export { onSocketEvent } from './feature/socket-controller/metadata/@onSocketEvent.js';
 export { SocketControllerMetadataStore } from './feature/socket-controller/metadata/SocketControllerMetadataStore.js';
 export { runSocketControllers } from './feature/socket-controller/runSocketControllers.js';
 export { PgJobRepository } from './addon/async/pg/PgJobRepository.js';
-export { apiKeyConnectionGuard } from './addon/auth/api-key/@apiKeyConnectionGuard.js';
+export { apiKeyHandshakeGuard } from './addon/auth/api-key/@apiKeyHandshakeGuard.js';
 export { apiKeyGuard } from './addon/auth/api-key/@apiKeyGuard.js';
 export { ApiKey } from './addon/auth/api-key/ApiKey.js';
-export { ApiKeyConnectionGuardMiddleware } from './addon/auth/api-key/ApiKeyConnectionGuardMiddleware.js';
+export { ApiKeyHandshakeGuardMiddleware } from './addon/auth/api-key/ApiKeyHandshakeGuardMiddleware.js';
 export { ApiKeyGuardMiddleware } from './addon/auth/api-key/ApiKeyGuardMiddleware.js';
 export { ApiKeyRepository } from './addon/auth/api-key/ApiKeyRepository.js';
 export { PgApiKeyRepository } from './addon/auth/api-key/PgApiKeyRepository.js';
 export { RemoteApiKeyRepository } from './addon/auth/api-key/RemoteApiKeyRepository.js';
-export { jwtConnectionGuard } from './addon/auth/jwt/@jwtConnectionGuard.js';
+export { jwtHandshakeGuard } from './addon/auth/jwt/@jwtHandshakeGuard.js';
 export { jwtGuard } from './addon/auth/jwt/@jwtGuard.js';
 export { Jwt } from './addon/auth/jwt/Jwt.js';
 export { JwtAccessAndRefreshTokenDto } from './addon/auth/jwt/JwtAccessAndRefreshTokenDto.js';
 export { JwtConfig } from './addon/auth/jwt/JwtConfig.js';
-export { JwtConnectionGuardMiddleware } from './addon/auth/jwt/JwtConnectionGuardMiddleware.js';
+export { JwtHandshakeGuardMiddleware } from './addon/auth/jwt/JwtHandshakeGuardMiddleware.js';
 export { JwtGuardMiddleware } from './addon/auth/jwt/JwtGuardMiddleware.js';
 export { JwtRefreshToken } from './addon/auth/jwt/JwtRefreshToken.js';
 export { JwtRefreshTokenRepository } from './addon/auth/jwt/JwtRefreshTokenRepository.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.2.0-beta.7",
+  "version": "0.2.0-beta.9",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",

package/dist/src/addon/auth/api-key/@apiKeyConnectionGuard.js

@@ -1,16 +0,0 @@
-import { connectionMiddleware } from '../../../feature/socket-controller/metadata/@connectionMiddleware.js';
-import '../../../core/injection/index.js';
-import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
-import 'path';
-import 'debug';
-import '../../../feature/socket/SocketServerProvider.js';
-import '../../../core/validation/metadata/ValidationMetadataStore.js';
-import { ApiKeyConnectionGuardMiddleware } from './ApiKeyConnectionGuardMiddleware.js';
-
-function apiKeyConnectionGuard() {
-    return function (target, propertyKey) {
-        connectionMiddleware(ApiKeyConnectionGuardMiddleware)(target, propertyKey);
-    };
-}
-
-export { apiKeyConnectionGuard };

package/dist/src/addon/auth/jwt/@jwtConnectionGuard.js

@@ -1,16 +0,0 @@
-import { connectionMiddleware } from '../../../feature/socket-controller/metadata/@connectionMiddleware.js';
-import '../../../core/injection/index.js';
-import '../../../feature/socket-controller/metadata/SocketControllerMetadataStore.js';
-import 'path';
-import 'debug';
-import '../../../feature/socket/SocketServerProvider.js';
-import '../../../core/validation/metadata/ValidationMetadataStore.js';
-import { JwtConnectionGuardMiddleware } from './JwtConnectionGuardMiddleware.js';
-
-function jwtConnectionGuard() {
-    return function (target, propertyKey) {
-        connectionMiddleware(JwtConnectionGuardMiddleware)(target, propertyKey);
-    };
-}
-
-export { jwtConnectionGuard };

package/dist/src/feature/socket-controller/metadata/@connectionMiddleware.js

@@ -1,16 +0,0 @@
-import { SocketControllerMetadataStore } from './SocketControllerMetadataStore.js';
-import { container } from '../../../core/injection/index.js';
-
-function connectionMiddleware(middlewareConstructor) {
-    return function (target, propertyKey) {
-        const functionName = propertyKey.toString();
-        const store = container.resolve(SocketControllerMetadataStore);
-        store.saveConnectionMiddlewareMetadata({
-            controllerConstructor: target.constructor,
-            functionName,
-            middlewareConstructor: middlewareConstructor,
-        });
-    };
-}
-
-export { connectionMiddleware };

package/dist/src/feature/socket-controller/metadata/@socketConnection.js

@@ -1,18 +0,0 @@
-import { container } from '../../../core/injection/index.js';
-import { SocketControllerMetadataStore } from './SocketControllerMetadataStore.js';
-
-function socketConnection(config) {
-    return function (target, propertyKey) {
-        const functionName = propertyKey.toString();
-        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
-        const store = container.resolve(SocketControllerMetadataStore);
-        store.saveSocketConnectionMetadata({
-            controllerConstructor: target.constructor,
-            config: typeof config === 'string' ? { namespace: config } : config,
-            functionName,
-            paramsTypes,
-        });
-    };
-}
-
-export { socketConnection };