@wabot-dev/framework 0.0.1

package/dist/src/mindset/MindsetOperator.js

@@ -0,0 +1,101 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../injection/index.js';
+import { Mindset } from './IMindset.js';
+import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
+import { Container } from '../injection/Container.js';
+
+let MindsetOperator = class MindsetOperator {
+    mindset;
+    container;
+    metadata;
+    constructor(mindset, container, metadataStore) {
+        this.mindset = mindset;
+        this.container = container;
+        this.metadata = metadataStore.getMindsetMetadata(this.mindset.constructor);
+    }
+    identity() {
+        return this.mindset.identity();
+    }
+    skills() {
+        return this.mindset.skills();
+    }
+    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}`;
+        }
+    }
+    async allFunctionsDescriptors() {
+        return this.metadata.modules
+            .map((module) => module.functions.map((fn) => this.functionDescriptor(fn)))
+            .flat();
+    }
+    functionDescriptor(fn) {
+        const description = fn.config.description.replaceAll('#', ' ');
+        return {
+            type: 'function',
+            name: fn.name,
+            description,
+            parameters: {
+                type: 'object',
+                properties: fn.params.reduce((prev, param) => ({
+                    ...prev,
+                    [param.name]: this.toolParam(param),
+                }), {}),
+                required: fn.params.map((param) => param.name),
+            },
+        };
+    }
+    toolParam(param) {
+        const addons = {
+            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}
+          ### format: ISO 8681 - YYYY-MM-DDTHH:mm:ssZ
+          ${addons.description}
+        `;
+                return 'string';
+            }
+            throw new Error(`Unsupported type`);
+        })();
+        return {
+            type,
+            ...addons,
+        };
+    }
+};
+MindsetOperator = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Mindset,
+        Container,
+        MindsetMetadataStore])
+], MindsetOperator);
+
+export { MindsetOperator };

package/dist/src/mindset/index.d.ts

@@ -0,0 +1,3 @@
+export * from './metadata';
+export * from './IMindset';
+export * from './MindsetOperator';

package/dist/src/mindset/metadata/IMindsetMetadata.d.ts

@@ -0,0 +1,28 @@
+import { IConstructor } from '@/shared';
+import { IMindset } from '../IMindset';
+import { IParamConfig } from './params/IParamConfig';
+import { IMindsetFunctionConfig } from './functions/IMindsetFunctionConfig';
+import { IMindsetModuleConfig } from './modules/IMindsetModuleConfig';
+import { IMindsetConfig } from './mindsets/IMindsetConfig';
+export interface IMindsetFunctionParamMetadata {
+    config: IParamConfig;
+    name: string;
+    type: Function;
+}
+export interface IMindsetFunctionMetadata {
+    moduleConstructor: Function;
+    requestConstructor?: Function;
+    name: string;
+    config: IMindsetFunctionConfig;
+    params: IMindsetFunctionParamMetadata[];
+}
+export interface IMindsetModuleMetadata {
+    constructor: Function;
+    config: IMindsetModuleConfig;
+    functions: IMindsetFunctionMetadata[];
+}
+export interface IMindsetMetadata {
+    constructor: IConstructor<IMindset>;
+    config: IMindsetConfig;
+    modules: IMindsetModuleMetadata[];
+}

package/dist/src/mindset/metadata/MindsetMetadataStore.d.ts

@@ -0,0 +1,19 @@
+import { IMindsetFunctionDecoration } from './functions/IMindsetFunctionDecoration';
+import { IMindsetFunctionMetadata, IMindsetFunctionParamMetadata, IMindsetMetadata, IMindsetModuleMetadata } from './IMindsetMetadata';
+import { IMindsetModuleDecoration } from './modules/IMindsetModuleDecoration';
+import { IParamDecoration } from './params/IParamDecoration';
+import { IMindsetDecoration } from './mindsets/IMindsetDecoration';
+export declare class MindsetMetadataStore {
+    private readonly paramsDecorations;
+    private readonly functionsDecorations;
+    private readonly modulesDecorations;
+    private readonly mindsetsDecorations;
+    saveParamDecoration(paramDecoration: IParamDecoration): void;
+    saveFunctionDecoration(functionDecoration: IMindsetFunctionDecoration): void;
+    saveModuleDecoration(moduleDecoration: IMindsetModuleDecoration): void;
+    saveMindsetDecoration(mindsetDecoration: IMindsetDecoration): void;
+    getRequestParamsMetadata(requestConstructor: Function): IMindsetFunctionParamMetadata[];
+    getFunctionsMetadata(moduleConstructor: Function): IMindsetFunctionMetadata[];
+    getModuleMetadata(moduleConstructor: Function): IMindsetModuleMetadata;
+    getMindsetMetadata(ctor: Function): IMindsetMetadata;
+}

package/dist/src/mindset/metadata/MindsetMetadataStore.js

@@ -0,0 +1,134 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../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';
+
+let MindsetMetadataStore = class MindsetMetadataStore {
+    paramsDecorations = new Map();
+    functionsDecorations = new Map();
+    modulesDecorations = new Map();
+    mindsetsDecorations = new Map();
+    saveParamDecoration(paramDecoration) {
+        let paramsMap = this.paramsDecorations.get(paramDecoration.constructor);
+        if (!paramsMap) {
+            paramsMap = new Map();
+            this.paramsDecorations.set(paramDecoration.constructor, paramsMap);
+        }
+        let decorations = paramsMap.get(paramDecoration.paramName);
+        if (!decorations) {
+            decorations = [];
+            paramsMap.set(paramDecoration.paramName, decorations);
+        }
+        decorations.push(paramDecoration);
+    }
+    saveFunctionDecoration(functionDecoration) {
+        let functionsMap = this.functionsDecorations.get(functionDecoration.constructor);
+        if (!functionsMap) {
+            functionsMap = new Map();
+            this.functionsDecorations.set(functionDecoration.constructor, functionsMap);
+        }
+        let decorations = functionsMap.get(functionDecoration.functionName);
+        if (!decorations) {
+            decorations = [];
+            functionsMap.set(functionDecoration.functionName, decorations);
+        }
+        decorations.push(functionDecoration);
+    }
+    saveModuleDecoration(moduleDecoration) {
+        let modulesDecorations = this.modulesDecorations.get(moduleDecoration.constructor);
+        if (!modulesDecorations) {
+            modulesDecorations = [];
+            this.modulesDecorations.set(moduleDecoration.constructor, modulesDecorations);
+        }
+        modulesDecorations.push(moduleDecoration);
+    }
+    saveMindsetDecoration(mindsetDecoration) {
+        let mindsetsDecorations = this.mindsetsDecorations.get(mindsetDecoration.constructor);
+        if (!mindsetsDecorations) {
+            mindsetsDecorations = [];
+            this.mindsetsDecorations.set(mindsetDecoration.constructor, mindsetsDecorations);
+        }
+        mindsetsDecorations.push(mindsetDecoration);
+    }
+    getRequestParamsMetadata(requestConstructor) {
+        const paramsMap = this.paramsDecorations.get(requestConstructor);
+        if (!paramsMap) {
+            return [];
+        }
+        const paramsMetadata = [];
+        paramsMap.forEach((decorations, paramName) => {
+            const paramMainDecoration = decorations.find((decoration) => decoration.decorationConfig);
+            if (!paramMainDecoration) {
+                return;
+            }
+            paramsMetadata.push({
+                config: paramMainDecoration.decorationConfig,
+                name: paramName,
+                type: paramMainDecoration.paramType,
+            });
+            // TODO: add support for validation decorators
+        });
+        return paramsMetadata;
+    }
+    getFunctionsMetadata(moduleConstructor) {
+        const functionsMap = this.functionsDecorations.get(moduleConstructor);
+        if (!functionsMap) {
+            return [];
+        }
+        const functionsMetadata = [];
+        functionsMap.forEach((decorations) => {
+            const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_FUNCTION_DECORATION_FUNCTION);
+            if (!mainDecoration) {
+                return;
+            }
+            functionsMetadata.push({
+                moduleConstructor: mainDecoration.constructor,
+                config: mainDecoration.decorationConfig,
+                name: mainDecoration.functionName,
+                requestConstructor: mainDecoration.paramsTypes[0],
+                params: mainDecoration.paramsTypes[0]
+                    ? this.getRequestParamsMetadata(mainDecoration.paramsTypes[0])
+                    : [],
+            });
+        });
+        return functionsMetadata;
+    }
+    getModuleMetadata(moduleConstructor) {
+        const decorations = this.modulesDecorations.get(moduleConstructor);
+        if (!decorations) {
+            throw new Error(`Module ${moduleConstructor.name} not found`);
+        }
+        const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_MODULE_DECORATION_MODULE);
+        if (!mainDecoration) {
+            throw new Error(`Module ${moduleConstructor.name} not found`);
+        }
+        return {
+            constructor: moduleConstructor,
+            config: mainDecoration.decorationConfig,
+            functions: this.getFunctionsMetadata(moduleConstructor),
+        };
+    }
+    getMindsetMetadata(ctor) {
+        const decorations = this.mindsetsDecorations.get(ctor);
+        if (!decorations) {
+            throw new Error(`Mindset ${ctor.name} not found`);
+        }
+        const mainDecoration = decorations.find((decoration) => decoration.decorationName === MINDSET_DECORATION_MINDSET);
+        if (!mainDecoration) {
+            throw new Error(`Mindset ${ctor.name} not found`);
+        }
+        return {
+            constructor: ctor,
+            config: mainDecoration.decorationConfig,
+            modules: mainDecoration.decorationConfig.modules
+                ? mainDecoration.decorationConfig.modules.map((module) => this.getModuleMetadata(module))
+                : [],
+        };
+    }
+};
+MindsetMetadataStore = __decorate([
+    singleton()
+], MindsetMetadataStore);
+
+export { MindsetMetadataStore };

package/dist/src/mindset/metadata/functions/@mindsetFunction.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { IMindsetFunctionConfig } from './IMindsetFunctionConfig';
+export declare function mindsetFunction(config: IMindsetFunctionConfig): (target: object, propertyKey: string | symbol) => void;

package/dist/src/mindset/metadata/functions/@mindsetFunction.js

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import { container } from '../../../injection/index.js';
+import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
+import { MINDSET_FUNCTION_DECORATION_FUNCTION } from './decoratorNames.js';
+
+function mindsetFunction(config) {
+    return function (target, propertyKey) {
+        const functionName = propertyKey.toString();
+        const paramsTypes = Reflect.getMetadata('design:paramtypes', target, functionName);
+        const store = container.resolve(MindsetMetadataStore);
+        store.saveFunctionDecoration({
+            decorationName: MINDSET_FUNCTION_DECORATION_FUNCTION,
+            paramsTypes: paramsTypes,
+            functionName,
+            constructor: target.constructor,
+            decorationConfig: config,
+        });
+    };
+}
+
+export { mindsetFunction };

package/dist/src/mindset/metadata/functions/IMindsetFunctionConfig.d.ts

@@ -0,0 +1,3 @@
+export interface IMindsetFunctionConfig {
+    description: string;
+}

package/dist/src/mindset/metadata/functions/IMindsetFunctionDecoration.d.ts

@@ -0,0 +1,7 @@
+export interface IMindsetFunctionDecoration {
+    decorationName: string;
+    functionName: string;
+    constructor: Function;
+    paramsTypes: Function[];
+    decorationConfig: any;
+}

package/dist/src/mindset/metadata/functions/decoratorNames.d.ts

@@ -0,0 +1 @@
+export declare const MINDSET_FUNCTION_DECORATION_FUNCTION = "mindsetFunction";

package/dist/src/mindset/metadata/functions/decoratorNames.js

@@ -0,0 +1,3 @@
+const MINDSET_FUNCTION_DECORATION_FUNCTION = 'mindsetFunction';
+
+export { MINDSET_FUNCTION_DECORATION_FUNCTION };

package/dist/src/mindset/metadata/functions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './@mindsetFunction';
+export * from './decoratorNames';
+export * from './IMindsetFunctionConfig';
+export * from './IMindsetFunctionDecoration';

package/dist/src/mindset/metadata/index.d.ts

@@ -0,0 +1,6 @@
+export * from './functions';
+export * from './mindsets';
+export * from './modules';
+export * from './params';
+export * from './IMindsetMetadata';
+export * from './MindsetMetadataStore';

package/dist/src/mindset/metadata/mindsets/@mindset.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+import { IConstructor } from '@/shared';
+import { IMindset } from '../../IMindset';
+import { IMindsetConfig } from './IMindsetConfig';
+export declare function mindset(config: IMindsetConfig): (target: IConstructor<IMindset>) => void;

package/dist/src/mindset/metadata/mindsets/@mindset.js

@@ -0,0 +1,18 @@
+import 'reflect-metadata';
+import { container, injectable } from '../../../injection/index.js';
+import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
+import { MINDSET_DECORATION_MINDSET } from './decoratorNames.js';
+
+function mindset(config) {
+    return function (target) {
+        const store = container.resolve(MindsetMetadataStore);
+        store.saveMindsetDecoration({
+            decorationName: MINDSET_DECORATION_MINDSET,
+            constructor: target,
+            decorationConfig: config,
+        });
+        injectable()(target);
+    };
+}
+
+export { mindset };

package/dist/src/mindset/metadata/mindsets/IMindsetConfig.d.ts

@@ -0,0 +1,4 @@
+import { IConstructor } from "@/shared";
+export interface IMindsetConfig {
+    modules?: IConstructor<any>[];
+}

package/dist/src/mindset/metadata/mindsets/IMindsetDecoration.d.ts

@@ -0,0 +1,6 @@
+import { IMindsetConfig } from "./IMindsetConfig";
+export interface IMindsetDecoration {
+    decorationName: string;
+    constructor: Function;
+    decorationConfig: IMindsetConfig;
+}

package/dist/src/mindset/metadata/mindsets/decoratorNames.d.ts

@@ -0,0 +1 @@
+export declare const MINDSET_DECORATION_MINDSET = "mindset";

package/dist/src/mindset/metadata/mindsets/decoratorNames.js

@@ -0,0 +1,3 @@
+const MINDSET_DECORATION_MINDSET = 'mindset';
+
+export { MINDSET_DECORATION_MINDSET };

package/dist/src/mindset/metadata/mindsets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './@mindset';
+export * from './decoratorNames';
+export * from './IMindsetDecoration';

package/dist/src/mindset/metadata/modules/@mindsetModule.d.ts

@@ -0,0 +1,4 @@
+import 'reflect-metadata';
+import { IConstructor } from '@/shared';
+import { IMindsetModuleConfig } from './IMindsetModuleConfig';
+export declare function mindsetModule<A>(config: IMindsetModuleConfig): (target: IConstructor<A>) => void;

package/dist/src/mindset/metadata/modules/@mindsetModule.js

@@ -0,0 +1,18 @@
+import 'reflect-metadata';
+import { container, injectable } from '../../../injection/index.js';
+import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
+import { MINDSET_MODULE_DECORATION_MODULE } from './decoratorNames.js';
+
+function mindsetModule(config) {
+    return function (target) {
+        const store = container.resolve(MindsetMetadataStore);
+        store.saveModuleDecoration({
+            decorationName: MINDSET_MODULE_DECORATION_MODULE,
+            constructor: target,
+            decorationConfig: config,
+        });
+        injectable()(target);
+    };
+}
+
+export { mindsetModule };

package/dist/src/mindset/metadata/modules/IMindsetModuleConfig.d.ts

@@ -0,0 +1,3 @@
+export interface IMindsetModuleConfig {
+    description: string;
+}

package/dist/src/mindset/metadata/modules/IMindsetModuleDecoration.d.ts

@@ -0,0 +1,5 @@
+export interface IMindsetModuleDecoration {
+    decorationName: string;
+    constructor: Function;
+    decorationConfig: any;
+}

package/dist/src/mindset/metadata/modules/decoratorNames.d.ts

@@ -0,0 +1 @@
+export declare const MINDSET_MODULE_DECORATION_MODULE = "mindsetModule";

package/dist/src/mindset/metadata/modules/decoratorNames.js

@@ -0,0 +1,3 @@
+const MINDSET_MODULE_DECORATION_MODULE = 'mindsetModule';
+
+export { MINDSET_MODULE_DECORATION_MODULE };

package/dist/src/mindset/metadata/modules/index.d.ts

@@ -0,0 +1,4 @@
+export * from './@mindsetModule';
+export * from './decoratorNames';
+export * from './IMindsetModuleConfig';
+export * from './IMindsetModuleDecoration';

package/dist/src/mindset/metadata/params/@isOptional.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function isOptional(): PropertyDecorator;

package/dist/src/mindset/metadata/params/@isOptional.js

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { PARAM_DECORATION_IS_OPTIONAL } from './decoratorNames.js';
+
+function isOptional() {
+    return (target, propertyKey) => {
+        const paramName = propertyKey.toString();
+        const paramType = Reflect.getMetadata('design:type', target, paramName);
+        const store = container.resolve(MindsetMetadataStore);
+        store.saveParamDecoration({
+            decorationName: PARAM_DECORATION_IS_OPTIONAL,
+            paramType: paramType,
+            paramName: paramName,
+            constructor: target.constructor,
+            decorationConfig: {}
+        });
+    };
+}
+
+export { isOptional };

package/dist/src/mindset/metadata/params/@param.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { IParamConfig } from './IParamConfig';
+export declare function param(config: IParamConfig): PropertyDecorator;

package/dist/src/mindset/metadata/params/@param.js

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+import { MindsetMetadataStore } from '../MindsetMetadataStore.js';
+import { container } from '../../../injection/index.js';
+import { PARAM_DECORATION_PARAM } from './decoratorNames.js';
+
+function param(config) {
+    return (target, propertyKey) => {
+        const paramName = propertyKey.toString();
+        const paramType = Reflect.getMetadata('design:type', target, paramName);
+        const store = container.resolve(MindsetMetadataStore);
+        store.saveParamDecoration({
+            decorationName: PARAM_DECORATION_PARAM,
+            paramType: paramType,
+            paramName: paramName,
+            constructor: target.constructor,
+            decorationConfig: config,
+        });
+    };
+}
+
+export { param };

package/dist/src/mindset/metadata/params/IParamConfig.d.ts

@@ -0,0 +1,4 @@
+export interface IParamConfig {
+    name?: string;
+    description: string;
+}

package/dist/src/mindset/metadata/params/IParamDecoration.d.ts

@@ -0,0 +1,7 @@
+export interface IParamDecoration {
+    decorationName: string;
+    paramType: any;
+    paramName: string;
+    constructor: Function;
+    decorationConfig: any;
+}

package/dist/src/mindset/metadata/params/decoratorNames.d.ts

@@ -0,0 +1,2 @@
+export declare const PARAM_DECORATION_IS_OPTIONAL = "isOptional";
+export declare const PARAM_DECORATION_PARAM = "param";

package/dist/src/mindset/metadata/params/decoratorNames.js

@@ -0,0 +1,4 @@
+const PARAM_DECORATION_IS_OPTIONAL = 'isOptional';
+const PARAM_DECORATION_PARAM = 'param';
+
+export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM };

package/dist/src/mindset/metadata/params/index.d.ts

@@ -0,0 +1,3 @@
+export * from './@isOptional';
+export * from './@param';
+export * from './IParamDecoration';