@wabot-dev/framework 0.1.0-beta.23 → 0.1.0-beta.25

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

@@ -0,0 +1,11 @@
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { container } from '../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/async/@commandHandler.js

@@ -0,0 +1,12 @@
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { container, injectable } from '../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/async/Async.js

@@ -0,0 +1,38 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../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/async/Command.js

@@ -0,0 +1,11 @@
+import '../core/chat/repository/IChatRepository.js';
+import { Storable } from '../core/Storable.js';
+import '../core/user/IUserRepository.js';
+
+class Command extends Storable {
+    getData() {
+        return this.data;
+    }
+}
+
+export { Command };

package/dist/src/async/CommandMetadataStore.js

@@ -0,0 +1,38 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../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/async/Job.js

@@ -0,0 +1,26 @@
+import '../core/chat/repository/IChatRepository.js';
+import { Entity } from '../core/Entity.js';
+import '../core/user/IUserRepository.js';
+import { CustomError } from '../error/CustomError.js';
+
+class Job extends Entity {
+    get commandName() {
+        return this.data.commandName;
+    }
+    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/async/JobRepository.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { Pool } from 'pg';
+import { Job } from './Job.js';
+import { singleton } from '../injection/index.js';
+import { PgCrudRepository } from '../repository/pg/PgCrudRepository.js';
+
+let JobRepository = class JobRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'job',
+            constructor: Job,
+        });
+    }
+};
+JobRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], JobRepository);
+
+export { JobRepository };

package/dist/src/async/JobRunner.js

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { JobRepository } from './JobRepository.js';
+import { singleton, container } from '../injection/index.js';
+
+let JobRunner = class JobRunner {
+    jobRepository;
+    handlerContainer;
+    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) {
+            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/async/JobsEventsHub.js

@@ -0,0 +1,24 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../injection/index.js';
+
+let JobsEventsHub = class JobsEventsHub {
+    jobsEventsListener = null;
+    notifyJobCreated(job) {
+        if (!this.jobsEventsListener) {
+            return;
+        }
+        this.jobsEventsListener({
+            jobId: job.id,
+            commandName: job.commandName,
+            type: 'created',
+        });
+    }
+    listenJobsEvents(listener) {
+        this.jobsEventsListener = listener;
+    }
+};
+JobsEventsHub = __decorate([
+    singleton()
+], JobsEventsHub);
+
+export { JobsEventsHub };

package/dist/src/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 '../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/auth/Auth.js

@@ -0,0 +1,24 @@
+import { __decorate } from 'tslib';
+import { CustomError } from '../error/CustomError.js';
+import { scoped, Lifecycle } from '../injection/index.js';
+
+let Auth = class Auth {
+    authInfo = null;
+    require() {
+        if (!this.authInfo) {
+            throw new CustomError({ message: 'Unauthorized', httpCode: 401 });
+        }
+        return this.authInfo;
+    }
+    assign(authInfo) {
+        if (this.authInfo) {
+            throw new CustomError({ message: 'Authorization info already assigned', httpCode: 401 });
+        }
+        this.authInfo = authInfo;
+    }
+};
+Auth = __decorate([
+    scoped(Lifecycle.ContainerScoped)
+], Auth);
+
+export { Auth };

package/dist/src/index.d.ts

@@ -1,14 +1,15 @@
 import InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
 import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
 import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
+import { Pool } from 'pg';
 import { Server } from 'http';
 import { Express, Request, Response } from 'express';
 import { Server as Server$1 } from 'socket.io';
-import { Pool } from 'pg';
 import { Socket } from 'socket.io-client';
 import * as tsyringe from 'tsyringe';
 import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
+import { Algorithm } from 'jsonwebtoken';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -411,6 +412,154 @@ declare class ClaudeChatBotAdapter extends ChatBotAdapter {
     private mapChatItems;
 }
 
+interface ICommandConfig {
+    name?: string;
+}
+declare function command(config?: ICommandConfig): (target: IConstructor<any>) => void;
+
+declare class Command<T extends IStorableData> extends Storable<T> {
+    getData(): T;
+}
+
+interface ICommandHandler<C extends Command<any>> {
+    handle(command: C): void | Promise<void>;
+}
+
+interface ICommandHandlerConfig<C extends Command<any>> {
+    command: IConstructor<C>;
+}
+declare function commandHandler<C extends Command<any>>(config: ICommandHandlerConfig<C>): (target: IConstructor<ICommandHandler<C>>) => void;
+
+declare class CommandMetadataStore {
+    private handlersMap;
+    private handlersInverseMap;
+    private commandsMap;
+    private commandsInverseMap;
+    registerCommand(command: IConstructor<Command<any>>, commandName: string): void;
+    registerHandler(command: IConstructor<Command<any>>, handlerConstructor: IConstructor<ICommandHandler<any>>): void;
+    getHandlerForCommandName(commandName: string): IConstructor<ICommandHandler<any>> | null;
+    getCommandNameForHandler(handlerConstructor: IConstructor<ICommandHandler<any>>): string | null;
+    getCommandName(command: IConstructor<Command<any>>): string | null;
+    getCommandForCommandName(commandName: string): IConstructor<Command<any>> | null;
+}
+
+interface IJobData extends IEntityData {
+    commandName: string;
+    commandData: any;
+    startedAt?: number;
+    successAt?: number;
+    failedAt?: number;
+    error?: {
+        message: string;
+        stack?: string;
+        info?: any;
+    };
+}
+declare class Job extends Entity<IJobData> {
+    get commandName(): string;
+    setAsStarted(): void;
+    setAsSuccess(): void;
+    setAsFailed(error: Error): void;
+}
+
+interface ICrudRepository<T> {
+    find(id: string): Promise<T | null>;
+    findOrThrow(id: string): Promise<T>;
+    findAll(id: string): Promise<T[]>;
+    create(item: T): Promise<void>;
+    update(item: T): Promise<void>;
+    discard(item: T): Promise<void>;
+}
+
+type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
+    schema?: string;
+    table: string;
+    constructor: IConstructor<P>;
+    add?: {
+        columns: {
+            [column: string]: {
+                type: string;
+                value: (item: P) => boolean | number | string | null | Date;
+            };
+        };
+    };
+};
+
+declare class PgRepositoryBase<P extends Entity<IEntityData>> {
+    protected pool: Pool;
+    protected config: IPgRepositoryConfig<any>;
+    private tableIsCreated;
+    protected schema: string;
+    protected table: string;
+    protected columnsList: string[];
+    protected columnsAndTypes: string;
+    protected columns: string;
+    protected vars: string;
+    protected updates: string;
+    addColumns: {
+        [columns: string]: {
+            type: string;
+            value: (item: P) => number | boolean | string | null | Date;
+        };
+    };
+    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
+    protected values(item: P): (string | number | boolean | Date | null)[];
+    protected exec(sql: string, values: any[]): Promise<void>;
+    protected query(sql: string, values: any[]): Promise<any[]>;
+    protected connect(): Promise<Pool>;
+    protected ensureTable(): Promise<void>;
+    protected ensureColumns(): Promise<void>;
+}
+
+declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgRepositoryBase<P> implements ICrudRepository<P> {
+    protected readonly config: IPgRepositoryConfig<P>;
+    constructor(pool: Pool, config: IPgRepositoryConfig<P>);
+    find(id: string): Promise<P | null>;
+    findOrThrow(id: string): Promise<P>;
+    findAll(): Promise<P[]>;
+    create(item: P): Promise<void>;
+    update(item: P): Promise<void>;
+    discard(item: P): Promise<void>;
+}
+
+declare class JobRepository extends PgCrudRepository<Job> {
+    constructor(pool: Pool);
+}
+
+interface IJobEvent extends IStorableData {
+    jobId: string;
+    type: 'created';
+}
+type IJobEventListener = (event: IJobEvent) => void | Promise<void>;
+declare class JobsEventsHub {
+    private jobsEventsListener;
+    notifyJobCreated(job: Job): void;
+    listenJobsEvents(listener: IJobEventListener): void;
+}
+
+declare class Async {
+    private jobRepository;
+    private handlerContainer;
+    private jobsEventsHub;
+    constructor(jobRepository: JobRepository, handlerContainer: CommandMetadataStore, jobsEventsHub: JobsEventsHub);
+    run<T extends IStorableData>(command: Command<T>): Promise<Job>;
+}
+
+declare class JobRunner {
+    private jobRepository;
+    private handlerContainer;
+    constructor(jobRepository: JobRepository, handlerContainer: CommandMetadataStore);
+    run(job: Job): Promise<void>;
+}
+
+declare function runAsyncCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
+
+declare class Auth<D extends IStorableData> {
+    private authInfo;
+    require(): D;
+    assign(authInfo: D): void;
+}
+
 declare function cmd(): (target: object, propertyKey: string | symbol) => void;
 
 declare class ChatResolver {
@@ -715,66 +864,6 @@ interface IAudioMessage extends IBaseMessage {
     };
 }
 
-interface ICrudRepository<T> {
-    find(id: string): Promise<T | null>;
-    findOrThrow(id: string): Promise<T>;
-    findAll(id: string): Promise<T[]>;
-    create(item: T): Promise<void>;
-    update(item: T): Promise<void>;
-    discard(item: T): Promise<void>;
-}
-
-type IPgRepositoryConfig<P extends Entity<IEntityData>> = {
-    schema?: string;
-    table: string;
-    constructor: IConstructor<P>;
-    add?: {
-        columns: {
-            [column: string]: {
-                type: string;
-                value: (item: P) => boolean | number | string | null | Date;
-            };
-        };
-    };
-};
-
-declare class PgRepositoryBase<P extends Entity<IEntityData>> {
-    protected pool: Pool;
-    protected config: IPgRepositoryConfig<any>;
-    private tableIsCreated;
-    protected schema: string;
-    protected table: string;
-    protected columnsList: string[];
-    protected columnsAndTypes: string;
-    protected columns: string;
-    protected vars: string;
-    protected updates: string;
-    addColumns: {
-        [columns: string]: {
-            type: string;
-            value: (item: P) => number | boolean | string | null | Date;
-        };
-    };
-    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
-    protected values(item: P): (string | number | boolean | Date | null)[];
-    protected exec(sql: string, values: any[]): Promise<void>;
-    protected query(sql: string, values: any[]): Promise<any[]>;
-    protected connect(): Promise<Pool>;
-    protected ensureTable(): Promise<void>;
-    protected ensureColumns(): Promise<void>;
-}
-
-declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgRepositoryBase<P> implements ICrudRepository<P> {
-    protected readonly config: IPgRepositoryConfig<P>;
-    constructor(pool: Pool, config: IPgRepositoryConfig<P>);
-    find(id: string): Promise<P | null>;
-    findOrThrow(id: string): Promise<P>;
-    findAll(): Promise<P[]>;
-    create(item: P): Promise<void>;
-    update(item: P): Promise<void>;
-    discard(item: P): Promise<void>;
-}
-
 declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
     constructor(pool: Pool);
     findBySlug(slug: string): Promise<WhatsApp | null>;
@@ -917,6 +1006,129 @@ declare class CustomError extends Error {
     constructor(data: ICustomErrorData);
 }
 
+declare function jwtGuard(): (target: object, propertyKey: string | symbol) => void;
+
+declare class JwtTokenDto {
+    token?: string;
+    expiration?: Date;
+}
+
+declare class JwtAccessAndRefreshTokenDto {
+    access?: JwtTokenDto;
+    refresh?: JwtTokenDto;
+}
+
+declare class JwtConfig {
+    secretOrPublicKey: string;
+    secretOrPrivateKey: string;
+    algorithm: Algorithm;
+    accessExpirationSeconds: number;
+    refreshExpirationSeconds: number;
+    constructor(env: Env);
+}
+
+interface IJwtRefreshTokenData<A extends IStorableData> extends IEntityData {
+    authInfo: A;
+}
+declare class JwtRefreshToken<A extends IStorableData> extends Entity<IJwtRefreshTokenData<A>> {
+    get authInfo(): A;
+}
+
+declare class Mapper {
+    map<T>(data: any, ctor: IConstructor<T>): T;
+}
+
+declare class JwtSigner {
+    private config;
+    private mapper;
+    constructor(config: JwtConfig, mapper: Mapper);
+    signAccessToken<D extends IStorableData>(info: D | JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtTokenDto>;
+    signAccessAndRefreshToken(refreshToken: JwtRefreshToken<any>): Promise<JwtAccessAndRefreshTokenDto>;
+}
+
+declare class JwtRefreshTokenRepository<D extends IStorableData> extends PgCrudRepository<JwtRefreshToken<D>> {
+    constructor(pool: Pool);
+}
+
+declare class Jwt {
+    private auth;
+    private jwtSigner;
+    private jwtRefreshTokenRepository;
+    constructor(auth: Auth<any>, jwtSigner: JwtSigner, jwtRefreshTokenRepository: JwtRefreshTokenRepository<any>);
+    createToken(): Promise<JwtAccessAndRefreshTokenDto>;
+}
+
+interface IGetConfig {
+    path?: string;
+}
+
+declare function get(config?: string | IGetConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IMiddleware {
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
+}
+
+declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
+
+interface IPostConfig {
+    path?: string;
+}
+
+declare function post(config?: string | IPostConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IRestControllerConfig {
+    path: string;
+}
+
+declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
+
+interface IEndPointMetadata {
+    method: 'get' | 'post';
+    path?: string;
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    paramsTypes: any[];
+}
+
+interface IMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IMiddleware>;
+}
+
+interface IRestControllerMetadata {
+    controllerConstructor: IConstructor<any>;
+    path: string;
+}
+
+declare class RestControllerMetadataStore {
+    private endPoints;
+    private middlewares;
+    private restControllers;
+    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
+    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
+    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
+    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
+        middlewares: IMiddlewareMetadata[];
+        controller: IRestControllerMetadata;
+        method: "get" | "post";
+        path?: string;
+        controllerConstructor: IConstructor<any>;
+        functionName: string;
+        paramsTypes: any[];
+    }[];
+}
+
+declare function runRestControllers(controllers: IConstructor<any>[]): void;
+
+declare class JwtGuardMiddleware implements IMiddleware {
+    private config;
+    private auth;
+    constructor(config: JwtConfig, auth: Auth<any>);
+    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
+}
+
 declare class SendOneTimePasswordRequest {
     fromEmail: string;
     toEmail: string;
@@ -1019,69 +1231,14 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-interface IGetConfig {
-    path?: string;
-}
-
-declare function get(config?: string | IGetConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IMiddleware {
-    handle(req: Request, res: Response, container: DependencyContainer$1): Promise<void>;
-}
-
-declare function middleware(middlewareConstructor: IConstructor<IMiddleware>): (target: object, propertyKey: string | symbol) => void;
-
-interface IPostConfig {
-    path?: string;
-}
-
-declare function post(config?: string | IPostConfig): (target: object, propertyKey: string | symbol) => void;
-
-interface IRestControllerConfig {
-    path: string;
-}
-
-declare function restController(config: string | IRestControllerConfig): (target: IConstructor<any>) => void;
-
-interface IEndPointMetadata {
-    method: 'get' | 'post';
-    path?: string;
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    paramsTypes: any[];
-}
-
-interface IMiddlewareMetadata {
-    controllerConstructor: IConstructor<any>;
-    functionName: string;
-    middlewareConstructor: IConstructor<IMiddleware>;
-}
-
-interface IRestControllerMetadata {
-    controllerConstructor: IConstructor<any>;
-    path: string;
-}
-
-declare class RestControllerMetadataStore {
-    private endPoints;
-    private middlewares;
-    private restControllers;
-    saveControllerMetadata(controllerMetadata: IRestControllerMetadata): void;
-    saveEndPointMetadata(endPointMetadata: IEndPointMetadata): void;
-    saveMiddlewareMetadata(middlewareMetadata: IMiddlewareMetadata): void;
-    getControllerEndPointsInfo(controllerConstructor: IConstructor<any>): {
-        middlewares: IMiddlewareMetadata[];
-        controller: IRestControllerMetadata;
-        method: "get" | "post";
-        path?: string;
-        controllerConstructor: IConstructor<any>;
-        functionName: string;
-        paramsTypes: any[];
-    }[];
+declare class Random {
+    static slug(name: string, options: {
+        randomLength: number;
+    }): string;
+    static string(length: number): string;
+    static numberCode(length: number): string;
 }
 
-declare function runRestControllers(controllers: IConstructor<any>[]): void;
-
 declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
 
 interface IrunChannelProps {
@@ -1202,4 +1359,4 @@ declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IM
 
 declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, scoped, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };
+export { Async, Auth, AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, ClaudeChatBotAdapter, CmdChannel, Command, CommandMetadataStore, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, Env, EnvWhatsAppRepository, ExpressProvider, HtmlModule, HttpServerProvider, type IChannelMetadata, type IChatBot, type IChatBotAdapter, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatFunctionCall, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConnectionChatMessage, type IConstructor, type ICrudRepository, type ICustomErrorData, type IEmailService, type IEndPointMetadata, type IEntityData, type IEnvType, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IJobData, type IJobEvent, type IJobEventListener, type IJwtRefreshTokenData, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistentData, type IPgRepositoryConfig, type IPostConfig, type IPrimitive, type IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type IStorableData, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplate, type IWhatsAppTemplateComponent, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppTemplateResponse, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, Job, JobRepository, JobRunner, JobsEventsHub, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Logger, MINDSET_DECORATION_MINDSET, MINDSET_FUNCTION_DECORATION_FUNCTION, MINDSET_MODULE_DECORATION_MODULE, Mapper, MessageContext, Mindset, MindsetMetadataStore, MindsetOperator, OpenaiChatBotAdapter, OtpService, PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM, Persistent, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, Random, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, command, commandHandler, container, get, inject, injectable, isBoolean, isDate, isModel, isNotEmpty, isNumber, isOptional, isPresent, isString, jwtGuard, max, middleware, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runAsyncCommandHandlers, runChannel, runRestControllers, runServer, scoped, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };

package/dist/src/index.js

@@ -1,6 +1,17 @@
 export { DeepSeekChatBotAdapter } from './ai/deepseek/DeepSeekChatBotAdapter.js';
 export { OpenaiChatBotAdapter } from './ai/openia/OpenaiChatBotAdapter.js';
 export { ClaudeChatBotAdapter } from './ai/claude/ClaudeChatBotAdapter.js';
+export { command } from './async/@command.js';
+export { commandHandler } from './async/@commandHandler.js';
+export { Async } from './async/Async.js';
+export { Command } from './async/Command.js';
+export { CommandMetadataStore } from './async/CommandMetadataStore.js';
+export { Job } from './async/Job.js';
+export { JobRepository } from './async/JobRepository.js';
+export { JobRunner } from './async/JobRunner.js';
+export { JobsEventsHub } from './async/JobsEventsHub.js';
+export { runAsyncCommandHandlers } from './async/runCommandHandlers.js';
+export { Auth } from './auth/Auth.js';
 export { cmd } from './channels/cmd/@cmd.js';
 export { CmdChannel } from './channels/cmd/CmdChannel.js';
 export { ExpressProvider } from './channels/express/ExpressProvider.js';
@@ -45,7 +56,17 @@ export { Storable } from './core/Storable.js';
 export { Env } from './env/Env.js';
 export { CustomError } from './error/CustomError.js';
 export { Lifecycle, container, inject, injectable, scoped, singleton } from './injection/index.js';
+export { jwtGuard } from './jwt/@jwtGuard.js';
+export { JwtAccessAndRefreshTokenDto } from './jwt/JwtAccessAndRefreshTokenDto.js';
+export { JwtConfig } from './jwt/JwtConfig.js';
+export { Jwt } from './jwt/Jwt.js';
+export { JwtGuardMiddleware } from './jwt/JwtGuardMiddleware.js';
+export { JwtRefreshToken } from './jwt/JwtRefreshToken.js';
+export { JwtSigner } from './jwt/JwtSigner.js';
+export { JwtTokenDto } from './jwt/JwtTokenDto.js';
+export { JwtRefreshTokenRepository } from './jwt/JwtRefreshTokenRepository.js';
 export { Logger } from './logger/Logger.js';
+export { Mapper } from './mapper/Mapper.js';
 export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.js';
 export { MINDSET_FUNCTION_DECORATION_FUNCTION } from './mindset/metadata/functions/decoratorNames.js';
 export { mindset } from './mindset/metadata/mindsets/@mindset.js';
@@ -71,6 +92,7 @@ export { PgChatRepository } from './pre-made/repository/chat/pg/PgChatRepository
 export { PgChatMemory } from './pre-made/repository/chat/pg/PgChatMemory.js';
 export { RamChatMemory } from './pre-made/repository/chat/ram/RamChatMemory.js';
 export { RamChatRepository } from './pre-made/repository/chat/ram/RamChatRepository.js';
+export { Random } from './random/Random.js';
 export { PgCrudRepository } from './repository/pg/PgCrudRepository.js';
 export { PgRepositoryBase } from './repository/pg/PgRepositoryBase.js';
 export { get } from './rest-controller/metadata/@get.js';

package/dist/src/jwt/@jwtGuard.js

@@ -0,0 +1,34 @@
+import '../injection/index.js';
+import '../rest-controller/metadata/RestControllerMetadataStore.js';
+import { middleware } from '../rest-controller/metadata/@middleware.js';
+import '../controller/channel/ChatResolver.js';
+import '../controller/channel/UserResolver.js';
+import '../controller/metadata/ControllerMetadataStore.js';
+import '../channels/cmd/CmdChannel.js';
+import '../channels/express/ExpressProvider.js';
+import '../channels/http/HttpServerProvider.js';
+import '../channels/socket/SocketChannel.js';
+import '../channels/socket/SocketChannelConfig.js';
+import '../channels/socket/SocketServerProvider.js';
+import '../channels/telegram/TelegramChannel.js';
+import '../channels/whatsapp/WhatsAppChannel.js';
+import '../channels/whatsapp/EnvWhatsAppRepository.js';
+import '../channels/whatsapp/PgWhatsAppRepository.js';
+import '../core/chat/repository/IChatRepository.js';
+import '../core/user/IUserRepository.js';
+import '../channels/whatsapp/WhatsAppReceiverByDevConnection.js';
+import '../channels/whatsapp/WhatsAppReceiverByWebHook.js';
+import '../channels/whatsapp/WhatsAppSenderByCloudApi.js';
+import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
+import 'debug';
+import '../validation/metadata/ValidationMetadataStore.js';
+import 'path';
+import { JwtGuardMiddleware } from './JwtGuardMiddleware.js';
+
+function jwtGuard() {
+    return function (target, propertyKey) {
+        middleware(JwtGuardMiddleware)(target, propertyKey);
+    };
+}
+
+export { jwtGuard };

package/dist/src/jwt/Jwt.js

@@ -0,0 +1,31 @@
+import { __decorate, __metadata } from 'tslib';
+import { Auth } from '../auth/Auth.js';
+import { JwtSigner } from './JwtSigner.js';
+import { JwtRefreshTokenRepository } from './JwtRefreshTokenRepository.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { injectable } from '../injection/index.js';
+
+let Jwt = class Jwt {
+    auth;
+    jwtSigner;
+    jwtRefreshTokenRepository;
+    constructor(auth, jwtSigner, jwtRefreshTokenRepository) {
+        this.auth = auth;
+        this.jwtSigner = jwtSigner;
+        this.jwtRefreshTokenRepository = jwtRefreshTokenRepository;
+    }
+    async createToken() {
+        const authInfo = this.auth.require();
+        const refreshToken = new JwtRefreshToken({ authInfo });
+        await this.jwtRefreshTokenRepository.create(refreshToken);
+        return await this.jwtSigner.signAccessAndRefreshToken(refreshToken);
+    }
+};
+Jwt = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Auth,
+        JwtSigner,
+        JwtRefreshTokenRepository])
+], Jwt);
+
+export { Jwt };

package/dist/src/jwt/JwtAccessAndRefreshTokenDto.js

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import '../injection/index.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { isModel } from '../validation/metadata/@isModel.js';
+import { JwtTokenDto } from './JwtTokenDto.js';
+
+class JwtAccessAndRefreshTokenDto {
+    access;
+    refresh;
+}
+__decorate([
+    isModel(JwtTokenDto),
+    __metadata("design:type", JwtTokenDto)
+], JwtAccessAndRefreshTokenDto.prototype, "access", void 0);
+__decorate([
+    isModel(JwtTokenDto),
+    __metadata("design:type", JwtTokenDto)
+], JwtAccessAndRefreshTokenDto.prototype, "refresh", void 0);
+
+export { JwtAccessAndRefreshTokenDto };

package/dist/src/jwt/JwtConfig.js

@@ -0,0 +1,28 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../env/Env.js';
+import { singleton } from '../injection/index.js';
+
+let JwtConfig = class JwtConfig {
+    secretOrPublicKey;
+    secretOrPrivateKey;
+    algorithm;
+    accessExpirationSeconds;
+    refreshExpirationSeconds;
+    constructor(env) {
+        this.algorithm = env.requireString('JWT_ALGORITHM', { default: 'HS256' });
+        this.secretOrPublicKey = env.requireString('JWT_SECRET');
+        this.secretOrPrivateKey = env.requireString('JWT_SECRET');
+        this.accessExpirationSeconds = env.requireNumber('JWT_ACCESS_EXPIRATION_SECONDS', {
+            default: 10 * 60,
+        });
+        this.refreshExpirationSeconds = env.requireNumber('JWT_REFRESH_EXPIRATION_SECONDS', {
+            default: 365 * 24 * 3600,
+        });
+    }
+};
+JwtConfig = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], JwtConfig);
+
+export { JwtConfig };

package/dist/src/jwt/JwtGuardMiddleware.js

@@ -0,0 +1,45 @@
+import { __decorate, __metadata } from 'tslib';
+import { Auth } from '../auth/Auth.js';
+import jwt from 'jsonwebtoken';
+import { JwtConfig } from './JwtConfig.js';
+import { injectable } from '../injection/index.js';
+import { CustomError } from '../error/CustomError.js';
+
+let JwtGuardMiddleware = class JwtGuardMiddleware {
+    config;
+    auth;
+    constructor(config, auth) {
+        this.config = config;
+        this.auth = auth;
+    }
+    async handle(req, res, container) {
+        const authorization = req.header('Authorization');
+        if (!authorization) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization header not available' });
+        }
+        const [bearer, token] = authorization.split(' ');
+        if (bearer.toLowerCase() !== 'bearer' || !token) {
+            throw new CustomError({ httpCode: 401, message: 'Authorization should be a bearer token' });
+        }
+        try {
+            const jwtPayload = jwt.verify(token, this.config.secretOrPublicKey, {
+                algorithms: [this.config.algorithm],
+            });
+            this.auth.assign(jwtPayload);
+        }
+        catch (err) {
+            throw new CustomError({
+                httpCode: 401,
+                message: err instanceof Error ? `Invalid token: ${err.message}` : 'Invalid token',
+                cause: err instanceof Error ? err : undefined,
+            });
+        }
+    }
+};
+JwtGuardMiddleware = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig,
+        Auth])
+], JwtGuardMiddleware);
+
+export { JwtGuardMiddleware };

package/dist/src/jwt/JwtRefreshToken.js

@@ -0,0 +1,11 @@
+import '../core/chat/repository/IChatRepository.js';
+import { Entity } from '../core/Entity.js';
+import '../core/user/IUserRepository.js';
+
+class JwtRefreshToken extends Entity {
+    get authInfo() {
+        return this.data.authInfo;
+    }
+}
+
+export { JwtRefreshToken };

package/dist/src/jwt/JwtRefreshTokenRepository.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../injection/index.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { Pool } from 'pg';
+import { PgCrudRepository } from '../repository/pg/PgCrudRepository.js';
+
+let JwtRefreshTokenRepository = class JwtRefreshTokenRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'jwt_refresh_token',
+            constructor: JwtRefreshToken,
+        });
+    }
+};
+JwtRefreshTokenRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], JwtRefreshTokenRepository);
+
+export { JwtRefreshTokenRepository };

package/dist/src/jwt/JwtSigner.js

@@ -0,0 +1,48 @@
+import { __decorate, __metadata } from 'tslib';
+import { JwtConfig } from './JwtConfig.js';
+import jwt from 'jsonwebtoken';
+import { JwtTokenDto } from './JwtTokenDto.js';
+import { JwtRefreshToken } from './JwtRefreshToken.js';
+import { JwtAccessAndRefreshTokenDto } from './JwtAccessAndRefreshTokenDto.js';
+import { injectable } from '../injection/index.js';
+import { Mapper } from '../mapper/Mapper.js';
+
+let JwtSigner = class JwtSigner {
+    config;
+    mapper;
+    constructor(config, mapper) {
+        this.config = config;
+        this.mapper = mapper;
+    }
+    async signAccessToken(info) {
+        const _authInfo = info instanceof JwtRefreshToken
+            ? {
+                ...info.authInfo,
+                refreshTokenId: info.id,
+            }
+            : info;
+        const token = jwt.sign(_authInfo, this.config.secretOrPrivateKey, {
+            expiresIn: this.config.accessExpirationSeconds,
+        });
+        const expiration = new Date().getTime() + this.config.accessExpirationSeconds * 1000;
+        return this.mapper.map({ token, expiration }, JwtTokenDto);
+    }
+    async signRefreshToken(refreshToken) {
+        const token = jwt.sign({ refreshTokenId: refreshToken.id }, this.config.secretOrPrivateKey, {
+            expiresIn: this.config.refreshExpirationSeconds,
+        });
+        const expiration = new Date().getTime() + this.config.refreshExpirationSeconds * 1000;
+        return this.mapper.map({ token, expiration }, JwtTokenDto);
+    }
+    async signAccessAndRefreshToken(refreshToken) {
+        const access = await this.signAccessToken(refreshToken);
+        const refresh = await this.signRefreshToken(refreshToken);
+        return this.mapper.map({ access, refresh }, JwtAccessAndRefreshTokenDto);
+    }
+};
+JwtSigner = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [JwtConfig, Mapper])
+], JwtSigner);
+
+export { JwtSigner };

package/dist/src/jwt/JwtTokenDto.js

@@ -0,0 +1,22 @@
+import { __decorate, __metadata } from 'tslib';
+import '../injection/index.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { isDate } from '../validation/metadata/@isDate.js';
+import { isNotEmpty } from '../validation/metadata/@isNotEmpty.js';
+import { isString } from '../validation/metadata/@isString.js';
+
+class JwtTokenDto {
+    token;
+    expiration;
+}
+__decorate([
+    isString(),
+    isNotEmpty(),
+    __metadata("design:type", String)
+], JwtTokenDto.prototype, "token", void 0);
+__decorate([
+    isDate(),
+    __metadata("design:type", Date)
+], JwtTokenDto.prototype, "expiration", void 0);
+
+export { JwtTokenDto };

package/dist/src/mapper/Mapper.js

@@ -0,0 +1,44 @@
+import '../core/chat/repository/IChatRepository.js';
+import { Storable } from '../core/Storable.js';
+import '../core/user/IUserRepository.js';
+import { CustomError } from '../error/CustomError.js';
+import '../injection/index.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { validate } from '../validation/validate.js';
+
+function deepCopyWithStorable(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return obj.getTime();
+    }
+    if (obj instanceof Storable) {
+        return deepCopyWithStorable(obj['data']);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepCopyWithStorable(item));
+    }
+    const copy = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            copy[key] = deepCopyWithStorable(obj[key]);
+        }
+    }
+    return copy;
+}
+class Mapper {
+    map(data, ctor) {
+        const validationResult = validate(deepCopyWithStorable(data), ctor);
+        if (validationResult.error) {
+            throw new CustomError({
+                httpCode: 500,
+                message: `Cant map value to ${ctor.name}`,
+                info: validationResult.error,
+            });
+        }
+        return validationResult.value;
+    }
+}
+
+export { Mapper };

package/dist/src/random/Random.js

@@ -0,0 +1,37 @@
+import { randomBytes } from 'node:crypto';
+
+const DIGITS = '0123456789';
+const CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+class Random {
+    static slug(name, options) {
+        const base = name
+            .toLowerCase()
+            .trim()
+            .replace(/[\s\_]+/g, '-') // spaces/underscores to hyphens
+            .replace(/[^a-z0-9\-]/g, '') // remove non-alphanumeric except hyphens
+            .replace(/\-+/g, '-') // collapse multiple hyphens
+            .replace(/^\-+|\-+$/g, ''); // trim hyphens from ends
+        const random = this.string(options.randomLength);
+        return `${base}-${random}`;
+    }
+    static string(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % CHARSET.length;
+            result += CHARSET[index];
+        }
+        return result;
+    }
+    static numberCode(length) {
+        const bytes = randomBytes(length);
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            const index = bytes[i] % 10; // 0–9
+            result += DIGITS[index];
+        }
+        return result;
+    }
+}
+
+export { Random };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.23",
+  "version": "0.1.0-beta.25",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -38,6 +38,7 @@
     "@anthropic-ai/sdk": "^0.60.0",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.1",
+    "@types/jsonwebtoken": "^9.0.10",
     "@types/pg": "^8.11.14",
     "@yucacodes/ts": "^0.0.4",
     "body-parser": "^2.2.0",
@@ -46,6 +47,7 @@
     "express": "^5.1.0",
     "grammy": "^1.36.0",
     "html-to-text": "^9.0.5",
+    "jsonwebtoken": "^9.0.2",
     "openai": "^4.93.0",
     "pg": "^8.15.6",
     "reflect-metadata": "^0.2.2",