@wabot-dev/framework 0.9.2 → 0.9.6

package/dist/src/addon/chat-controller/cmd/runCmdClient.js

@@ -0,0 +1,226 @@
+import * as net from 'node:net';
+import * as readline from 'node:readline';
+import { cmdChannelSocketPath } from './cmdChannelSocketPath.js';
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR && process.env.TERM !== 'dumb';
+const ansi = (code) => (text) => useColor ? `\x1b[${code}m${text}\x1b[0m` : text;
+const bold = ansi('1');
+const dim = ansi('2');
+const cyan = ansi('1;36');
+const green = ansi('1;32');
+const greenText = ansi('32');
+const red = ansi('1;31');
+const yellow = ansi('33');
+const COMMANDS = ['/channels', '/help', '/exit'];
+const HELP_LINES = [
+    'Commands:',
+    '  /channels   list channels and switch',
+    '  /help       show this help',
+    '  /exit       quit',
+];
+const RECONNECT_DELAY_MS = 1000;
+function runCmdClient() {
+    const socketPath = cmdChannelSocketPath();
+    let socket = null;
+    let buffer = '';
+    let routes = [];
+    let state = 'disconnected';
+    let selected = null;
+    let reconnectTimer = null;
+    let waitingNoticeShown = false;
+    let exiting = false;
+    let restoring = false;
+    const completer = (line) => {
+        if (line.startsWith('/')) {
+            const hits = COMMANDS.filter((c) => c.startsWith(line));
+            return [hits.length > 0 ? hits : [...COMMANDS], line];
+        }
+        if (state === 'choosing') {
+            const hits = routes
+                .map((r) => r.route)
+                .filter((r) => r.toLowerCase().startsWith(line.toLowerCase()));
+            return [hits, line];
+        }
+        return [[], line];
+    };
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        completer,
+    });
+    const send = (msg) => {
+        if (!socket) {
+            process.stderr.write(red('not connected to framework — waiting for server...') + '\n');
+            rl.prompt();
+            return false;
+        }
+        socket.write(JSON.stringify(msg) + '\n');
+        return true;
+    };
+    const printChannels = (list) => {
+        routes = list;
+        if (list.length === 0) {
+            process.stdout.write(yellow('No cmd channels are registered on the server yet.') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (list.length === 1) {
+            send({ type: 'select', route: list[0].route });
+            return;
+        }
+        process.stdout.write(bold('Available cmd channels:') + '\n');
+        list.forEach((entry, i) => {
+            const marker = entry.route === selected ? ' ' + yellow('(active)') : '';
+            process.stdout.write(`  ${dim(`${i + 1}.`)} ${cyan(entry.route)}${marker}\n`);
+        });
+        state = 'choosing';
+        rl.setPrompt(bold('select # ') + dim('> '));
+        rl.prompt();
+    };
+    const handleServerMessage = (msg) => {
+        switch (msg.type) {
+            case 'channels':
+                printChannels(msg.list);
+                return;
+            case 'selected':
+                selected = msg.route;
+                state = 'chatting';
+                if (!restoring) {
+                    process.stdout.write(green(`[connected to ${msg.route}]`) + '\n');
+                }
+                restoring = false;
+                rl.setPrompt(cyan(msg.route) + dim(' > '));
+                rl.prompt();
+                return;
+            case 'reply':
+                process.stdout.write(`\n${green(`[${msg.senderName ?? 'bot'}]:`)} ${greenText(msg.text)}\n\n`);
+                rl.prompt();
+                return;
+            case 'error':
+                process.stderr.write(red('error: ') + red(msg.message) + '\n');
+                rl.prompt();
+                return;
+        }
+    };
+    const scheduleReconnect = () => {
+        if (exiting || reconnectTimer)
+            return;
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            connect();
+        }, RECONNECT_DELAY_MS);
+    };
+    const connect = () => {
+        if (exiting)
+            return;
+        buffer = '';
+        socket = net.connect(socketPath);
+        socket.on('connect', () => {
+            waitingNoticeShown = false;
+            // Silent reconnect when we're restoring a prior selection;
+            // otherwise announce the connection and ask for channels.
+            if (selected) {
+                restoring = true;
+                socket.write(JSON.stringify({ type: 'select', route: selected }) + '\n');
+                state = 'chatting';
+                rl.setPrompt(cyan(selected) + dim(' > '));
+                rl.prompt();
+            }
+            else {
+                process.stdout.write(green('[connected to framework]') + '\n');
+                socket.write(JSON.stringify({ type: 'hello' }) + '\n');
+            }
+        });
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString();
+            let idx;
+            while ((idx = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, idx);
+                buffer = buffer.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    handleServerMessage(JSON.parse(line));
+                }
+                catch (err) {
+                    process.stderr.write(red(`invalid server message: ${err.message}`) + '\n');
+                }
+            }
+        });
+        socket.on('error', (err) => {
+            const transient = err.code === 'ENOENT' ||
+                err.code === 'ECONNREFUSED' ||
+                err.code === 'ECONNRESET' ||
+                err.code === 'EPIPE';
+            if (!transient) {
+                process.stderr.write(red(`socket error: ${err.message}`) + '\n');
+            }
+        });
+        socket.on('close', () => {
+            const wasConnected = state !== 'disconnected';
+            state = 'disconnected';
+            socket = null;
+            if (exiting)
+                return;
+            if (wasConnected) {
+                process.stdout.write(yellow('\n[disconnected — waiting for framework to come back...]') + '\n');
+            }
+            else if (!waitingNoticeShown && !selected) {
+                waitingNoticeShown = true;
+                process.stdout.write(dim('Waiting for framework...') + '\n');
+            }
+            scheduleReconnect();
+        });
+    };
+    const cleanup = (code) => {
+        exiting = true;
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+        rl.close();
+        if (socket)
+            socket.end();
+        process.exit(code);
+    };
+    rl.on('line', (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+        if (trimmed === '/exit' || trimmed.toLowerCase() === 'exit') {
+            cleanup(0);
+            return;
+        }
+        if (trimmed === '/help') {
+            process.stdout.write(HELP_LINES.join('\n') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (trimmed === '/channels') {
+            send({ type: 'hello' });
+            return;
+        }
+        if (state === 'disconnected') {
+            process.stderr.write(red('not connected to framework — waiting for server...') + '\n');
+            rl.prompt();
+            return;
+        }
+        if (state === 'choosing') {
+            const num = Number.parseInt(trimmed, 10);
+            if (!Number.isInteger(num) || num < 1 || num > routes.length) {
+                process.stderr.write(red(`Invalid selection. Enter a number between 1 and ${routes.length}.`) + '\n');
+                rl.prompt();
+                return;
+            }
+            send({ type: 'select', route: routes[num - 1].route });
+            return;
+        }
+        send({ type: 'message', text: trimmed });
+    });
+    rl.on('close', () => cleanup(0));
+    connect();
+}
+
+export { runCmdClient };

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/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

@@ -1,13 +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 } from './PgRepositoryBase.js';
+export { PgRepositoryBase, PgRepositoryBase as PgRepositoryExtension } 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 { buildQuerySql } from './buildQuerySql.js';
 export { getPgClient, withPgClient } from './withPgClient.js';
 export { withPgTransaction } from './withPgTransaction.js';

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

@@ -30,9 +30,13 @@ 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';
+import { MemoryRepositoryAdapter } from '../repository/MemoryRepositoryAdapter.js';
+import { RepositoryMetadataStore } from '../repository/RepositoryMetadataStore.js';
+import { RepositoryAdapterRegistry } from '../repository/RepositoryAdapterRegistry.js';
 
 const logger = new Logger('wabot:project-runner');
 const TEST_FILE_PATTERNS = /\.(test|spec|unit|integration|e2e|multiprocess)\.(ts|js)$/;
+const DEFAULT_EXCLUDE = ['run.ts', 'cmd.ts'];
 const DEFAULT_CHAT_ADAPTERS = [
     ['../../addon/chat-bot/openia', 'OpenaiChatAdapter'],
     ['../../addon/chat-bot/openrouter', 'OpenRouterChatAdapter'],
@@ -41,12 +45,14 @@ const DEFAULT_CHAT_ADAPTERS = [
 ];
 class ProjectRunner {
     directories;
+    exclude;
     chatAdapters;
     connectionString;
     isPg;
     pool = null;
     constructor(config = {}) {
         this.directories = config.directories ?? ['src'];
+        this.exclude = [...DEFAULT_EXCLUDE, ...(config.exclude ?? [])];
         this.chatAdapters = config.chatAdapters;
         this.connectionString = this.resolveConnectionString(config.connectionString);
         this.isPg = this.connectionString != null && isPostgresUrl(this.connectionString);
@@ -83,10 +89,30 @@ class ProjectRunner {
             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 [];
-        })));
+        const excludedNames = new Set();
+        const excludedPathsByRoot = new Map();
+        for (const entry of this.exclude) {
+            if (entry.includes('/') || entry.includes('\\')) {
+                for (const root of roots) {
+                    let paths = excludedPathsByRoot.get(root);
+                    if (!paths) {
+                        paths = new Set();
+                        excludedPathsByRoot.set(root, paths);
+                    }
+                    paths.add(resolve(root, entry));
+                }
+            }
+            else {
+                excludedNames.add(entry);
+            }
+        }
+        const results = await Promise.all(roots.map((dir) => {
+            const excludedPaths = excludedPathsByRoot.get(dir) ?? new Set();
+            return scanDir(dir, excludedNames, excludedPaths).catch((err) => {
+                logger.warn(`Could not read directory ${dir}: ${err.message}`);
+                return [];
+            });
+        }));
         return results.flat();
     }
     async importFiles(files) {
@@ -97,6 +123,7 @@ class ProjectRunner {
         const results = await Promise.allSettled(files.map((file) => import(pathToFileURL(file).href)));
         let imported = 0;
         let failed = 0;
+        const errorGroups = new Map();
         for (let i = 0; i < results.length; i++) {
             const result = results[i];
             if (result.status === 'fulfilled') {
@@ -104,10 +131,21 @@ class ProjectRunner {
             }
             else {
                 failed++;
-                const reason = result.reason;
-                logger.error(`Failed to import ${files[i]}: ${reason.message}`);
+                const message = result.reason.message;
+                const group = errorGroups.get(message);
+                if (group) {
+                    group.push(files[i]);
+                }
+                else {
+                    errorGroups.set(message, [files[i]]);
+                }
             }
         }
+        for (const [message, affected] of errorGroups) {
+            const [first, ...rest] = affected;
+            const suffix = rest.length > 0 ? ` (also affects ${rest.length} more file(s))` : '';
+            logger.error(`Failed to import ${first}: ${message}${suffix}`);
+        }
         if (failed > 0) {
             logger.warn(`Imported ${imported}/${files.length} files (${failed} failed)`);
         }
@@ -143,12 +181,17 @@ class ProjectRunner {
             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);
+        container.register(ChatRepository, { useToken: chatBotMod.InMemoryChatRepository });
+        container.register(Locker, { useToken: lockMod.InMemoryLocker });
+        const memoryAdapter = new MemoryRepositoryAdapter();
+        container.resolve(RepositoryAdapterRegistry).setDefault(memoryAdapter);
+        container.resolve(RepositoryMetadataStore).validateExtensionsRegistered(memoryAdapter.id);
         if (asyncMod) {
-            container.registerType(JobRepository, asyncMod.InMemoryJobRepository);
+            container.register(JobRepository, { useToken: asyncMod.InMemoryJobRepository });
             if (components.cronHandlers.length > 0) {
-                container.registerType(CronJobRepository, asyncMod.InMemoryCronJobRepository);
+                container.register(CronJobRepository, {
+                    useToken: asyncMod.InMemoryCronJobRepository,
+                });
             }
         }
         logger.info('Configured with in-memory adapters');
@@ -162,17 +205,20 @@ class ProjectRunner {
             import('../pg/index.js'),
             import('../../addon/async/pg/index.js'),
         ]);
-        container.registerType(ChatRepository, chatBotMod.PgChatRepository);
-        container.registerType(Locker, pgMod.PgLocker);
+        container.register(ChatRepository, { useToken: chatBotMod.PgChatRepository });
+        container.register(Locker, { useToken: pgMod.PgLocker });
+        const pgAdapter = new pgMod.PgJsonRepositoryAdapter(this.pool);
+        container.resolve(RepositoryAdapterRegistry).setDefault(pgAdapter);
+        container.resolve(RepositoryMetadataStore).validateExtensionsRegistered(pgAdapter.id);
         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);
+            container.register(JobRepository, { useToken: asyncMod.PgJobRepository });
         }
         if (hasCronHandlers) {
-            container.registerType(CronJobRepository, asyncMod.PgCronJobRepository);
+            container.register(CronJobRepository, { useToken: asyncMod.PgCronJobRepository });
         }
         logger.info('Configured with PostgreSQL adapters');
     }
@@ -227,14 +273,19 @@ function run(config) {
 function isPostgresUrl(cs) {
     return cs.startsWith('postgres://') || cs.startsWith('postgresql://');
 }
-async function scanDir(dir) {
+async function scanDir(dir, excludedNames, excludedPaths) {
     const entries = await readdir(dir, { withFileTypes: true });
     const subResults = await Promise.all(entries.map(async (entry) => {
         const name = entry.name;
+        const fullPath = join(dir, name);
+        if (excludedNames.has(name))
+            return [];
+        if (excludedPaths.has(fullPath))
+            return [];
         if (entry.isDirectory()) {
             if (name.startsWith('__'))
                 return [];
-            return scanDir(join(dir, name));
+            return scanDir(fullPath, excludedNames, excludedPaths);
         }
         if (!entry.isFile())
             return [];
@@ -242,7 +293,6 @@ async function scanDir(dir) {
             return [];
         if (name.endsWith('.d.ts'))
             return [];
-        const fullPath = join(dir, name);
         if (TEST_FILE_PATTERNS.test(fullPath))
             return [];
         return [fullPath];

package/dist/src/feature/repository/@memoryExtension.js

@@ -0,0 +1,29 @@
+import { container } from '../../core/injection/index.js';
+import { MEMORY_ADAPTER_ID, MemoryRepositoryExtension } from './MemoryRepositoryAdapter.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function inheritsFrom(ctor, base) {
+    let proto = ctor.prototype;
+    while (proto) {
+        if (proto === base.prototype)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}
+function memoryExtension(repositoryClass) {
+    if (typeof repositoryClass !== 'function') {
+        throw new Error(`@memoryExtension: repository argument must be a class, ` +
+            `got ${typeof repositoryClass}`);
+    }
+    return function (target) {
+        if (!inheritsFrom(target, MemoryRepositoryExtension)) {
+            throw new Error(`@memoryExtension on ${target.name}: extension class must extend ` +
+                `MemoryRepositoryExtension.`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveExtension(repositoryClass, MEMORY_ADAPTER_ID, target);
+    };
+}
+
+export { memoryExtension };

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

@@ -0,0 +1,22 @@
+import { container } from '../../core/injection/index.js';
+import { parseQueryMethodName } from './parseQueryMethodName.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function query() {
+    return function (target, propertyKey, descriptor) {
+        const functionName = propertyKey.toString();
+        const ctor = target.constructor;
+        parseQueryMethodName(functionName);
+        const value = descriptor ? descriptor.value : target[propertyKey];
+        if (value !== undefined && typeof value !== 'function') {
+            throw new Error(`@query() on ${ctor.name}.${functionName}: decorated property must be a function`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveQueryMethodMetadata({
+            repositoryConstructor: ctor,
+            functionName,
+        });
+    };
+}
+
+export { query };

package/dist/src/feature/repository/@queryExtension.js

@@ -0,0 +1,21 @@
+import { container } from '../../core/injection/index.js';
+import { RepositoryMetadataStore } from './RepositoryMetadataStore.js';
+
+function queryExtension() {
+    return function (target, propertyKey, descriptor) {
+        const functionName = propertyKey.toString();
+        const ctor = target.constructor;
+        const value = descriptor ? descriptor.value : target[propertyKey];
+        if (value !== undefined && typeof value !== 'function') {
+            throw new Error(`@queryExtension() on ${ctor.name}.${functionName}: ` +
+                `decorated property must be a function (typically a declare).`);
+        }
+        const store = container.resolve(RepositoryMetadataStore);
+        store.saveExtensionMethodMetadata({
+            repositoryConstructor: ctor,
+            functionName,
+        });
+    };
+}
+
+export { queryExtension };