@wabot-dev/framework 0.9.1 → 0.9.5

package/dist/src/addon/chat-controller/{wasender/WhatsAppByWasenderChannel.js → whatsapp/wasender/WasenderChannel.js}

@@ -1,26 +1,26 @@
 import { __decorate, __metadata } from 'tslib';
-import { injectable } from '../../../core/injection/index.js';
-import { Env } from '../../../core/env/Env.js';
-import { Logger } from '../../../core/logger/Logger.js';
-import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
-import { WhatsAppReceiverByWasender } from './WhatsAppReceiverByWasender.js';
-import { WhatsAppSenderByWasender } from './WhatsAppSenderByWasender.js';
-import { whatsAppByWasenderChannelName } from './whatsAppByWasenderChannelName.js';
+import { injectable } from '../../../../core/injection/index.js';
+import { Env } from '../../../../core/env/Env.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { WasenderChannelConfig } from './WasenderChannelConfig.js';
+import { WasenderReceiver } from './WasenderReceiver.js';
+import { WasenderSender } from './WasenderSender.js';
+import { wasenderChannelName } from './WasenderChannelName.js';
 
-var WhatsAppByWasenderChannel_1;
-let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
-    static { WhatsAppByWasenderChannel_1 = this; }
+var WasenderChannel_1;
+let WasenderChannel = class WasenderChannel {
+    static { WasenderChannel_1 = this; }
     logger = new Logger('wabot:whatsapp-by-wasender-channel');
     sender;
     receiver;
     phoneNumber;
-    static channelName = whatsAppByWasenderChannelName;
+    static channelName = wasenderChannelName;
     constructor(config, env) {
         const apiKey = config.apiKey ?? env.requireString('WASENDER_API_KEY');
         const webhookSecret = config.webhookSecret ?? env.requireString('WASENDER_WEBHOOK_SECRET');
         this.phoneNumber = config.phoneNumber ?? env.requireString('WASENDER_PHONE_NUMBER');
-        this.sender = new WhatsAppSenderByWasender(apiKey, config.retryOptions);
-        this.receiver = new WhatsAppReceiverByWasender({
+        this.sender = new WasenderSender(apiKey, config.retryOptions);
+        this.receiver = new WasenderReceiver({
             apiKey,
             webhookSecret,
             webhookPath: config.webhookPath,
@@ -31,15 +31,15 @@ let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
         this.receiver.listenMessage(async (message, from) => {
             try {
                 await callback({
-                    channel: whatsAppByWasenderChannelName,
+                    channel: wasenderChannelName,
                     chatConnection: {
                         chatType: 'PRIVATE',
-                        channelName: WhatsAppByWasenderChannel_1.channelName,
+                        channelName: WasenderChannel_1.channelName,
                         id: from,
                     },
                     message,
                     reply: async (replyMessage) => {
-                        await this.sender.send({
+                        await this.sender.sendMessage({
                             from: this.phoneNumber,
                             to: from,
                             message: replyMessage,
@@ -59,9 +59,9 @@ let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
         this.receiver.disconnect();
     }
 };
-WhatsAppByWasenderChannel = WhatsAppByWasenderChannel_1 = __decorate([
+WasenderChannel = WasenderChannel_1 = __decorate([
     injectable(),
-    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig, Env])
-], WhatsAppByWasenderChannel);
+    __metadata("design:paramtypes", [WasenderChannelConfig, Env])
+], WasenderChannel);
 
-export { WhatsAppByWasenderChannel };
+export { WasenderChannel };

package/dist/src/addon/chat-controller/{wasender/WhatsAppByWasenderChannelConfig.js → whatsapp/wasender/WasenderChannelConfig.js}

@@ -1,4 +1,4 @@
-class WhatsAppByWasenderChannelConfig {
+class WasenderChannelConfig {
     apiKey;
     webhookSecret;
     phoneNumber;
@@ -9,8 +9,8 @@ class WhatsAppByWasenderChannelConfig {
         this.webhookSecret = config.webhookSecret;
         this.phoneNumber = config.phoneNumber;
         this.webhookPath = config.webhookPath ?? '/wasender/hook';
-        this.retryOptions = config.retryOptions ?? { enabled: true, maxRetries: 3 };
+        this.retryOptions = { enabled: true, maxRetries: 3 };
     }
 }
 
-export { WhatsAppByWasenderChannelConfig };
+export { WasenderChannelConfig };

package/dist/src/addon/chat-controller/whatsapp/wasender/WasenderChannelName.js

@@ -0,0 +1,3 @@
+const wasenderChannelName = 'WhatsAppByWasenderChannel';
+
+export { wasenderChannelName };

package/dist/src/addon/chat-controller/{wasender/WhatsAppReceiverByWasender.js → whatsapp/wasender/WasenderReceiver.js}

@@ -1,12 +1,12 @@
 import { __decorate, __metadata } from 'tslib';
-import '../../../core/injection/index.js';
-import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
-import { restController } from '../../../feature/rest-controller/metadata/@restController.js';
-import { runRestControllers } from '../../../feature/rest-controller/runRestControllers.js';
-import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import '../../../../core/injection/index.js';
+import '../../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { restController } from '../../../../feature/rest-controller/metadata/@restController.js';
+import { runRestControllers } from '../../../../feature/rest-controller/runRestControllers.js';
+import { createWasender } from '../../../../node_modules/wasenderapi/dist/index.js';
 import { WasenderWebhookController } from './WasenderWebhookController.js';
 
-class WhatsAppReceiverByWasender {
+class WasenderReceiver {
     config;
     wasender;
     listener = null;
@@ -36,4 +36,4 @@ class WhatsAppReceiverByWasender {
     }
 }
 
-export { WhatsAppReceiverByWasender };
+export { WasenderReceiver };

package/dist/src/addon/chat-controller/{wasender/WhatsAppSenderByWasender.js → whatsapp/wasender/WasenderSender.js}

@@ -1,13 +1,13 @@
-import { Logger } from '../../../core/logger/Logger.js';
-import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import { createWasender } from '../../../../node_modules/wasenderapi/dist/index.js';
 
-class WhatsAppSenderByWasender {
+class WasenderSender {
     wasender;
     logger = new Logger('wabot:whatsapp-sender-by-wasender');
     constructor(apiKey, retryOptions) {
         this.wasender = createWasender(apiKey, undefined, undefined, undefined, retryOptions, undefined);
     }
-    async send(request) {
+    async sendMessage(request) {
         try {
             const textPayload = {
                 messageType: 'text',
@@ -28,6 +28,9 @@ class WhatsAppSenderByWasender {
             }
         }
     }
+    sendTemplate(request) {
+        throw new Error('Method not implemented.');
+    }
 }
 
-export { WhatsAppSenderByWasender };
+export { WasenderSender };

package/dist/src/addon/chat-controller/{wasender → whatsapp/wasender}/WasenderWebhookController.js

@@ -1,8 +1,8 @@
 import { __decorate, __metadata } from 'tslib';
-import { Logger } from '../../../core/logger/Logger.js';
-import '../../../core/injection/index.js';
-import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
-import { onPost } from '../../../feature/rest-controller/metadata/@onPost.js';
+import { Logger } from '../../../../core/logger/Logger.js';
+import '../../../../core/injection/index.js';
+import '../../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { onPost } from '../../../../feature/rest-controller/metadata/@onPost.js';
 import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
 import { IncomingMessage } from 'node:http';
 

package/dist/src/addon/lock/InMemoryLockKey.js

@@ -0,0 +1,45 @@
+class InMemoryLockKey {
+    key;
+    static locks = new Map();
+    constructor(key) {
+        this.key = key;
+    }
+    async run(fn) {
+        let release;
+        const lock = new Promise((r) => {
+            release = r;
+        });
+        const prev = InMemoryLockKey.locks.get(this.key) ?? Promise.resolve();
+        InMemoryLockKey.locks.set(this.key, lock);
+        try {
+            await prev;
+            return await fn();
+        }
+        finally {
+            if (InMemoryLockKey.locks.get(this.key) === lock) {
+                InMemoryLockKey.locks.delete(this.key);
+            }
+            release();
+        }
+    }
+    async tryRun(fn) {
+        if (InMemoryLockKey.locks.has(this.key))
+            return undefined;
+        let release;
+        const lock = new Promise((r) => {
+            release = r;
+        });
+        InMemoryLockKey.locks.set(this.key, lock);
+        try {
+            return await fn();
+        }
+        finally {
+            if (InMemoryLockKey.locks.get(this.key) === lock) {
+                InMemoryLockKey.locks.delete(this.key);
+            }
+            release();
+        }
+    }
+}
+
+export { InMemoryLockKey };

package/dist/src/addon/lock/InMemoryLocker.js

@@ -0,0 +1,15 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { InMemoryLockKey } from './InMemoryLockKey.js';
+
+let InMemoryLocker = class InMemoryLocker {
+    withKey(key) {
+        const resolved = typeof key === 'object' ? key.lockerKey() : key;
+        return new InMemoryLockKey(resolved);
+    }
+};
+InMemoryLocker = __decorate([
+    singleton()
+], InMemoryLocker);
+
+export { InMemoryLocker };

package/dist/src/addon/lock/index.js

@@ -0,0 +1,2 @@
+export { InMemoryLockKey } from './InMemoryLockKey.js';
+export { InMemoryLocker } from './InMemoryLocker.js';

package/dist/src/core/repository/CrudRepository.js

@@ -0,0 +1,25 @@
+class CrudRepository {
+    find(id) {
+        throw new Error("Method not implemented.");
+    }
+    findOrThrow(id) {
+        throw new Error("Method not implemented.");
+    }
+    findByIds(ids) {
+        throw new Error("Method not implemented.");
+    }
+    findAll(id) {
+        throw new Error("Method not implemented.");
+    }
+    create(item) {
+        throw new Error("Method not implemented.");
+    }
+    update(item) {
+        throw new Error("Method not implemented.");
+    }
+    delete(item) {
+        throw new Error("Method not implemented.");
+    }
+}
+
+export { CrudRepository };

package/dist/src/feature/async/{@cron.js → @cronHandler.js}

@@ -1,7 +1,7 @@
 import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { container, singleton } from '../../core/injection/index.js';
 
-function cron(config) {
+function cronHandler(config) {
     return function (target) {
         const metadataStore = container.resolve(AsyncMetadataStore);
         metadataStore.registerCron(target, {
@@ -14,4 +14,4 @@ function cron(config) {
     };
 }
 
-export { cron };
+export { cronHandler };

package/dist/src/feature/async/@transaction.js

@@ -0,0 +1,22 @@
+import { container } from '../../core/injection/index.js';
+import { TransactionMetadataStore } from './TransactionMetadataStore.js';
+
+function transaction(dbNames) {
+    return function (_target, _propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        const store = container.resolve(TransactionMetadataStore);
+        descriptor.value = function (...args) {
+            const adapters = dbNames ? store.requireAdapters(dbNames) : store.getAllAdapters();
+            return runInTransactions(adapters, () => originalMethod.apply(this, args));
+        };
+        return descriptor;
+    };
+}
+function runInTransactions(adapters, fn) {
+    if (adapters.length === 0)
+        return fn();
+    const composed = adapters.reduceRight((next, adapter) => () => adapter.run(next), fn);
+    return composed();
+}
+
+export { transaction };

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

@@ -52,6 +52,12 @@ let AsyncMetadataStore = class AsyncMetadataStore {
     getCommandForCommandName(commandName) {
         return this.commandsMap.get(commandName) ?? null;
     }
+    getAllCommandHandlers() {
+        return Array.from(this.handlersInverseMap.keys());
+    }
+    getAllCronHandlers() {
+        return Array.from(this.cronsMap.keys());
+    }
 };
 AsyncMetadataStore = __decorate([
     singleton()

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

@@ -0,0 +1,28 @@
+import { __decorate } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+
+let TransactionMetadataStore = class TransactionMetadataStore {
+    adapters = new Map();
+    registerAdapter(dbName, adapter) {
+        this.adapters.set(dbName, adapter);
+    }
+    requireAdapter(dbName) {
+        const adapter = this.adapters.get(dbName);
+        if (!adapter) {
+            throw new Error(`No transaction adapter registered for "${dbName}". ` +
+                `Register one with container.resolve(TransactionMetadataStore).registerAdapter("${dbName}", adapter)`);
+        }
+        return adapter;
+    }
+    requireAdapters(dbNames) {
+        return dbNames.map((name) => this.requireAdapter(name));
+    }
+    getAllAdapters() {
+        return Array.from(this.adapters.values());
+    }
+};
+TransactionMetadataStore = __decorate([
+    singleton()
+], TransactionMetadataStore);
+
+export { TransactionMetadataStore };

package/dist/src/feature/chat-controller/metadata/ControllerMetadataStore.js

@@ -20,6 +20,9 @@ let ControllerMetadataStore = class ControllerMetadataStore {
     saveChatControllerMetadata(controllerMetadata) {
         this.chatControllers.set(controllerMetadata.controllerConstructor, controllerMetadata);
     }
+    getAllChatControllerConstructors() {
+        return Array.from(this.chatControllers.keys());
+    }
     getChatControllerMetadata(controllerConstructor) {
         const mainMetadata = this.chatControllers.get(controllerConstructor);
         if (!mainMetadata)

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

@@ -0,0 +1,33 @@
+import { container } from '../../core/injection/index.js';
+import 'short-uuid';
+import '../../core/error/setupErrorHandlers.js';
+import { RepositoryMetadataStore } from '../repository/RepositoryMetadataStore.js';
+import '../repository/RepositoryAdapterRegistry.js';
+import { PgRepositoryBase } from './PgRepositoryBase.js';
+
+const PG_ADAPTER_ID = Symbol('wabot:pg-adapter');
+function inheritsFrom(ctor, base) {
+    let proto = ctor.prototype;
+    while (proto) {
+        if (proto === base.prototype)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+function pgExtension(repositoryClass) {
+    if (typeof repositoryClass !== 'function') {
+        throw new Error(`@pgExtension: repository argument must be a class, ` +
+            `got ${typeof repositoryClass}`);
+    }
+    return function (target) {
+        if (!inheritsFrom(target, PgRepositoryBase)) {
+            throw new Error(`@pgExtension on ${target.name}: extension class must extend ` +
+                `PgRepositoryExtension.`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveExtension(repositoryClass, PG_ADAPTER_ID, target);
+    };
+}
+
+export { PG_ADAPTER_ID, pgExtension };

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

@@ -0,0 +1,50 @@
+import { PgCrudRepository } from './PgCrudRepository.js';
+import { PG_ADAPTER_ID } from './@pgExtension.js';
+import { buildQuerySql } from './buildQuerySql.js';
+import { withPgClient } from './withPgClient.js';
+
+class PgJsonRepositoryRuntime extends PgCrudRepository {
+    async runQuery(ast, args) {
+        const built = buildQuerySql(ast, this.table, this.columns);
+        const params = built.buildParams(args);
+        return this.query(built.sql, params);
+    }
+    async runCount(ast, args) {
+        const built = buildQuerySql(ast, this.table, this.columns);
+        const params = built.buildParams(args);
+        return withPgClient(this.pool, async (client) => {
+            await this.ensureTable(client);
+            const result = await client.query(built.sql, params);
+            return result.rows[0]?.count ?? 0;
+        });
+    }
+    async runExists(ast, args) {
+        const built = buildQuerySql(ast, this.table, this.columns);
+        const params = built.buildParams(args);
+        return withPgClient(this.pool, async (client) => {
+            await this.ensureTable(client);
+            const result = await client.query(built.sql, params);
+            return Boolean(result.rows[0]?.exists);
+        });
+    }
+    async runDelete(ast, args) {
+        const built = buildQuerySql(ast, this.table, this.columns);
+        const params = built.buildParams(args);
+        await this.exec(built.sql, params);
+    }
+}
+class PgJsonRepositoryAdapter {
+    pool;
+    id = PG_ADAPTER_ID;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    build(config) {
+        return new PgJsonRepositoryRuntime(this.pool, config);
+    }
+    buildExtension(config, ExtensionCtor) {
+        return new ExtensionCtor(this.pool, config);
+    }
+}
+
+export { PgJsonRepositoryAdapter };

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

@@ -0,0 +1,10 @@
+export { PG_ADAPTER_ID, pgExtension } from './@pgExtension.js';
+export { PgCrudRepository } from './PgCrudRepository.js';
+export { PgJsonRepositoryAdapter } from './PgJsonRepositoryAdapter.js';
+export { PgLocker } from './PgLocker.js';
+export { PgLockKey } from './PgLockKey.js';
+export { PgRepositoryBase, PgRepositoryBase as PgRepositoryExtension } from './PgRepositoryBase.js';
+export { getClientMap, pgStorage } from './pgStorage.js';
+export { buildQuerySql } from './buildQuerySql.js';
+export { getPgClient, withPgClient } from './withPgClient.js';
+export { withPgTransaction } from './withPgTransaction.js';