@wabot-dev/framework 0.1.0-beta.9 → 0.2.0-beta.1

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

@@ -0,0 +1,36 @@
+function validateModel(value, info) {
+    if (typeof value !== 'object' || value === null) {
+        return { error: { description: 'Invalid object', properties: {} } };
+    }
+    let propertiesErrors = {};
+    let resultValue = new info.modelConstructor();
+    for (const propertyName in info.properties) {
+        const propertyInfo = info.properties[propertyName];
+        const propertyValidators = propertyInfo.validators ?? [];
+        resultValue[propertyName] = propertyInfo.isOptional
+            ? (value[propertyName] ?? resultValue[propertyName])
+            : value[propertyName];
+        if (resultValue[propertyName] == null && propertyInfo.isOptional) {
+            resultValue[propertyName] = undefined;
+            continue;
+        }
+        for (let propertyValidatorInfo of propertyValidators) {
+            const propertyValidatorResult = propertyValidatorInfo.validator(resultValue[propertyName], propertyValidatorInfo.validatorOptions);
+            resultValue[propertyName] = propertyValidatorResult.value;
+            if (propertyValidatorResult.error) {
+                let propertyErrors = propertiesErrors[propertyName];
+                if (!propertyErrors) {
+                    propertyErrors = [];
+                    propertiesErrors[propertyName] = propertyErrors;
+                }
+                propertyErrors.push(propertyValidatorResult.error.description);
+            }
+        }
+    }
+    if (Object.keys(propertiesErrors).length > 0) {
+        return { error: { description: 'Invalid properties', properties: propertiesErrors } };
+    }
+    return { value: resultValue };
+}
+
+export { validateModel };

package/dist/src/{validation/metadata/@isNumber.js → core/validation/metadata/@isArray.js}

@@ -1,17 +1,18 @@
 import { container } from '../../injection/index.js';
-import { validateIsNumber } from '../validators/validateIsNumber.js';
+import { validateArray } from '../core/validateArray.js';
 import { ValidationMetadataStore } from './ValidationMetadataStore.js';
 
-function isNumber() {
+function isArray(options) {
     return function (target, propertyKey) {
         const propertyName = propertyKey.toString();
         const store = container.resolve(ValidationMetadataStore);
         store.saveValidatorMetadata({
             modelConstructor: target.constructor,
             propertyName,
-            validator: validateIsNumber,
+            validator: validateArray,
+            validatorOptions: options,
         });
     };
 }
 
-export { isNumber };
+export { isArray };

package/dist/src/{validation/metadata/@isDate.js → core/validation/metadata/@isModel.js}

@@ -1,17 +1,18 @@
 import { container } from '../../injection/index.js';
-import { validateIsDate } from '../validators/validateIsDate.js';
+import { validateModel } from '../core/validateModel.js';
 import { ValidationMetadataStore } from './ValidationMetadataStore.js';
 
-function isDate() {
+function isModel(model) {
     return function (target, propertyKey) {
         const propertyName = propertyKey.toString();
         const store = container.resolve(ValidationMetadataStore);
         store.saveValidatorMetadata({
             modelConstructor: target.constructor,
             propertyName,
-            validator: validateIsDate,
+            validator: validateModel,
+            validatorOptions: store.getModelValidatorsInfo(model),
         });
     };
 }
 
-export { isDate };
+export { isModel };

package/dist/src/{validation → core/validation}/metadata/@isOptional.js

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

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

@@ -0,0 +1,98 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { _IS_OPTIONAL_DUMMY_VALIDATOR_ } from '../core/validateIsOptional.js';
+import { validateArray } from '../core/validateArray.js';
+
+function getClassHierarchy(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
+let ValidationMetadataStore = class ValidationMetadataStore {
+    validators = new Map();
+    saveValidatorMetadata(validatorMetadata) {
+        let modelValidators = this.validators.get(validatorMetadata.modelConstructor);
+        if (!modelValidators) {
+            this.validators.set(validatorMetadata.modelConstructor, (modelValidators = new Map()));
+        }
+        let propertyValidators = modelValidators.get(validatorMetadata.propertyName);
+        if (!propertyValidators) {
+            propertyValidators = [];
+            modelValidators.set(validatorMetadata.propertyName, propertyValidators);
+        }
+        propertyValidators.unshift(validatorMetadata);
+        const arrayValidatorMetadata = propertyValidators.find((x) => x.validator === validateArray);
+        if (!arrayValidatorMetadata) {
+            return;
+        }
+        if (!arrayValidatorMetadata.validatorOptions) {
+            arrayValidatorMetadata.validatorOptions = {};
+        }
+        const arrayValidatorOptions = arrayValidatorMetadata.validatorOptions;
+        if (!arrayValidatorOptions.itemsValidator) {
+            arrayValidatorOptions.itemsValidator = [];
+        }
+        const removeValidatorsMetadata = [];
+        for (const validatorMetadata of propertyValidators) {
+            if (validatorMetadata.validator === validateArray ||
+                validatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
+                continue;
+            }
+            arrayValidatorOptions.itemsValidator.push({
+                options: validatorMetadata.validatorOptions,
+                validator: validatorMetadata.validator,
+            });
+            removeValidatorsMetadata.push(validatorMetadata);
+        }
+        for (const toRemove of removeValidatorsMetadata) {
+            const indexToRemove = propertyValidators.indexOf(toRemove);
+            propertyValidators.splice(indexToRemove, 1);
+        }
+    }
+    getModelValidatorsInfo(modelConstructor) {
+        const constructors = getClassHierarchy(modelConstructor);
+        constructors.unshift(modelConstructor);
+        const modelValidators = {
+            modelConstructor: modelConstructor,
+            properties: Object.assign({}, ...constructors.map((x) => this.getConstructorPropertiesValidatorsInfo(x))),
+        };
+        return modelValidators;
+    }
+    getConstructorPropertiesValidatorsInfo(modelConstructor) {
+        const properties = {};
+        [...(this.validators.get(modelConstructor)?.values() ?? [])].forEach((propertyValidatorsMetadata) => {
+            const propertyName = propertyValidatorsMetadata.at(0)?.propertyName;
+            if (!propertyName) {
+                return;
+            }
+            let propertyInfo = properties[propertyName];
+            if (!propertyInfo) {
+                propertyInfo = {};
+                properties[propertyName] = propertyInfo;
+            }
+            let validators = propertyInfo.validators;
+            if (!validators) {
+                validators = [];
+                propertyInfo.validators = validators;
+            }
+            propertyValidatorsMetadata.forEach((propertyValidatorMetadata) => {
+                if (propertyValidatorMetadata.validator === _IS_OPTIONAL_DUMMY_VALIDATOR_) {
+                    propertyInfo.isOptional = true;
+                }
+                else {
+                    validators.push(propertyValidatorMetadata);
+                }
+            });
+        });
+        return properties;
+    }
+};
+ValidationMetadataStore = __decorate([
+    singleton()
+], ValidationMetadataStore);
+
+export { ValidationMetadataStore };

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

@@ -0,0 +1,9 @@
+import { container } from '../injection/index.js';
+import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
+
+function modelInfo(modelConstructor) {
+    const metadataStore = container.resolve(ValidationMetadataStore);
+    return metadataStore.getModelValidatorsInfo(modelConstructor);
+}
+
+export { modelInfo };

package/dist/src/{validation/validateModel2.js → core/validation/validate.js}

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

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateIsBoolean } from '../validators/validateIsBoolean.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateIsBoolean } from './validateIsBoolean.js';
 
 function isBoolean() {
     return function (target, propertyKey) {

package/dist/src/core/validation/validators/is-date/@isDate.js

@@ -0,0 +1,17 @@
+import { container } from '../../../injection/index.js';
+import { validateIsDate } from './validateIsDate.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+
+function isDate() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsDate,
+        });
+    };
+}
+
+export { isDate };

package/dist/src/core/validation/validators/is-in/@isIn.js

@@ -0,0 +1,18 @@
+import { container } from '../../../injection/index.js';
+import { validateIsIn } from './validateIsIn.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+
+function isIn(values) {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsIn,
+            validatorOptions: { values },
+        });
+    };
+}
+
+export { isIn };

package/dist/src/core/validation/validators/is-in/validateIsIn.js

@@ -0,0 +1,12 @@
+function validateIsIn(value, options) {
+    if (!options.values.includes(value)) {
+        return {
+            error: { description: `value not included in array` },
+        };
+    }
+    return {
+        value,
+    };
+}
+
+export { validateIsIn };

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateIsNotEmpty } from '../validators/validateIsNotEmpty.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateIsNotEmpty } from './validateIsNotEmpty.js';
 
 function isNotEmpty() {
     return function (target, propertyKey) {

package/dist/src/core/validation/validators/is-number/@isNumber.js

@@ -0,0 +1,17 @@
+import { container } from '../../../injection/index.js';
+import { validateIsNumber } from './validateIsNumber.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+
+function isNumber() {
+    return function (target, propertyKey) {
+        const propertyName = propertyKey.toString();
+        const store = container.resolve(ValidationMetadataStore);
+        store.saveValidatorMetadata({
+            modelConstructor: target.constructor,
+            propertyName,
+            validator: validateIsNumber,
+        });
+    };
+}
+
+export { isNumber };

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateIsPresent } from '../validators/validateIsPresent.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateIsPresent } from './validateIsPresent.js';
 
 function isPresent() {
     return function (target, propertyKey) {

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateIsString } from '../validators/validateIsString.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateIsString } from './validateIsString.js';
 
 function isString() {
     return function (target, propertyKey) {

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateMax } from '../validators/validateMax.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateMax } from './validateMax.js';
 
 function max(limit) {
     return function (target, propertyKey) {

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

@@ -1,6 +1,6 @@
-import { container } from '../../injection/index.js';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateMin } from '../validators/validateMin.js';
+import { container } from '../../../injection/index.js';
+import { ValidationMetadataStore } from '../../metadata/ValidationMetadataStore.js';
+import { validateMin } from './validateMin.js';
 
 function min(limit) {
     return function (target, propertyKey) {

package/dist/src/feature/async/@command.js

@@ -0,0 +1,11 @@
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { container } from '../../core/injection/index.js';
+
+function command(config) {
+    return function (target) {
+        const handlerContainer = container.resolve(CommandMetadataStore);
+        handlerContainer.registerCommand(target, config?.name ?? target.name);
+    };
+}
+
+export { command };

package/dist/src/feature/async/@commandHandler.js

@@ -0,0 +1,12 @@
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { container, injectable } from '../../core/injection/index.js';
+
+function commandHandler(config) {
+    return function (target) {
+        const handlerContainer = container.resolve(CommandMetadataStore);
+        handlerContainer.registerHandler(config.command, target);
+        injectable()(target);
+    };
+}
+
+export { commandHandler };

package/dist/src/feature/async/Async.js

@@ -0,0 +1,38 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { Job } from './Job.js';
+import { JobRepository } from './JobRepository.js';
+import { JobsEventsHub } from './JobsEventsHub.js';
+
+let Async = class Async {
+    jobRepository;
+    handlerContainer;
+    jobsEventsHub;
+    constructor(jobRepository, handlerContainer, jobsEventsHub) {
+        this.jobRepository = jobRepository;
+        this.handlerContainer = handlerContainer;
+        this.jobsEventsHub = jobsEventsHub;
+    }
+    async run(command) {
+        const commandName = this.handlerContainer.getCommandName(command.constructor);
+        if (!commandName) {
+            throw new Error(`${command.constructor.name} is not registered as command`);
+        }
+        const job = new Job({
+            commandName,
+            commandData: command['data'],
+        });
+        await this.jobRepository.create(job);
+        this.jobsEventsHub.notifyJobCreated(job);
+        return job;
+    }
+};
+Async = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [JobRepository,
+        CommandMetadataStore,
+        JobsEventsHub])
+], Async);
+
+export { Async };

package/dist/src/feature/async/Command.js

@@ -0,0 +1,9 @@
+import { Storable } from '../../core/storable/Storable.js';
+
+class Command extends Storable {
+    getData() {
+        return this.data;
+    }
+}
+
+export { Command };

package/dist/src/feature/async/CommandMetadataStore.js

@@ -0,0 +1,38 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let CommandMetadataStore = class CommandMetadataStore {
+    handlersMap = new Map();
+    handlersInverseMap = new Map();
+    commandsMap = new Map();
+    commandsInverseMap = new Map();
+    registerCommand(command, commandName) {
+        this.commandsMap.set(commandName, command);
+        this.commandsInverseMap.set(command, commandName);
+    }
+    registerHandler(command, handlerConstructor) {
+        let commandName = this.commandsInverseMap.get(command);
+        if (!commandName) {
+            throw new Error(`Should use @command decorator on command class ${command.name}`);
+        }
+        this.handlersMap.set(commandName, handlerConstructor);
+        this.handlersInverseMap.set(handlerConstructor, commandName);
+    }
+    getHandlerForCommandName(commandName) {
+        return this.handlersMap.get(commandName) ?? null;
+    }
+    getCommandNameForHandler(handlerConstructor) {
+        return this.handlersInverseMap.get(handlerConstructor) ?? null;
+    }
+    getCommandName(command) {
+        return this.commandsInverseMap.get(command) ?? null;
+    }
+    getCommandForCommandName(commandName) {
+        return this.commandsMap.get(commandName) ?? null;
+    }
+};
+CommandMetadataStore = __decorate([
+    singleton()
+], CommandMetadataStore);
+
+export { CommandMetadataStore };

package/dist/src/feature/async/Job.js

@@ -0,0 +1,27 @@
+import { Entity } from '../../core/entity/Entity.js';
+import { CustomError } from '../../core/error/CustomError.js';
+
+class Job extends Entity {
+    get commandName() {
+        return this.data.commandName;
+    }
+    hasFinished() {
+        return this.data.successAt != null || this.data.failedAt != null;
+    }
+    setAsStarted() {
+        this.data.startedAt = new Date().getTime();
+    }
+    setAsSuccess() {
+        this.data.successAt = new Date().getTime();
+    }
+    setAsFailed(error) {
+        this.data.failedAt = new Date().getTime();
+        this.data.error = {
+            message: error.message,
+            stack: error.stack,
+            info: error instanceof CustomError ? error.info : undefined,
+        };
+    }
+}
+
+export { Job };

package/dist/src/feature/async/JobRepository.js

@@ -0,0 +1,31 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let JobRepository = class JobRepository {
+    find(id) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+    findByIds(ids) {
+        throw new Error('Method not implemented.');
+    }
+    findAll(id) {
+        throw new Error('Method not implemented.');
+    }
+    create(item) {
+        throw new Error('Method not implemented.');
+    }
+    update(item) {
+        throw new Error('Method not implemented.');
+    }
+    delete(item) {
+        throw new Error('Method not implemented.');
+    }
+};
+JobRepository = __decorate([
+    singleton()
+], JobRepository);
+
+export { JobRepository };

package/dist/src/feature/async/JobRunner.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from 'tslib';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { JobRepository } from './JobRepository.js';
+import { singleton, container } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+
+let JobRunner = class JobRunner {
+    jobRepository;
+    handlerContainer;
+    logger = new Logger('wabot:job-runner');
+    constructor(jobRepository, handlerContainer) {
+        this.jobRepository = jobRepository;
+        this.handlerContainer = handlerContainer;
+    }
+    async run(job) {
+        try {
+            const { commandName, commandData } = job['data'];
+            const handlerConstructor = this.handlerContainer.getHandlerForCommandName(commandName);
+            if (!handlerConstructor) {
+                throw new Error(`Not found handler for command '${commandName}'`);
+            }
+            const handler = container.resolve(handlerConstructor);
+            const commandConstructor = this.handlerContainer.getCommandForCommandName(commandName);
+            if (!commandConstructor) {
+                throw new Error(`Not found class for command name '${commandName}'`);
+            }
+            job.setAsStarted();
+            await this.jobRepository.update(job);
+            const command = new commandConstructor(commandData);
+            await handler.handle(command);
+            job.setAsSuccess();
+        }
+        catch (e) {
+            this.logger.error(e);
+            job.setAsFailed(e instanceof Error ? e : new Error('Invalid Job error'));
+        }
+        finally {
+            await this.jobRepository.update(job);
+        }
+    }
+};
+JobRunner = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [JobRepository,
+        CommandMetadataStore])
+], JobRunner);
+
+export { JobRunner };

package/dist/src/feature/async/JobsEventsHub.js

@@ -0,0 +1,36 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+
+let JobsEventsHub = class JobsEventsHub {
+    logger = new Logger('wabot:jobs-events-hub');
+    jobsEventsListener = null;
+    notifyJobCreated(job) {
+        const timer = setTimeout(async () => {
+            if (!this.jobsEventsListener) {
+                return;
+            }
+            try {
+                await this.jobsEventsListener({
+                    jobId: job.id,
+                    commandName: job.commandName,
+                    type: 'created',
+                });
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        }, 1000);
+    }
+    listenJobsEvents(listener) {
+        this.jobsEventsListener = listener;
+    }
+};
+JobsEventsHub = __decorate([
+    singleton()
+], JobsEventsHub);
+
+export { JobsEventsHub };

package/dist/src/feature/async/runCommandHandlers.js

@@ -0,0 +1,29 @@
+import { JobsEventsHub } from './JobsEventsHub.js';
+import { JobRunner } from './JobRunner.js';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { JobRepository } from './JobRepository.js';
+import { container } from '../../core/injection/index.js';
+
+function runAsyncCommandHandlers(handlers) {
+    const eventsHub = container.resolve(JobsEventsHub);
+    const jobRunner = container.resolve(JobRunner);
+    const jobRepository = container.resolve(JobRepository);
+    const commandsHandlersContainer = container.resolve(CommandMetadataStore);
+    const handledCommands = handlers
+        .map((x) => commandsHandlersContainer.getCommandNameForHandler(x))
+        .filter((x) => x)
+        .map((x) => x);
+    eventsHub.listenJobsEvents(async (event) => {
+        try {
+            const job = await jobRepository.findOrThrow(event.jobId);
+            if (handledCommands.includes(job.commandName)) {
+                jobRunner.run(job);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+}
+
+export { runAsyncCommandHandlers };

package/dist/src/{core/chat → feature/chat-bot}/Chat.js

@@ -1,6 +1,6 @@
-import { Persistent } from '../Persistent.js';
+import { Entity } from '../../core/entity/Entity.js';
 
-class Chat extends Persistent {
+class Chat extends Entity {
     constructor(data) {
         super(data);
     }