@wabot-dev/framework 0.2.6 → 0.4.0-beta.1

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

@@ -0,0 +1,80 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { JobRepository } from './JobRepository.js';
+import { Env } from '../../core/env/Env.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { JobExecutor } from './JobExecutor.js';
+import { Locker } from '../../core/lock/Locker.js';
+
+let JobScheduler = class JobScheduler {
+    locker;
+    repo;
+    executor;
+    env;
+    timeout;
+    logger = new Logger('wabot:job-scheduler');
+    commands = new Set();
+    running = false;
+    constructor(locker, repo, executor, env) {
+        this.locker = locker;
+        this.repo = repo;
+        this.executor = executor;
+        this.env = env;
+    }
+    start(commands) {
+        this.logger.info(`starting handlers for commands ${commands}`);
+        commands.forEach((x) => this.commands.add(x));
+        this.logger.info(`starting job handlers for commands ${commands.join(', ')}`);
+        if (this.commands.size > 0 && !this.running) {
+            this.running = true;
+            this.tick();
+        }
+    }
+    stop(commands) {
+        this.logger.info(`stoping handlers for commands ${commands}`);
+        commands.forEach((x) => this.commands.delete(x));
+        if (this.commands.size === 0) {
+            this.running = false;
+            if (this.timeout) {
+                clearTimeout(this.timeout);
+            }
+        }
+    }
+    tryExecuteNow(job) {
+        if (this.commands.has(job.commandName))
+            this.executor.execute(job).catch((e) => this.logger.error(e));
+    }
+    async tick() {
+        if (!this.running)
+            return;
+        const interval = this.env.requireNumber('WABOT_JOB_SCHEDULER_INTERVAL_SECONDS', {
+            default: 10,
+        });
+        try {
+            const remainingSlots = this.executor.remainingSlots();
+            if (remainingSlots === 0)
+                return;
+            await this.locker.withKey('wabot-job-scheduler-loop').run(async () => {
+                const jobs = await this.repo.findPendingForRunFrom(new Date(), this.executor.remainingSlots());
+                const readyToRunJobs = jobs.filter((job) => this.commands.has(job.commandName) && job.isScheduleReady());
+                readyToRunJobs.forEach((j) => this.executor.execute(j).catch((e) => this.logger.error(e)));
+                await new Promise((r) => setTimeout(r, 10));
+            });
+        }
+        catch (e) {
+            this.logger.error(e);
+        }
+        finally {
+            this.timeout = setTimeout(() => this.tick(), interval * 1000);
+        }
+    }
+};
+JobScheduler = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Locker,
+        JobRepository,
+        JobExecutor,
+        Env])
+], JobScheduler);
+
+export { JobScheduler };

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

@@ -0,0 +1,74 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { JobRepository } from './JobRepository.js';
+import { Env } from '../../core/env/Env.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { Locker } from '../../core/lock/Locker.js';
+
+let JobWatchdog = class JobWatchdog {
+    locker;
+    repo;
+    env;
+    timeout;
+    logger = new Logger('wabot:job-watchdog');
+    commands = new Set();
+    running = false;
+    constructor(locker, repo, env) {
+        this.locker = locker;
+        this.repo = repo;
+        this.env = env;
+    }
+    start(commands) {
+        commands.forEach((x) => this.commands.add(x));
+        if (this.commands.size > 0 && !this.running) {
+            this.running = true;
+            this.tick();
+        }
+    }
+    stop(commands) {
+        commands.forEach((x) => this.commands.delete(x));
+        if (this.commands.size === 0) {
+            this.running = false;
+            if (this.timeout)
+                clearTimeout(this.timeout);
+        }
+    }
+    async tick() {
+        if (!this.running)
+            return;
+        const interval = this.env.requireNumber('WABOT_JOB_WATCHDOG_INTERVAL_SECONDS', {
+            default: 300,
+        });
+        try {
+            await this.locker.withKey('wabot-job-watchdog-loop').run(async () => {
+                const jobs = await this.repo.findRunningJobs();
+                for (const job of jobs) {
+                    if (!job.isStuck() || !this.commands.has(job.commandName))
+                        continue;
+                    try {
+                        this.logger.warn(`Recovering stuck job ${job.id}`);
+                        job.recover();
+                        await this.repo.update(job);
+                    }
+                    catch (e) {
+                        this.logger.error(`Failed to recover job ${job.id}`, e);
+                    }
+                }
+            });
+        }
+        catch (e) {
+            this.logger.error('Recovery process failed', e);
+        }
+        finally {
+            this.timeout = setTimeout(() => this.tick(), interval * 1000);
+        }
+    }
+};
+JobWatchdog = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Locker,
+        JobRepository,
+        Env])
+], JobWatchdog);
+
+export { JobWatchdog };

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

@@ -1,29 +1,23 @@
-import { JobsEventsHub } from './JobsEventsHub.js';
-import { JobRunner } from './JobRunner.js';
-import { CommandMetadataStore } from './CommandMetadataStore.js';
-import { JobRepository } from './JobRepository.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { container } from '../../core/injection/index.js';
+import { JobScheduler } from './JobScheduler.js';
+import { JobWatchdog } from './JobWatchdog.js';
 
-function runAsyncCommandHandlers(handlers) {
-    const eventsHub = container.resolve(JobsEventsHub);
-    const jobRunner = container.resolve(JobRunner);
-    const jobRepository = container.resolve(JobRepository);
-    const commandsHandlersContainer = container.resolve(CommandMetadataStore);
-    const handledCommands = handlers
-        .map((x) => commandsHandlersContainer.getCommandNameForHandler(x))
-        .filter((x) => x)
-        .map((x) => x);
-    eventsHub.listenJobsEvents(async (event) => {
-        try {
-            const job = await jobRepository.findOrThrow(event.jobId);
-            if (handledCommands.includes(job.commandName)) {
-                jobRunner.run(job);
-            }
-        }
-        catch (e) {
-            console.error(e);
-        }
-    });
+function runCommandHandlers(handlers) {
+    const jobScheduler = container.resolve(JobScheduler);
+    const jobWatchdog = container.resolve(JobWatchdog);
+    const metadataStore = container.resolve(AsyncMetadataStore);
+    const commands = handlers.map((x) => metadataStore.requireCommandNameForHandler(x));
+    jobScheduler.start(commands);
+    jobWatchdog.start(commands);
+}
+function stopCommandHandlers(handlers) {
+    const jobScheduler = container.resolve(JobScheduler);
+    const jobWatchdog = container.resolve(JobWatchdog);
+    const metadataStore = container.resolve(AsyncMetadataStore);
+    const commands = handlers.map((x) => metadataStore.requireCommandNameForHandler(x));
+    jobScheduler.stop(commands);
+    jobWatchdog.stop(commands);
 }
 
-export { runAsyncCommandHandlers };
+export { runCommandHandlers, stopCommandHandlers };

package/dist/src/feature/chat-bot/Chat.js

@@ -10,6 +10,9 @@ class Chat extends Entity {
     isGroup() {
         return this.data.type === 'GROUP';
     }
+    get connections() {
+        return this.data.connections;
+    }
     hasConnection(connection) {
         for (const con of this.data.connections) {
             if (con.channelName === connection.channelName && con.id === connection.id) {

package/dist/src/feature/chat-controller/runChatControllers.js

@@ -20,7 +20,7 @@ async function prepareChatContainer(container, messageContext, mindsetCtor) {
     const chatRepository = container.resolve(ChatRepository);
     const chatMemory = await chatRepository.findMemory(messageContext.chat.id);
     if (!chatMemory) {
-        throw new Error('Not found Chat Memory for Chat with Id=' + messageContext.chat.id);
+        throw new Error('Not found Chaqt Memory for Chat with Id=' + messageContext.chat.id);
     }
     chatContainer.registerInstance(ChatMemory, chatMemory);
     if (messageContext.authInfo) {

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

@@ -1,6 +1,7 @@
 import * as shortUUID from 'short-uuid';
 import { PgRepositoryBase } from './PgRepositoryBase.js';
 import { CustomError } from '../../core/error/CustomError.js';
+import { withPgClient } from './withPgClient.js';
 
 class PgCrudRepository extends PgRepositoryBase {
     config;
@@ -69,7 +70,12 @@ class PgCrudRepository extends PgRepositoryBase {
          SET ${this.updates}
       WHERE id = $${this.columnsList.length + 1}
     `;
-        await this.exec(sql, [...this.values(item), item.id]);
+        const result = await withPgClient(this.pool, async (client) => {
+            return await client.query(sql, [...this.values(item), item.id]);
+        });
+        if (result.rowCount === 0) {
+            throw new Error(`Update failed: no affected rows'`);
+        }
     }
     async delete(item) {
         const sql = `

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

@@ -0,0 +1,20 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { Pool } from 'pg';
+import { PgLockKey } from './PgLockKey.js';
+
+let PgLocker = class PgLocker {
+    pool;
+    constructor(pool) {
+        this.pool = pool;
+    }
+    withKey(key) {
+        return new PgLockKey(key, this.pool);
+    }
+};
+PgLocker = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgLocker);
+
+export { PgLocker };

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

@@ -0,0 +1,68 @@
+import { Logger } from '../../core/logger/Logger.js';
+import { createHash } from 'node:crypto';
+import { withPgClient } from './withPgClient.js';
+
+class PgLockKey {
+    key;
+    pool;
+    value;
+    logger = new Logger('wabot:pg-lock-key');
+    constructor(key, pool) {
+        this.key = key;
+        this.pool = pool;
+        this.value = typeof key === 'number' ? BigInt(key) : PgLockKey.hashString(key);
+    }
+    async run(fn) {
+        return withPgClient(this.pool, async (client) => {
+            let locked = false;
+            try {
+                this.logger.debug(`try to adquire ${this.key}`);
+                await client.query('SELECT pg_advisory_lock($1)', [this.value]);
+                this.logger.debug(`adquired ${this.key}`);
+                locked = true;
+                return await fn();
+            }
+            finally {
+                if (locked) {
+                    this.logger.debug(`try to release ${this.key}`);
+                    const res = await client.query('SELECT pg_advisory_unlock($1) AS unlocked', [this.value]);
+                    if (!res.rows[0]?.unlocked) {
+                        this.logger.error('error - no unlock');
+                    }
+                    else {
+                        this.logger.debug(`released ${this.key}`);
+                    }
+                }
+            }
+        });
+    }
+    async tryRun(fn) {
+        return withPgClient(this.pool, async (client) => {
+            let locked = false;
+            try {
+                const result = await client.query('SELECT pg_try_advisory_lock($1) AS locked', [this.value]);
+                locked = result.rows[0]?.locked === true;
+                if (!locked)
+                    return undefined;
+                return await fn();
+            }
+            finally {
+                if (locked) {
+                    const res = await client.query('SELECT pg_advisory_unlock($1) AS unlocked', [this.value]);
+                    if (!res.rows[0]?.unlocked) {
+                        this.logger.error('error - no unlock');
+                    }
+                }
+            }
+        });
+    }
+    toString() {
+        return `PgLockKey(${String(this.key)})`;
+    }
+    static hashString(key) {
+        const hash = createHash('sha256').update(key).digest('hex').slice(0, 15);
+        return BigInt('0x' + hash);
+    }
+}
+
+export { PgLockKey };

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

@@ -1,7 +1,11 @@
+import { withPgClient } from './withPgClient.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { PgLocker } from './PgLock.js';
+
 class PgRepositoryBase {
     pool;
     config;
-    tableIsCreated = false;
+    tableIsReady = false;
     schema;
     table;
     columnsList;
@@ -9,6 +13,7 @@ class PgRepositoryBase {
     columns;
     vars;
     updates;
+    logger = new Logger('wabot:pg-repository-base');
     addColumns;
     constructor(pool, config) {
         this.pool = pool;
@@ -25,7 +30,7 @@ class PgRepositoryBase {
             '"created_at" TIMESTAMP',
             '"data" JSONB',
             ...this.columnsList.slice(3).map((x) => `${x} ${this.addColumns[x].type}`),
-        ].join(', ');
+        ];
         this.columns = this.columnsList.map((x) => `"${x}"`).join(', ');
         this.vars = this.columnsList.map((_, i) => `$${i + 1}`).join(', ');
         this.updates = this.columnsList.map((x, i) => `"${x}" = $${i + 1}`).join(', ');
@@ -39,36 +44,44 @@ class PgRepositoryBase {
         ];
     }
     async exec(sql, values) {
-        const conn = await this.connect();
-        await conn.query(sql, values);
+        return withPgClient(this.pool, async (client) => {
+            await this.ensureTable(client);
+            await client.query(sql, values);
+        });
     }
     async query(sql, values) {
-        const conn = await this.connect();
-        const { rows } = await conn.query(sql, values);
-        return rows.map((row) => new this.config.constructor(row.data));
+        return withPgClient(this.pool, async (client) => {
+            await this.ensureTable(client);
+            const { rows } = await client.query(sql, values);
+            return rows.map((row) => new this.config.constructor(row.data));
+        });
     }
-    async connect() {
-        await this.ensureTable();
-        return this.pool;
-    }
-    async ensureTable() {
-        if (this.tableIsCreated) {
+    async ensureTable(client) {
+        if (this.tableIsReady) {
             return;
         }
-        const schemaQuery = `
-      CREATE SCHEMA IF NOT EXISTS ${this.schema}
-    `;
-        const tableQuery = `
-      CREATE TABLE IF NOT EXISTS ${this.table} (
-      ${this.columnsAndTypes}
-      )
-    `;
-        await this.pool.query(schemaQuery);
-        await this.pool.query(tableQuery);
-        await this.ensureColumns();
+        const locker = new PgLocker(this.pool);
+        await locker.withKey(`wabot-pgrepo-ensure-table-${this.table}`).run(async () => {
+            if (this.tableIsReady) {
+                return;
+            }
+            this.logger.debug(`running  schema sync for ${this.table}`);
+            const schemaQuery = `
+        CREATE SCHEMA IF NOT EXISTS ${this.schema}
+      `;
+            const tableQuery = `
+        CREATE TABLE IF NOT EXISTS ${this.table} (
+          ${this.columnsAndTypes.join(', ')}
+        )
+      `;
+            await client.query(schemaQuery);
+            await client.query(tableQuery);
+            await this.ensureColumns(client);
+            this.tableIsReady = true;
+        });
     }
-    async ensureColumns() {
-        const { rows: existing } = await this.pool.query(`
+    async ensureColumns(client) {
+        const { rows: existing } = await client.query(`
       SELECT column_name
       FROM information_schema.columns
       WHERE table_name = $1 AND table_schema = $2
@@ -80,7 +93,7 @@ class PgRepositoryBase {
             if (!existingColumns.has(col)) {
                 const alterSql = `ALTER TABLE ${this.table} ADD COLUMN ${columnAndType}`;
                 console.log(`[INFO] Adding column: ${alterSql}`);
-                await this.pool.query(alterSql);
+                await client.query(alterSql);
             }
         }
     }

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

@@ -0,0 +1,16 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+const pgStorage = new AsyncLocalStorage();
+/**
+ * Get or initialize the client map for the current async context
+ */
+function getClientMap() {
+    let map = pgStorage.getStore();
+    if (!map) {
+        map = new Map();
+        pgStorage.enterWith(map);
+    }
+    return map;
+}
+
+export { getClientMap, pgStorage };

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

@@ -0,0 +1,45 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+// Async-local storage for clients per pool
+const pgStorage = new AsyncLocalStorage();
+function getClientMap() {
+    let map = pgStorage.getStore();
+    if (!map) {
+        map = new Map();
+        pgStorage.enterWith(map);
+    }
+    return map;
+}
+/**
+ * Runs a function with a shared Postgres client for the given pool.
+ * Reuses the client if already present in the async context.
+ */
+async function withPgClient(pool, fn) {
+    const clients = getClientMap();
+    if (clients.has(pool)) {
+        // Already a shared client in async context, reuse it
+        return fn(clients.get(pool));
+    }
+    // No client yet, acquire a new one
+    const client = await pool.connect();
+    try {
+        clients.set(pool, client);
+        return await fn(client);
+    }
+    finally {
+        clients.delete(pool);
+        client.release();
+    }
+}
+/**
+ * Get the current shared client for a pool.
+ * Falls back to the pool itself if no shared client exists.
+ */
+function getPgClient(pool) {
+    const clients = pgStorage.getStore();
+    if (clients?.has(pool))
+        return clients.get(pool);
+    return pool;
+}
+
+export { getPgClient, withPgClient };

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

@@ -0,0 +1,45 @@
+import { getPgClient } from './withPgClient.js';
+
+let savepointCounter = 0;
+async function withPgTransaction(pool, fn) {
+    // Always get the shared client
+    const client = getPgClient(pool);
+    if (!('__transactionStack' in client)) {
+        client.__transactionStack = [];
+    }
+    const stack = client.__transactionStack;
+    const isOuterTransaction = stack.length === 0;
+    const savepointName = isOuterTransaction ? null : `sp_${++savepointCounter}`;
+    if (savepointName)
+        await client.query(`SAVEPOINT ${savepointName}`);
+    if (isOuterTransaction)
+        await client.query('BEGIN');
+    stack.push(savepointName || 'outer');
+    try {
+        const result = await fn(client);
+        if (savepointName) {
+            await client.query(`RELEASE SAVEPOINT ${savepointName}`);
+        }
+        else if (isOuterTransaction) {
+            await client.query('COMMIT');
+        }
+        stack.pop();
+        if (isOuterTransaction)
+            delete client.__transactionStack;
+        return result;
+    }
+    catch (err) {
+        if (savepointName) {
+            await client.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+        }
+        else if (isOuterTransaction) {
+            await client.query('ROLLBACK');
+        }
+        stack.pop();
+        if (isOuterTransaction)
+            delete client.__transactionStack;
+        throw err;
+    }
+}
+
+export { withPgTransaction };