@wabot-dev/framework 0.9.1 → 0.9.5

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppSenderByWabotProxy.js

@@ -1,63 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { WhatsAppSender } from '../WhatsAppSender.js';
-import { singleton } from '../../../../core/injection/index.js';
-import { Logger } from '../../../../core/logger/Logger.js';
-import '../../../../feature/chat-bot/ChatAdapterRegistry.js';
-import '../../../../feature/chat-bot/ChatBot.js';
-import '../../../../feature/chat-bot/ChatOperator.js';
-import { ChatRepository } from '../../../../feature/chat-bot/ChatRepository.js';
-import '../../../../feature/chat-bot/UnionChatAdapter.js';
-import '../../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
-import 'uuid';
-import '../../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
-import '../../../../core/error/setupErrorHandlers.js';
-import '../../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
-import { ChatResolver } from '../../../../feature/chat-controller/ChatResolver.js';
-import '../../../../feature/chat-controller/runChatControllers.js';
-import { WhatsAppRepository } from '../WhatsAppRepository.js';
-import { WhatsAppWabotProxyConnection } from './WhatsAppWabotProxyConnection.js';
-
-let WhatsAppSenderByWabotProxy = class WhatsAppSenderByWabotProxy extends WhatsAppSender {
-    wabotDevConnection;
-    logger = new Logger('wabot:whatsapp-sender-by-wabot-proxy');
-    constructor(wabotDevConnection, chatRepository, chatResolver, whatsAppRepository) {
-        super(chatRepository, chatResolver, whatsAppRepository);
-        this.wabotDevConnection = wabotDevConnection;
-    }
-    async sendWhatsApp(request, options) {
-        try {
-            const socket = await this.wabotDevConnection.getSocket();
-            const req = {
-                event: 'sendMessage',
-                data: {
-                    from: request.from,
-                    to: request.to,
-                    content: {
-                        text: request.message.text ?? 'No Text',
-                    },
-                },
-            };
-            const ack = await socket.timeout(5000).emitWithAck(req.event, req.data);
-            if (!ack || !ack.success) {
-                throw new Error(`not success ack, when send whatsapp from '${request.from}' to '${request.to}'`);
-            }
-            this.logger.trace(`success send whatsapp from '${request.from}' to '${request.to}'`);
-            if (options?.writeChatMemory) {
-                await this.writePrivateChatMemory(request.message, request.to);
-            }
-        }
-        catch (err) {
-            this.logger.error(`Failed to send WhatsApp from '${request.from}' to '${request.to}'`, err);
-            throw new Error(undefined, { cause: err });
-        }
-    }
-};
-WhatsAppSenderByWabotProxy = __decorate([
-    singleton(),
-    __metadata("design:paramtypes", [WhatsAppWabotProxyConnection,
-        ChatRepository,
-        ChatResolver,
-        WhatsAppRepository])
-], WhatsAppSenderByWabotProxy);
-
-export { WhatsAppSenderByWabotProxy };

package/dist/src/addon/chat-controller/whatsapp/proxy/WhatsAppWabotProxyConnection.js

@@ -1,45 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Env } from '../../../../core/env/Env.js';
-import { injectable } from '../../../../core/injection/index.js';
-import { Logger } from '../../../../core/logger/Logger.js';
-import { io } from 'socket.io-client';
-
-let WhatsAppWabotProxyConnection = class WhatsAppWabotProxyConnection {
-    baseUrl;
-    socket = null;
-    apiKey;
-    logger = new Logger('wabot:whats-app-wabot-proxy-connection');
-    constructor(env) {
-        this.apiKey = env.requireString('WABOT_API_KEY');
-        this.baseUrl = env.requireString('WABOT_PROXY_URL');
-        while (this.baseUrl.endsWith('/')) {
-            this.baseUrl = this.baseUrl.substring(0, this.baseUrl.length - 1);
-        }
-    }
-    async getSocket() {
-        if (this.socket) {
-            return this.socket;
-        }
-        return new Promise((resolve, reject) => {
-            const socket = io(`${this.baseUrl}/whats-app`, {
-                autoConnect: false,
-                auth: { token: this.apiKey },
-                reconnection: true,
-            });
-            socket.on('connect', async () => {
-                this.socket = socket;
-                resolve(socket);
-            });
-            socket.on('connect_error', (err) => {
-                reject(new Error(err && err.message ? err.message : 'connection error', { cause: err }));
-            });
-            socket.connect();
-        });
-    }
-};
-WhatsAppWabotProxyConnection = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [Env])
-], WhatsAppWabotProxyConnection);
-
-export { WhatsAppWabotProxyConnection };

package/dist/src/feature/pg/query/@pgJsonRepository.js

@@ -1,73 +0,0 @@
-import { container, singleton } from '../../../core/injection/index.js';
-import { withPgClient } from '../withPgClient.js';
-import { buildQuerySql } from './buildQuerySql.js';
-import { parseQueryMethodName } from './parseQueryMethodName.js';
-import { PgJsonRepository } from './PgJsonRepository.js';
-import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
-
-const QUERY_CACHE_KEY = Symbol('wabot:pgQueryCache');
-function makeQueryImpl(methodName, ast) {
-    return async function (...args) {
-        let cache = this[QUERY_CACHE_KEY];
-        if (!cache) {
-            cache = new Map();
-            Object.defineProperty(this, QUERY_CACHE_KEY, { value: cache, enumerable: false });
-        }
-        let built = cache.get(methodName);
-        if (!built) {
-            built = buildQuerySql(ast, this.table, this.columns);
-            cache.set(methodName, built);
-        }
-        const params = built.buildParams(args);
-        switch (ast.prefix) {
-            case 'find': {
-                return await this.query(built.sql, params);
-            }
-            case 'findOne': {
-                const items = await this.query(built.sql, params);
-                return items[0] ?? null;
-            }
-            case 'count': {
-                return await withPgClient(this.pool, async (client) => {
-                    await this.ensureTable(client);
-                    const result = await client.query(built.sql, params);
-                    return result.rows[0]?.count ?? 0;
-                });
-            }
-            case 'exists': {
-                return await withPgClient(this.pool, async (client) => {
-                    await this.ensureTable(client);
-                    const result = await client.query(built.sql, params);
-                    return Boolean(result.rows[0]?.exists);
-                });
-            }
-            case 'delete': {
-                await this.exec(built.sql, params);
-                return;
-            }
-        }
-    };
-}
-function pgJsonRepository(config) {
-    return function (target) {
-        if (target !== PgJsonRepository && !(target.prototype instanceof PgJsonRepository)) {
-            throw new Error(`@pgJsonRepository: ${target.name} must extend PgJsonRepository`);
-        }
-        const store = container.resolve(PgRepositoryMetadataStore);
-        store.saveRepositoryConfig(target, config);
-        const queryMethods = store.getQueryMethods(target);
-        for (const meta of queryMethods) {
-            if (Object.prototype.hasOwnProperty.call(target.prototype, meta.functionName)) {
-                const existing = target.prototype[meta.functionName];
-                if (typeof existing === 'function') {
-                    continue;
-                }
-            }
-            const ast = parseQueryMethodName(meta.functionName);
-            target.prototype[meta.functionName] = makeQueryImpl(meta.functionName, ast);
-        }
-        singleton()(target);
-    };
-}
-
-export { pgJsonRepository };

package/dist/src/feature/pg/query/@query.js

@@ -1,14 +0,0 @@
-import { container } from '../../../core/injection/index.js';
-import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
-
-function query() {
-    return function (target, propertyKey) {
-        const store = container.resolve(PgRepositoryMetadataStore);
-        store.saveQueryMethodMetadata({
-            repositoryConstructor: target.constructor,
-            functionName: propertyKey.toString(),
-        });
-    };
-}
-
-export { query };

package/dist/src/feature/pg/query/PgJsonRepository.js

@@ -1,23 +0,0 @@
-import { __decorate, __metadata } from 'tslib';
-import { Pool } from 'pg';
-import { injectable, container } from '../../../core/injection/index.js';
-import { PgCrudRepository } from '../PgCrudRepository.js';
-import { PgRepositoryMetadataStore } from './PgRepositoryMetadataStore.js';
-
-let PgJsonRepository = class PgJsonRepository extends PgCrudRepository {
-    constructor(pool) {
-        const ctor = new.target;
-        const store = container.resolve(PgRepositoryMetadataStore);
-        const config = store.getRepositoryConfig(ctor);
-        if (!config) {
-            throw new Error(`${ctor.name} must be decorated with @pgJsonRepository`);
-        }
-        super(pool, config);
-    }
-};
-PgJsonRepository = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [Pool])
-], PgJsonRepository);
-
-export { PgJsonRepository };

package/dist/src/feature/pg/query/PgRepositoryMetadataStore.js

@@ -1,44 +0,0 @@
-import { __decorate } from 'tslib';
-import { singleton } from '../../../core/injection/index.js';
-
-let PgRepositoryMetadataStore = class PgRepositoryMetadataStore {
-    queryMethods = new Map();
-    repositoryConfigs = new Map();
-    saveQueryMethodMetadata(metadata) {
-        let perClass = this.queryMethods.get(metadata.repositoryConstructor);
-        if (!perClass) {
-            perClass = new Map();
-            this.queryMethods.set(metadata.repositoryConstructor, perClass);
-        }
-        perClass.set(metadata.functionName, metadata);
-    }
-    saveRepositoryConfig(ctor, config) {
-        this.repositoryConfigs.set(ctor, config);
-    }
-    getRepositoryConfig(ctor) {
-        return this.repositoryConfigs.get(ctor);
-    }
-    getQueryMethods(ctor) {
-        const collected = new Map();
-        const hierarchy = [];
-        let proto = ctor.prototype;
-        while (proto && proto.constructor !== Object) {
-            hierarchy.unshift(proto.constructor);
-            proto = Object.getPrototypeOf(proto);
-        }
-        for (const cls of hierarchy) {
-            const perClass = this.queryMethods.get(cls);
-            if (perClass) {
-                for (const [name, meta] of perClass) {
-                    collected.set(name, meta);
-                }
-            }
-        }
-        return [...collected.values()];
-    }
-};
-PgRepositoryMetadataStore = __decorate([
-    singleton()
-], PgRepositoryMetadataStore);
-
-export { PgRepositoryMetadataStore };