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

package/dist/src/addon/async/pg/PgJobRepository.js

@@ -2,12 +2,18 @@ import { __decorate, __metadata } from 'tslib';
 import { Pool } from 'pg';
 import { singleton } from '../../../core/injection/index.js';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
-import '../../../feature/async/CommandMetadataStore.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import { withPgClient } from '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
+import '../../../feature/async/AsyncMetadataStore.js';
 import '../../../feature/async/Async.js';
 import { Job } from '../../../feature/async/Job.js';
 import '../../../feature/async/JobRepository.js';
 import '../../../feature/async/JobRunner.js';
-import '../../../feature/async/JobsEventsHub.js';
+import '../../../feature/async/JobScheduler.js';
+import '../../../feature/async/JobWatchdog.js';
 
 let PgJobRepository = class PgJobRepository extends PgCrudRepository {
     constructor(pool) {
@@ -17,6 +23,48 @@ let PgJobRepository = class PgJobRepository extends PgCrudRepository {
             constructor: Job,
         });
     }
+    async findPendingForRunFrom(date, limit) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data ? 'scheduledAt'
+        AND (data->>'scheduledAt')::bigint <= $1
+        AND data->>'startedAt' IS NULL
+        AND data->>'successAt' IS NULL
+        AND data->>'failedAt' IS NULL 
+      ORDER BY (data->>'scheduledAt')::bigint ASC
+      LIMIT $2
+    `;
+        const items = await this.query(sql, [date.getTime(), limit]);
+        return items;
+    }
+    async findRunningJobs() {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data ? 'startedAt'
+        AND data->>'startedAt' IS NOT NULL
+        AND data->>'successAt' IS NULL
+        AND data->>'failedAt' IS NULL
+    `;
+        const items = await this.query(sql, []);
+        return items;
+    }
+    async countRunningByCommand(commandName) {
+        const sql = `
+      SELECT COUNT(*)::int AS count
+      FROM ${this.table}
+      WHERE data ? 'startedAt'
+        AND data->>'startedAt' IS NOT NULL
+        AND data->>'successAt' IS NULL
+        AND data->>'failedAt' IS NULL
+        AND data->>'commandName' = $1
+    `;
+        return withPgClient(this.pool, async (client) => {
+            const result = await client.query(sql, [commandName]);
+            return result.rows[0]?.count ?? 0;
+        });
+    }
 };
 PgJobRepository = __decorate([
     singleton(),

package/dist/src/addon/auth/api-key/PgApiKeyRepository.js

@@ -1,5 +1,10 @@
 import { __decorate, __metadata } from 'tslib';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
 import { Pool } from 'pg';
 import { ApiKey } from './ApiKey.js';
 import { CustomError } from '../../../core/error/CustomError.js';

package/dist/src/addon/auth/jwt/PgJwtRefreshTokenRepository.js

@@ -1,9 +1,14 @@
 import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
-import { Pool } from 'pg';
+import { CustomError } from '../../../core/error/CustomError.js';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
+import { Pool } from 'pg';
 import { JwtRefreshToken } from './JwtRefreshToken.js';
-import { CustomError } from '../../../core/error/CustomError.js';
 
 let PgJwtRefreshTokenRepository = class PgJwtRefreshTokenRepository extends PgCrudRepository {
     constructor(pool) {

package/dist/src/addon/chat-bot/pg/PgChatMemory.js

@@ -1,4 +1,9 @@
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import { ChatItem } from '../../../feature/chat-bot/ChatItem.js';
 import '../../../core/injection/index.js';

package/dist/src/addon/chat-bot/pg/PgChatRepository.js

@@ -3,6 +3,11 @@ import { Pool } from 'pg';
 import { PgChatMemory } from './PgChatMemory.js';
 import { singleton } from '../../../core/injection/index.js';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
 import { Chat } from '../../../feature/chat-bot/Chat.js';
 import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';

package/dist/src/addon/chat-controller/whatsapp/PgWhatsAppRepository.js

@@ -3,6 +3,11 @@ import { Pool } from 'pg';
 import { WhatsApp } from './WhatsApp.js';
 import { singleton } from '../../../core/injection/index.js';
 import { PgCrudRepository } from '../../../feature/pg/PgCrudRepository.js';
+import '../../../feature/pg/PgLock.js';
+import 'debug';
+import 'node:crypto';
+import '../../../feature/pg/withPgClient.js';
+import '../../../feature/pg/pgStorage.js';
 
 let PgWhatsAppRepository = class PgWhatsAppRepository extends PgCrudRepository {
     constructor(pool) {

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

@@ -44,6 +44,7 @@ let WhatsAppReceiverByWabotProxy = class WhatsAppReceiverByWabotProxy extends Wh
                 this.loger.trace(`success receive message from '${data.from}' to '${data.to}'`);
                 request.listener({
                     chatConnection: {
+                        chatType: 'PRIVATE',
                         channelName: 'WhatsAppChannel',
                         id: data.from,
                     },

package/dist/src/core/lock/Locker.js

@@ -0,0 +1,7 @@
+class Locker {
+    withKey(key) {
+        throw new Error('Not implemented');
+    }
+}
+
+export { Locker };

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

@@ -1,10 +1,10 @@
-import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { container } from '../../core/injection/index.js';
 
 function command(config) {
     return function (target) {
-        const handlerContainer = container.resolve(CommandMetadataStore);
-        handlerContainer.registerCommand(target, config?.name ?? target.name);
+        const metadataStore = container.resolve(AsyncMetadataStore);
+        metadataStore.registerCommand(target, typeof config === 'string' ? config : config.name);
     };
 }
 

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

@@ -1,10 +1,10 @@
-import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { container, injectable } from '../../core/injection/index.js';
 
 function commandHandler(config) {
     return function (target) {
-        const handlerContainer = container.resolve(CommandMetadataStore);
-        handlerContainer.registerHandler(config.command, target);
+        const metadataStore = container.resolve(AsyncMetadataStore);
+        metadataStore.registerCommandHandler(typeof config === 'function' ? config : config.command, target);
         injectable()(target);
     };
 }

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

@@ -1,38 +1,45 @@
 import { __decorate, __metadata } from 'tslib';
 import { singleton } from '../../core/injection/index.js';
-import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { Job } from './Job.js';
 import { JobRepository } from './JobRepository.js';
-import { JobsEventsHub } from './JobsEventsHub.js';
+import { JobScheduler } from './JobScheduler.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
 
 let Async = class Async {
     jobRepository;
-    handlerContainer;
-    jobsEventsHub;
-    constructor(jobRepository, handlerContainer, jobsEventsHub) {
+    metadataStore;
+    jobScheduler;
+    constructor(jobRepository, metadataStore, jobScheduler) {
         this.jobRepository = jobRepository;
-        this.handlerContainer = handlerContainer;
-        this.jobsEventsHub = jobsEventsHub;
+        this.metadataStore = metadataStore;
+        this.jobScheduler = jobScheduler;
     }
-    async run(command) {
-        const commandName = this.handlerContainer.getCommandName(command.constructor);
+    async runCommand(ctor, data) {
+        const commandName = this.metadataStore.getCommandName(ctor);
         if (!commandName) {
-            throw new Error(`${command.constructor.name} is not registered as command`);
+            throw new Error(`${ctor.name} is not registered as command`);
+        }
+        const { error, value: commandData } = validateAndTransform(data, ctor);
+        if (!commandData) {
+            throw new Error('Invalid command data');
         }
         const job = new Job({
             commandName,
-            commandData: command['data'],
+            commandData,
+            scheduledAt: new Date().getTime(),
         });
         await this.jobRepository.create(job);
-        this.jobsEventsHub.notifyJobCreated(job);
+        this.jobScheduler.tryExecuteNow(job);
         return job;
     }
 };
 Async = __decorate([
     singleton(),
     __metadata("design:paramtypes", [JobRepository,
-        CommandMetadataStore,
-        JobsEventsHub])
+        AsyncMetadataStore,
+        JobScheduler])
 ], Async);
 
 export { Async };

package/dist/src/feature/async/{CommandMetadataStore.js → AsyncMetadataStore.js}

@@ -1,16 +1,32 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../core/injection/index.js';
 
-let CommandMetadataStore = class CommandMetadataStore {
+let AsyncMetadataStore = class AsyncMetadataStore {
     handlersMap = new Map();
     handlersInverseMap = new Map();
     commandsMap = new Map();
     commandsInverseMap = new Map();
+    cronsMap = new Map();
+    registerCron(cron, config) {
+        let ctorCrons = this.cronsMap.get(cron);
+        if (!ctorCrons) {
+            this.cronsMap.set(cron, (ctorCrons = []));
+        }
+        ctorCrons.push({ handlerConstructor: cron, config });
+        this.handlersMap.set(config.commandName, cron);
+    }
+    requireCronMetadata(cron) {
+        const metadata = this.cronsMap.get(cron);
+        if (!metadata) {
+            throw new Error(`cron ${cron.name} is not registered`);
+        }
+        return metadata;
+    }
     registerCommand(command, commandName) {
         this.commandsMap.set(commandName, command);
         this.commandsInverseMap.set(command, commandName);
     }
-    registerHandler(command, handlerConstructor) {
+    registerCommandHandler(command, handlerConstructor) {
         let commandName = this.commandsInverseMap.get(command);
         if (!commandName) {
             throw new Error(`Should use @command decorator on command class ${command.name}`);
@@ -24,6 +40,12 @@ let CommandMetadataStore = class CommandMetadataStore {
     getCommandNameForHandler(handlerConstructor) {
         return this.handlersInverseMap.get(handlerConstructor) ?? null;
     }
+    requireCommandNameForHandler(handlerConstructor) {
+        const commmandName = this.handlersInverseMap.get(handlerConstructor) ?? null;
+        if (!commmandName)
+            throw new Error(`Can't found a registered command for ${handlerConstructor.name}`);
+        return commmandName;
+    }
     getCommandName(command) {
         return this.commandsInverseMap.get(command) ?? null;
     }
@@ -31,8 +53,8 @@ let CommandMetadataStore = class CommandMetadataStore {
         return this.commandsMap.get(commandName) ?? null;
     }
 };
-CommandMetadataStore = __decorate([
+AsyncMetadataStore = __decorate([
     singleton()
-], CommandMetadataStore);
+], AsyncMetadataStore);
 
-export { CommandMetadataStore };
+export { AsyncMetadataStore };

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

@@ -5,22 +5,112 @@ class Job extends Entity {
     get commandName() {
         return this.data.commandName;
     }
+    get commandData() {
+        return this.data.commandData;
+    }
+    get reintentsDelaysInSeconds() {
+        return this.data.reintentsDelaysInSeconds;
+    }
+    get aceptableRunningTimeSeconds() {
+        return this.data.aceptableRunningTimeSeconds;
+    }
+    get stuckRetryAttempts() {
+        return this.data.stuckRetryAttempts;
+    }
+    get runningSeconds() {
+        if (!this.isRunning())
+            return -1;
+        const now = new Date().getTime();
+        return (now - this.data.startedAt) / 1000;
+    }
+    get successAt() {
+        return this.data.successAt != null ? new Date(this.data.successAt) : null;
+    }
+    get failedAt() {
+        return this.data.failedAt != null ? new Date(this.data.failedAt) : null;
+    }
+    get scheduledAt() {
+        return this.data.scheduledAt != null ? new Date(this.data.scheduledAt) : null;
+    }
+    get intentNumber() {
+        return this.data.intentNumber ?? 0;
+    }
+    wasSuccess() {
+        return this.successAt != null;
+    }
+    wasFailed() {
+        return this.data.failedAt != null;
+    }
     hasFinished() {
-        return this.data.successAt != null || this.data.failedAt != null;
+        return this.wasSuccess() || this.wasFailed();
+    }
+    isRunning() {
+        return (!this.hasFinished() &&
+            this.data.scheduledAt != null &&
+            this.data.startedAt != null &&
+            this.data.startedAt >= this.data.scheduledAt &&
+            this.data.startedAt <= new Date().getTime() &&
+            this.data.intentNumber != null);
+    }
+    isScheduleReady() {
+        return (!this.hasFinished() &&
+            !this.isRunning() &&
+            this.data.scheduledAt != null &&
+            this.data.scheduledAt <= new Date().getTime());
+    }
+    isStuck() {
+        return this.runningSeconds > (this.data.aceptableRunningTimeSeconds ?? 900);
     }
     setAsStarted() {
+        if (!this.isScheduleReady())
+            throw new Error(`job ${this.id} can't be started without ready schedule`);
         this.data.startedAt = new Date().getTime();
+        this.data.intentNumber = this.data.intentNumber == null ? 0 : this.data.intentNumber + 1;
     }
     setAsSuccess() {
+        if (this.hasFinished())
+            throw new Error(`job ${this.id} Can't be set as success because has be finished previously`);
+        if (!this.isRunning())
+            throw new Error(`job ${this.id} can't be set as success because is no running`);
         this.data.successAt = new Date().getTime();
     }
     setAsFailed(error) {
-        this.data.failedAt = new Date().getTime();
+        if (this.hasFinished())
+            throw new Error(`job ${this.id} Can't be set as failed because has be finished previously`);
+        if (!this.isRunning())
+            throw new Error(`job ${this.id} can't be set as failed because is no running`);
+        const now = new Date().getTime();
         this.data.error = {
+            time: now,
             message: error.message,
             stack: error.stack,
             info: error instanceof CustomError ? error.info : undefined,
         };
+        if (this.data.intentNumber == null)
+            throw new Error('Invalid intent number');
+        const currentReintentDelay = (this.data.reintentsDelaysInSeconds ?? []).at(this.data.intentNumber);
+        if (currentReintentDelay == null) {
+            this.data.failedAt = now;
+        }
+        else {
+            this.data.scheduledAt = now + currentReintentDelay * 1000;
+            this.data.startedAt = undefined;
+        }
+    }
+    recover() {
+        if (!this.isStuck())
+            throw new Error(`job ${this.id} Can't be recovered because is not stuck`);
+        const now = Date.now();
+        this.data.intentNumber = (this.data.intentNumber ?? 0) + 1;
+        const configuredAttempts = this.data.stuckRetryAttempts ?? 2;
+        if (this.data.intentNumber <= configuredAttempts) {
+            this.data.scheduledAt = now;
+            this.data.startedAt = undefined;
+        }
+        else {
+            this.data.failedAt = now;
+            this.data.error = { time: now, message: 'Job stuck and exceeded maximum retries' };
+        }
     }
 }
 

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

@@ -0,0 +1,62 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { JobRunner } from './JobRunner.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 JobExecutor = class JobExecutor {
+    locker;
+    runner;
+    repo;
+    env;
+    activeJobs = 0;
+    logger = new Logger('wabot:job-executor');
+    constructor(locker, runner, repo, env) {
+        this.locker = locker;
+        this.runner = runner;
+        this.repo = repo;
+        this.env = env;
+    }
+    remainingSlots() {
+        const max = this.env.requireNumber('WABOT_JOB_EXECUTOR_MAX_CONCURRENT_JOBS', { default: 5 });
+        return max - this.activeJobs;
+    }
+    async execute(job) {
+        if (!this.tryAcquire())
+            return;
+        try {
+            await this.locker.withKey(`wabot-job-${job.id}`).tryRun(async () => {
+                const fresh = await this.repo.findOrThrow(job.id);
+                if (!fresh.isScheduleReady())
+                    return;
+                await this.runner.run(fresh);
+            });
+        }
+        catch (e) {
+            this.logger.error(e);
+        }
+        finally {
+            this.release();
+        }
+    }
+    tryAcquire() {
+        if (this.remainingSlots() <= 0)
+            return false;
+        this.activeJobs++;
+        return true;
+    }
+    release() {
+        this.activeJobs = Math.max(0, this.activeJobs - 1);
+    }
+};
+JobExecutor = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Locker,
+        JobRunner,
+        JobRepository,
+        Env])
+], JobExecutor);
+
+export { JobExecutor };

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

@@ -2,6 +2,12 @@ import { __decorate } from 'tslib';
 import { singleton } from '../../core/injection/index.js';
 
 let JobRepository = class JobRepository {
+    findRunningJobs() {
+        throw new Error('Method not implemented.');
+    }
+    findPendingForRunFrom(date, limit) {
+        throw new Error('Method not implemented.');
+    }
     find(id) {
         throw new Error('Method not implemented.');
     }
@@ -23,6 +29,9 @@ let JobRepository = class JobRepository {
     delete(item) {
         throw new Error('Method not implemented.');
     }
+    countRunningByCommand(commandName) {
+        throw new Error('Method not implemented.');
+    }
 };
 JobRepository = __decorate([
     singleton()

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

@@ -1,8 +1,10 @@
 import { __decorate, __metadata } from 'tslib';
-import { CommandMetadataStore } from './CommandMetadataStore.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
 import { JobRepository } from './JobRepository.js';
 import { singleton, container } from '../../core/injection/index.js';
 import { Logger } from '../../core/logger/Logger.js';
+import '../../core/validation/metadata/ValidationMetadataStore.js';
+import { validateAndTransform } from '../../core/validation/validateAndTransform.js';
 
 let JobRunner = class JobRunner {
     jobRepository;
@@ -14,20 +16,29 @@ let JobRunner = class JobRunner {
     }
     async run(job) {
         try {
-            const { commandName, commandData } = job['data'];
+            const { commandName, commandData } = job;
             const handlerConstructor = this.handlerContainer.getHandlerForCommandName(commandName);
             if (!handlerConstructor) {
                 throw new Error(`Not found handler for command '${commandName}'`);
             }
             const handler = container.resolve(handlerConstructor);
             const commandConstructor = this.handlerContainer.getCommandForCommandName(commandName);
-            if (!commandConstructor) {
-                throw new Error(`Not found class for command name '${commandName}'`);
+            if (commandConstructor === undefined && commandData != undefined) {
+                throw new Error(`Not found class for validate data of command '${commandName}'`);
             }
             job.setAsStarted();
             await this.jobRepository.update(job);
-            const command = new commandConstructor(commandData);
+            let command = undefined;
+            if (commandConstructor) {
+                const validationResult = validateAndTransform(commandData, commandConstructor);
+                if (!validationResult.value) {
+                    throw new Error('Invalid command data');
+                }
+                command = validationResult.value;
+            }
+            this.logger.debug(`start running command ${commandName}`);
             await handler.handle(command);
+            this.logger.debug(`command ${commandName} run successfull`);
             job.setAsSuccess();
         }
         catch (e) {
@@ -42,7 +53,7 @@ let JobRunner = class JobRunner {
 JobRunner = __decorate([
     singleton(),
     __metadata("design:paramtypes", [JobRepository,
-        CommandMetadataStore])
+        AsyncMetadataStore])
 ], JobRunner);
 
 export { JobRunner };

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 };