@wabot-dev/framework 0.5.0 → 0.5.2

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

@@ -1,5 +1,6 @@
 import { Entity } from '../../core/entity/Entity.js';
 import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
 
 class Job extends Entity {
     get commandName() {

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

@@ -35,7 +35,14 @@ let JobExecutor = class JobExecutor {
             });
         }
         catch (e) {
-            this.logger.error(e);
+            this.logger.error(`Job ${job.id} execution error:`, e);
+            try {
+                job.setAsFailed(e instanceof Error ? e : new Error('Job execution error'));
+                await this.repo.update(job);
+            }
+            catch (updateError) {
+                this.logger.error(`Failed to update job ${job.id} status:`, updateError);
+            }
         }
         finally {
             this.release();

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

@@ -1,6 +1,7 @@
 import { __decorate, __metadata } from 'tslib';
 import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { JobRepository } from './JobRepository.js';
+import { Job } from './Job.js';
 import { singleton, container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
@@ -8,21 +9,23 @@ import { validateAndTransform } from '../../core/validation/validateAndTransform
 
 let JobRunner = class JobRunner {
     jobRepository;
-    handlerContainer;
+    asyncMetadataStore;
     logger = new Logger('wabot:job-runner');
-    constructor(jobRepository, handlerContainer) {
+    constructor(jobRepository, asyncMetadataStore) {
         this.jobRepository = jobRepository;
-        this.handlerContainer = handlerContainer;
+        this.asyncMetadataStore = asyncMetadataStore;
     }
     async run(job) {
+        const jobRunnerContainer = container.createChildContainer();
         try {
             const { commandName, commandData } = job;
-            const handlerConstructor = this.handlerContainer.getHandlerForCommandName(commandName);
+            const handlerConstructor = this.asyncMetadataStore.getHandlerForCommandName(commandName);
             if (!handlerConstructor) {
                 throw new Error(`Not found handler for command '${commandName}'`);
             }
-            const handler = container.resolve(handlerConstructor);
-            const commandConstructor = this.handlerContainer.getCommandForCommandName(commandName);
+            jobRunnerContainer.registerInstance(Job, job);
+            const handler = jobRunnerContainer.resolve(handlerConstructor);
+            const commandConstructor = this.asyncMetadataStore.getCommandForCommandName(commandName);
             if (commandConstructor === undefined && commandData != undefined) {
                 throw new Error(`Not found class for validate data of command '${commandName}'`);
             }
@@ -47,6 +50,7 @@ let JobRunner = class JobRunner {
         }
         finally {
             await this.jobRepository.update(job);
+            await jobRunnerContainer.dispose();
         }
     }
 };

package/dist/src/feature/chat-bot/safeJsonParse.js

@@ -0,0 +1,19 @@
+import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
+
+function safeJsonParse(json, context) {
+    const input = json || '{}';
+    try {
+        return JSON.parse(input);
+    }
+    catch (error) {
+        throw new CustomError({
+            message: `Failed to parse JSON${context ? ` in ${context}` : ''}: ${input}`,
+            code: 'JSON_PARSE_ERROR',
+            httpCode: 400,
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+}
+
+export { safeJsonParse };

package/dist/src/feature/chat-controller/ChatResolver.js

@@ -5,11 +5,15 @@ import { ChatRepository } from '../chat-bot/ChatRepository.js';
 import { injectable } from '../../core/injection/index.js';
 import 'uuid';
 import '../chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../core/error/setupErrorHandlers.js';
+import { Locker } from '../../core/lock/Locker.js';
 
 let ChatResolver = class ChatResolver {
     chatRepository;
-    constructor(chatRepository) {
+    locker;
+    constructor(chatRepository, locker) {
         this.chatRepository = chatRepository;
+        this.locker = locker;
     }
     async resolve(connection) {
         if (connection.chatType === 'GROUP') {
@@ -18,25 +22,47 @@ let ChatResolver = class ChatResolver {
         return this.resolvePrivateChat(connection);
     }
     async resolveGroupChat(connection) {
+        // Fast path: check without lock
         let chat = await this.chatRepository.findByConnection(connection);
-        if (!chat) {
-            chat = new Chat({ type: 'GROUP', connections: [connection] });
-            await this.chatRepository.create(chat);
+        if (chat) {
+            return chat;
         }
-        return chat;
+        // Slow path: acquire lock and double-check
+        const lockKey = this.buildLockKey(connection);
+        return this.locker.withKey(lockKey).run(async () => {
+            chat = await this.chatRepository.findByConnection(connection);
+            if (!chat) {
+                chat = new Chat({ type: 'GROUP', connections: [connection] });
+                await this.chatRepository.create(chat);
+            }
+            return chat;
+        });
     }
     async resolvePrivateChat(connection) {
+        // Fast path: check without lock
         let chat = await this.chatRepository.findByConnection(connection);
-        if (!chat) {
-            chat = new Chat({ type: 'PRIVATE', connections: [connection] });
-            await this.chatRepository.create(chat);
+        if (chat) {
+            return chat;
         }
-        return chat;
+        // Slow path: acquire lock and double-check
+        const lockKey = this.buildLockKey(connection);
+        return this.locker.withKey(lockKey).run(async () => {
+            chat = await this.chatRepository.findByConnection(connection);
+            if (!chat) {
+                chat = new Chat({ type: 'PRIVATE', connections: [connection] });
+                await this.chatRepository.create(chat);
+            }
+            return chat;
+        });
+    }
+    buildLockKey(connection) {
+        return `chat-resolver:${connection.channelName}:${connection.id}`;
     }
 };
 ChatResolver = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [ChatRepository])
+    __metadata("design:paramtypes", [ChatRepository,
+        Locker])
 ], ChatResolver);
 
 export { ChatResolver };

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -1,11 +1,13 @@
 import { Auth } from '../../core/auth/Auth.js';
 import { container } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
 import { Chat } from '../chat-bot/Chat.js';
 import { ChatBot } from '../chat-bot/ChatBot.js';
 import { ChatMemory } from '../chat-bot/ChatMemory.js';
 import { ChatRepository } from '../chat-bot/ChatRepository.js';
 import 'uuid';
 import { ChatBotMetadataStore } from '../chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../core/error/setupErrorHandlers.js';
 import '../mindset/metadata/MindsetMetadataStore.js';
 import { Mindset } from '../mindset/IMindset.js';
 import '../mindset/MindsetOperator.js';
@@ -39,6 +41,7 @@ async function prepareChatContainer(container, messageContext, mindsetCtor) {
     }
     return chatContainer;
 }
+const logger = new Logger('wabot:chat-controller');
 function runChatControllers(controllers) {
     const metadataStore = container.resolve(ControllerMetadataStore);
     const chatResolver = container.resolve(ChatResolver);
@@ -71,7 +74,12 @@ function runChatControllers(controllers) {
                     message: channelMessage.message,
                     reply: channelMessage.reply,
                 };
-                chatController[channelMetadata.functionName](receivedMessage);
+                try {
+                    await chatController[channelMetadata.functionName](receivedMessage);
+                }
+                catch (error) {
+                    logger.error(`Error in chat controller ${channelMetadata.controllerConstructor.name}.${channelMetadata.functionName}:`, error);
+                }
             });
             channel.connect();
         }

package/dist/src/feature/mindset/MindsetOperator.js

@@ -5,6 +5,7 @@ import { MindsetMetadataStore } from './metadata/MindsetMetadataStore.js';
 import { validateModel } from '../../core/validation/core/validateModel.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
 import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
 import { Container } from '../../core/injection/Container.js';
 
 let MindsetOperator = class MindsetOperator {
@@ -114,7 +115,11 @@ let MindsetOperator = class MindsetOperator {
             .flat()
             .find((fn) => fn.name === name);
         if (!fnMetadata) {
-            throw new Error(`Function ${name} not found`);
+            throw new CustomError({
+                httpCode: 400,
+                code: 'FUNCTION_NOT_WHITELISTED',
+                message: `Function '${name}' is not registered in mindset tools`,
+            });
         }
         try {
             let paramsObj = JSON.parse(params);

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

@@ -1,6 +1,7 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
 import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
 import { withPgClient } from './withPgClient.js';
 
 class PgCrudRepository extends PgRepositoryBase {

package/dist/src/feature/pg/PgLocker.js

@@ -9,7 +9,7 @@ let PgLocker = class PgLocker {
         this.pool = pool;
     }
     withKey(key) {
-        return new PgLockKey(key, this.pool);
+        return new PgLockKey(typeof key === 'object' ? key.lockerKey() : key, this.pool);
     }
 };
 PgLocker = __decorate([

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

@@ -89,10 +89,10 @@ class PgRepositoryBase {
         const existingColumns = new Set(existing.map((col) => col.column_name));
         for (let i = 0; i < this.columnsList.length; i++) {
             const col = this.columnsList[i];
-            const columnAndType = this.columnsAndTypes[0];
+            const columnAndType = this.columnsAndTypes[i];
             if (!existingColumns.has(col)) {
                 const alterSql = `ALTER TABLE ${this.table} ADD COLUMN ${columnAndType}`;
-                console.log(`[INFO] Adding column: ${alterSql}`);
+                this.logger.info(`Adding column: ${alterSql}`);
                 await client.query(alterSql);
             }
         }

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

@@ -1,4 +1,5 @@
 import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import { validateModel } from '../../core/validation/core/validateModel.js';

package/dist/src/feature/socket/SocketServerConfig.js

@@ -0,0 +1,25 @@
+import { __decorate, __metadata } from 'tslib';
+import { Env } from '../../core/env/Env.js';
+import { singleton } from '../../core/injection/index.js';
+
+let SocketServerConfig = class SocketServerConfig {
+    corsOrigin;
+    constructor(env) {
+        const origin = env.requireString('SOCKET_CORS_ORIGIN', { default: '' });
+        if (!origin) {
+            this.corsOrigin = false;
+        }
+        else if (origin === '*') {
+            this.corsOrigin = '*';
+        }
+        else {
+            this.corsOrigin = origin.split(',').map((o) => o.trim());
+        }
+    }
+};
+SocketServerConfig = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], SocketServerConfig);
+
+export { SocketServerConfig };

package/dist/src/feature/socket/SocketServerProvider.js

@@ -3,13 +3,16 @@ import { singleton } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import { HttpServerProvider } from '../http/HttpServerProvider.js';
 import { Server } from 'socket.io';
+import { SocketServerConfig } from './SocketServerConfig.js';
 
 let SocketServerProvider = class SocketServerProvider {
     httpServerProvider;
+    config;
     socketServer = null;
     logger = new Logger('wabot:socket');
-    constructor(httpServerProvider) {
+    constructor(httpServerProvider, config) {
         this.httpServerProvider = httpServerProvider;
+        this.config = config;
     }
     getSocketServer() {
         if (!this.socketServer) {
@@ -20,11 +23,19 @@ let SocketServerProvider = class SocketServerProvider {
     listen() {
         this.httpServerProvider.listen();
     }
+    close() {
+        if (this.socketServer) {
+            this.socketServer.removeAllListeners();
+            this.socketServer.close();
+            this.socketServer = null;
+            this.logger.info('socket server closed');
+        }
+    }
     createSocketServer() {
         const httpServer = this.httpServerProvider.getHttpServer();
         const socketServer = new Server(httpServer, {
             cors: {
-                origin: '*',
+                origin: this.config.corsOrigin,
             },
         });
         socketServer.on('connection', (socket) => {
@@ -44,7 +55,8 @@ let SocketServerProvider = class SocketServerProvider {
 };
 SocketServerProvider = __decorate([
     singleton(),
-    __metadata("design:paramtypes", [HttpServerProvider])
+    __metadata("design:paramtypes", [HttpServerProvider,
+        SocketServerConfig])
 ], SocketServerProvider);
 
 export { SocketServerProvider };

package/dist/src/feature/socket-controller/runSocketControllers.js

@@ -1,9 +1,11 @@
 import { CustomError } from '../../core/error/CustomError.js';
+import '../../core/error/setupErrorHandlers.js';
 import { container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
 import '../../core/validation/metadata/ValidationMetadataStore.js';
 import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
 import { Socket } from 'socket.io';
+import '../socket/SocketServerConfig.js';
 import { SocketServerProvider } from '../socket/SocketServerProvider.js';
 import { SocketControllerMetadataStore } from './metadata/SocketControllerMetadataStore.js';
 

package/dist/src/index.d.ts

@@ -30,6 +30,21 @@ declare class Auth<D> {
     wasOverrided(): boolean;
 }
 
+interface ILockKey {
+    run<T>(fn: () => Promise<T>): Promise<T>;
+    tryRun<T>(fn: () => Promise<T>): Promise<T | undefined>;
+}
+
+interface ILockerKey {
+    lockerKey(): string | number;
+}
+interface ILocker {
+    withKey(key: string | number | ILockerKey): ILockKey;
+}
+declare class Locker implements ILocker {
+    withKey(key: string | number | ILockerKey): ILockKey;
+}
+
 type IStorableData<O extends object> = {
     [K in keyof O]: IStorableType<O[K]>;
 };
@@ -44,7 +59,7 @@ interface IEntityData {
     createdAt?: number | null;
     discardedAt?: number | null;
 }
-declare class Entity<D extends IEntityData> extends Storable<D> {
+declare class Entity<D extends IEntityData> extends Storable<D> implements ILockerKey {
     get id(): NonNullable<IStorableType<D["id"]>>;
     /**
      * @deprecated use id
@@ -58,6 +73,7 @@ declare class Entity<D extends IEntityData> extends Storable<D> {
     update(newData: Partial<Omit<D, 'id' | 'createdAt' | 'discardedAt'>>): void;
     wasCreated(): boolean;
     validate(): void;
+    lockerKey(): string | number;
 }
 /**
  * @deprecated Should use IEntityData
@@ -101,6 +117,44 @@ declare class CustomError extends Error {
     constructor(data: ICustomErrorData);
 }
 
+type ErrorSeverity = 'warning' | 'error' | 'fatal';
+interface IErrorMonitorContext {
+    logger: string;
+    level: ErrorSeverity;
+    timestamp: Date;
+    extra?: Record<string, unknown>;
+}
+interface IErrorMonitor {
+    captureError(error: Error, context: IErrorMonitorContext): void;
+    captureMessage(message: string, context: IErrorMonitorContext): void;
+}
+
+declare class Logger {
+    private static monitor;
+    private debuggers;
+    private name;
+    constructor(name: string);
+    static setMonitor(monitor: IErrorMonitor): void;
+    static getMonitor(): IErrorMonitor | null;
+    trace(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    fatal(...args: any[]): void;
+    private log;
+    private sendToMonitor;
+    private extractExtra;
+    private formatArgs;
+}
+
+interface IErrorHandlersConfig {
+    exitOnUncaughtException?: boolean;
+    exitOnUnhandledRejection?: boolean;
+    logger?: Logger;
+}
+declare function setupErrorHandlers(config?: IErrorHandlersConfig): void;
+
 type IConstructor<T> = new (...args: any[]) => T;
 
 declare class Container implements DependencyContainer {
@@ -126,18 +180,6 @@ declare const inject: typeof tsyringe.inject;
 declare const scoped: typeof tsyringe.scoped;
 declare const Lifecycle: typeof tsyringe.Lifecycle;
 
-declare class Logger {
-    private debuggers;
-    constructor(name: string);
-    trace(...args: any[]): void;
-    debug(...args: any[]): void;
-    info(...args: any[]): void;
-    warn(...args: any[]): void;
-    error(...args: any[]): void;
-    fatal(...args: any[]): void;
-    private log;
-}
-
 declare function isModel(model: IConstructor<any>): (target: object, propertyKey: string | symbol) => void;
 
 declare function isOptional(): (target: object, propertyKey: string | symbol) => void;
@@ -341,18 +383,6 @@ declare class DescriptionMetadataStore {
     getModelDescriptions(model: IConstructor<any>): IDescriptionMetadata[];
 }
 
-interface ILockKey {
-    run<T>(fn: () => Promise<T>): Promise<T>;
-    tryRun<T>(fn: () => Promise<T>): Promise<T | undefined>;
-}
-
-interface ILocker {
-    withKey(key: string | number): ILockKey;
-}
-declare class Locker implements ILocker {
-    withKey(key: string | number): ILockKey;
-}
-
 interface ICommandConfig {
     name: string;
 }
@@ -471,9 +501,9 @@ declare class JobRepository implements IJobRepository {
 
 declare class JobRunner {
     private jobRepository;
-    private handlerContainer;
+    private asyncMetadataStore;
     private logger;
-    constructor(jobRepository: JobRepository, handlerContainer: AsyncMetadataStore);
+    constructor(jobRepository: JobRepository, asyncMetadataStore: AsyncMetadataStore);
     run(job: Job): Promise<void>;
 }
 
@@ -507,12 +537,24 @@ declare class JobScheduler {
     private tick;
 }
 
+type IScheduleDelay = {
+    seconds: number;
+} | {
+    minutes: number;
+} | {
+    hours: number;
+} | {
+    days: number;
+};
+type IScheduleAt = Date | IScheduleDelay;
 declare class Async {
     private jobRepository;
     private metadataStore;
     private jobScheduler;
     constructor(jobRepository: JobRepository, metadataStore: AsyncMetadataStore, jobScheduler: JobScheduler);
     runCommand<T>(ctor: IConstructor<T>, data: IValidateInputShape<T>): Promise<Job>;
+    scheduleCommand<T>(ctor: IConstructor<T>, data: IValidateInputShape<T>, scheduledAt: IScheduleAt): Promise<Job>;
+    private resolveScheduledDate;
 }
 
 interface ICronJobData extends IEntityData {
@@ -884,6 +926,8 @@ declare class ChatBotMetadataStore {
     getChatBotsMetadata(): IChatBotMetadata[];
 }
 
+declare function safeJsonParse<T = unknown>(json: string | undefined | null, context?: string): T;
+
 interface IchatControllerConfig {
 }
 
@@ -906,6 +950,7 @@ interface IChannelMessage extends IReceivedMessage {
 interface IChatChannel {
     listen(callback: (received: IChannelMessage) => Promise<void>): void;
     connect(): void;
+    disconnect(): void;
 }
 
 interface IChannelMetadata {
@@ -928,10 +973,12 @@ declare class ControllerMetadataStore {
 
 declare class ChatResolver {
     private chatRepository;
-    constructor(chatRepository: ChatRepository);
+    private locker;
+    constructor(chatRepository: ChatRepository, locker: Locker);
     resolve(connection: IChatConnection): Promise<Chat>;
     private resolveGroupChat;
     private resolvePrivateChat;
+    private buildLockKey;
 }
 
 interface IMessageContext extends IReceivedMessage {
@@ -1040,7 +1087,7 @@ declare class PgCrudRepository<P extends Entity<IEntityData>> extends PgReposito
 declare class PgLocker implements ILocker {
     private readonly pool;
     constructor(pool: Pool);
-    withKey(key: string | number): ILockKey;
+    withKey(key: string | number | ILockerKey): ILockKey;
 }
 
 declare class PgLockKey implements ILockKey {
@@ -1147,13 +1194,20 @@ declare class RestRequest {
     headers?: Record<string, string>;
 }
 
+declare class SocketServerConfig {
+    corsOrigin: string | string[];
+    constructor(env: Env);
+}
+
 declare class SocketServerProvider {
     private httpServerProvider;
+    private config;
     private socketServer;
     private logger;
-    constructor(httpServerProvider: HttpServerProvider);
+    constructor(httpServerProvider: HttpServerProvider, config: SocketServerConfig);
     getSocketServer(): Server$1;
     listen(): void;
+    close(): void;
     private createSocketServer;
 }
 
@@ -1516,6 +1570,7 @@ declare class CmdChannel implements IChatChannel {
     private callBack;
     constructor(auth: Auth<any>);
     listen(callback: (message: IChannelMessage) => Promise<void>): void;
+    disconnect(): void;
     connect(): void;
 }
 declare function writeJsonToFile<T>(filename: string, data: T): void;
@@ -1552,6 +1607,7 @@ declare class SocketChannel implements IChatChannel {
     private configController;
     listen(callback: (message: IChannelMessage) => Promise<void>): void;
     connect(): void;
+    disconnect(): void;
 }
 
 interface ITelegramChannelConfig {
@@ -1570,6 +1626,7 @@ declare class TelegramChannel implements IChatChannel {
     constructor(config: TelegramChannelConfig);
     listen(callback: (message: IChannelMessage) => Promise<void>): void;
     connect(): void;
+    disconnect(): void;
 }
 
 interface IWhatsappChannelConfig {
@@ -1638,6 +1695,7 @@ interface IListenWhatsAppMessageRequest {
 }
 declare class WhatsAppReceiver {
     connect(): Promise<void>;
+    disconnect(): void;
     listenMessage(request: IListenWhatsAppMessageRequest): void;
 }
 
@@ -1735,6 +1793,7 @@ declare class WhatsAppChannel implements IChatChannel {
     constructor(config: WhatsappChannelConfig, sender: WhatsAppSender, receiver: WhatsAppReceiver);
     listen(callback: (message: IChannelMessage) => Promise<void>): void;
     connect(): void;
+    disconnect(): void;
 }
 
 interface IWhatsAppCloudWebhookPayload {
@@ -1874,4 +1933,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CronJob, CronJobRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatAssociation, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronJobData, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, cron, description, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, stopCommandHandlers, stopCronHandlers, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, withPgClient, withPgTransaction, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CronJob, CronJobRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, type ErrorSeverity, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatAssociation, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronJobData, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IErrorHandlersConfig, type IErrorMonitor, type IErrorMonitorContext, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type ILockerKey, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type IScheduleAt, type IScheduleDelay, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerConfig, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, cron, description, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, safeJsonParse, scoped, setupErrorHandlers, singleton, socket, socketController, stopCommandHandlers, stopCronHandlers, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, withPgClient, withPgTransaction, writeJsonToFile };

package/dist/src/index.js

@@ -2,6 +2,7 @@ export { Auth } from './core/auth/Auth.js';
 export { Entity, Persistent } from './core/entity/Entity.js';
 export { Env } from './core/env/Env.js';
 export { CustomError } from './core/error/CustomError.js';
+export { setupErrorHandlers } from './core/error/setupErrorHandlers.js';
 export { Lifecycle, container, inject, injectable, scoped, singleton } from './core/injection/index.js';
 export { Logger } from './core/logger/Logger.js';
 export { Mapper } from './core/mapper/Mapper.js';
@@ -60,6 +61,7 @@ export { ChatRepository } from './feature/chat-bot/ChatRepository.js';
 export { chatItemTypeOptions } from './feature/chat-bot/IChatItem.js';
 export { chatBot } from './feature/chat-bot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './feature/chat-bot/metadata/ChatBotMetadataStore.js';
+export { safeJsonParse } from './feature/chat-bot/safeJsonParse.js';
 export { chatController } from './feature/chat-controller/metadata/controller/@chatController.js';
 export { ControllerMetadataStore } from './feature/chat-controller/metadata/ControllerMetadataStore.js';
 export { ChatResolver } from './feature/chat-controller/ChatResolver.js';
@@ -90,6 +92,7 @@ export { RestControllerMetadataStore } from './feature/rest-controller/metadata/
 export { runRestControllers } from './feature/rest-controller/runRestControllers.js';
 export { EXPRESS_REQ, EXPRESS_RES } from './feature/rest-controller/injection-tokens.js';
 export { RestRequest } from './feature/rest-controller/RestRequest.js';
+export { SocketServerConfig } from './feature/socket/SocketServerConfig.js';
 export { SocketServerProvider } from './feature/socket/SocketServerProvider.js';
 export { handshakeMiddlewares } from './feature/socket-controller/metadata/@handshakeMiddlewares.js';
 export { socketController } from './feature/socket-controller/metadata/@socketController.js';