@wabot-dev/framework 0.0.13 → 0.0.16

package/dist/src/channels/cmd/@cmd.js

@@ -4,6 +4,8 @@ import { container } from '../../injection/index.js';
 import '../../core/chat/repository/IChatRepository.js';
 import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
 import { CmdChannel } from './CmdChannel.js';
 
 function cmd() {

package/dist/src/channels/cmd/CmdChannel.js

@@ -5,6 +5,8 @@ import { injectable } from '../../injection/index.js';
 import '../../core/chat/repository/IChatRepository.js';
 import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
 import * as readline from 'readline';
 
 var CmdChannel_1;

package/dist/src/channels/telegram/@telegram.js

@@ -4,6 +4,8 @@ import '../../controller/channel/UserResolver.js';
 import '../../core/chat/repository/IChatRepository.js';
 import '../../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
 import { TelegramChannel } from './TelegramChannel.js';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

package/dist/src/channels/telegram/TelegramChannel.js

@@ -5,6 +5,8 @@ import { injectable } from '../../injection/index.js';
 import '../../core/chat/repository/IChatRepository.js';
 import '../../core/user/IUserRepository.js';
 import '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
 import { Bot } from 'grammy';
 import { TelegramChannelConfig } from './TelegramChannelConfig.js';
 

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

@@ -0,0 +1,24 @@
+import { container } from '../../injection/index.js';
+import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
+import '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import { ControllerMetadataStore } from '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
+import { WhatsAppChannel } from './WhatsAppChannel.js';
+
+function whatsapp(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsappChannelConfig(config.number),
+        });
+    };
+}
+
+export { whatsapp };

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

@@ -0,0 +1,63 @@
+import { __decorate, __metadata } from 'tslib';
+import { ChatResolver } from '../../controller/channel/ChatResolver.js';
+import { UserResolver } from '../../controller/channel/UserResolver.js';
+import { injectable } from '../../injection/index.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
+import { WabotEnv } from '../../env/WabotEnv.js';
+import { Logger } from '../../logger/Logger.js';
+import { WhatsappChannelConfig } from './WhatsAppChannelConfig.js';
+import { WhatsAppDevConnection } from './WhatsAppDevConnection.js';
+import { WhatsAppProdConnection } from './WhatsAppProdConnection.js';
+
+let WhatsAppChannel = class WhatsAppChannel {
+    config;
+    chatResolver;
+    userResolver;
+    wabotEnv;
+    logger = new Logger('wabot:whatsapp-channel');
+    whatsAppConection;
+    constructor(config, chatResolver, userResolver, wabotEnv, devConnection, prodConnection) {
+        this.config = config;
+        this.chatResolver = chatResolver;
+        this.userResolver = userResolver;
+        this.wabotEnv = wabotEnv;
+        this.whatsAppConection = this.wabotEnv.isProduction() ? prodConnection : devConnection;
+    }
+    listen(callback) {
+        this.whatsAppConection.listenMessage(this.config.number, async (message) => {
+            try {
+                const chat = await this.chatResolver.resolve(message.chatConnection);
+                const user = await this.userResolver.resolve(message.userConnection);
+                callback({
+                    chat,
+                    user,
+                    message,
+                    reply: (replyMessage) => {
+                        this.whatsAppConection.sendWhatsApp(this.config.number, message.userConnection.id, replyMessage);
+                    },
+                });
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        });
+    }
+    connect() {
+        this.whatsAppConection.connect();
+    }
+};
+WhatsAppChannel = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsappChannelConfig,
+        ChatResolver,
+        UserResolver,
+        WabotEnv,
+        WhatsAppDevConnection,
+        WhatsAppProdConnection])
+], WhatsAppChannel);
+
+export { WhatsAppChannel };

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

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

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

@@ -0,0 +1,61 @@
+import 'debug';
+
+class WhatsAppConnection {
+    logger;
+    listeners = new Map();
+    constructor(logger) {
+        this.logger = logger;
+    }
+    listenMessage(businessNumber, listener) {
+        this.listeners.set(businessNumber, listener);
+    }
+    async handlePayload(payload) {
+        try {
+            for (const entry of payload.entry) {
+                for (const change of entry.changes) {
+                    if (change.field !== 'messages' || !change.value.messages || !change.value.contacts) {
+                        continue;
+                    }
+                    for (const message of change.value.messages) {
+                        const contact = change.value.contacts.find((x) => x.wa_id === message.from);
+                        if (!contact) {
+                            continue;
+                        }
+                        await this.emmitMessage(change.value.metadata, message, contact);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+    }
+    async emmitMessage(metadata, message, contact) {
+        const listener = this.listeners.get(metadata.display_phone_number);
+        if (!listener) {
+            return;
+        }
+        if (message.type !== 'text') {
+            this.logger.error(`message type ${message.type} is not supported yet`);
+            return;
+        }
+        const channelName = 'WhatsAppChannel';
+        const chatConnection = {
+            id: contact.wa_id,
+            chatType: 'PRIVATE',
+            channelName,
+        };
+        const userConnection = {
+            id: contact.wa_id,
+            channelName,
+        };
+        await listener({
+            chatConnection,
+            userConnection,
+            senderName: contact.profile.name,
+            text: message.text.body,
+        });
+    }
+}
+
+export { WhatsAppConnection };

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

@@ -0,0 +1,61 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../injection/index.js';
+import { Logger } from '../../logger/Logger.js';
+import { io } from 'socket.io-client';
+import { WhatsAppConnection } from './WhatsAppConnection.js';
+import { devWhatsappEmitEvent, devWhatsAppListentEvent } from './whatsAppDevSocketContracts.js';
+
+let WhatsAppDevConnection = class WhatsAppDevConnection extends WhatsAppConnection {
+    devProxy;
+    devProxySocket;
+    devToken;
+    connected = false;
+    constructor() {
+        super(new Logger('wabot:whatsapp-dev-connection'));
+        this.devProxy = process.env.WABOT_DEV_PROXY ?? 'https://proxy.wabot.dev';
+        this.devToken = process.env.WABOT_DEV_TOKEN;
+        this.devProxySocket = io(this.devProxy, { autoConnect: false });
+    }
+    async sendWhatsApp(businessNumber, to, chatMessage) {
+        const req = {
+            from: businessNumber,
+            to,
+            message: chatMessage,
+        };
+        await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_SEND_WHATSAPP, req);
+    }
+    connect() {
+        if (this.connected) {
+            return;
+        }
+        this.connected = true;
+        this.devProxySocket.connect();
+        this.devProxySocket.on('connect', async () => {
+            if (!this.devToken) {
+                return;
+            }
+            try {
+                const req = {
+                    token: this.devToken,
+                };
+                const ack = await this.devProxySocket.emitWithAck(devWhatsappEmitEvent.DEV_CONNECTION, req);
+                if (ack != 'OK') {
+                    return this.logger.debug('dev connection fails');
+                }
+                this.devProxySocket.on(devWhatsAppListentEvent.DEV_WATSAPP_WEBHOOK, async (payload) => {
+                    await this.handlePayload(payload);
+                });
+                return this.logger.debug('success dev connection');
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        });
+    }
+};
+WhatsAppDevConnection = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], WhatsAppDevConnection);
+
+export { WhatsAppDevConnection };

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

@@ -0,0 +1,36 @@
+import { __decorate, __param, __metadata } from 'tslib';
+import '../../controller/channel/ChatResolver.js';
+import '../../controller/channel/UserResolver.js';
+import { inject } from '../../injection/index.js';
+import '../../core/chat/repository/IChatRepository.js';
+import '../../core/user/IUserRepository.js';
+import '../../controller/metadata/ControllerMetadataStore.js';
+import { ExpressApp } from '../../controller/express/Express.js';
+import 'socket.io';
+import { singleton } from 'tsyringe';
+
+let WhatsAppProdConnection = class WhatsAppProdConnection {
+    express;
+    constructor(express) {
+        this.express = express;
+        this.express.get('/try-express', (req, res) => {
+            res.status(200).json({ success: true });
+        });
+    }
+    listenMessage(businessNumber, listener) {
+        throw new Error('Method not implemented.');
+    }
+    sendWhatsApp(businessNumber, to, replyMessage) {
+        throw new Error('Method not implemented.');
+    }
+    connect() {
+        throw new Error('Method not implemented.');
+    }
+};
+WhatsAppProdConnection = __decorate([
+    singleton(),
+    __param(0, inject(ExpressApp)),
+    __metadata("design:paramtypes", [Function])
+], WhatsAppProdConnection);
+
+export { WhatsAppProdConnection };

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

@@ -0,0 +1,9 @@
+const devWhatsAppListentEvent = {
+    DEV_WATSAPP_WEBHOOK: 'dev-whatsapp-webhook',
+};
+const devWhatsappEmitEvent = {
+    DEV_CONNECTION: 'dev-connection',
+    DEV_SEND_WHATSAPP: 'dev-send-whatsapp',
+};
+
+export { devWhatsAppListentEvent, devWhatsappEmitEvent };

package/dist/src/controller/express/Express.js

@@ -0,0 +1,5 @@
+import 'express';
+
+const ExpressApp = Symbol.for('ExpressApp');
+
+export { ExpressApp };

package/dist/src/controller/socket.io/SocketIO.js

@@ -0,0 +1,5 @@
+import 'socket.io';
+
+const SocketIoApp = Symbol.for('SocketIoApp');
+
+export { SocketIoApp };

package/dist/src/env/WabotEnv.js

@@ -0,0 +1,21 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from 'tsyringe';
+
+let WabotEnv = class WabotEnv {
+    envType;
+    constructor() {
+        this.envType = process.env.WABOT_ENV ?? 'development';
+    }
+    isDevelopment() {
+        return this.envType === 'development';
+    }
+    isProduction() {
+        return this.envType === 'production';
+    }
+};
+WabotEnv = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [])
+], WabotEnv);
+
+export { WabotEnv };

package/dist/src/index.d.ts

@@ -1,12 +1,15 @@
 import InjectionToken from 'tsyringe/dist/typings/providers/injection-token';
 import DependencyContainer, { PreResolutionInterceptorCallback, PostResolutionInterceptorCallback } from 'tsyringe/dist/typings/types/dependency-container';
 import InterceptionOptions from 'tsyringe/dist/typings/types/interceptor-options';
+import { Express } from 'express';
+export { Express } from 'express';
 import * as tsyringe from 'tsyringe';
 import { DependencyContainer as DependencyContainer$1 } from 'tsyringe';
 export { DependencyContainer } from 'tsyringe';
 import { Pool } from 'pg';
 import { Database } from 'sqlite';
 import sqlite3 from 'sqlite3';
+export { Server as SocketIo } from 'socket.io';
 
 interface IMindsetFunctionConfig {
     description: string;
@@ -423,6 +426,10 @@ declare class ControllerMetadataStore {
     } | null;
 }
 
+declare const ExpressApp: unique symbol;
+
+declare const SocketIoApp: unique symbol;
+
 declare class CmdChannel implements IChatChannel {
     private chatResolver;
     private userResolver;
@@ -453,6 +460,153 @@ declare class TelegramChannel implements IChatChannel {
     connect(): void;
 }
 
+interface IWhatsappChannelConfig {
+    number: string;
+    proxy?: string;
+}
+declare class WhatsappChannelConfig implements IWhatsappChannelConfig {
+    number: string;
+    constructor(number: string);
+}
+
+declare function whatsapp(config: IWhatsappChannelConfig): (target: object, propertyKey: string | symbol) => void;
+
+interface IWhatsAppWebhookPayload {
+    object: 'whatsapp_business_account';
+    entry: IEntry[];
+}
+interface IEntry {
+    id: string;
+    changes: IChange[];
+}
+type IChange = IMessagesChange;
+interface IMessagesChange {
+    value: IMessagesChangeValue;
+    field: 'messages';
+}
+interface IMessagesChangeValue {
+    messaging_product: 'whatsapp';
+    metadata: IMessageMetadata;
+    contacts?: IWhatsAppContact[];
+    messages?: IWhatsAppMessage[];
+}
+interface IMessageMetadata {
+    display_phone_number: string;
+    phone_number_id: string;
+}
+interface IWhatsAppContact {
+    profile: {
+        name: string;
+    };
+    wa_id: string;
+}
+type IWhatsAppMessage = ITextMessage | IAudioMessage;
+interface IBaseMessage {
+    from: string;
+    id: string;
+    timestamp: string;
+    type: string;
+}
+interface ITextMessage extends IBaseMessage {
+    type: 'text';
+    text: {
+        body: string;
+    };
+}
+interface IAudioMessage extends IBaseMessage {
+    type: 'audio';
+    audio: {
+        mime_type: string;
+        sha256: string;
+        id: string;
+        voice: boolean;
+    };
+}
+
+type IWabotEnvType = 'development' | 'staging' | 'testing' | 'production';
+declare class WabotEnv {
+    private envType;
+    constructor();
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+}
+
+type IWhatsAppMessageListener = (message: IConnectionChatMessage) => Promise<void>;
+interface IWhatsAppConnection {
+    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
+    sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
+    connect(): void;
+}
+
+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 abstract class WhatsAppConnection implements IWhatsAppConnection {
+    protected logger: Logger;
+    private listeners;
+    constructor(logger: Logger);
+    abstract sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
+    abstract connect(): void;
+    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
+    protected handlePayload(payload: IWhatsAppWebhookPayload): Promise<void>;
+    private emmitMessage;
+}
+
+declare class WhatsAppDevConnection extends WhatsAppConnection implements IWhatsAppConnection {
+    private devProxy;
+    private devProxySocket;
+    private devToken?;
+    private connected;
+    constructor();
+    sendWhatsApp(businessNumber: string, to: string, chatMessage: IChatMessage): Promise<void>;
+    connect(): void;
+}
+
+declare class WhatsAppProdConnection implements IWhatsAppConnection {
+    private express;
+    constructor(express: Express);
+    listenMessage(businessNumber: string, listener: IWhatsAppMessageListener): void;
+    sendWhatsApp(businessNumber: string, to: string, replyMessage: IChatMessage): Promise<void>;
+    connect(): void;
+}
+
+declare class WhatsAppChannel implements IChatChannel {
+    private config;
+    private chatResolver;
+    private userResolver;
+    private wabotEnv;
+    private logger;
+    private whatsAppConection;
+    constructor(config: WhatsappChannelConfig, chatResolver: ChatResolver, userResolver: UserResolver, wabotEnv: WabotEnv, devConnection: WhatsAppDevConnection, prodConnection: WhatsAppProdConnection);
+    listen(callback: (message: IReceivedMessage) => void): void;
+    connect(): void;
+}
+
+declare const devWhatsAppListentEvent: {
+    readonly DEV_WATSAPP_WEBHOOK: "dev-whatsapp-webhook";
+};
+declare const devWhatsappEmitEvent: {
+    readonly DEV_CONNECTION: "dev-connection";
+    readonly DEV_SEND_WHATSAPP: "dev-send-whatsapp";
+};
+interface IDevConnectionRequest {
+    token: string;
+}
+interface IDevSendWhatsappRequest {
+    from: string;
+    to: string;
+    message: IChatMessage;
+}
+
 declare function prepareChatContainer(container: DependencyContainer$1, context: IMessageContext, mindsetCtor?: IConstructor<IMindset>): Promise<DependencyContainer$1>;
 
 interface IrunChannelProps {
@@ -674,4 +828,4 @@ declare class RamChatRepository implements IChatRepository {
     private getMemory;
 }
 
-export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, EmailService, 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 IMessageContext, type IMindset, type IMindsetDecoration, type IMindsetFunctionConfig, type IMindsetFunctionDecoration, type IMindsetFunctionMetadata, type IMindsetFunctionParamMetadata, type IMindsetIdentity, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleDecoration, type IMindsetModuleMetadata, type IOtpService, type IParamConfig, type IParamDecoration, type IPersistent, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IchatControllerConfig, type IrunChannelProps, 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, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, chatBot, chatController, cmd, container, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, sqliteMapperFor, telegram };
+export { AuthenticationModule, Chat, ChatBot, ChatBotAdapter, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, CmdChannel, Container, ControllerMetadataStore, EmailService, ExpressApp, 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 IDevConnectionRequest, type IDevSendWhatsappRequest, type IEmailService, 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 IOtpService, type IParamConfig, type IParamDecoration, type IPersistent, type IPgRepositoryConfig, type IReceivedMessage, type IReceivedMessageItem, type IReversibleMapper, type ISendEmailRequest, type IServerConfig, type IServerProvider, type ISqliteRecord, type ISystemFunctionCallItem, type ISystemMessageItem, type ITelegramChannelConfig, type IUserConnection, type IUserData, type IUserRepository, type IWabotEnvType, type IWhatsAppContact, type IWhatsAppMessage, 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, RamChatMemory, RamChatRepository, RamUserRepository, RegisterUserModule, RegisterUserWithEmailRequest, SendOneTimePasswordRequest, SocketIoApp, SqliteChatMemory, SqliteChatRepository, SqliteCrudRepository, SqlitePersistentMapper, SqliteUserRepository, TelegramChannel, TelegramChannelConfig, User, UserRepository, UserResolver, ValidateOneTimePasswordRequest, WabotEnv, WhatsAppChannel, WhatsappChannelConfig, chatBot, chatController, cmd, container, devWhatsAppListentEvent, devWhatsappEmitEvent, inject, injectable, isOptional, mindset, mindsetFunction, mindsetModule, param, prepareChatContainer, runChannel, runServer, singleton, sqliteMapperFor, telegram, whatsapp };

package/dist/src/index.js

@@ -4,6 +4,10 @@ export { CmdChannel } from './channels/cmd/CmdChannel.js';
 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 { WhatsAppChannel } from './channels/whatsapp/WhatsAppChannel.js';
+export { WhatsappChannelConfig } from './channels/whatsapp/WhatsAppChannelConfig.js';
+export { devWhatsAppListentEvent, devWhatsappEmitEvent } from './channels/whatsapp/whatsAppDevSocketContracts.js';
 export { chatBot } from './chatbot/metadata/@chatBot.js';
 export { ChatBotMetadataStore } from './chatbot/metadata/ChatBotMetadataStore.js';
 export { mindsetFunction } from './mindset/metadata/functions/@mindsetFunction.js';
@@ -32,6 +36,8 @@ export { ChatResolver } from './controller/channel/ChatResolver.js';
 export { UserResolver } from './controller/channel/UserResolver.js';
 export { chatController } from './controller/metadata/controller/@chatController.js';
 export { ControllerMetadataStore } from './controller/metadata/ControllerMetadataStore.js';
+export { ExpressApp } from './controller/express/Express.js';
+export { SocketIoApp } from './controller/socket.io/SocketIO.js';
 export { container, inject, injectable, singleton } from './injection/index.js';
 export { prepareChatContainer } from './server/prepareChatContainer.js';
 export { runChannel } from './server/runChannel.js';
@@ -56,4 +62,6 @@ export { PgCrudRepository } from './repository/pg/PgCrudRepository.js';
 export { PgRepositoryBase } from './repository/pg/PgRepositoryBase.js';
 export { SqliteCrudRepository } from './repository/sqlite/SqliteCrudRepository.js';
 export { SqlitePersistentMapper, sqliteMapperFor } from './repository/sqlite/SqlitePersistentMapper.js';
+export { Logger } from './logger/Logger.js';
+export { WabotEnv } from './env/WabotEnv.js';
 export { Container } from './injection/Container.js';

package/dist/src/logger/Logger.js

@@ -0,0 +1,65 @@
+import debug from 'debug';
+
+const levelColors = {
+    trace: 0,
+    debug: 0,
+    info: 0,
+    warn: 5,
+    error: 1,
+    fatal: 1,
+};
+class Logger {
+    debuggers;
+    constructor(name) {
+        this.debuggers = {};
+        for (const level of Object.keys(levelColors)) {
+            const dbg = debug(`${name}:${level}`);
+            dbg.color = '' + levelColors[level];
+            this.debuggers[level] = dbg;
+        }
+    }
+    trace(...args) {
+        this.log(this.debuggers['trace'], args);
+    }
+    debug(...args) {
+        this.log(this.debuggers['debug'], args);
+    }
+    info(...args) {
+        this.log(this.debuggers['info'], args);
+    }
+    warn(...args) {
+        this.log(this.debuggers['warn'], args);
+    }
+    error(...args) {
+        this.log(this.debuggers['error'], args);
+    }
+    fatal(...args) {
+        this.log(this.debuggers['fatal'], args);
+    }
+    log(debugg, args) {
+        const _args = args.map((arg) => {
+            if (arg instanceof Error) {
+                return JSON.stringify({
+                    name: arg.name,
+                    message: arg.message,
+                    stack: arg.stack,
+                });
+            }
+            if (arg === null) {
+                return 'null';
+            }
+            if (typeof arg === 'object') {
+                try {
+                    return JSON.stringify(arg);
+                }
+                catch (e) {
+                    return '[Circular]';
+                }
+            }
+            return arg;
+        });
+        debugg(..._args);
+    }
+}
+
+export { Logger };

package/dist/src/server/runChannel.js

@@ -1,20 +1,20 @@
-import dotenv from 'dotenv';
-import '../controller/channel/ChatResolver.js';
-import '../controller/channel/UserResolver.js';
+import 'reflect-metadata';
 import { container } from '../injection/index.js';
+import '../mindset/metadata/MindsetMetadataStore.js';
 import { ChatRepository } from '../core/chat/repository/IChatRepository.js';
 import '../core/user/IUserRepository.js';
-import '../controller/metadata/ControllerMetadataStore.js';
-import 'reflect-metadata';
-import '../mindset/metadata/MindsetMetadataStore.js';
 import '../mindset/MindsetOperator.js';
-import { prepareChatContainer } from './prepareChatContainer.js';
 import 'uuid';
 import '../chatbot/metadata/ChatBotMetadataStore.js';
 import { ChatBot } from '../chatbot/ChatBot.js';
 import { ChatBotAdapter } from '../chatbot/ChatBotAdapter.js';
+import '../controller/channel/ChatResolver.js';
+import '../controller/channel/UserResolver.js';
+import '../controller/metadata/ControllerMetadataStore.js';
+import 'express';
+import 'socket.io';
+import { prepareChatContainer } from './prepareChatContainer.js';
 
-dotenv.config();
 function runChannel(props) {
     container.registerSingleton(ChatRepository, props.chatRepository);
     container.register(ChatBotAdapter, { useClass: props.chatBotAdapter });

package/dist/src/server/runServer.js

@@ -1,14 +1,49 @@
-import dotenv from 'dotenv';
 import '../controller/channel/ChatResolver.js';
 import '../controller/channel/UserResolver.js';
 import { container } from '../injection/index.js';
 import '../core/chat/repository/IChatRepository.js';
 import '../core/user/IUserRepository.js';
 import { ControllerMetadataStore } from '../controller/metadata/ControllerMetadataStore.js';
+import { ExpressApp } from '../controller/express/Express.js';
+import { SocketIoApp } from '../controller/socket.io/SocketIO.js';
 import { prepareChatContainer } from './prepareChatContainer.js';
+import express from 'express';
+import { Server } from 'socket.io';
+import http from 'http';
+import bodyParser from 'body-parser';
+import { Logger } from '../logger/Logger.js';
 
-dotenv.config();
 function runServer(config) {
+    const httpLogger = new Logger('wabot:http');
+    const socketLogger = new Logger('wabot:socket');
+    const expressApp = express();
+    const httpServer = http.createServer(expressApp);
+    const io = new Server(httpServer, {
+        cors: {
+            origin: '*',
+        },
+    });
+    expressApp.use(bodyParser.json());
+    expressApp.use((req, res, next) => {
+        const start = process.hrtime();
+        res.on('finish', () => {
+            const [seconds, nanoseconds] = process.hrtime(start);
+            const ms = (seconds * 1000 + nanoseconds / 1e6).toFixed(2);
+            httpLogger.trace(`${req.method} ${req.originalUrl} ${res.statusCode} - ${ms}ms`);
+        });
+        next();
+    });
+    io.on('connection', (socket) => {
+        socketLogger.trace(`socket:${socket.id} connection`);
+        socket.onAny((event) => {
+            socketLogger.trace(`socket:${socket.id} emmits ${event}`);
+        });
+        socket.on('disconnect', (reason) => {
+            socketLogger.trace(`socket:${socket.id} disconnect with reason: ${reason}`);
+        });
+    });
+    container.register(ExpressApp, { useValue: expressApp });
+    container.register(SocketIoApp, { useValue: io });
     for (const provider of config.providers ?? []) {
         if (provider.singleton) {
             container.registerSingleton(provider.replace, provider.with);
@@ -39,6 +74,10 @@ function runServer(config) {
             channel.connect();
         }
     }
+    const PORT = process.env.PORT || 3000;
+    httpServer.listen(PORT, () => {
+        httpLogger.info(`server listenig on port ${PORT}`);
+    });
 }
 
 export { runServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/framework",
-  "version": "0.0.13",
+  "version": "0.0.16",
   "description": "Framework for IA Chat Bots",
   "type": "module",
   "main": "dist/src/index.js",
@@ -16,8 +16,7 @@
     "fmt": "prettier --write .",
     "fmt:check": "prettier --check .",
     "types:check": "tsc --noEmit",
-    "elia:cmd": "node --import @yucacodes/ts/src/custom-import.mjs  ./test/elia/runEliaCmd.ts",
-    "elia:telegram": "node --import @yucacodes/ts/src/custom-import.mjs  ./test/elia/runEliaTelegram.ts"
+    "elia:dev": "yts --import ./dotenv.config.mjs  ./test/elia/runElia.ts"
   },
   "devDependencies": {
     "@rollup/plugin-alias": "5.1.1",
@@ -35,10 +34,14 @@
     "typescript": "5.8.3"
   },
   "peerDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/express": "^5.0.1",
     "@types/pg": "^8.11.14",
     "@yucacodes/ts": "^0.0.4",
+    "body-parser": "^2.2.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "debug": "^4.4.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "grammy": "^1.36.0",
@@ -46,6 +49,8 @@
     "pg": "^8.15.6",
     "reflect-metadata": "^0.2.2",
     "short-uuid": "^5.2.0",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
     "tslib": "^2.8.1",