@wabot-dev/framework 0.1.0-beta.6 → 0.1.0-beta.61

package/dist/src/{mindset → feature/mindset}/MindsetOperator.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../injection/index.js';
+import { injectable } from '../../core/injection/index.js';
 import { Mindset } from './IMindset.js';
 import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
-import { Container } from '../injection/Container.js';
+import { Container } from '../../core/injection/Container.js';
 
 let MindsetOperator = class MindsetOperator {
     mindset;
@@ -22,64 +22,69 @@ let MindsetOperator = class MindsetOperator {
     limits() {
         return this.mindset.limits();
     }
-    async callFunction(name, params) {
-        const fnMetadata = this.metadata.modules
-            .map((module) => module.functions)
-            .flat()
-            .find((fn) => fn.name === name);
-        if (!fnMetadata) {
-            throw new Error(`Function ${name} not found`);
-        }
-        const paramsObj = JSON.parse(params);
-        const module = this.container.resolve(fnMetadata.moduleConstructor);
-        try {
-            const response = await module[name](paramsObj);
-            if (!response) {
-                return 'success';
-            }
-            return response.toString();
-        }
-        catch (error) {
-            return `Error: ${error}`;
-        }
+    llms() {
+        return this.mindset.llms();
     }
-    async allFunctionsDescriptors() {
+    async systemPrompt() {
+        let [identity, skills, limits] = await Promise.all([
+            this.identity(),
+            this.skills(),
+            this.limits(),
+        ]);
+        const language = identity.language.replaceAll('#', ' ');
+        const name = identity.name.replaceAll('#', ' ');
+        const age = identity.age ? identity.age.toString().replaceAll('#', ' ') : null;
+        const personality = identity.personality ? identity.personality.replaceAll('#', ' ') : null;
+        skills = skills.replaceAll('#', ' ');
+        limits = limits.replaceAll('#', ' ');
+        const systemPrompt = `
+         # System Instructions
+         you should act as a assistant.
+         your main language is ${language}.
+         your name is ${name}.
+         ${age ? 'you are ' + age + ' years old.' : ''}
+         
+          ${personality ? '## Personality (in your main language) \n' + personality : ''}
+  
+          ## Skills (in your main language)
+          ${skills}
+  
+          ## System limitations (in your main language)
+          ${limits}
+  
+          ## Chat memory
+          Next you will receive a chat history,
+          you should use this information to answer the user.
+      `;
+        return systemPrompt;
+    }
+    tools() {
         return this.metadata.modules
-            .map((module) => module.functions.map((fn) => this.functionDescriptor(fn)))
+            .map((module) => module.functions.map((fn) => this.tool(fn, module)))
             .flat();
     }
-    functionDescriptor(fn) {
+    tool(fn, module) {
         const description = fn.config.description.replaceAll('#', ' ');
         return {
-            type: 'function',
+            language: module.config.language ?? 'english',
             name: fn.name,
             description,
-            parameters: {
-                type: 'object',
-                properties: fn.params.reduce((prev, param) => ({
-                    ...prev,
-                    [param.name]: this.toolParam(param),
-                }), {}),
-                required: fn.params.filter((param) => !param.config.optional).map((param) => param.name)
-            },
+            parameters: fn.params.map((param) => this.toolParameter(param)),
         };
     }
-    toolParam(param) {
-        const addons = {
-            description: `
+    toolParameter(param) {
+        let description = `
       ### description (in your main language)
       ${param.config.description.replaceAll('#', ' ')}
-      `,
-        };
+      `;
         const type = (() => {
             if (param.type === Number)
                 return 'number';
             if (param.type === String)
                 return 'string';
             if (param.type === Date) {
-                addons.description = `${addons.description}
+                description = `${description}
           ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
-          ${addons.description}
         `;
                 return 'string';
             }
@@ -87,9 +92,31 @@ let MindsetOperator = class MindsetOperator {
         })();
         return {
             type,
-            ...addons,
+            name: param.name,
+            description,
         };
     }
+    async callFunction(name, params) {
+        const fnMetadata = this.metadata.modules
+            .map((module) => module.functions)
+            .flat()
+            .find((fn) => fn.name === name);
+        if (!fnMetadata) {
+            throw new Error(`Function ${name} not found`);
+        }
+        const paramsObj = JSON.parse(params);
+        const module = this.container.resolve(fnMetadata.moduleConstructor);
+        try {
+            const response = await module[name](paramsObj);
+            if (!response) {
+                return 'success';
+            }
+            return response.toString();
+        }
+        catch (error) {
+            return `Error: ${error}`;
+        }
+    }
 };
 MindsetOperator = __decorate([
     injectable(),

package/dist/src/{mindset → feature/mindset}/metadata/MindsetMetadataStore.js

@@ -1,5 +1,5 @@
 import { __decorate } from 'tslib';
-import { singleton } from '../../injection/index.js';
+import { singleton } from '../../../core/injection/index.js';
 import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './functions/decoratorNames.js';
 import { MINDSET_DECORATION_MINDSET } from './mindsets/decoratorNames.js';
 import { MINDSET_MODULE_DECORATION_MODULE } from './modules/decoratorNames.js';

package/dist/src/{mindset → feature/mindset}/metadata/functions/@mindsetFunction.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { container } from '../../../injection/index.js';
+import { container } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/mindsets/@mindset.js

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { container, injectable } from '../../../injection/index.js';
+import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_DECORATION_MINDSET } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/modules/@mindsetModule.js

@@ -1,5 +1,4 @@
-import 'reflect-metadata';
-import { container, injectable } from '../../../injection/index.js';
+import { container, injectable } from '../../../../core/injection/index.js';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
 import { MINDSET_MODULE_DECORATION_MODULE } from './decoratorNames.js';
 

package/dist/src/{mindset → feature/mindset}/metadata/params/@param.js

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
 import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
-import { container } from '../../../injection/index.js';
+import { container } from '../../../../core/injection/index.js';
 import { PARAM_DECORATION_PARAM } from './decoratorNames.js';
 
 function param(config) {

package/dist/src/feature/money/Money.js

@@ -0,0 +1,61 @@
+import { Storable } from '../../core/storable/Storable.js';
+import { Big } from 'big.js';
+
+Big.strict = true;
+class Money extends Storable {
+    getData() {
+        return { ...this.data };
+    }
+    get amount() {
+        return Big(this.data.amount);
+    }
+    get currency() {
+        return this.data.currency;
+    }
+    plus(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return new Money({
+            amount: this.amount.plus(money.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    minus(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return new Money({
+            amount: this.amount.minus(money.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    times(value) {
+        return new Money({
+            amount: this.amount.times(new Big(String(value))).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    div(value) {
+        return new Money({
+            amount: this.amount.div(new Big(String(value))).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    negative() {
+        return new Money({
+            amount: new Big('0').minus(this.amount).toFixed(6),
+            currency: this.currency,
+        });
+    }
+    isGretterThan(money) {
+        this.validateEqualCurrencies(this.data.currency, money.data.currency);
+        return this.amount.gt(money.amount);
+    }
+    validateEqualCurrencies(left, right) {
+        if (left !== right) {
+            throw new Error(`Is not posible operate with diferent currencies: '${left}' and '${right}'`);
+        }
+    }
+    static zero(currency) {
+        return new Money({ currency, amount: '0' });
+    }
+}
+
+export { Money };

package/dist/src/feature/money/MoneyDto.js

@@ -0,0 +1,22 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../core/injection/index.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';
+
+class MoneyDto {
+    amount = '';
+    currency = '';
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], MoneyDto.prototype, "amount", void 0);
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], MoneyDto.prototype, "currency", void 0);
+
+export { MoneyDto };

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

@@ -1,5 +1,6 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
+import { CustomError } from '../../core/error/CustomError.js';
 
 class PgCrudRepository extends PgRepositoryBase {
     config;
@@ -17,6 +18,28 @@ class PgCrudRepository extends PgRepositoryBase {
         const items = await this.query(sql, [id]);
         return items.at(0) ?? null;
     }
+    async findByIds(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE id IN (${ids.map((_, i) => '$' + (i + 1)).join(',')})
+    `;
+        const items = await this.query(sql, ids);
+        return items;
+    }
+    async findOrThrow(id) {
+        const item = await this.find(id);
+        if (!item) {
+            throw new CustomError({
+                message: `Not found ${this.config.constructor.name} with id = '${id}'`,
+                httpCode: 404,
+            });
+        }
+        return item;
+    }
     async findAll() {
         const sql = `
       SELECT ${this.columns}
@@ -46,16 +69,14 @@ class PgCrudRepository extends PgRepositoryBase {
          SET ${this.updates}
       WHERE id = $${this.columnsList.length + 1}
     `;
-        await this.exec(sql, [...this.values(item), item.getId()]);
+        await this.exec(sql, [...this.values(item), item.id]);
     }
-    async discard(item) {
-        const _item = await this.find(item.getId());
-        if (!_item) {
-            throw new Error('Not found');
-        }
-        item.discard();
-        _item.discard();
-        await this.update(_item);
+    async delete(item) {
+        const sql = `
+      DELETE FROM ${this.table}
+      WHERE id = $1
+    `;
+        await this.exec(sql, [item.id]);
     }
 }
 

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

@@ -32,8 +32,8 @@ class PgRepositoryBase {
     }
     values(item) {
         return [
-            item.getId(),
-            item.getCreatedAt(),
+            item.id,
+            item.createdAt,
             JSON.stringify(item['data']),
             ...this.columnsList.slice(3).map((x) => this.addColumns[x].value(item)),
         ];

package/dist/src/feature/rest-controller/injection-tokens.js

@@ -0,0 +1,4 @@
+const EXPRESS_REQ = 'EXPRESS_REQ';
+const EXPRESS_RES = 'EXPRESS_RES';
+
+export { EXPRESS_REQ, EXPRESS_RES };

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/@onDelete.js

@@ -0,0 +1,7 @@
+import { methodDecorator } from './methodDecorator.js';
+
+function onDelete(config) {
+    return methodDecorator('delete', config);
+}
+
+export { onDelete };

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

@@ -0,0 +1,7 @@
+import { methodDecorator } from './methodDecorator.js';
+
+function onGet(config) {
+    return methodDecorator('get', config);
+}
+
+export { onGet };

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

@@ -0,0 +1,7 @@
+import { methodDecorator } from './methodDecorator.js';
+
+function onPost(config) {
+    return methodDecorator('post', config);
+}
+
+export { onPost };

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

@@ -0,0 +1,7 @@
+import { methodDecorator } from './methodDecorator.js';
+
+function onPut(config) {
+    return methodDecorator('put', config);
+}
+
+export { onPut };

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/metadata/methodDecorator.js

@@ -0,0 +1,19 @@
+import { container } from '../../../core/injection/index.js';
+import { RestControllerMetadataStore } from './RestControllerMetadataStore.js';
+
+function methodDecorator(method, 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,
+            config: typeof config === 'string' ? { path: config } : config,
+            functionName,
+            paramsTypes,
+        });
+    };
+}
+
+export { methodDecorator };

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

@@ -0,0 +1,103 @@
+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) {
+                    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;
+                        }, {});
+                        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 };