@wabot-dev/framework 0.2.0-beta.8 → 0.2.0

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

@@ -1,65 +1,106 @@
 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';
+import { Auth } from '../../../core/auth/Auth.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 {
+            auth;
+            constructor(auth) {
+                this.auth = auth;
+            }
+            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);
-                    },
-                    authInfo: socket.data.authInfo,
-                    setAuthInfo: (authInfo) => {
-                        socket.data.authInfo = authInfo;
+                        socket.emit('message', message);
                     },
+                    injectInstances: [
+                        [Socket, socket],
+                        [Auth, this.auth],
+                    ],
                 });
-            });
-        });
-        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 ?? []),
+            __metadata("design:paramtypes", [Auth])
+        ], 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/feature/chat-bot/ChatAdapter.js

@@ -1,5 +1,5 @@
 class ChatAdapter {
-    nextItem(req) {
+    nextItems(req) {
         throw new Error('Method not implemented.');
     }
 }

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

@@ -41,23 +41,27 @@ let ChatBot = class ChatBot {
             throw new Error(`Invalid ${this.mindset.constructor.name} - llms not found`);
         }
         const llm = llms[0];
-        const { chatItem: newItemData } = await this.adapter.nextItem({
+        const { nextItems: newItemsData } = await this.adapter.nextItems({
             model: llm.model,
             provider: llm.provider,
             systemPrompt,
             tools,
             prevItems: prevItems.map((x) => x.getData()),
         });
-        if (newItemData.type === 'functionCall') {
-            newItemData.functionCall.result = await this.mindset.callFunction(newItemData.functionCall.name, newItemData.functionCall.arguments ?? '{}');
+        for (const newItemData of newItemsData) {
+            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 (newItemData.type === 'botMessage') {
+                callback(newChatItem.botMessage);
+            }
         }
-        else if (newItemData.type === 'botMessage') {
-            newItemData.botMessage.senderName = identity.name;
-        }
-        const newChatItem = new ChatItem(newItemData);
-        await this.memory.create(newChatItem);
-        if (newChatItem.type === 'botMessage') {
-            callback(newChatItem.botMessage);
+        if (newItemsData.length == 0 || newItemsData[newItemsData.length - 1].type === 'botMessage') {
             return;
         }
         this.processLoop(callback);

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

@@ -62,16 +62,15 @@ function runChatControllers(controllers) {
                     chat,
                     ...channelMessage,
                 });
+                if (channelMessage.injectInstances) {
+                    for (const [token, instance] of channelMessage.injectInstances) {
+                        chatContainer.registerInstance(token, instance);
+                    }
+                }
                 const chatController = chatContainer.resolve(channelMetadata.controllerConstructor);
                 const receivedMessage = {
                     message: channelMessage.message,
-                    reply: (message) => {
-                        channelMessage.reply(message);
-                        if (channelMessage.setAuthInfo) {
-                            const auth = chatContainer.resolve(Auth);
-                            channelMessage.setAuthInfo(auth['authInfo'] || undefined);
-                        }
-                    },
+                    reply: channelMessage.reply,
                 };
                 chatController[channelMetadata.functionName](receivedMessage);
             });

package/dist/src/feature/rest-controller/runRestControllers.js

@@ -59,7 +59,7 @@ function runRestControllers(controllers) {
                         }
                     }
                     const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
-                    res.status(200).json(response);
+                    res.status(200).json(response ?? null);
                 }
                 catch (err) {
                     logger.error(err);

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,
+                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,103 @@ 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;
+                connectionContainer.registerInstance(Socket, socket);
+                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();