@wabot-dev/framework 0.1.0-beta.45 → 0.1.0-beta.47

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppProxyContracts.js

@@ -0,0 +1,5 @@
+const WHATSAPP_PROXY_SEND_MESSAGE_EVENT = 'sendMessage';
+const WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT = 'listenMessage';
+const WHATSAPP_MESSAGE_EVENT = 'message';
+
+export { WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT };

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppReceiverByWabotProxy.js

@@ -0,0 +1,65 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppReceiver } from '../WhatsAppReceiver.js';
+import { injectable } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { WHATSAPP_MESSAGE_EVENT } from './WhatsAppProxyContracts.js';
+import { WhatsAppWabotProxyConnection } from './WhatsAppWabotProxyConnection.js';
+
+let WhatsAppReceiverByWabotProxy = class WhatsAppReceiverByWabotProxy extends WhatsAppReceiver {
+    connection;
+    loger = new Logger('wabot:whats-app-receiver-by-wabot-proxy');
+    constructor(connection) {
+        super();
+        this.connection = connection;
+    }
+    async connect() {
+        // Nothing
+    }
+    listenMessage(request) {
+        this.connection.getSocket().then(async (socket) => {
+            const req = {
+                event: 'listenMessage',
+                data: {
+                    to: [request.to],
+                },
+            };
+            const response = await socket.emitWithAck(req.event, req.data);
+            if (response && typeof response == 'object' && response['error']) {
+                this.loger.error(response.error);
+                return;
+            }
+            else if (!response ||
+                typeof response !== 'object' ||
+                !Array.isArray(response.from) ||
+                !Array.isArray(response.to)) {
+                this.loger.error('unknown response');
+                return;
+            }
+            this.loger.trace(`succes add whats-app proxy listener for messages from [${response.from.join(',')}] to [${response.to.join(',')}]`);
+            socket.on(WHATSAPP_MESSAGE_EVENT, (data, callback) => {
+                if (data.to !== request.to) {
+                    throw new Error(`expecting message to '${request.to}' but received to='${data.to}'`);
+                }
+                callback({ success: true });
+                this.loger.trace(`success receive message from '${data.from}' to '${data.to}'`);
+                request.listener({
+                    chatConnection: {
+                        channelName: 'WhatsAppChannel',
+                        id: data.from,
+                    },
+                    message: {
+                        text: data.content.text,
+                        senderName: data.senderName,
+                        senderId: data.from,
+                    },
+                });
+            });
+        });
+    }
+};
+WhatsAppReceiverByWabotProxy = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppWabotProxyConnection])
+], WhatsAppReceiverByWabotProxy);
+
+export { WhatsAppReceiverByWabotProxy };

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppSenderByWabotProxy.js

@@ -0,0 +1,60 @@
+import { __decorate, __metadata } from 'tslib';
+import { WhatsAppSender } from '../WhatsAppSender.js';
+import { singleton } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import '../../../../feature/chat-bot/ChatBot.js';
+import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
+import 'uuid';
+import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
+import 'reflect-metadata';
+import '../../../../feature/mindset/metadata/MindsetMetadataStore.js';
+import '../../../../feature/mindset/MindsetOperator.js';
+import { WhatsAppRepository } from '../WhatsAppRepository.js';
+import { WhatsAppWabotProxyConnection } from './WhatsAppWabotProxyConnection.js';
+
+let WhatsAppSenderByWabotProxy = class WhatsAppSenderByWabotProxy extends WhatsAppSender {
+    wabotDevConnection;
+    logger = new Logger('wabot:whatsapp-sender-by-wabot-proxy');
+    constructor(wabotDevConnection, chatRepository, chatResolver, whatsAppRepository) {
+        super(chatRepository, chatResolver, whatsAppRepository);
+        this.wabotDevConnection = wabotDevConnection;
+    }
+    async sendWhatsApp(request, options) {
+        try {
+            const socket = await this.wabotDevConnection.getSocket();
+            const req = {
+                event: 'sendMessage',
+                data: {
+                    from: request.from,
+                    to: request.to,
+                    content: {
+                        text: request.message.text ?? 'No Text',
+                    },
+                },
+            };
+            const ack = await socket.timeout(5000).emitWithAck(req.event, req.data);
+            if (!ack || !ack.success) {
+                throw new Error(`not success ack, when send whatsapp from '${request.from}' to '${request.to}'`);
+            }
+            this.logger.trace(`success send whatsapp from '${request.from}' to '${request.to}'`);
+            if (options?.writeChatMemory) {
+                await this.writePrivateChatMemory(request.message, request.to);
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+            throw new Error(undefined, { cause: err });
+        }
+    }
+};
+WhatsAppSenderByWabotProxy = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [WhatsAppWabotProxyConnection,
+        ChatRepository,
+        ChatResolver,
+        WhatsAppRepository])
+], WhatsAppSenderByWabotProxy);
+
+export { WhatsAppSenderByWabotProxy };

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppWabotProxyConnection.js

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../../../core/env/Env.js';
+import { injectable } from '../../../../core/injection/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { io } from 'socket.io-client';
+
+let WhatsAppWabotProxyConnection = class WhatsAppWabotProxyConnection {
+    baseUrl;
+    socket = null;
+    apiKey;
+    logger = new Logger('wabot:whats-app-wabot-proxy-connection');
+    constructor(env) {
+        this.apiKey = env.requireString('WABOT_API_KEY');
+        this.baseUrl = env.requireString('WABOT_PROXY_URL');
+        while (this.baseUrl.endsWith('/')) {
+            this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
+        }
+    }
+    async getSocket() {
+        if (this.socket) {
+            return this.socket;
+        }
+        return new Promise((resolve, reject) => {
+            const socket = io(`${this.baseUrl}/whats-app`, {
+                autoConnect: false,
+                auth: { token: this.apiKey },
+                reconnection: true,
+            });
+            socket.on('connect', async () => {
+                this.socket = socket;
+                resolve(socket);
+            });
+            socket.on('connect_error', (err) => {
+                reject(new Error(err && err.message ? err.message : 'connection error', { cause: err }));
+            });
+            socket.connect();
+        });
+    }
+};
+WhatsAppWabotProxyConnection = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Env])
+], WhatsAppWabotProxyConnection);
+
+export { WhatsAppWabotProxyConnection };

package/dist/src/core/password/Password.js

@@ -0,0 +1,30 @@
+import { randomBytes, scryptSync, timingSafeEqual } from 'node:crypto';
+import { Random } from '../random/Random.js';
+
+class Password {
+    static hash(options) {
+        const { password: secret, saltLength = 16, keyLength = 64 } = options;
+        const salt = randomBytes(saltLength).toString('hex');
+        const derivedKey = scryptSync(secret, salt, keyLength);
+        return `${salt}:${derivedKey.toString('hex')}`;
+    }
+    static isValid(req) {
+        const [salt, storedKeyHex] = req.hash.split(':');
+        if (!salt || !storedKeyHex)
+            return false;
+        try {
+            const keyLength = Buffer.from(storedKeyHex, 'hex').length;
+            const derivedKey = scryptSync(req.password, salt, keyLength);
+            const storedKey = Buffer.from(storedKeyHex, 'hex');
+            return timingSafeEqual(derivedKey, storedKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    static generate(length) {
+        return Random.string(length);
+    }
+}
+
+export { Password };

package/dist/src/core/validation/metadata/@isArray.js

@@ -1,5 +1,5 @@
 import { container } from '../../injection/index.js';
-import { validateArray } from '../validators/validateArray.js';
+import { validateArray } from '../core/validateArray.js';
 import { ValidationMetadataStore } from './ValidationMetadataStore.js';
 
 function isArray(options) {

package/dist/src/core/validation/metadata/@isModel.js

@@ -1,5 +1,5 @@
 import { container } from '../../injection/index.js';
-import { validateModel } from '../validators/validateModel.js';
+import { validateModel } from '../core/validateModel.js';
 import { ValidationMetadataStore } from './ValidationMetadataStore.js';
 
 function isModel(model) {

package/dist/src/core/validation/metadata/@isOptional.js

@@ -1,6 +1,6 @@
 import { container } from '../../injection/index.js';
 import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../validators/validateIsOptional.js';
+import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../core/validateIsOptional.js';
 
 function isOptional() {
     return function (target, propertyKey) {

package/dist/src/core/validation/metadata/ValidationMetadataStore.js

@@ -1,7 +1,7 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../injection/index.js';
-import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../validators/validateIsOptional.js';
-import { validateArray } from '../validators/validateArray.js';
+import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../core/validateIsOptional.js';
+import { validateArray } from '../core/validateArray.js';
 
 function getClassHierarchy(cls) {
     const classes = [];

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

@@ -1,6 +1,6 @@
 import { container } from '../injection/index.js';
 import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
-import { validateModel } from './validators/validateModel.js';
+import { validateModel } from './core/validateModel.js';
 
 function validate(value, modelConstructor) {
     const metadataStore = container.resolve(ValidationMetadataStore);

package/dist/src/{addon/validation → core/validation/validators}/is-boolean/@isBoolean.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateIsBoolean } from './validateIsBoolean.js';
 
 function isBoolean() {

package/dist/src/{addon/validation → core/validation/validators}/is-date/@isDate.js

@@ -1,6 +1,6 @@
-import { container } from '../../../core/injection/index.js';
+import { container } from '../../../injection/index.js';
 import { validateIsDate } from './validateIsDate.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 
 function isDate() {
     return function (target, propertyKey) {

package/dist/src/{addon/validation → core/validation/validators}/is-not-empty/@isNotEmpty.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateIsNotEmpty } from './validateIsNotEmpty.js';
 
 function isNotEmpty() {

package/dist/src/{addon/validation → core/validation/validators}/is-number/@isNumber.js

@@ -1,6 +1,6 @@
-import { container } from '../../../core/injection/index.js';
+import { container } from '../../../injection/index.js';
 import { validateIsNumber } from './validateIsNumber.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 
 function isNumber() {
     return function (target, propertyKey) {

package/dist/src/{addon/validation → core/validation/validators}/is-present/@isPresent.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateIsPresent } from './validateIsPresent.js';
 
 function isPresent() {

package/dist/src/{addon/validation → core/validation/validators}/is-string/@isString.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateIsString } from './validateIsString.js';
 
 function isString() {

package/dist/src/{addon/validation → core/validation/validators}/max/@max.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateMax } from './validateMax.js';
 
 function max(limit) {

package/dist/src/{addon/validation → core/validation/validators}/min/@min.js

@@ -1,5 +1,5 @@
-import { container } from '../../../core/injection/index.js';
-import { ValidationMetadataStore } from '../../../core/validation/metadata/ValidationMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
 import { validateMin } from './validateMin.js';
 
 function min(limit) {

package/dist/src/feature/chat-bot/ChatBot.js

@@ -35,6 +35,7 @@ let ChatBot = class ChatBot {
         }
         const systemPrompt = await this.mindset.systemPrompt();
         const tools = this.mindset.tools();
+        const identity = await this.mindset.identity();
         const llms = await this.mindset.llms();
         if (llms.length === 0) {
             throw new Error(`Invalid ${this.mindset.constructor.name} - llms not found`);
@@ -50,6 +51,9 @@ let ChatBot = class ChatBot {
         if (newItemData.type === 'functionCall') {
             newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
         }
+        else if (newItemData.type === 'botMessage') {
+            newItemData.botMessage.senderName = identity.name;
+        }
         const newChatItem = new ChatItem(newItemData);
         await this.memory.create(newChatItem);
         if (newChatItem.type === 'botMessage') {

package/dist/src/{addon → feature}/money/MoneyDto.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
 import '../../core/injection/index.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
-import { isNotEmpty } from '../validation/is-not-empty/@isNotEmpty.js';
-import { isString } from '../validation/is-string/@isString.js';
+import { isNotEmpty } from '../../core/validation/validators/is-not-empty/@isNotEmpty.js';
+import { isString } from '../../core/validation/validators/is-string/@isString.js';
 
 class MoneyDto {
     amount = '';

package/dist/src/{addon/repository → feature}/pg/PgCrudRepository.js

@@ -1,6 +1,6 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
-import { CustomError } from '../../../core/error/CustomError.js';
+import { CustomError } from '../../core/error/CustomError.js';
 
 class PgCrudRepository extends PgRepositoryBase {
     config;

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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,18 @@
+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 };

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

@@ -0,0 +1,15 @@
+import { SocketControllerMetadataStore } from './SocketControllerMetadataStore.js';
+import { container, injectable } from '../../../core/injection/index.js';
+
+function socketController(config) {
+    return function (target) {
+        const metaDataStore = container.resolve(SocketControllerMetadataStore);
+        metaDataStore.saveControllerMetadata({
+            controllerConstructor: target,
+            config: typeof config === 'string' ? { namespace: config } : config,
+        });
+        injectable()(target);
+    };
+}
+
+export { socketController };

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

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

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

@@ -0,0 +1,65 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+
+let SocketControllerMetadataStore = class SocketControllerMetadataStore {
+    socketControllers = new Map();
+    socketConnections = new Map();
+    socketEvents = new Map();
+    connectionMiddlewares = 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) {
+            this.socketEvents.set(socketEventMetadata.controllerConstructor, (controllerEvents = new Map()));
+        }
+        controllerEvents.set(socketEventMetadata.functionName, socketEventMetadata);
+    }
+    saveConnectionMiddlewareMetadata(middlewareMetadata) {
+        let controllerMiddlewares = this.connectionMiddlewares.get(middlewareMetadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.connectionMiddlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(middlewareMetadata);
+    }
+    getControllerSockerConnectionsInfo(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 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),
+        }));
+    }
+};
+SocketControllerMetadataStore = __decorate([
+    singleton()
+], SocketControllerMetadataStore);
+
+export { SocketControllerMetadataStore };

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

@@ -0,0 +1,98 @@
+import { SocketControllerMetadataStore } from './metadata/SocketControllerMetadataStore.js';
+import { container } from '../../core/injection/index.js';
+import path 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';
+
+function runSocketControllers(controllers) {
+    const logger = new Logger('wabot:socket');
+    const metadataStore = container.resolve(SocketControllerMetadataStore);
+    const socketServerProvider = container.resolve(SocketServerProvider);
+    const socketServer = socketServerProvider.getSocketServer();
+    controllers.forEach((controller) => {
+        const connections = metadataStore.getControllerSockerConnectionsInfo(controller);
+        connections.forEach((connection) => {
+            const namespace = path
+                .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();
+                }
+                catch (err) {
+                    next(err);
+                    connectionContainer.dispose();
+                }
+            });
+            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) {
+                                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' } });
+                                    }
+                                }
+                            }
+                        });
+                    });
+                    await controllerInstance[connection.functionName].apply(controllerInstance, [socket]);
+                }
+                catch (err) {
+                    logger.error(err);
+                    socket.disconnect();
+                    connectionContainer.dispose();
+                }
+            });
+        });
+    });
+    socketServerProvider.listen();
+}
+
+export { runSocketControllers };