@wabot-dev/framework 0.1.0-beta.5 → 0.1.0-beta.51

package/dist/src/feature/rest-controller/metadata/@get.js

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

package/dist/src/feature/rest-controller/metadata/@middleware.js

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

package/dist/src/feature/rest-controller/metadata/@post.js

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

package/dist/src/feature/rest-controller/metadata/@restController.js

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

package/dist/src/feature/rest-controller/metadata/RestControllerMetadataStore.js

@@ -0,0 +1,50 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+
+let RestControllerMetadataStore = class RestControllerMetadataStore {
+    endPoints = new Map();
+    middlewares = new Map();
+    restControllers = new Map();
+    saveControllerMetadata(controllerMetadata) {
+        this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
+    }
+    saveEndPointMetadata(endPointMetadata) {
+        let controllerEndPoints = this.endPoints.get(endPointMetadata.controllerConstructor);
+        if (!controllerEndPoints) {
+            this.endPoints.set(endPointMetadata.controllerConstructor, (controllerEndPoints = new Map()));
+        }
+        controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
+    }
+    saveMiddlewareMetadata(middlewareMetadata) {
+        let controllerMiddlewares = this.middlewares.get(middlewareMetadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(middlewareMetadata);
+    }
+    getControllerEndPointsInfo(controllerConstructor) {
+        const controller = this.restControllers.get(controllerConstructor);
+        if (!controller) {
+            throw new Error(`${controllerConstructor.name} should be decorated with @restController`);
+        }
+        const endPoints = this.endPoints.get(controllerConstructor);
+        if (!endPoints?.size) {
+            // TODO: Warning
+            return [];
+        }
+        return [...endPoints.values()].map((endPoint) => ({
+            ...endPoint,
+            middlewares: this.middlewares.get(endPoint.controllerConstructor)?.get(endPoint.functionName) ?? [],
+            controller: this.restControllers.get(endPoint.controllerConstructor),
+        }));
+    }
+};
+RestControllerMetadataStore = __decorate([
+    singleton()
+], RestControllerMetadataStore);
+
+export { RestControllerMetadataStore };

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

@@ -0,0 +1,102 @@
+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 { ExpressProvider } from '../express/ExpressProvider.js';
+import { json, urlencoded } from 'express';
+import path from 'path';
+import { EXPRESS_REQ, EXPRESS_RES } from './injection-tokens.js';
+import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
+
+function buildRequest(req) {
+    return Object.assign({}, req.body, req.query, req.params);
+}
+function runRestControllers(controllers) {
+    const logger = new Logger('wabot:rest');
+    const metadataStore = container.resolve(RestControllerMetadataStore);
+    const expressProvider = container.resolve(ExpressProvider);
+    const expressApp = expressProvider.getExpress();
+    controllers.forEach((controller) => {
+        const endPoints = metadataStore.getControllerEndPointsInfo(controller);
+        endPoints.forEach((endPoint) => {
+            const method = endPoint.method;
+            const route = path
+                .join(endPoint.controller.path, endPoint.config?.path ?? '')
+                .replaceAll('\\', '/');
+            logger.info(`config ${endPoint.method.toUpperCase()} ${route}`);
+            const rawMiddlewares = [];
+            if (!endPoint.config?.disableJsonParser) {
+                rawMiddlewares.push(json());
+            }
+            if (!endPoint.config?.disableUrlEncodedParser) {
+                rawMiddlewares.push(urlencoded({ extended: true }));
+            }
+            expressApp[method](route, ...rawMiddlewares, async (req, res) => {
+                const requestContainer = container.createChildContainer();
+                requestContainer.register(EXPRESS_REQ, { useValue: req });
+                requestContainer.register(EXPRESS_RES, { useValue: req });
+                try {
+                    const middlewares = endPoint.middlewares.map((x) => requestContainer.resolve(x.middlewareConstructor));
+                    for (const middleware of middlewares) {
+                        await middleware.handle(req, res, requestContainer);
+                    }
+                    const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
+                    const endPointArgs = [];
+                    let defaultArgFound = false;
+                    for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
+                        const paramType = endPoint.paramsTypes[paramIndex];
+                        if (defaultArgFound) {
+                            throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                        }
+                        defaultArgFound = true;
+                        if (typeof paramType === 'function') {
+                            const { value, error } = validate(buildRequest(req), paramType);
+                            if (error) {
+                                throw new CustomError({ httpCode: 400, message: error.description, info: error });
+                            }
+                            endPointArgs.push(value);
+                        }
+                    }
+                    const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
+                    res.status(200).json(response);
+                }
+                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;
+                        }, {});
+                        res
+                            .status(httpCode ?? 500)
+                            .json(removeCircular({ error: { message: err.message, stack: err.stack, ...info } }));
+                    }
+                    else {
+                        res.status(500).json({ error: { message: 'Unknown error' } });
+                    }
+                }
+                finally {
+                    requestContainer.dispose();
+                }
+            });
+        });
+    });
+    expressProvider.listen();
+}
+function removeCircular(obj, seen = new WeakSet()) {
+    if (obj && typeof obj === 'object') {
+        if (seen.has(obj)) {
+            return undefined; // remove circular ref
+        }
+        seen.add(obj);
+        const clone = Array.isArray(obj) ? [] : {};
+        for (const key in obj) {
+            clone[key] = removeCircular(obj[key], seen);
+        }
+        return clone;
+    }
+    return obj;
+}
+
+export { runRestControllers };

package/dist/src/{channels → feature}/socket/SocketServerProvider.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../logger/Logger.js';
+import { singleton } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { HttpServerProvider } from '../http/HttpServerProvider.js';
 import { Server } from 'socket.io';
-import { singleton } from 'tsyringe';
 
 let SocketServerProvider = class SocketServerProvider {
     httpServerProvider;

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 };