@wabot-dev/framework 0.4.0-beta.2 → 0.4.0-beta.4

package/dist/src/_virtual/CronDate.js

@@ -0,0 +1,3 @@
+var CronDate = {};
+
+export { CronDate as __exports };

package/dist/src/_virtual/CronDayOfMonth.js

@@ -0,0 +1,3 @@
+var CronDayOfMonth = {};
+
+export { CronDayOfMonth as __exports };

package/dist/src/_virtual/CronDayOfWeek.js

@@ -0,0 +1,3 @@
+var CronDayOfWeek = {};
+
+export { CronDayOfWeek as __exports };

package/dist/src/_virtual/CronExpression.js

@@ -0,0 +1,3 @@
+var CronExpression = {};
+
+export { CronExpression as __exports };

package/dist/src/_virtual/CronExpressionParser.js

@@ -0,0 +1,3 @@
+var CronExpressionParser = {};
+
+export { CronExpressionParser as __exports };

package/dist/src/_virtual/CronField.js

@@ -0,0 +1,3 @@
+var CronField = {};
+
+export { CronField as __exports };

package/dist/src/_virtual/CronFieldCollection.js

@@ -0,0 +1,3 @@
+var CronFieldCollection = {};
+
+export { CronFieldCollection as __exports };

package/dist/src/_virtual/CronFileParser.js

@@ -0,0 +1,3 @@
+var CronFileParser = {};
+
+export { CronFileParser as __exports };

package/dist/src/_virtual/CronHour.js

@@ -0,0 +1,3 @@
+var CronHour = {};
+
+export { CronHour as __exports };

package/dist/src/_virtual/CronMinute.js

@@ -0,0 +1,3 @@
+var CronMinute = {};
+
+export { CronMinute as __exports };

package/dist/src/_virtual/CronMonth.js

@@ -0,0 +1,3 @@
+var CronMonth = {};
+
+export { CronMonth as __exports };

package/dist/src/_virtual/CronSecond.js

@@ -0,0 +1,3 @@
+var CronSecond = {};
+
+export { CronSecond as __exports };

package/dist/src/_virtual/index.js

@@ -0,0 +1,5 @@
+import { __require as requireDist } from '../node_modules/cron-parser/dist/index.js';
+
+var distExports = requireDist();
+
+export { distExports as d };

package/dist/src/_virtual/index2.js

@@ -0,0 +1,3 @@
+var dist = {};
+
+export { dist as __exports };

package/dist/src/_virtual/index3.js

@@ -0,0 +1,3 @@
+var fields = {};
+
+export { fields as __exports };

package/dist/src/_virtual/luxon.js

@@ -0,0 +1,3 @@
+var luxon = {};
+
+export { luxon as __exports };

package/dist/src/_virtual/random.js

@@ -0,0 +1,3 @@
+var random = {};
+
+export { random as __exports };

package/dist/src/_virtual/types.js

@@ -0,0 +1,3 @@
+var types = {};
+
+export { types as __exports };

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

@@ -0,0 +1,49 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../../core/injection/index.js';
+import { CronJob } from '../../../feature/async/CronJob.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';
+
+let PgCronJobRepository = class PgCronJobRepository extends PgCrudRepository {
+    constructor(pool) {
+        super(pool, {
+            schema: 'wabot',
+            table: 'cron_job',
+            constructor: CronJob,
+        });
+    }
+    async findDue(date) {
+        date = date ?? new Date();
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table}
+      WHERE data ? 'nextRunAt'
+        AND (data->>'nextRunAt')::bigint <= $1
+        AND (data->>'enabled')::boolean
+      ORDER BY (data->>'nextRunAt')::bigint ASC
+    `;
+        const items = await this.query(sql, [date.getTime()]);
+        return items;
+    }
+    async findByName(name) {
+        const sql = `
+      SELECT ${this.columns}
+      FROM ${this.table} 
+      WHERE data @> $1::jsonb
+      LIMIT 1
+    `;
+        const items = await this.query(sql, [JSON.stringify({ name })]);
+        return items[0] ?? null;
+    }
+};
+PgCronJobRepository = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Pool])
+], PgCronJobRepository);
+
+export { PgCronJobRepository };

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

@@ -9,11 +9,13 @@ import { withPgClient } from '../../../feature/pg/withPgClient.js';
 import '../../../feature/pg/pgStorage.js';
 import '../../../feature/async/AsyncMetadataStore.js';
 import '../../../feature/async/Async.js';
+import '../../../_virtual/index.js';
 import { Job } from '../../../feature/async/Job.js';
 import '../../../feature/async/JobRepository.js';
 import '../../../feature/async/JobRunner.js';
 import '../../../feature/async/JobScheduler.js';
 import '../../../feature/async/JobWatchdog.js';
+import '../../../feature/async/CronScheduler.js';
 
 let PgJobRepository = class PgJobRepository extends PgCrudRepository {
     constructor(pool) {

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

@@ -0,0 +1,17 @@
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
+import { container, singleton } from '../../core/injection/index.js';
+
+function cron(config) {
+    return function (target) {
+        const metadataStore = container.resolve(AsyncMetadataStore);
+        metadataStore.registerCron(target, {
+            name: config.name,
+            commandName: `cron:${config.name}`,
+            cron: config.cron,
+            enabled: !config.disabled,
+        });
+        singleton()(target);
+    };
+}
+
+export { cron };

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

@@ -0,0 +1,67 @@
+import { d as distExports } from '../../_virtual/index.js';
+import { Entity } from '../../core/entity/Entity.js';
+import { Job } from './Job.js';
+
+class CronJob extends Entity {
+    constructor(data) {
+        super(data);
+        if (!data.nextRunAt) {
+            this.computeNextRun(new Date());
+        }
+    }
+    get nextRunAt() {
+        return this.data.nextRunAt ? new Date(this.data.nextRunAt) : null;
+    }
+    get lastRunAt() {
+        return this.data.lastRunAt ? new Date(this.data.lastRunAt) : null;
+    }
+    get maxConcurrency() {
+        return this.data.maxRunningJobs ?? 1;
+    }
+    get misfirePolicy() {
+        return this.data.misfirePolicy ?? 'RUN_ONCE';
+    }
+    get commandName() {
+        return this.data.commandName;
+    }
+    get name() {
+        return this.data.name;
+    }
+    isDue(now) {
+        if (!this.data.nextRunAt)
+            throw new Error(`CronJon with id = '${this.data.id}' nextRunAt is invalid`);
+        return this.data.enabled && this.data.nextRunAt <= now.getTime();
+    }
+    computeNextRun(from) {
+        const interval = distExports.CronExpressionParser.parse(this.data.cron, {
+            currentDate: from,
+        });
+        this.data.nextRunAt = interval.next().getTime();
+    }
+    markAsExecuted(at) {
+        this.data.lastRunAt = at.getTime();
+        this.computeNextRun(at);
+    }
+    nextJob() {
+        return new Job({
+            commandName: this.data.commandName,
+            commandData: this.data.commandData,
+            scheduledAt: this.data.nextRunAt,
+            reintentsDelaysInSeconds: this.data.reintentsDelaysInSeconds,
+            aceptableRunningTimeSeconds: this.data.aceptableRunningTimeSeconds,
+            stuckRetryAttempts: this.data.stuckRetryAttempts,
+        });
+    }
+    validate() {
+        try {
+            distExports.CronExpressionParser.parse(this.data.cron);
+        }
+        catch (err) {
+            throw new Error(`CronJob with id = '${this.data.id}' has invalid cron expression: ${this.data.cron}`);
+        }
+        if (!this.data.nextRunAt)
+            throw new Error(`CronJon with id = '${this.data.id}' nextRunAt is invalid`);
+    }
+}
+
+export { CronJob };

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

@@ -0,0 +1,19 @@
+class CronJobRepository {
+    create(cronJob) {
+        throw new Error('Method not implemented.');
+    }
+    findByName(name) {
+        throw new Error('Method not implemented.');
+    }
+    update(cronJob) {
+        throw new Error('Method not implemented.');
+    }
+    findDue(date) {
+        throw new Error('Method not implemented.');
+    }
+    findOrThrow(id) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+export { CronJobRepository };

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

@@ -0,0 +1,165 @@
+import { __decorate, __metadata } from 'tslib';
+import { singleton } from '../../core/injection/index.js';
+import { JobRepository } from './JobRepository.js';
+import { Logger } from '../../core/logger/Logger.js';
+import { CronJob } from './CronJob.js';
+import { CronJobRepository } from './CronJobRepository.js';
+import { JobScheduler } from './JobScheduler.js';
+import { Locker } from '../../core/lock/Locker.js';
+import { Env } from '../../core/env/Env.js';
+import { JobWatchdog } from './JobWatchdog.js';
+
+let CronScheduler = class CronScheduler {
+    locker;
+    cronRepo;
+    jobRepo;
+    jobScheduler;
+    jobWatchdog;
+    env;
+    running = false;
+    timeout;
+    configuredCrons = new Map();
+    logger = new Logger('wabot:cron-scheduler');
+    constructor(locker, cronRepo, jobRepo, jobScheduler, jobWatchdog, env) {
+        this.locker = locker;
+        this.cronRepo = cronRepo;
+        this.jobRepo = jobRepo;
+        this.jobScheduler = jobScheduler;
+        this.jobWatchdog = jobWatchdog;
+        this.env = env;
+    }
+    start(crons) {
+        crons.forEach((x) => this.configuredCrons.set(x.name, x));
+        if (this.configuredCrons.size > 0 && !this.running) {
+            this.running = true;
+            this.tick();
+        }
+        if (this.running)
+            this.reconciliation();
+    }
+    stop(crons) {
+        crons.forEach((x) => {
+            const configured = this.configuredCrons.get(x.name);
+            if (!configured) {
+                return;
+            }
+            if (configured.reconciliated) {
+                this.jobScheduler.stop([configured.commandName]);
+                this.jobWatchdog.stop([configured.commandName]);
+            }
+            this.configuredCrons.delete(x.name);
+        });
+        if (this.configuredCrons.size === 0) {
+            this.running = false;
+            if (this.timeout)
+                clearTimeout(this.timeout);
+        }
+    }
+    async reconciliation() {
+        const configToReconciliate = Array.from(this.configuredCrons.values()).filter((x) => !x.reconciliated);
+        this.logger.debug(`start reconciliation of crons ${configToReconciliate.map((x) => x.name).join(', ')}`);
+        try {
+            const cronJobs = await Promise.all(configToReconciliate.map((x) => this.reconciliateConfig(x)));
+            this.logger.info(`success reconciliation of reconciliation of crons ${configToReconciliate.map((x) => x.name).join(', ')}`);
+            this.jobScheduler.start(cronJobs.map((x) => x.commandName));
+            this.jobWatchdog.start(cronJobs.map((x) => x.commandName));
+        }
+        catch (e) {
+            this.logger.error(e);
+            this.stop(configToReconciliate);
+            this.logger.error(`reconciliation fail - stopped crons ${configToReconciliate.map((x) => x.name).join(', ')}`);
+            throw e;
+        }
+    }
+    async tick() {
+        if (!this.running)
+            return;
+        const interval = this.env.requireNumber('WABOT_CRON_SCHEDULER_INTERVAL_SECONDS', {
+            default: 30,
+        });
+        try {
+            await this.locker.withKey('wabot-cron-scheduler').run(async () => {
+                const now = new Date();
+                const dueCrons = await this.cronRepo.findDue(now);
+                const readyToRunCrons = dueCrons.filter((x) => x.isDue(now) && this.configuredCrons.get(x.name)?.reconciliated);
+                for (const cron of readyToRunCrons) {
+                    await this.spawnJobs(cron);
+                }
+            });
+        }
+        catch (e) {
+            this.logger.error(e);
+        }
+        finally {
+            this.timeout = setTimeout(() => this.tick(), interval * 1000);
+        }
+    }
+    async spawnJobs(cron) {
+        await this.locker.withKey(`wabot-cron-${cron.id}`).run(async () => {
+            let now = new Date();
+            const fresh = await this.cronRepo.findOrThrow(cron.id);
+            if (!fresh.isDue(now))
+                return;
+            // ---- Overlap prevention ----
+            const running = await this.jobRepo.countRunningByCommand(fresh.commandName);
+            if (running >= fresh.maxConcurrency) {
+                this.logger.debug(`Cron ${fresh.id} skipped (running ${running}/${fresh.maxConcurrency})`);
+                return;
+            }
+            // ---- Misfire handling ----
+            now = new Date();
+            let executions = 0;
+            while (fresh.isDue(now)) {
+                executions++;
+                await this.jobRepo.create(fresh.nextJob());
+                fresh.markAsExecuted(now);
+                if (fresh.misfirePolicy === 'RUN_ONCE')
+                    break;
+                if (fresh.misfirePolicy === 'SKIP') {
+                    fresh.computeNextRun(now);
+                    break;
+                }
+                // Safety guard (never infinite)
+                if (executions >= 10) {
+                    this.logger.warn(`Cron ${fresh.id} reached max misfire executions`);
+                    break;
+                }
+            }
+            await this.cronRepo.update(fresh);
+            this.logger.info(`Cron ${fresh.id} spawned ${executions} job(s), next at ${fresh.nextRunAt.toISOString()}`);
+        });
+    }
+    async reconciliateConfig(config) {
+        return await this.locker.withKey(`wabot-cron-config-${config.name}`).run(async () => {
+            let cronJob = await this.cronRepo.findByName(config.name);
+            if (cronJob) {
+                this.logger.debug(`found cron job for name='${config.name}'`);
+                cronJob.update({ cron: config.cron, enabled: config.enabled });
+                await this.cronRepo.update(cronJob);
+                this.logger.debug(`cron job for name='${config.name}' updated`);
+            }
+            else {
+                cronJob = new CronJob({
+                    name: config.name,
+                    cron: config.cron,
+                    commandName: config.commandName,
+                    enabled: config.enabled,
+                });
+                await this.cronRepo.create(cronJob);
+            }
+            config.reconciliated = true;
+            return cronJob;
+        });
+    }
+};
+CronScheduler = __decorate([
+    singleton(),
+    __metadata("design:paramtypes", [Locker,
+        CronJobRepository,
+        JobRepository,
+        JobScheduler,
+        JobWatchdog,
+        Env])
+], CronScheduler);
+
+export { CronScheduler };

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

@@ -0,0 +1,18 @@
+import { container } from '../../core/injection/index.js';
+import { AsyncMetadataStore } from './AsyncMetadataStore.js';
+import { CronScheduler } from './CronScheduler.js';
+
+function runCronHandlers(handlers) {
+    const metadataStore = container.resolve(AsyncMetadataStore);
+    const cronScheduler = container.resolve(CronScheduler);
+    const cronsMetadata = handlers.map((x) => metadataStore.requireCronMetadata(x)).flat();
+    cronScheduler.start(cronsMetadata.map((x) => x.config));
+}
+function stopCronHandlers(handlers) {
+    const metadataStore = container.resolve(AsyncMetadataStore);
+    const cronScheduler = container.resolve(CronScheduler);
+    const cronsMetadata = handlers.map((x) => metadataStore.requireCronMetadata(x)).flat();
+    cronScheduler.stop(cronsMetadata.map((x) => x.config));
+}
+
+export { runCronHandlers, stopCronHandlers };

package/dist/src/index.d.ts

@@ -372,6 +372,13 @@ interface ICronHandler {
     handleError?(e: any): void | Promise<void>;
 }
 
+interface ICronConfig {
+    name: string;
+    cron: string;
+    disabled?: boolean;
+}
+declare function cron(config: ICronConfig): (target: IConstructor<ICronHandler>) => void;
+
 interface ICronJobScheduleConfig {
     name: string;
     commandName: string;
@@ -508,9 +515,57 @@ declare class Async {
     runCommand<T>(ctor: IConstructor<T>, data: IValidateInputShape<T>): Promise<Job>;
 }
 
+interface ICronJobData extends IEntityData {
+    name: string;
+    commandName: string;
+    commandData?: object;
+    cron: string;
+    enabled: boolean;
+    lastRunAt?: number;
+    nextRunAt?: number;
+    maxRunningJobs?: number;
+    misfirePolicy?: 'RUN_ONCE' | 'RUN_ALL' | 'SKIP';
+    reintentsDelaysInSeconds?: number[];
+    aceptableRunningTimeSeconds?: number;
+    stuckRetryAttempts?: number;
+}
+declare class CronJob extends Entity<ICronJobData> {
+    constructor(data: ICronJobData);
+    get nextRunAt(): Date | null;
+    get lastRunAt(): Date | null;
+    get maxConcurrency(): number;
+    get misfirePolicy(): "RUN_ONCE" | "RUN_ALL" | "SKIP";
+    get commandName(): string;
+    get name(): string;
+    isDue(now: Date): boolean;
+    computeNextRun(from: Date): void;
+    markAsExecuted(at: Date): void;
+    nextJob(): Job;
+    validate(): void;
+}
+
+interface ICronJobRepository {
+    create(cronJob: CronJob): Promise<void>;
+    findDue(date?: Date): Promise<CronJob[]>;
+    findOrThrow(id: string): Promise<CronJob>;
+    update(cronJob: CronJob): Promise<void>;
+    findByName(name: string): Promise<CronJob | null>;
+}
+
+declare class CronJobRepository implements ICronJobRepository {
+    create(cronJob: CronJob): Promise<void>;
+    findByName(name: string): Promise<CronJob | null>;
+    update(cronJob: CronJob): Promise<void>;
+    findDue(date?: Date): Promise<CronJob[]>;
+    findOrThrow(id: string): Promise<CronJob>;
+}
+
 declare function runCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
 declare function stopCommandHandlers(handlers: IConstructor<ICommandHandler<any>>[]): void;
 
+declare function runCronHandlers(handlers: IConstructor<ICronHandler>[]): void;
+declare function stopCronHandlers(handlers: IConstructor<ICronHandler>[]): void;
+
 interface IChatConnection {
     chatType: 'GROUP' | 'PRIVATE';
     channelName: string;
@@ -1133,6 +1188,12 @@ declare class PgJobRepository extends PgCrudRepository<Job> implements IJobRepos
     countRunningByCommand(commandName: string): Promise<number>;
 }
 
+declare class PgCronJobRepository extends PgCrudRepository<CronJob> implements ICronJobRepository {
+    constructor(pool: Pool);
+    findDue(date?: Date): Promise<CronJob[]>;
+    findByName(name: string): Promise<CronJob | null>;
+}
+
 declare function apiKeyHandshakeGuard(): (target: IConstructor<any>) => void;
 
 declare function apiKeyGuard(): (target: object, propertyKey: string | symbol) => void;
@@ -1785,4 +1846,4 @@ declare function HtmlModule(options: IHtmlModuleOptions): {
     new (): {};
 };
 
-export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, description, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, stopCommandHandlers, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, withPgClient, withPgTransaction, writeJsonToFile };
+export { AnthropicChatAdapter, ApiKey, ApiKeyGuardMiddleware, ApiKeyHandshakeGuardMiddleware, ApiKeyRepository, Async, AsyncMetadataStore, Auth, Chat, ChatAdapter, ChatBot, ChatBotMetadataStore, ChatItem, ChatMemory, ChatRepository, ChatResolver, type ClientMap, CmdChannel, Container, ControllerMetadataStore, CronJob, CronJobRepository, CustomError, DeepSeekChatAdapter, DescriptionMetadataStore, EXPRESS_REQ, EXPRESS_RES, Entity, Env, EnvWhatsAppRepository, ExpressProvider, GoogleChatAdapter, type GoogleChatAdapterV2Options, HtmlModule, HttpServerProvider, type IApiKeyData, type IApiKeyRepository, type IArrayValidationError, type IArrayValidationResult, type IBotMessageItem, type IChannelMessage, type IChannelMetadata, type IChatAdapter, type IChatAdapterNextItemsReq, type IChatAdapterNextItemsRes, type IChatBot, type IChatBotMetadata, type IChatChannel, type IChatConnection, type IChatControllerMetadata, type IChatData, type IChatItem, type IChatItemData, type IChatItemType, type IChatMemory, type IChatMessage, type IChatRepository, type IChatType, type ICommandConfig, type ICommandHandler, type ICommandHandlerConfig, type IConstructor, type ICronConfig, type ICronJobData, type ICrudRepository, type ICustomErrorData, type IDescriptionMetadata, type IEndPointConfig, type IEndPointMetadata, type IEntityData, type IEnvType, type IFunctionCall, type IFunctionCallItem, type IGenerateApiKeyReq, type IGenerateApiKeyRes, type IGetWhatsAppTemplateRequest, type IHandshakeMiddleware, type IHandshakeMiddlewareMetadata, type IHtmlModuleOptions, type IHumanMessageItem, type IJobData, type IJobRepository, type IJwtRefreshTokenData, type IJwtRefreshTokenRepository, type ILanguageModelUsage, type IListenWhatsAppMessageRequest, type ILockKey, type ILocker, type IMessageContext, type IMiddleware, type IMiddlewareMetadata, type IMindset, type IMindsetConfig, type IMindsetIdentity, type IMindsetLlm, type IMindsetMetadata, type IMindsetModuleConfig, type IMindsetModuleMetadata, type IMindsetTool, type IMindsetToolParameter, type IModelValidationError, type IModelValidationResult, type IModelValidatorsInfo, type IMoneyData, type IPersistentData, type IPgRepositoryConfig, type IPropertyValidatorInfo, type IReceivedMessage, type IRemoteApiKeyFetcher, type IRestControllerConfig, type IRestControllerMetadata, type ISendWhatsAppRequest, type ISendWhatsAppTemplateRequest, type ISocketChannelConfig, type ISocketChannelReceivedMessage, type ISocketControllerConfig, type ISocketControllerMetadata, type ISocketEventConfig, type ISocketEventMetadata, type IStorableData, type ITelegramChannelConfig, type IValidateArrayOptions, type IValidateArrayOptionsWithItemsValidators, type IValidateInputShape, type IValidateIsInOptions, type IValidateIsRecordOptions, type IValidateMaxOptions, type IValidateMinOptions, type IValidationError, type IValidationResult, type IValidator, type IValidatorMetadata, type IWhatsAppBusinessAccount, type IWhatsAppBusinessNumber, type IWhatsAppCloudContact, type IWhatsAppCloudMessage, type IWhatsAppCloudMessageMetadata, type IWhatsAppCloudTemplate, type IWhatsAppCloudTemplateComponent, type IWhatsAppCloudTemplateMessage, type IWhatsAppCloudTemplateParameter, type IWhatsAppCloudTemplateResponse, type IWhatsAppCloudWebhookPayload, type IWhatsAppData, type IWhatsAppMessageListener, type IWhatsAppProxyListenMessageEventData, type IWhatsAppProxyListenMessageEventReq, type IWhatsAppProxyMessage, type IWhatsAppProxyMessageContent, type IWhatsAppProxyMessageEventReq, type IWhatsAppProxySendMessageEventReq, type IWhatsAppRepository, type IWhatsAppSenderOptions, type IWhatsappChannelConfig, type IchatControllerConfig, Job, JobRepository, JobRunner, Jwt, JwtAccessAndRefreshTokenDto, JwtConfig, JwtGuardMiddleware, JwtHandshakeGuardMiddleware, JwtRefreshToken, JwtRefreshTokenRepository, JwtSigner, JwtTokenDto, Lifecycle, Locker, Logger, Mapper, Mindset, MindsetMetadataStore, MindsetOperator, Money, MoneyDto, OpenaiChatAdapter, Password, type PasswordHashOptions, Persistent, PgApiKeyRepository, PgChatMemory, PgChatRepository, PgCronJobRepository, PgCrudRepository, PgJobRepository, PgJwtRefreshTokenRepository, PgLockKey, PgLocker, PgRepositoryBase, PgWhatsAppRepository, RamChatMemory, RamChatRepository, Random, RemoteApiKeyRepository, RestControllerMetadataStore, RestRequest, SocketChannel, SocketChannelConfig, SocketChannelReceivedMessage, SocketControllerMetadataStore, SocketServerProvider, Storable, TelegramChannel, TelegramChannelConfig, ValidationMetadataStore, WHATSAPP_MESSAGE_EVENT, WHATSAPP_PROXY_LISTEN_MESSAGE_EVENT, WHATSAPP_PROXY_SEND_MESSAGE_EVENT, WabotChatAdapter, WhatsApp, WhatsAppChannel, WhatsAppReceiver, WhatsAppReceiverByCloudApi, WhatsAppReceiverByWabotProxy, WhatsAppRepository, WhatsAppSender, WhatsAppSenderByCloudApi, WhatsAppSenderByWabotProxy, WhatsAppWabotProxyConnection, WhatsappChannelConfig, apiKeyGuard, apiKeyHandshakeGuard, chatBot, chatController, chatItemTypeOptions, cmd, command, commandHandler, container, cron, description, getClientMap, getPgClient, handshakeMiddlewares, inject, injectable, isArray, isBoolean, isDate, isIn, isModel, isNotEmpty, isNumber, isOptional, isPresent, isRecord, isString, jwtGuard, jwtHandshakeGuard, max, middleware, min, mindset, mindsetModule, modelInfo, onDelete, onGet, onPost, onPut, onSocketEvent, pgStorage, readJsonFromFile, restController, runChatControllers, runCommandHandlers, runCronHandlers, runRestControllers, runSocketControllers, scoped, singleton, socket, socketController, stopCommandHandlers, stopCronHandlers, telegram, validateAndTransform, validateArray, validateIsBoolean, validateIsDate, validateIsIn, validateIsNotEmpty, validateIsNumber, validateIsPresent, validateIsRecord, validateIsString, validateMax, validateMin, validateModel, whatsApp, withPgClient, withPgTransaction, writeJsonToFile };

package/dist/src/index.js

@@ -41,12 +41,16 @@ export { DescriptionMetadataStore } from './core/description/metadata/Descriptio
 export { Locker } from './core/lock/Locker.js';
 export { command } from './feature/async/@command.js';
 export { commandHandler } from './feature/async/@commandHandler.js';
+export { cron } from './feature/async/@cron.js';
 export { Async } from './feature/async/Async.js';
 export { AsyncMetadataStore } from './feature/async/AsyncMetadataStore.js';
+export { CronJob } from './feature/async/CronJob.js';
+export { CronJobRepository } from './feature/async/CronJobRepository.js';
 export { Job } from './feature/async/Job.js';
 export { JobRepository } from './feature/async/JobRepository.js';
 export { JobRunner } from './feature/async/JobRunner.js';
 export { runCommandHandlers, stopCommandHandlers } from './feature/async/runCommandHandlers.js';
+export { runCronHandlers, stopCronHandlers } from './feature/async/runCronHandlers.js';
 export { Chat } from './feature/chat-bot/Chat.js';
 export { ChatAdapter } from './feature/chat-bot/ChatAdapter.js';
 export { ChatBot } from './feature/chat-bot/ChatBot.js';
@@ -93,6 +97,7 @@ export { onSocketEvent } from './feature/socket-controller/metadata/@onSocketEve
 export { SocketControllerMetadataStore } from './feature/socket-controller/metadata/SocketControllerMetadataStore.js';
 export { runSocketControllers } from './feature/socket-controller/runSocketControllers.js';
 export { PgJobRepository } from './addon/async/pg/PgJobRepository.js';
+export { PgCronJobRepository } from './addon/async/pg/PgCronJobRepository.js';
 export { apiKeyHandshakeGuard } from './addon/auth/api-key/@apiKeyHandshakeGuard.js';
 export { apiKeyGuard } from './addon/auth/api-key/@apiKeyGuard.js';
 export { ApiKey } from './addon/auth/api-key/ApiKey.js';