@wabot-dev/framework 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/src/channels/whatsapp/WhatsApp.js

@@ -1,8 +1,8 @@
 import '../../core/chat/repository/IChatRepository.js';
-import { Persistent } from '../../core/Persistent.js';
+import { Entity } from '../../core/Entity.js';
 import '../../core/user/IUserRepository.js';
 
-class WhatsApp extends Persistent {
+class WhatsApp extends Entity {
     getVerifyToken() {
         return this.data.verifyToken;
     }

package/dist/src/channels/whatsapp/WhatsAppSender.js

@@ -13,6 +13,15 @@ class WhatsAppSender {
         this.chatResolver = chatResolver;
         this.whatsAppRepository = whatsAppRepository;
     }
+    handleSendRequest(request) {
+        throw new Error('Not implemented');
+    }
+    handleSendTemplateRequest(request) {
+        throw new Error('Not implemented');
+    }
+    handleGetWhatsAppTemplate(request) {
+        throw new Error('Not implemented');
+    }
     async sendWhatsApp(request, options) {
         try {
             await this.handleSendRequest(request);
@@ -22,6 +31,7 @@ class WhatsAppSender {
         }
         catch (error) {
             this.logger.error(`Error sending WhatsApp message: ${error}`);
+            throw new Error(`Error sending WhatsApp message: ${error}`, { cause: error });
         }
     }
     async sendWhatsAppTemplate(request, options) {
@@ -34,6 +44,7 @@ class WhatsAppSender {
         }
         catch (error) {
             this.logger.error(`Error sending WhatsApp message: ${error}`);
+            throw new Error(`Error sending WhatsApp message: ${error}`, { cause: error });
         }
     }
     async getWhatsAppTemplate(request) {
@@ -71,7 +82,7 @@ class WhatsAppSender {
             channelName: 'WhatsAppChannel',
         };
         const chat = await this.chatResolver.resolve(chatConnection);
-        const chatMemory = await this.chatRepository.findMemory(chat.getId());
+        const chatMemory = await this.chatRepository.findMemory(chat.id);
         const chatItem = new ChatItem({
             type: 'BOT_MESSAGE',
             content: message,

package/dist/src/channels/whatsapp/WhatsAppSenderByCloudApi.js

@@ -1,14 +1,13 @@
 import { __decorate, __metadata } from 'tslib';
 import { Logger } from '../../logger/Logger.js';
 import { WhatsAppSender } from './WhatsAppSender.js';
-import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
-import { singleton, container } from '../../injection/index.js';
+import { singleton } from '../../injection/index.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
 import { WhatsAppRepository } from './WhatsAppRepository.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
 
 let WhatsAppSenderByCloudApi = class WhatsAppSenderByCloudApi extends WhatsAppSender {
     constructor(chatRepository, chatResolver, whatsAppRepository) {
@@ -115,10 +114,5 @@ WhatsAppSenderByCloudApi = __decorate([
         ChatResolver,
         WhatsAppRepository])
 ], WhatsAppSenderByCloudApi);
-if (!WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppSender, {
-        useClass: WhatsAppSenderByCloudApi,
-    });
-}
 
 export { WhatsAppSenderByCloudApi };

package/dist/src/channels/whatsapp/WhatsAppSenderByDevConnection.js

@@ -1,14 +1,14 @@
 import { __decorate, __metadata } from 'tslib';
 import { WhatsAppSender } from './WhatsAppSender.js';
-import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
-import { devEmitEvent } from '../wabot/WabotDevSocketContracts.js';
-import { Logger } from '../../logger/Logger.js';
-import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
-import '../../core/user/IUserRepository.js';
-import { singleton, container } from '../../injection/index.js';
 import { ChatResolver } from '../../controller/channel/ChatResolver.js';
 import '../../controller/channel/UserResolver.js';
+import { singleton } from '../../injection/index.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
+import { ChatRepository } from '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { Logger } from '../../logger/Logger.js';
+import { WabotDevConnection } from '../wabot/WabotDevConnection.js';
+import { devEmitEvent } from '../wabot/WabotDevSocketContracts.js';
 import { WhatsAppRepository } from './WhatsAppRepository.js';
 
 let WhatsAppSenderByDevConnection = class WhatsAppSenderByDevConnection extends WhatsAppSender {
@@ -52,10 +52,5 @@ WhatsAppSenderByDevConnection = __decorate([
         ChatResolver,
         WhatsAppRepository])
 ], WhatsAppSenderByDevConnection);
-if (WabotDevConnection.isTokenAvailable()) {
-    container.register(WhatsAppSender, {
-        useClass: WhatsAppSenderByDevConnection,
-    });
-}
 
 export { WhatsAppSenderByDevConnection };

package/dist/src/core/{Persistent.js → Entity.js}

@@ -1,22 +1,32 @@
-class Persistent {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    getId() {
+import { Storable } from './Storable.js';
+
+class Entity extends Storable {
+    get id() {
         if (!this.data.id) {
             throw new Error('id is required');
         }
         return this.data.id;
     }
-    getCreatedAt() {
+    /**
+     * @deprecated use id
+     */
+    getId() {
+        return this.id;
+    }
+    get createdAt() {
         if (!this.data.createdAt) {
             throw new Error('createdAt is required');
         }
         return new Date(this.data.createdAt);
     }
+    /**
+     * @deprecated use createdAt
+     */
+    getCreatedAt() {
+        return this.createdAt;
+    }
     update(newData) {
-        this.data = newData;
+        this.data = { ...this.data, newData, updatedAt: new Date().getTime() };
     }
     wasCreated() {
         return !!this.data.createdAt || !!this.data.id;
@@ -33,5 +43,10 @@ class Persistent {
         this.data.discardedAt = new Date().getTime();
     }
 }
+/**
+ * @deprecated Should use Entity
+ */
+class PersistentData extends Entity {
+}
 
-export { Persistent };
+export { Entity, PersistentData };

package/dist/src/core/Storable.js

@@ -0,0 +1,8 @@
+class Storable {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+
+export { Storable };

package/dist/src/core/chat/Chat.js

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

package/dist/src/core/chat/ChatItem.js

@@ -1,6 +1,6 @@
-import { Persistent } from '../Persistent.js';
+import { Entity } from '../Entity.js';
 
-class ChatItem extends Persistent {
+class ChatItem extends Entity {
     getType() {
         return this.data.type;
     }

package/dist/src/core/user/User.js

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

package/dist/src/error/CustomError.js

@@ -0,0 +1,14 @@
+class CustomError extends Error {
+    humanMessage;
+    code;
+    httpCode;
+    info;
+    constructor(data) {
+        super(data.message, { cause: data.cause });
+        this.humanMessage = data.humanMessage;
+        this.code = data.code;
+        this.httpCode = data.httpCode;
+    }
+}
+
+export { CustomError };

package/dist/src/index.d.ts

@@ -2,10 +2,10 @@ 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 { Server } from 'http';
-import { Express } from 'express';
+import { Express, Request, Response } from 'express';
 import { Server as Server$1 } from 'socket.io';
-import { Socket } from 'socket.io-client';
 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';
@@ -26,33 +26,58 @@ interface IMindsetFunctionDecoration {
     decorationConfig: any;
 }
 
-interface IPersistentData {
+type IPrimitive = null | number | string | boolean | undefined;
+type IStorableData = {
+    [key: string]: IPrimitive | IPrimitive[] | IStorableData | IStorableData[];
+};
+declare class Storable<D extends IStorableData> {
+    protected data: D;
+    constructor(data: D);
+}
+
+interface IEntityData extends IStorableData {
     id?: string;
     createdAt?: number | null;
     discardedAt?: number | null;
 }
-declare class Persistent<D extends IPersistentData = IPersistentData> {
-    protected data: D;
-    constructor(data: D);
+declare class Entity<D extends IEntityData> extends Storable<D> {
+    get id(): string;
+    /**
+     * @deprecated use id
+     */
     getId(): string;
+    get createdAt(): Date;
+    /**
+     * @deprecated use createdAt
+     */
     getCreatedAt(): Date;
-    update(newData: D): void;
+    update(newData: Omit<D, 'id' | 'createdAt' | 'discardedAt'>): void;
     wasCreated(): boolean;
     validate(): void;
     discard(): void;
 }
+/**
+ * @deprecated Should use IEntityData
+ */
+interface IPersistentData extends IEntityData {
+}
+/**
+ * @deprecated Should use Entity
+ */
+declare class PersistentData<D extends IPersistentData> extends Entity<D> {
+}
 
 type IChatType = 'PRIVATE' | 'GROUP';
-interface IChatConnection {
+interface IChatConnection extends IStorableData {
     chatType: IChatType;
     channelName: string;
     id: string;
 }
-interface IChatData extends IPersistentData {
+interface IChatData extends IEntityData {
     type: IChatType;
     connections: IChatConnection[];
 }
-declare class Chat extends Persistent<IChatData> {
+declare class Chat extends Entity<IChatData> {
     constructor(data: IChatData);
     isPrivate(): boolean;
     isGroup(): boolean;
@@ -62,24 +87,24 @@ declare class Chat extends Persistent<IChatData> {
     validate(): void;
 }
 
-interface IChatDocument {
+interface IChatDocument extends IStorableData {
 }
 
-interface IChatImage {
+interface IChatImage extends IStorableData {
 }
 
-interface IUserConnection {
+interface IUserConnection extends IStorableData {
     channelName: string;
     id: string;
 }
-interface IUserData extends IPersistentData {
+interface IUserData extends IEntityData {
     shortName: string;
     connections: IUserConnection[];
     keyValueData: {
         [key: string]: string;
     };
 }
-declare class User extends Persistent<IUserData> {
+declare class User extends Entity<IUserData> {
     constructor(data: IUserData);
     hasConnection(connection: IUserConnection): boolean;
     getValue(key: string): string;
@@ -87,7 +112,7 @@ declare class User extends Persistent<IUserData> {
     addConnection(connection: IUserConnection): void;
 }
 
-interface IChatMessage {
+interface IChatMessage extends IStorableData {
     text?: string;
     documents?: IChatDocument[];
     images?: IChatImage[];
@@ -118,12 +143,9 @@ type ISystemFunctionCallItem = {
     type: 'FUNCTION_CALL';
     content: IChatFunctionCall;
 };
-type IChatItemData = {
-    id?: string;
-    createdAt?: number;
-} & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
+type IChatItemData = IEntityData & (ISystemMessageItem | IReceivedMessageItem | ISystemFunctionCallItem);
 type IChatItemType = IChatItemData['type'];
-declare class ChatItem extends Persistent<IChatItemData> {
+declare class ChatItem extends Entity<IChatItemData> {
     getType(): "BOT_MESSAGE" | "CONNECTION_MESSAGE" | "FUNCTION_CALL";
     getContent(): IChatMessage | IConnectionChatMessage | IChatFunctionCall;
     getData(): IChatItemData;
@@ -172,11 +194,6 @@ declare class MessageContext implements IMessageContext {
     constructor(message: IConnectionChatMessage, chat: Chat, user: User | null);
 }
 
-interface IReversibleMapper<T1, T2> {
-    map(input: T1): T2;
-    rev(input: T2): T1;
-}
-
 type IConstructor<T> = new (...args: any[]) => T;
 
 interface IMindsetIdentity {
@@ -532,6 +549,54 @@ declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
 
 declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
 
+interface IWhatsAppBusinessNumber extends IStorableData {
+    id: string;
+    number: string;
+}
+interface IWhatsAppBusinessAccount extends IStorableData {
+    id: string;
+}
+interface IWhatsAppData extends IEntityData {
+    slug: string;
+    verifyToken: string;
+    appSecret: string;
+    accessToken: string;
+    businessAccount: IWhatsAppBusinessAccount;
+    businessNumbers: IWhatsAppBusinessNumber[];
+}
+declare class WhatsApp extends Entity<IWhatsAppData> {
+    getVerifyToken(): string;
+    getSlug(): string;
+    getBusinessAccount(): IWhatsAppBusinessAccount;
+    getAppSecret(): string;
+    getBusinessNumbers(): IWhatsAppBusinessNumber[];
+    getAccessToken(): string;
+    hasBusinessNumber(number: string): boolean;
+    getBussinessNumber(number: string): IWhatsAppBusinessNumber | null;
+}
+
+interface IWhatsAppRepository {
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+}
+
+type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
+declare class WabotEnv {
+    private envType;
+    constructor();
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+    requireString(varName: string): string;
+}
+
+declare class EnvWhatsAppRepository implements IWhatsAppRepository {
+    private env;
+    constructor(env: WabotEnv);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
+    private getFromEnvVars;
+}
+
 type IWhatsAppTemplateParameter = {
     type: 'text';
     text: string;
@@ -555,6 +620,32 @@ interface IWhatsAppTemplateMessage {
     parameters: IWhatsAppTemplateParameter[];
 }
 
+interface IWhatsAppTemplateResponse {
+    data: IWhatsAppTemplate[];
+    paging: IWhatsAppApiPaging;
+}
+interface IWhatsAppTemplate {
+    name: string;
+    parameter_format: 'POSITIONAL' | 'OTHER';
+    components: IWhatsAppTemplateComponent[];
+    language: string;
+    status: string;
+    category: string;
+    id: string;
+}
+interface IWhatsAppTemplateComponent {
+    type: 'HEADER' | 'BODY' | 'FOOTER';
+    format?: 'TEXT';
+    text?: string;
+}
+interface IWhatsAppApiPaging {
+    cursors: IWhatsAppApiCursors;
+}
+interface IWhatsAppApiCursors {
+    before: string;
+    after: string;
+}
+
 interface IWhatsAppWebhookPayload {
     object: 'whatsapp_business_account';
     entry: IEntry[];
@@ -607,30 +698,70 @@ interface IAudioMessage extends IBaseMessage {
     };
 }
 
-interface IWhatsAppBusinessNumber {
-    id: string;
-    number: string;
+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>;
 }
-interface IWhatsAppBusinessAccount {
-    id: string;
+
+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>;
 }
-interface IWhatsAppData extends IPersistentData {
-    slug: string;
-    verifyToken: string;
-    appSecret: string;
-    accessToken: string;
-    businessAccount: IWhatsAppBusinessAccount;
-    businessNumbers: IWhatsAppBusinessNumber[];
+
+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 WhatsApp extends Persistent<IWhatsAppData> {
-    getVerifyToken(): string;
-    getSlug(): string;
-    getBusinessAccount(): IWhatsAppBusinessAccount;
-    getAppSecret(): string;
-    getBusinessNumbers(): IWhatsAppBusinessNumber[];
-    getAccessToken(): string;
-    hasBusinessNumber(number: string): boolean;
-    getBussinessNumber(number: string): IWhatsAppBusinessNumber | null;
+
+declare class PgWhatsAppRepository extends PgCrudRepository<WhatsApp> implements IWhatsAppRepository {
+    constructor(pool: Pool);
+    findBySlug(slug: string): Promise<WhatsApp | null>;
+    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
 declare class Logger {
@@ -660,31 +791,11 @@ declare abstract class WhatsAppReceiver {
     private emmitMessage;
 }
 
-interface IWhatsAppRepository {
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
-}
-
 declare class WhatsAppRepository implements IWhatsAppRepository {
     findBySlug(slug: string): Promise<WhatsApp | null>;
     findByBusinessNumber(number: string): Promise<WhatsApp | null>;
 }
 
-interface IWhatsAppTemplate {
-    name: string;
-    parameter_format: 'POSITIONAL' | 'OTHER';
-    components: IWhatsAppTemplateComponent[];
-    language: string;
-    status: string;
-    category: string;
-    id: string;
-}
-interface IWhatsAppTemplateComponent {
-    type: 'HEADER' | 'BODY' | 'FOOTER';
-    format?: 'TEXT';
-    text?: string;
-}
-
 interface ISendWhatsAppRequest {
     from: string;
     to: string;
@@ -704,15 +815,15 @@ interface IGetWhatsAppTemplateRequest {
 interface IWhatsAppSenderOptions {
     writeChatMemory?: boolean;
 }
-declare abstract class WhatsAppSender {
+declare class WhatsAppSender {
     protected logger: Logger;
     protected chatRepository: ChatRepository;
     protected chatResolver: ChatResolver;
     protected whatsAppRepository: WhatsAppRepository;
     constructor(logger: Logger, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
-    protected abstract handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
-    protected abstract handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
-    protected abstract handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
+    protected handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
+    protected handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
+    protected handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
     sendWhatsApp(request: ISendWhatsAppRequest, options?: IWhatsAppSenderOptions): Promise<void>;
     sendWhatsAppTemplate(request: ISendWhatsAppTemplateRequest, options?: IWhatsAppSenderOptions): Promise<void>;
     getWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
@@ -758,125 +869,36 @@ declare class WhatsAppReceiverByWebHook extends WhatsAppReceiver {
     connect(): Promise<void>;
 }
 
-declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
-    private wabotDevConnection;
-    constructor(wabotDevConnection: WabotDevConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+declare class WhatsAppSenderByCloudApi extends WhatsAppSender {
+    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
     handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
     handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
     handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
 }
 
-declare class WhatsAppSenderByCloudApi extends WhatsAppSender {
-    constructor(chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
+declare class WhatsAppSenderByDevConnection extends WhatsAppSender {
+    private wabotDevConnection;
+    constructor(wabotDevConnection: WabotDevConnection, chatRepository: ChatRepository, chatResolver: ChatResolver, whatsAppRepository: WhatsAppRepository);
     handleSendRequest(request: ISendWhatsAppRequest): Promise<void>;
     handleSendTemplateRequest(request: ISendWhatsAppTemplateRequest): Promise<void>;
     handleGetWhatsAppTemplate(request: IGetWhatsAppTemplateRequest): Promise<IWhatsAppTemplate | null>;
 }
 
-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 Persistent> = {
-    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 Persistent> {
-    protected pool: Pool;
-    protected config: IPgRepositoryConfig<any>;
-    private tableIsCreated;
-    schema: string;
-    table: string;
-    columnsList: string[];
-    columnsAndTypes: string;
-    columns: string;
-    vars: string;
-    updates: string;
-    addColumns: {
-        [columns: string]: {
-            type: string;
-            value: (item: P) => number | boolean | string | null | Date;
-        };
-    };
-    constructor(pool: Pool, config: IPgRepositoryConfig<any>);
-    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 Persistent> 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>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
-}
-
-type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
-declare class WabotEnv {
-    private envType;
-    constructor();
-    isDevelopment(): boolean;
-    isProduction(): boolean;
-    requireString(varName: string): string;
-}
-
-declare class EnvWhatsAppRepository implements IWhatsAppRepository {
-    private env;
-    constructor(env: WabotEnv);
-    findBySlug(slug: string): Promise<WhatsApp | null>;
-    findByBusinessNumber(number: string): Promise<WhatsApp | null>;
-    private getFromEnvVars;
-}
-
-declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
-
-interface IrunChannelProps {
-    channel: IConstructor<IChatChannel>;
-    channelConfig?: object;
-    mindset: IConstructor<IMindset>;
-    chatRepository: IConstructor<IChatRepository>;
-    chatBotAdapter: IConstructor<IChatBotAdapter>;
-}
-declare function runChannel(props: IrunChannelProps): void;
-
-interface IServerProvider<T, ST extends T> {
-    replace: IConstructor<T>;
-    with: IConstructor<ST>;
-    singleton?: true;
+interface ICustomErrorData {
+    message: string;
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    cause?: Error;
+    info?: any;
 }
-interface IServerConfig {
-    controllers: IConstructor<any>[];
-    providers?: IServerProvider<unknown, unknown>[];
+declare class CustomError extends Error {
+    humanMessage?: string;
+    code?: string;
+    httpCode?: number;
+    info?: any;
+    constructor(data: ICustomErrorData);
 }
-declare function runServer(config: IServerConfig): void;
 
 declare class SendOneTimePasswordRequest {
     fromEmail: string;
@@ -986,6 +1008,12 @@ interface IGetConfig {
 
 declare function get(config?: 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;
 }
@@ -1006,6 +1034,12 @@ interface IEndPointMetadata {
     paramsTypes: any[];
 }
 
+interface IMiddlewareMetadata {
+    controllerConstructor: IConstructor<any>;
+    functionName: string;
+    middlewareConstructor: IConstructor<IMiddleware>;
+}
+
 interface IRestControllerMetadata {
     controllerConstructor: IConstructor<any>;
     path: string;
@@ -1013,10 +1047,13 @@ interface IRestControllerMetadata {
 
 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;
@@ -1028,10 +1065,34 @@ declare class RestControllerMetadataStore {
 
 declare function runRestControllers(controllers: IConstructor<any>[], container: DependencyContainer$1): void;
 
+declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
+
+interface IrunChannelProps {
+    channel: IConstructor<IChatChannel>;
+    channelConfig?: object;
+    mindset: IConstructor<IMindset>;
+    chatRepository: IConstructor<IChatRepository>;
+    chatBotAdapter: IConstructor<IChatBotAdapter>;
+}
+declare function runChannel(props: IrunChannelProps): void;
+
+interface IServerProvider<T, ST extends T> {
+    replace: IConstructor<T>;
+    with: IConstructor<ST>;
+    singleton?: true;
+}
+interface IServerConfig {
+    controllers: IConstructor<any>[];
+    providers?: IServerProvider<unknown, unknown>[];
+}
+declare function runServer(config: IServerConfig): void;
+
 declare function isBoolean(): (target: object, propertyKey: string | symbol) => void;
 
 declare function isDate(): (target: object, propertyKey: string | symbol) => void;
 
+declare function isModel(model: IConstructor<any>): (target: object, propertyKey: string | symbol) => void;
+
 declare function isNotEmpty(): (target: object, propertyKey: string | symbol) => void;
 
 declare function isNumber(): (target: object, propertyKey: string | symbol) => void;
@@ -1046,13 +1107,10 @@ declare function max(limit: any): (target: object, propertyKey: string | symbol)
 
 declare function min(limit: any): (target: object, propertyKey: string | symbol) => void;
 
-declare function validable<A>(): (target: IConstructor<A>) => void;
-
 interface IValidationError {
     description: string;
 }
-interface IModelValidationError {
-    model: IValidationError[];
+interface IModelValidationError extends IValidationError {
     properties: {
         name: string;
         errors: IValidationError[];
@@ -1119,6 +1177,6 @@ declare function validateIsPresent(value: any): IValidationResult<any>;
 
 declare function validateModel<V>(value: any, info: IModelValidatorsInfo<V>): IModelValidationResult<V>;
 
-declare function validateModel2<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
+declare function validate<V>(value: any, modelConstructor: IConstructor<V>): IModelValidationResult<V>;
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, DeepSeekChatBotAdapter, EmailService, 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 IEmailService, type IEndPointMetadata, type IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, 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 IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type IReversibleMapper, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, 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 IWabotEnvType, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppContact, type IWhatsAppData, type IWhatsAppMessage, type IWhatsAppMessageListener, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsAppTemplateMessage, type IWhatsAppTemplateParameter, type IWhatsAppWebhookPayload, type IWhatsappChannelConfig, type IchatControllerConfig, type IrunChannelProps, 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, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByDevConnection, WhatsAppReceiverByWebHook, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByDevConnection, WhatsappChannelConfig, chatBot, chatController, cmd, container, get, inject, injectable, isBoolean, isDate, isNotEmpty, isNumber, isOptional, isPresent, isString, max, min, mindset, mindsetFunction, mindsetModule, param, post, prepareChatContainer, restController, runChannel, runRestControllers, runServer, singleton, socket, telegram, validable, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, validateModel2, whatsapp };
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatBotAdapter, EmailService, Entity, 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 IGetConfig, type IGetWhatsAppTemplateRequest, type IHtmlModuleOptions, type IListenWhatsAppMessageRequest, type IMessageContext, type IMessageMetadata, 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 IPropertyValidatorInfo, type IReceivedMessage, type IReceivedMessageItem, type IRestControllerConfig, type IRestControllerMetadata, type ISendEmailRequest, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type IServerConfig, type IServerProvider, type ISocketChannelConfig, type ISocketChannelReceivedMessage, 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 IWabotEnvType, 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, 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, PersistentData, PgChatMemory, PgChatRepository, PgCrudRepository, PgRepositoryBase, PgUserRepository, PgWhatsAppRepository, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, RestControllerMetadataStore, SendOneTimePasswordRequest, SocketChannel, SocketChannelConfig, SocketServerProvider, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, ValidationMetadataStore, WabotEnv, 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, singleton, socket, telegram, validate, validateIsBoolean, validateIsDate, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsString, validateMax, validateMin, validateModel, whatsapp };

package/dist/src/index.js

@@ -12,6 +12,8 @@ export { telegram } from './channels/telegram/@telegram.js';
 export { TelegramChannelConfig } from './channels/telegram/TelegramChannelConfig.js';
 export { TelegramChannel } from './channels/telegram/TelegramChannel.js';
 export { whatsapp } from './channels/whatsapp/@whatsapp.js';
+export { EnvWhatsAppRepository } from './channels/whatsapp/EnvWhatsAppRepository.js';
+export { PgWhatsAppRepository } from './channels/whatsapp/PgWhatsAppRepository.js';
 export { WhatsApp } from './channels/whatsapp/WhatsApp.js';
 export { WhatsAppChannel } from './channels/whatsapp/WhatsAppChannel.js';
 export { WhatsappChannelConfig } from './channels/whatsapp/WhatsAppChannelConfig.js';
@@ -20,10 +22,8 @@ export { WhatsAppReceiverByDevConnection } from './channels/whatsapp/WhatsAppRec
 export { WhatsAppReceiverByWebHook } from './channels/whatsapp/WhatsAppReceiverByWebHook.js';
 export { WhatsAppRepository } from './channels/whatsapp/WhatsAppRepository.js';
 export { WhatsAppSender } from './channels/whatsapp/WhatsAppSender.js';
-export { WhatsAppSenderByDevConnection } from './channels/whatsapp/WhatsAppSenderByDevConnection.js';
 export { WhatsAppSenderByCloudApi } from './channels/whatsapp/WhatsAppSenderByCloudApi.js';
-export { PgWhatsAppRepository } from './channels/whatsapp/PgWhatsAppRepository.js';
-export { EnvWhatsAppRepository } from './channels/whatsapp/EnvWhatsAppRepository.js';
+export { WhatsAppSenderByDevConnection } from './channels/whatsapp/WhatsAppSenderByDevConnection.js';
 export { chatBot } from './chatbot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './chatbot/metadata/ChatBotMetadataStore.js';
 export { ChatBot } from './chatbot/ChatBot.js';
@@ -39,8 +39,11 @@ export { ChatItem } from './core/chat/ChatItem.js';
 export { User } from './core/user/User.js';
 export { UserRepository } from './core/user/IUserRepository.js';
 export { MessageContext } from './core/IMessageContext.js';
-export { Persistent } from './core/Persistent.js';
+export { Entity, PersistentData } from './core/Entity.js';
+export { WabotEnv } from './env/WabotEnv.js';
+export { CustomError } from './error/CustomError.js';
 export { container, inject, injectable, singleton } from './injection/index.js';
+export { Logger } from './logger/Logger.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';
@@ -52,9 +55,6 @@ export { PARAM_DECORATION_IS_OPTIONAL, PARAM_DECORATION_PARAM } from './mindset/
 export { MindsetMetadataStore } from './mindset/metadata/MindsetMetadataStore.js';
 export { Mindset } from './mindset/IMindset.js';
 export { MindsetOperator } from './mindset/MindsetOperator.js';
-export { prepareChatContainer } from './server/prepareChatContainer.js';
-export { runChannel } from './server/runChannel.js';
-export { runServer } from './server/runServer.js';
 export { SendOneTimePasswordRequest } from './pre-made/module/authentication/requests/SendOneTimePasswordRequest.js';
 export { ValidateOneTimePasswordRequest } from './pre-made/module/authentication/requests/ValidateOneTimePasswordRequest.js';
 export { AuthenticationModule } from './pre-made/module/authentication/AuthenticationModule.js';
@@ -71,15 +71,18 @@ export { RamChatMemory } from './pre-made/repository/chat/ram/RamChatMemory.js';
 export { RamChatRepository } from './pre-made/repository/chat/ram/RamChatRepository.js';
 export { PgCrudRepository } from './repository/pg/PgCrudRepository.js';
 export { PgRepositoryBase } from './repository/pg/PgRepositoryBase.js';
-export { Logger } from './logger/Logger.js';
-export { WabotEnv } from './env/WabotEnv.js';
 export { get } from './rest-controller/metadata/@get.js';
+export { middleware } from './rest-controller/metadata/@middleware.js';
 export { post } from './rest-controller/metadata/@post.js';
 export { restController } from './rest-controller/metadata/@restController.js';
 export { RestControllerMetadataStore } from './rest-controller/metadata/RestControllerMetadataStore.js';
 export { runRestControllers } from './rest-controller/runRestControllers.js';
+export { prepareChatContainer } from './server/prepareChatContainer.js';
+export { runChannel } from './server/runChannel.js';
+export { runServer } from './server/runServer.js';
 export { isBoolean } from './validation/metadata/@isBoolean.js';
 export { isDate } from './validation/metadata/@isDate.js';
+export { isModel } from './validation/metadata/@isModel.js';
 export { isNotEmpty } from './validation/metadata/@isNotEmpty.js';
 export { isNumber } from './validation/metadata/@isNumber.js';
 export { isOptional } from './validation/metadata/@isOptional.js';
@@ -87,7 +90,6 @@ export { isPresent } from './validation/metadata/@isPresent.js';
 export { isString } from './validation/metadata/@isString.js';
 export { max } from './validation/metadata/@max.js';
 export { min } from './validation/metadata/@min.js';
-export { validable } from './validation/metadata/@validable.js';
 export { ValidationMetadataStore } from './validation/metadata/ValidationMetadataStore.js';
 export { validateIsBoolean } from './validation/validators/validateIsBoolean.js';
 export { validateIsDate } from './validation/validators/validateIsDate.js';
@@ -98,5 +100,5 @@ export { validateMax } from './validation/validators/validateMax.js';
 export { validateMin } from './validation/validators/validateMin.js';
 export { validateIsPresent } from './validation/validators/validateIsPresent.js';
 export { validateModel } from './validation/validators/validateModel.js';
-export { validateModel2 } from './validation/validateModel2.js';
+export { validate } from './validation/validate.js';
 export { Container } from './injection/Container.js';

package/dist/src/pre-made/repository/chat/ram/RamChatRepository.js

@@ -16,7 +16,7 @@ let RamChatRepository = class RamChatRepository {
         this.items.push(chat);
         const memory = {
             memory: new RamChatMemory(),
-            chatId: chat.getId(),
+            chatId: chat.id,
         };
         this.memories.push(memory);
     }

package/dist/src/repository/pg/PgCrudRepository.js

@@ -1,5 +1,6 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
+import { CustomError } from '../../error/CustomError.js';
 
 class PgCrudRepository extends PgRepositoryBase {
     config;
@@ -20,7 +21,10 @@ class PgCrudRepository extends PgRepositoryBase {
     async findOrThrow(id) {
         const item = await this.find(id);
         if (!item) {
-            throw new Error(`Not found ${this.config.constructor.name} with id = '${id}'`);
+            throw new CustomError({
+                message: `Not found ${this.config.constructor.name} with id = '${id}'}`,
+                httpCode: 404,
+            });
         }
         return item;
     }
@@ -53,10 +57,10 @@ class PgCrudRepository extends PgRepositoryBase {
          SET ${this.updates}
       WHERE id = $${this.columnsList.length + 1}
     `;
-        await this.exec(sql, [...this.values(item), item.getId()]);
+        await this.exec(sql, [...this.values(item), item.id]);
     }
     async discard(item) {
-        const _item = await this.find(item.getId());
+        const _item = await this.find(item.id);
         if (!_item) {
             throw new Error('Not found');
         }

package/dist/src/repository/pg/PgRepositoryBase.js

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

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

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

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

@@ -3,6 +3,7 @@ import { singleton } from 'tsyringe';
 
 let RestControllerMetadataStore = class RestControllerMetadataStore {
     endPoints = new Map();
+    middlewares = new Map();
     restControllers = new Map();
     saveControllerMetadata(controllerMetadata) {
         this.restControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
@@ -14,6 +15,17 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         controllerEndPoints.set(endPointMetadata.functionName, endPointMetadata);
     }
+    saveMiddlewareMetadata(middlewareMetadata) {
+        let controllerMiddlewares = this.middlewares.get(middlewareMetadata.controllerConstructor);
+        if (!controllerMiddlewares) {
+            this.middlewares.set(middlewareMetadata.controllerConstructor, (controllerMiddlewares = new Map()));
+        }
+        let methodMiddlewares = controllerMiddlewares.get(middlewareMetadata.functionName);
+        if (!methodMiddlewares) {
+            controllerMiddlewares.set(middlewareMetadata.functionName, (methodMiddlewares = []));
+        }
+        methodMiddlewares.unshift(middlewareMetadata);
+    }
     getControllerEndPointsInfo(controllerConstructor) {
         const controller = this.restControllers.get(controllerConstructor);
         if (!controller) {
@@ -26,6 +38,7 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         return [...endPoints.values()].map((endPoint) => ({
             ...endPoint,
+            middlewares: this.middlewares.get(endPoint.controllerConstructor)?.get(endPoint.functionName) ?? [],
             controller: this.restControllers.get(endPoint.controllerConstructor),
         }));
     }

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

@@ -1,7 +1,6 @@
-import '../injection/index.js';
-import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
 import '../controller/channel/ChatResolver.js';
 import '../controller/channel/UserResolver.js';
+import '../injection/index.js';
 import '../controller/metadata/ControllerMetadataStore.js';
 import '../channels/cmd/CmdChannel.js';
 import { ExpressProvider } from '../channels/express/ExpressProvider.js';
@@ -11,16 +10,20 @@ 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/WhatsAppSenderByDevConnection.js';
 import '../channels/whatsapp/WhatsAppSenderByCloudApi.js';
-import '../channels/whatsapp/PgWhatsAppRepository.js';
-import '../channels/whatsapp/EnvWhatsAppRepository.js';
-import path from 'path';
+import '../channels/whatsapp/WhatsAppSenderByDevConnection.js';
 import { Logger } from '../logger/Logger.js';
+import '../validation/metadata/ValidationMetadataStore.js';
+import { validate } from '../validation/validate.js';
+import path from 'path';
+import { RestControllerMetadataStore } from './metadata/RestControllerMetadataStore.js';
+import { CustomError } from '../error/CustomError.js';
 
 function buildRequest(req) {
     return Object.assign({}, req.body, req.query, req.params);
@@ -38,33 +41,49 @@ function runRestControllers(controllers, container) {
             logger.info(`config ${endPoint.method.toUpperCase()} ${route}`);
             expressApp[method](route, async (req, res) => {
                 const requestContainer = container.createChildContainer();
-                const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
-                const endPointArgs = [];
-                let defaultArgFound = false;
-                for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
-                    const paramType = endPoint.paramsTypes[paramIndex];
-                    if (defaultArgFound) {
-                        throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                try {
+                    const middlewares = endPoint.middlewares.map((x) => requestContainer.resolve(x.middlewareConstructor));
+                    for (const middleware of middlewares) {
+                        await middleware.handle(req, res, requestContainer);
                     }
-                    defaultArgFound = true;
-                    if (typeof paramType === 'function' && typeof paramType.__validate__ === 'function') {
-                        const { value, error } = paramType.__validate__(buildRequest(req));
-                        debugger;
-                        if (error) {
-                            res.status(400).json({ error });
-                            return;
+                    const controllerInstance = requestContainer.resolve(endPoint.controllerConstructor);
+                    const endPointArgs = [];
+                    let defaultArgFound = false;
+                    for (let paramIndex = 0; paramIndex < endPoint.paramsTypes.length; paramIndex++) {
+                        const paramType = endPoint.paramsTypes[paramIndex];
+                        if (defaultArgFound) {
+                            throw new Error(`Cant determine de parameter ${paramIndex} value`);
+                        }
+                        defaultArgFound = true;
+                        if (typeof paramType === 'function') {
+                            const { value, error } = validate(buildRequest(req), paramType);
+                            if (error) {
+                                throw new CustomError({ httpCode: 400, message: error.description, info: error });
+                            }
+                            endPointArgs.push(value);
                         }
-                        endPointArgs.push(value);
                     }
-                }
-                try {
                     const response = await controllerInstance[endPoint.functionName].apply(controllerInstance, endPointArgs);
                     res.status(200).json(response);
                 }
                 catch (err) {
-                    res.sendStatus(500);
+                    if (err instanceof Error) {
+                        const keys = Object.keys(err).filter((key) => !['message', 'stack'].includes(key));
+                        const { httpCode, ...info } = keys.reduce((acc, key) => {
+                            acc[key] = err[key];
+                            return acc;
+                        }, {});
+                        res
+                            .status(httpCode ?? 500)
+                            .json({ error: { message: err.message, stack: err.stack, ...info } });
+                    }
+                    else {
+                        res.status(500).json({ error: { message: 'Unknown error' } });
+                    }
+                }
+                finally {
+                    requestContainer.dispose();
                 }
-                requestContainer.dispose();
             });
         });
     });

package/dist/src/server/prepareChatContainer.js

@@ -19,9 +19,9 @@ async function prepareChatContainer(container, context, mindsetCtor) {
         useValue: new MessageContext(context.message, context.chat, context.user),
     });
     const chatRepository = container.resolve(ChatRepository);
-    const chatMemory = await chatRepository.findMemory(context.chat.getId());
+    const chatMemory = await chatRepository.findMemory(context.chat.id);
     if (!chatMemory) {
-        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.getId());
+        throw new Error('Not found Chat Memory for Chat with Id=' + context.chat.id);
     }
     chatContainer.register(ChatMemory, { useValue: chatMemory });
     const chatBotMetadataStore = container.resolve(ChatBotMetadataStore);

package/dist/src/validation/metadata/@isModel.js

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

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

@@ -2,10 +2,10 @@ import { container } from '../injection/index.js';
 import { ValidationMetadataStore } from './metadata/ValidationMetadataStore.js';
 import { validateModel } from './validators/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/validators/validateModel.js

@@ -2,11 +2,7 @@ function validateModel(value, info) {
     const result = {};
     if (typeof value !== 'object') {
         result.error = {
-            model: [
-                {
-                    description: `the value should be an object`,
-                },
-            ],
+            description: 'the value should be an object',
             properties: [],
         };
         return result;
@@ -26,7 +22,7 @@ function validateModel(value, info) {
             if (propertyValidatorResult.error) {
                 let resultError = result.error;
                 if (!resultError) {
-                    resultError = { model: [], properties: [] };
+                    resultError = { description: `Error on properties`, properties: [] };
                     result.error = resultError;
                 }
                 let propertyErrors = resultError.properties.find((x) => x.name === propertyName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.1.0-beta.10",
+  "version": "0.1.0-beta.12",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",

package/dist/src/validation/metadata/@validable.js

@@ -1,14 +0,0 @@
-import { container } from 'tsyringe';
-import { ValidationMetadataStore } from './ValidationMetadataStore.js';
-import { validateModel } from '../validators/validateModel.js';
-
-function validable() {
-    return function (target) {
-        target.__validate__ = function (value) {
-            const info = container.resolve(ValidationMetadataStore).getModelValidatorsInfo(target);
-            return validateModel(value, info);
-        };
-    };
-}
-
-export { validable };