@wabot-dev/framework 0.9.0 → 0.9.2

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/config/resolver.js

@@ -1,3 +1,21 @@
+function resolveConfigReferences(config) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (isConfigReference(value)) {
+            resolved[key] = ConfigResolver.resolve(value);
+        }
+        else {
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
+function isConfigReference(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        '__isConfigReference' in value &&
+        value.__isConfigReference === true);
+}
 class ConfigResolver {
     static resolve(reference) {
         const envValue = this.loadFromEnv(reference.path);
@@ -67,4 +85,4 @@ class ConfigResolver {
     }
 }
 
-export { ConfigResolver };
+export { ConfigResolver, resolveConfigReferences };

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/index.js

@@ -0,0 +1,13 @@
+export { PgCrudRepository } from './PgCrudRepository.js';
+export { PgLocker } from './PgLocker.js';
+export { PgLockKey } from './PgLockKey.js';
+export { PgRepositoryBase } from './PgRepositoryBase.js';
+export { getClientMap, pgStorage } from './pgStorage.js';
+export { pgJsonRepository } from './query/@pgJsonRepository.js';
+export { query } from './query/@query.js';
+export { PgJsonRepository } from './query/PgJsonRepository.js';
+export { PgRepositoryMetadataStore } from './query/PgRepositoryMetadataStore.js';
+export { buildQuerySql } from './query/buildQuerySql.js';
+export { parseQueryMethodName } from './query/parseQueryMethodName.js';
+export { getPgClient, withPgClient } from './withPgClient.js';
+export { withPgTransaction } from './withPgTransaction.js';

package/dist/src/feature/project-runner/ProjectRunner.js

@@ -0,0 +1,253 @@
+import { readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { container } from '../../core/injection/index.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { Locker } from '../../core/lock/Locker.js';
+import '../chat-bot/ChatAdapterRegistry.js';
+import '../chat-bot/ChatBot.js';
+import '../chat-bot/ChatOperator.js';
+import { ChatRepository } from '../chat-bot/ChatRepository.js';
+import '../chat-bot/UnionChatAdapter.js';
+import '../chat-bot/metadata/ChatAdapterMetadataStore.js';
+import 'uuid';
+import '../chat-bot/metadata/ChatBotMetadataStore.js';
+import { runChatAdapters } from '../chat-bot/runChatAdapters.js';
+import '../../core/error/setupErrorHandlers.js';
+import { ControllerMetadataStore } from '../chat-controller/metadata/ControllerMetadataStore.js';
+import '../chat-controller/ChatResolver.js';
+import { runChatControllers } from '../chat-controller/runChatControllers.js';
+import { RestControllerMetadataStore } from '../rest-controller/metadata/RestControllerMetadataStore.js';
+import { runRestControllers } from '../rest-controller/runRestControllers.js';
+import { AsyncMetadataStore } from '../async/AsyncMetadataStore.js';
+import { TransactionMetadataStore } from '../async/TransactionMetadataStore.js';
+import '../async/Async.js';
+import '../../_virtual/index.js';
+import { CronJobRepository } from '../async/CronJobRepository.js';
+import { JobRepository } from '../async/JobRepository.js';
+import '../async/JobRunner.js';
+import { runCommandHandlers } from '../async/runCommandHandlers.js';
+import { runCronHandlers } from '../async/runCronHandlers.js';
+import { SocketControllerMetadataStore } from '../socket-controller/metadata/SocketControllerMetadataStore.js';
+import { runSocketControllers } from '../socket-controller/runSocketControllers.js';
+
+const logger = new Logger('wabot:project-runner');
+const TEST_FILE_PATTERNS = /\.(test|spec|unit|integration|e2e|multiprocess)\.(ts|js)$/;
+const DEFAULT_CHAT_ADAPTERS = [
+    ['../../addon/chat-bot/openia', 'OpenaiChatAdapter'],
+    ['../../addon/chat-bot/openrouter', 'OpenRouterChatAdapter'],
+    ['../../addon/chat-bot/anthropic', 'AnthropicChatAdapter'],
+    ['../../addon/chat-bot/google', 'GoogleChatAdapter'],
+];
+class ProjectRunner {
+    directories;
+    chatAdapters;
+    connectionString;
+    isPg;
+    pool = null;
+    constructor(config = {}) {
+        this.directories = config.directories ?? ['src'];
+        this.chatAdapters = config.chatAdapters;
+        this.connectionString = this.resolveConnectionString(config.connectionString);
+        this.isPg = this.connectionString != null && isPostgresUrl(this.connectionString);
+    }
+    async run() {
+        const [, files] = await Promise.all([
+            this.isPg ? this.initPool() : Promise.resolve(),
+            this.scanDirectories(),
+        ]);
+        await this.importFiles(files);
+        const components = this.discoverComponents();
+        await this.registerAdapters(components);
+        await this.startComponents(components);
+    }
+    resolveConnectionString(configValue) {
+        const cs = configValue ?? process.env.DATABASE_URL ?? null;
+        if (cs && !isPostgresUrl(cs)) {
+            logger.warn(`connectionString "${cs}" does not match a known scheme (postgres://, postgresql://); falling back to in-memory adapters`);
+        }
+        return cs;
+    }
+    async initPool() {
+        const { Pool } = await import('pg');
+        this.pool = new Pool({ connectionString: this.connectionString });
+        container.registerInstance(Pool, this.pool);
+    }
+    async scanDirectories() {
+        const seen = new Set();
+        const roots = this.directories
+            .map((d) => resolve(d))
+            .filter((d) => {
+            if (seen.has(d))
+                return false;
+            seen.add(d);
+            return true;
+        });
+        const results = await Promise.all(roots.map((dir) => scanDir(dir).catch((err) => {
+            logger.warn(`Could not read directory ${dir}: ${err.message}`);
+            return [];
+        })));
+        return results.flat();
+    }
+    async importFiles(files) {
+        if (files.length === 0) {
+            logger.info('No files to import');
+            return;
+        }
+        const results = await Promise.allSettled(files.map((file) => import(pathToFileURL(file).href)));
+        let imported = 0;
+        let failed = 0;
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            if (result.status === 'fulfilled') {
+                imported++;
+            }
+            else {
+                failed++;
+                const reason = result.reason;
+                logger.error(`Failed to import ${files[i]}: ${reason.message}`);
+            }
+        }
+        if (failed > 0) {
+            logger.warn(`Imported ${imported}/${files.length} files (${failed} failed)`);
+        }
+        else {
+            logger.info(`Imported ${imported}/${files.length} files`);
+        }
+    }
+    discoverComponents() {
+        const asyncStore = container.resolve(AsyncMetadataStore);
+        return {
+            chatControllers: container
+                .resolve(ControllerMetadataStore)
+                .getAllChatControllerConstructors(),
+            restControllers: container
+                .resolve(RestControllerMetadataStore)
+                .getAllRestControllerConstructors(),
+            commandHandlers: asyncStore.getAllCommandHandlers(),
+            cronHandlers: asyncStore.getAllCronHandlers(),
+            socketControllers: container
+                .resolve(SocketControllerMetadataStore)
+                .getAllSocketControllerConstructors(),
+        };
+    }
+    registerAdapters(components) {
+        return this.isPg
+            ? this.registerPostgresAdapters(components)
+            : this.registerMemoryAdapters(components);
+    }
+    async registerMemoryAdapters(components) {
+        const needsJobs = components.commandHandlers.length > 0 || components.cronHandlers.length > 0;
+        const [chatBotMod, lockMod, asyncMod] = await Promise.all([
+            import('../../addon/chat-bot/in-memory/index.js'),
+            import('../../addon/lock/index.js'),
+            needsJobs ? import('../../addon/async/in-memory/index.js') : Promise.resolve(null),
+        ]);
+        container.registerType(ChatRepository, chatBotMod.InMemoryChatRepository);
+        container.registerType(Locker, lockMod.InMemoryLocker);
+        if (asyncMod) {
+            container.registerType(JobRepository, asyncMod.InMemoryJobRepository);
+            if (components.cronHandlers.length > 0) {
+                container.registerType(CronJobRepository, asyncMod.InMemoryCronJobRepository);
+            }
+        }
+        logger.info('Configured with in-memory adapters');
+    }
+    async registerPostgresAdapters(components) {
+        if (!this.pool) {
+            throw new Error('Postgres pool was not initialized');
+        }
+        const [chatBotMod, pgMod, asyncMod] = await Promise.all([
+            import('../../addon/chat-bot/pg/index.js'),
+            import('../pg/index.js'),
+            import('../../addon/async/pg/index.js'),
+        ]);
+        container.registerType(ChatRepository, chatBotMod.PgChatRepository);
+        container.registerType(Locker, pgMod.PgLocker);
+        const transactionStore = container.resolve(TransactionMetadataStore);
+        transactionStore.registerAdapter('default', new asyncMod.PgTransactionAdapter(this.pool));
+        const hasCommandHandlers = components.commandHandlers.length > 0;
+        const hasCronHandlers = components.cronHandlers.length > 0;
+        if (hasCommandHandlers || hasCronHandlers) {
+            container.registerType(JobRepository, asyncMod.PgJobRepository);
+        }
+        if (hasCronHandlers) {
+            container.registerType(CronJobRepository, asyncMod.PgCronJobRepository);
+        }
+        logger.info('Configured with PostgreSQL adapters');
+    }
+    async startComponents(components) {
+        const chatAdapters = this.chatAdapters ?? (await this.resolveDefaultChatAdapters());
+        if (chatAdapters.length > 0) {
+            runChatAdapters(chatAdapters);
+        }
+        if (components.chatControllers.length > 0) {
+            logger.info(`Starting ${components.chatControllers.length} chat controller(s)`);
+            runChatControllers(components.chatControllers);
+        }
+        if (components.restControllers.length > 0) {
+            logger.info(`Starting ${components.restControllers.length} REST controller(s)`);
+            runRestControllers(components.restControllers);
+        }
+        if (components.commandHandlers.length > 0) {
+            logger.info(`Starting ${components.commandHandlers.length} command handler(s)`);
+            runCommandHandlers(components.commandHandlers);
+        }
+        if (components.cronHandlers.length > 0) {
+            logger.info(`Starting ${components.cronHandlers.length} cron handler(s)`);
+            runCronHandlers(components.cronHandlers);
+        }
+        if (components.socketControllers.length > 0) {
+            logger.info(`Starting ${components.socketControllers.length} socket controller(s)`);
+            runSocketControllers(components.socketControllers);
+        }
+    }
+    async resolveDefaultChatAdapters() {
+        const results = await Promise.all(DEFAULT_CHAT_ADAPTERS.map(async ([path, name]) => {
+            try {
+                const mod = await import(path);
+                const adapter = mod[name];
+                if (!adapter) {
+                    logger.warn(`Skipping ${name}: module loaded but no '${name}' export found`);
+                    return null;
+                }
+                return adapter;
+            }
+            catch {
+                logger.warn(`Skipping ${name}: missing peer dependency`);
+                return null;
+            }
+        }));
+        return results.filter((a) => a != null);
+    }
+}
+function run(config) {
+    return new ProjectRunner(config).run();
+}
+function isPostgresUrl(cs) {
+    return cs.startsWith('postgres://') || cs.startsWith('postgresql://');
+}
+async function scanDir(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const subResults = await Promise.all(entries.map(async (entry) => {
+        const name = entry.name;
+        if (entry.isDirectory()) {
+            if (name.startsWith('__'))
+                return [];
+            return scanDir(join(dir, name));
+        }
+        if (!entry.isFile())
+            return [];
+        if (!(name.endsWith('.ts') || name.endsWith('.js')))
+            return [];
+        if (name.endsWith('.d.ts'))
+            return [];
+        const fullPath = join(dir, name);
+        if (TEST_FILE_PATTERNS.test(fullPath))
+            return [];
+        return [fullPath];
+    }));
+    return subResults.flat();
+}
+
+export { ProjectRunner, run };

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

@@ -35,6 +35,9 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         }
         methodMiddlewares.unshift(middlewareMetadata);
     }
+    getAllRestControllerConstructors() {
+        return Array.from(this.restControllers.keys());
+    }
     getControllerEndPointsInfo(controllerConstructor) {
         const controller = this.restControllers.get(controllerConstructor);
         if (!controller) {

package/dist/src/feature/socket-controller/metadata/SocketControllerMetadataStore.js

@@ -22,6 +22,9 @@ let SocketControllerMetadataStore = class SocketControllerMetadataStore {
         }
         controllerMiddlewares.unshift(handshakeMetadata);
     }
+    getAllSocketControllerConstructors() {
+        return Array.from(this.socketControllers.keys());
+    }
     getSocketControllerInfo(controllerConstructor) {
         const controller = this.socketControllers.get(controllerConstructor);
         if (!controller) {