@wabot-dev/framework 0.1.0 → 0.2.0-beta.10

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

@@ -1,65 +1,100 @@
 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';
+import '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { isNotEmpty } from '../../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../../core/validation/validators/is-string/@isString.js';
 
 var SocketChannel_1;
+class SocketChannelReceivedMessage {
+    chatId;
+    senderName;
+    text;
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "chatId", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "senderName", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], SocketChannelReceivedMessage.prototype, "text", void 0);
 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", [SocketChannelReceivedMessage, 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 };
+export { SocketChannel, SocketChannelReceivedMessage };

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/core/mapper/Mapper.js

@@ -2,9 +2,9 @@ import { Storable } from '../storable/Storable.js';
 import { CustomError } from '../error/CustomError.js';
 import '../injection/index.js';
 import '../validation/metadata/ValidationMetadataStore.js';
-import { validate } from '../validation/validate.js';
+import { validateAndTransform } from '../validation/validateAndTransform.js';
 
-function deepCopyWithStorable(obj) {
+function deepCopyWithStorable(obj, visited = new WeakMap()) {
     if (obj === null || typeof obj !== 'object') {
         return obj;
     }
@@ -12,22 +12,38 @@ function deepCopyWithStorable(obj) {
         return obj.getTime();
     }
     if (obj instanceof Storable) {
-        return deepCopyWithStorable(obj['data']);
+        const dataCopy = deepCopyWithStorable(obj['data'], visited);
+        const result = { ...dataCopy };
+        // Handle getters from prototype
+        const proto = Object.getPrototypeOf(obj);
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        for (const [key, descriptor] of Object.entries(descriptors)) {
+            if (typeof descriptor.get === 'function') {
+                try {
+                    const value = obj[key];
+                    result[key] = deepCopyWithStorable(value, visited);
+                }
+                catch {
+                    // Silently ignore getters that throw
+                }
+            }
+        }
+        return result;
     }
     if (Array.isArray(obj)) {
-        return obj.map((item) => deepCopyWithStorable(item));
+        return obj.map((item) => deepCopyWithStorable(item, visited));
     }
     const copy = {};
     for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            copy[key] = deepCopyWithStorable(obj[key]);
+            copy[key] = deepCopyWithStorable(obj[key], visited);
         }
     }
     return copy;
 }
 class Mapper {
     map(data, ctor) {
-        const validationResult = validate(deepCopyWithStorable(data), ctor);
+        const validationResult = validateAndTransform(deepCopyWithStorable(data), ctor);
         if (validationResult.error) {
             throw new CustomError({
                 httpCode: 500,

package/dist/src/core/validation/core/validateModel.js

@@ -4,19 +4,52 @@ function validateModel(value, info) {
     }
     let propertiesErrors = {};
     let resultValue = new info.modelConstructor();
+    const properties = [];
+    const getters = [];
     for (const propertyName in info.properties) {
+        const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(resultValue), propertyName);
+        if (descriptor?.get) {
+            getters.push(propertyName);
+        }
+        if (!descriptor?.set && !descriptor?.get) {
+            properties.push(propertyName);
+        }
+    }
+    for (const propertyName of properties) {
         const propertyInfo = info.properties[propertyName];
         const propertyValidators = propertyInfo.validators ?? [];
-        resultValue[propertyName] = propertyInfo.isOptional
+        let currentPropValue = propertyInfo.isOptional
             ? (value[propertyName] ?? resultValue[propertyName])
             : value[propertyName];
-        if (resultValue[propertyName] == null && propertyInfo.isOptional) {
+        if (currentPropValue == null && propertyInfo.isOptional) {
             resultValue[propertyName] = undefined;
             continue;
         }
         for (let propertyValidatorInfo of propertyValidators) {
-            const propertyValidatorResult = propertyValidatorInfo.validator(resultValue[propertyName], propertyValidatorInfo.validatorOptions);
-            resultValue[propertyName] = propertyValidatorResult.value;
+            const propertyValidatorResult = propertyValidatorInfo.validator(currentPropValue, propertyValidatorInfo.validatorOptions);
+            if (propertyValidatorResult.error) {
+                let propertyErrors = propertiesErrors[propertyName];
+                if (!propertyErrors) {
+                    propertyErrors = [];
+                    propertiesErrors[propertyName] = propertyErrors;
+                }
+                propertyErrors.push(propertyValidatorResult.error.description);
+            }
+            else {
+                currentPropValue = propertyValidatorResult.value;
+            }
+        }
+        resultValue[propertyName] = currentPropValue;
+    }
+    for (const propertyName of getters) {
+        const propertyInfo = info.properties[propertyName];
+        const propertyValidators = propertyInfo.validators ?? [];
+        let propValue = resultValue[propertyName];
+        if (propValue == null && propertyInfo.isOptional) {
+            continue;
+        }
+        for (let propertyValidatorInfo of propertyValidators) {
+            const propertyValidatorResult = propertyValidatorInfo.validator(propValue, propertyValidatorInfo.validatorOptions);
             if (propertyValidatorResult.error) {
                 let propertyErrors = propertiesErrors[propertyName];
                 if (!propertyErrors) {

package/dist/src/core/validation/{validate.js → validateAndTransform.js}

@@ -2,10 +2,10 @@ import { container } from '../injection/index.js';
 import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
 import { validateModel } from './core/validateModel.js';
 
-function validate(value, modelConstructor) {
+function validateAndTransform(value, modelConstructor) {
     const metadataStore = container.resolve(ValidationMetadataStore);
     const info = metadataStore.getModelValidatorsInfo(modelConstructor);
     return validateModel(value, info);
 }
 
-export { validate };
+export { validateAndTransform };

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/rest-controller/runRestControllers.js

@@ -2,7 +2,7 @@ import { CustomError } from '../../core/error/CustomError.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
-import { validate } from '../../core/validation/validate.js';
+import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
 import { ExpressProvider } from '../express/ExpressProvider.js';
 import { json, urlencoded } from 'express';
 import path__default from 'path';
@@ -51,7 +51,7 @@ function runRestControllers(controllers) {
                         }
                         defaultArgFound = true;
                         if (typeof paramType === 'function') {
-                            const { value, error } = validate(buildRequest(req), paramType);
+                            const { value, error } = validateAndTransform(buildRequest(req), paramType);
                             if (error) {
                                 throw new CustomError({ httpCode: 400, message: error.description, info: error });
                             }

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 { validate } from '../../core/validation/validate.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 } = validate(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();