@clairejs/server 3.22.15 → 3.23.1

package/README.md

@@ -1,5 +1,10 @@
 ## Change Log
 
+#### 3.23.1
+
+-   fix retryDelayMs
+-   improve JobScheduler
+
 #### 3.22.15
 
 -   skip 4xx log in DefaultHttpRequestHandler

package/dist/job/AbstractJobRepository.d.ts

@@ -1,18 +1,23 @@
-import { type ITransaction } from "@clairejs/orm";
-import { type CustomJobInfo } from "./interfaces";
-export declare abstract class AbstractJobRepository<T extends CustomJobInfo> {
+import { GetManyOptions, QueryCondition, type ITransaction } from "@clairejs/orm";
+import { type AbstractJob } from "./interfaces";
+export declare abstract class AbstractJobRepository<T extends AbstractJob = AbstractJob> {
     /**
      * Return all persisted jobs
      */
-    abstract getJobs(): Promise<T[]>;
+    abstract getJobs(query?: QueryCondition<T>, options?: GetManyOptions<T, keyof T>): Promise<T[]>;
     /**
      * Save the job info and return a unique id
-     * @param jobInfo The custom job info to save
+     * @param jobInfo The job info to save
      */
-    abstract saveJob(jobInfo: T, tx?: ITransaction): Promise<string>;
+    abstract insertJob(jobInfo: Partial<T>, tx?: ITransaction): Promise<string>;
     /**
      * Remove job info by id
-     * @param id Unique id of job
+     * @param jobId Unique id of job
      */
-    abstract removeJobById(id: string, tx?: ITransaction): Promise<void>;
+    abstract removeJobById(jobId: string, tx?: ITransaction): Promise<void>;
+    /**
+     * Remove job info by id
+     * @param jobId Unique id of job
+     */
+    abstract updateJobById(jobId: string, update: Partial<Omit<T, "jobId">>, tx?: ITransaction): Promise<void>;
 }

package/dist/job/AbstractJobScheduler.d.ts

@@ -1,42 +1,42 @@
 import { AbstractLogger } from "@clairejs/core";
 import { ITransaction, ITransactionFactory } from "@clairejs/orm";
-import { CustomJobInfo, JobInfo, JobInfoMetadata, ScheduledJob } from "./interfaces";
-export type JobHandlerFn = (job: ScheduledJob, tx: ITransaction) => Promise<ScheduledJob | void>;
+import { AbstractJob, JobInfoMetadata, JobSchedulePayload } from "./interfaces";
+import { AbstractJobRepository } from "./AbstractJobRepository";
+export type JobHandlerFn = (job: AbstractJob) => Promise<AbstractJob | void>;
 interface JobHandlerMetadata extends JobInfoMetadata {
     handlerFn: JobHandlerFn;
 }
 export declare abstract class AbstractJobScheduler {
     protected readonly logger: AbstractLogger;
     protected readonly db: ITransactionFactory;
-    protected abstract isActiveScheduler(): boolean;
+    protected readonly jobRepo: AbstractJobRepository;
     private _jobs;
-    constructor(logger: AbstractLogger, db: ITransactionFactory);
-    protected getAvailableJobInfo(): Promise<JobHandlerMetadata[]>;
-    abstract getAllScheduledJobs(): Promise<ScheduledJob[]>;
-    /**
-     * Return unique job id which can then be used to cancel the job
-     * @param jobInfo the necessary info to launch the job
-     */
-    protected abstract scheduleJob(jobInfo: JobInfo): Promise<string>;
-    protected abstract afterJob(job: ScheduledJob, tx: ITransaction): Promise<void>;
+    constructor(logger: AbstractLogger, db: ITransactionFactory, jobRepo: AbstractJobRepository);
+    protected getCurrentJobHandlers(): Promise<JobHandlerMetadata[]>;
     /**
      * Sync all jobs to running state. This should be called only at init time.
      */
     abstract syncJobs(): Promise<void>;
     /**
      * Return unique job id which can then be used to cancel the job
-     * @param jobInfo the necessary info to launch the job
+     * @param payload the necessary info to launch the job
      */
-    scheduleJobAt(jobInfo: CustomJobInfo): Promise<string>;
+    protected abstract _scheduleJob(payload: JobSchedulePayload): Promise<void>;
+    scheduleJob({ jobId, ...payload }: JobSchedulePayload): Promise<string>;
     /**
-     * Remove the scheduled job and prevent if from running in the future
+     * Cancel the scheduled job and prevent if from running in the future
      * @param id The job id returned from scheduleJobAt function
      */
-    abstract removeJob(id: string, tx?: ITransaction): Promise<void>;
+    protected abstract cancelJob(jobId: string): Promise<void>;
+    /**
+     * Remove the scheduled job and prevent if from running in the future
+     * @param jobId The job id returned from scheduleJobAt function
+     */
+    disableJob(jobId: string, tx?: ITransaction): Promise<void>;
     /**
      * Execute the scheduled job
      * @param job The schedled job info to execute
      */
-    protected executeJob(job: ScheduledJob): Promise<void>;
+    protected executeJob(job: AbstractJob): Promise<void>;
 }
 export {};

package/dist/job/AbstractJobScheduler.js

@@ -1,14 +1,16 @@
-import { getServiceProvider } from "@clairejs/core";
+import { diffData, getServiceProvider } from "@clairejs/core";
 import { AbstractJobController } from "./AbstractJobController";
 export class AbstractJobScheduler {
     logger;
     db;
+    jobRepo;
     _jobs = null;
-    constructor(logger, db) {
+    constructor(logger, db, jobRepo) {
         this.logger = logger;
         this.db = db;
+        this.jobRepo = jobRepo;
     }
-    async getAvailableJobInfo() {
+    async getCurrentJobHandlers() {
         if (this._jobs === null) {
             //-- read all job info
             const injector = getServiceProvider().getInjector();
@@ -20,47 +22,95 @@ export class AbstractJobScheduler {
         }
         return this._jobs;
     }
+    async scheduleJob({ jobId, ...payload }) {
+        let uniqueId = jobId;
+        const tx = await this.db.createTransaction();
+        if (!uniqueId) {
+            uniqueId = await this.jobRepo.insertJob(payload, tx);
+        }
+        else {
+            const [job] = await this.jobRepo.getJobs({ _eq: { jobId: uniqueId } }, { limit: 1 });
+            if (!job) {
+                await this.jobRepo.insertJob({ ...payload, jobId: uniqueId }, tx);
+            }
+            else {
+                const diff = diffData(job, payload);
+                if (diff) {
+                    await this.jobRepo.updateJobById(uniqueId, payload, tx);
+                }
+            }
+        }
+        await this._scheduleJob({ ...payload, jobId: uniqueId });
+        await tx.commit();
+        return uniqueId;
+    }
     /**
-     * Return unique job id which can then be used to cancel the job
-     * @param jobInfo the necessary info to launch the job
+     * Remove the scheduled job and prevent if from running in the future
+     * @param jobId The job id returned from scheduleJobAt function
      */
-    scheduleJobAt(jobInfo) {
-        return this.scheduleJob(jobInfo);
+    async disableJob(jobId, tx) {
+        await this.cancelJob(jobId);
+        await this.jobRepo.updateJobById(jobId, { disabled: true }, tx);
     }
     /**
      * Execute the scheduled job
      * @param job The schedled job info to execute
      */
     async executeJob(job) {
+        if (job.disabled) {
+            return;
+        }
         //-- run job
-        const allJobs = await this.getAvailableJobInfo();
-        const jobHandler = allJobs.find((j) => j.jobName === job.jobName);
+        const allHandlers = await this.getCurrentJobHandlers();
+        const jobHandler = allHandlers.find((j) => j.jobName === job.jobName);
         const tx = await this.db.createTransaction();
-        try {
-            if (!jobHandler) {
-                //-- remove job
-                this.logger.info(`Remove job with id: ${job.id} as handler is not found`);
-                await this.removeJob(job.id, tx);
+        if (!jobHandler) {
+            this.logger.info(`Disable job with id: ${job.jobId} as handler is not found`);
+            await this.disableJob(job.jobId, tx);
+        }
+        else {
+            const update = {
+                lastRunAt: Date.now(),
+                execCount: (job.execCount || 0) + 1,
+            };
+            try {
+                await jobHandler.handlerFn(job);
+                //-- job run success, update
+                update.lastSuccessAt = Date.now();
+                //-- reset retry count if this is cron job
+                if (job.cron) {
+                    if (job.retryCount) {
+                        update.retryCount = 0;
+                    }
+                }
+                else {
+                    update.disabled = true;
+                }
             }
-            else {
-                const newJob = await jobHandler.handlerFn({ ...job }, tx);
-                if (job.at) {
-                    if (!newJob) {
-                        await this.removeJob(job.id, tx);
-                        this.logger.info(`Remove one-time job ${job.jobName} at timestamp ${job.at}`);
+            catch (err) {
+                update.failCount = (job.failCount || 0) + 1;
+                update.lastError = String(err);
+                //-- job run error, check retry
+                if (job.retryOnFail) {
+                    if ((job.retryCount || 0) < (job.maxRetry || 1)) {
+                        //-- retry by reschedule the job
+                        update.retryCount = (job.retryCount || 0) + 1;
+                        const retryDelay = job.retryDelayMs || 0;
+                        await this.scheduleJob({ ...job, at: Date.now() + (retryDelay < 60000 ? 60000 : retryDelay) });
                     }
                     else {
-                        await this.afterJob(newJob, tx);
+                        if (job.cron) {
+                            update.at = undefined;
+                        }
+                        else {
+                            update.disabled = true;
+                            await this.cancelJob(job.jobId);
+                        }
                     }
                 }
             }
-            this.logger.debug("Job tx commiting");
-            await tx.commit();
-            this.logger.debug("Job tx committed");
-        }
-        catch (err) {
-            this.logger.error("Error handling job", err);
-            await tx.rollback();
+            await this.jobRepo.updateJobById(job.jobId, update, tx);
         }
+        await tx.commit();
     }
 }

package/dist/job/AwsJobScheduler.d.ts

@@ -1,8 +1,9 @@
 import { AbstractLogger } from "@clairejs/core";
-import { AbstractDbAdapter, ITransaction } from "@clairejs/orm";
+import { AbstractDbAdapter } from "@clairejs/orm";
 import aws from "aws-sdk";
+import { AbstractJob } from "./interfaces";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
-import { JobInfo, ScheduledJob } from "./interfaces";
+import { AbstractJobRepository } from "./AbstractJobRepository";
 /**
  * Following EventBrige permissions is required: listRules, putRule, deleteRule, listTargetsByRule, putTargets, removeTargets.
  * Also update Lambda function to alow function invocation from events.amazonaws.com.
@@ -10,18 +11,16 @@ import { JobInfo, ScheduledJob } from "./interfaces";
 export declare class AwsJobScheduler extends AbstractJobScheduler {
     protected readonly logger: AbstractLogger;
     protected readonly db: AbstractDbAdapter;
-    protected readonly uniqueJobIdFactory: () => string;
+    protected readonly jobRepo: AbstractJobRepository;
     protected readonly apiLambdaFunctionArn: string;
     protected readonly jobNamespace: string;
     protected readonly eventBusName: string;
     protected readonly eventbridge: aws.EventBridge;
-    constructor(logger: AbstractLogger, db: AbstractDbAdapter, uniqueJobIdFactory: () => string, apiLambdaFunctionArn: string, jobNamespace: string, eventBusName?: string);
-    handleCron(jobInfo: ScheduledJob): Promise<void>;
-    protected afterJob(_job: ScheduledJob, _tx: ITransaction): Promise<void>;
+    constructor(logger: AbstractLogger, db: AbstractDbAdapter, jobRepo: AbstractJobRepository, apiLambdaFunctionArn: string, jobNamespace: string, eventBusName?: string);
+    handleCron(jobInfo: AbstractJob): Promise<void>;
     private generateCronFromTimestamp;
-    protected isActiveScheduler(): boolean;
-    getAllScheduledJobs(): Promise<ScheduledJob[]>;
-    protected scheduleJob(jobInfo: JobInfo): Promise<string>;
+    getAllScheduledJobs(): Promise<AbstractJob[]>;
+    protected _scheduleJob(jobInfo: AbstractJob): Promise<void>;
     syncJobs(): Promise<void>;
-    removeJob(jobId: string): Promise<void>;
+    cancelJob(jobId: string): Promise<void>;
 }

package/dist/job/AwsJobScheduler.js

@@ -12,6 +12,7 @@ import { AbstractDbAdapter } from "@clairejs/orm";
 import assert from "assert";
 import aws from "aws-sdk";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
+import { AbstractJobRepository } from "./AbstractJobRepository";
 /**
  * Following EventBrige permissions is required: listRules, putRule, deleteRule, listTargetsByRule, putTargets, removeTargets.
  * Also update Lambda function to alow function invocation from events.amazonaws.com.
@@ -19,16 +20,16 @@ import { AbstractJobScheduler } from "./AbstractJobScheduler";
 let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     logger;
     db;
-    uniqueJobIdFactory;
+    jobRepo;
     apiLambdaFunctionArn;
     jobNamespace;
     eventBusName;
     eventbridge = new aws.EventBridge();
-    constructor(logger, db, uniqueJobIdFactory, apiLambdaFunctionArn, jobNamespace, eventBusName = "default") {
-        super(logger, db);
+    constructor(logger, db, jobRepo, apiLambdaFunctionArn, jobNamespace, eventBusName = "default") {
+        super(logger, db, jobRepo);
         this.logger = logger;
         this.db = db;
-        this.uniqueJobIdFactory = uniqueJobIdFactory;
+        this.jobRepo = jobRepo;
         this.apiLambdaFunctionArn = apiLambdaFunctionArn;
         this.jobNamespace = jobNamespace;
         this.eventBusName = eventBusName;
@@ -37,10 +38,6 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         this.logger.debug(`Handle cron`, jobInfo);
         await this.executeJob(jobInfo);
     }
-    async afterJob(_job, _tx) {
-        //-- do nothing
-        return;
-    }
     generateCronFromTimestamp(at) {
         const date = new Date(at);
         return [
@@ -52,9 +49,6 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
             date.getUTCFullYear(),
         ].join(" ");
     }
-    isActiveScheduler() {
-        return false;
-    }
     async getAllScheduledJobs() {
         const allRules = await this.eventbridge
             .listRules({
@@ -78,12 +72,12 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
             return jobInfo;
         }));
         //-- concat with interval jobs because we don't register them
-        return allJobs.filter((job) => !!job);
+        return allJobs.flatMap((job) => (job ? [job] : []));
     }
-    async scheduleJob(jobInfo) {
+    async _scheduleJob(jobInfo) {
         this.logger.debug("Scheduling job: ", jobInfo);
         if (jobInfo.cron || jobInfo.at) {
-            const jobId = `${this.jobNamespace}${this.uniqueJobIdFactory()}`;
+            const jobId = `${this.jobNamespace}${jobInfo.jobId}`;
             let cronExpression;
             if (jobInfo.at) {
                 cronExpression = this.generateCronFromTimestamp(jobInfo.at);
@@ -118,7 +112,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
                         Input: JSON.stringify({
                             requestContext: {
                                 cronScheduler: {
-                                    data: { ...jobInfo, id: jobId },
+                                    data: { ...jobInfo, jobId },
                                 },
                             },
                         }),
@@ -126,7 +120,6 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
                 ],
             })
                 .promise();
-            return jobId;
         }
         else {
             throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
@@ -135,14 +128,12 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     async syncJobs() {
         //-- check jobs
         const scheduledJobs = await this.getAllScheduledJobs();
-        const allJobs = await this.getAvailableJobInfo();
+        const allHandlers = await this.getCurrentJobHandlers();
         //-- remove job that no more exist
-        const nomoreExistJobs = scheduledJobs.filter((job) => !allJobs.find((j) => j.jobName === job.jobName));
+        const nomoreExistJobs = scheduledJobs.filter((job) => !allHandlers.find((handler) => handler.jobName === job.jobName));
         for (const job of nomoreExistJobs) {
-            if (job.id) {
-                this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.id}`);
-                await this.removeJob(job.id);
-            }
+            this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.jobId}`);
+            await this.disableJob(job.jobId);
         }
         if (nomoreExistJobs.length) {
             this.logger.info(`Cleaned up: ${nomoreExistJobs.length} stale jobs`);
@@ -150,12 +141,12 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         //-- remove scheduled cron jobs that diff the cron expression
         this.logger.debug("Remove scheduled cron jobs");
         const scheduledCronJobs = scheduledJobs.filter((j) => j.cron);
-        const unmatchedCronJobs = scheduledCronJobs.filter((j) => j.cron && !allJobs.find((job) => job.jobName === j.jobName && job.cron === j.cron));
+        const unmatchedCronJobs = scheduledCronJobs.filter((j) => j.cron && !allHandlers.find((job) => job.jobName === j.jobName && job.cron === j.cron));
         if (unmatchedCronJobs.length) {
-            await Promise.all(unmatchedCronJobs.map((j) => this.removeJob(j.id)));
+            await Promise.all(unmatchedCronJobs.map((j) => this.disableJob(j.jobId)));
         }
         //-- reschedule new cron jobs and those which are not synced
-        const resyncCronJobs = allJobs.filter((job) => job.cron &&
+        const resyncCronJobs = allHandlers.filter((job) => job.cron &&
             (unmatchedCronJobs.some((j) => j.jobName === job.jobName) ||
                 !scheduledCronJobs.some((j) => j.jobName === job.jobName)));
         this.logger.debug("Reschedule cron jobs", resyncCronJobs);
@@ -167,7 +158,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         }
         //-- keep "at" jobs as is
     }
-    async removeJob(jobId) {
+    async cancelJob(jobId) {
         await this.eventbridge
             .removeTargets({
             EventBusName: this.eventBusName,
@@ -186,6 +177,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
 AwsJobScheduler = __decorate([
     LogContext(),
     __metadata("design:paramtypes", [AbstractLogger,
-        AbstractDbAdapter, Function, String, String, Object])
+        AbstractDbAdapter,
+        AbstractJobRepository, String, String, Object])
 ], AwsJobScheduler);
 export { AwsJobScheduler };

package/dist/job/LocalJobScheduler.d.ts

@@ -1,15 +1,15 @@
 import { AbstractLogger, IInit } from "@clairejs/core";
 import Redis from "ioredis";
-import { AbstractDbAdapter, ITransaction } from "@clairejs/orm";
+import { AbstractDbAdapter } from "@clairejs/orm";
+import { AbstractJob } from "./interfaces";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
-import { CustomJobInfo, JobInfo, ScheduledJob } from "./interfaces";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 export declare class LocalJobScheduler extends AbstractJobScheduler implements IInit {
     protected readonly logger: AbstractLogger;
     protected readonly db: AbstractDbAdapter;
     protected readonly redisClient: Redis;
     protected readonly subscribeClient: Redis;
-    protected readonly jobRepo: AbstractJobRepository<CustomJobInfo>;
+    protected readonly jobRepo: AbstractJobRepository;
     /**
      * Redis lock key to select active scheduler
      */
@@ -18,10 +18,6 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
      * Redis key to hold active scheduler role
      */
     protected readonly holdMutexKey: string;
-    /**
-     * Redis key to get unique incremental id
-     */
-    protected readonly uniqueIdKey: string;
     /**
      * The channel for communication between passive and active schedulers
      */
@@ -33,9 +29,8 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
     protected intervals: any[];
     private mutexHoldInterval?;
     private isActive;
-    private notifyResolver;
     private jobHolder;
-    constructor(logger: AbstractLogger, db: AbstractDbAdapter, redisClient: Redis, subscribeClient: Redis, jobRepo: AbstractJobRepository<CustomJobInfo>, 
+    constructor(logger: AbstractLogger, db: AbstractDbAdapter, redisClient: Redis, subscribeClient: Redis, jobRepo: AbstractJobRepository, 
     /**
      * Redis lock key to select active scheduler
      */
@@ -44,10 +39,6 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
      * Redis key to hold active scheduler role
      */
     holdMutexKey: string, 
-    /**
-     * Redis key to get unique incremental id
-     */
-    uniqueIdKey: string, 
     /**
      * The channel for communication between passive and active schedulers
      */
@@ -59,12 +50,9 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
     private sendJob;
     private processMessage;
     private extendMutexKey;
-    protected afterJob({ at, ...job }: ScheduledJob, tx: ITransaction): Promise<void>;
     init(): Promise<void>;
     exit(): void;
-    protected isActiveScheduler(): boolean;
-    getAllScheduledJobs(): Promise<ScheduledJob[]>;
     syncJobs(): Promise<void>;
-    protected scheduleJob(jobInfo: JobInfo, tx?: ITransaction): Promise<string>;
-    removeJob(id: string, tx?: ITransaction): Promise<void>;
+    protected _scheduleJob(jobInfo: AbstractJob): Promise<void>;
+    protected cancelJob(jobId: string): Promise<void>;
 }

package/dist/job/LocalJobScheduler.js

@@ -12,7 +12,6 @@ import Redis from "ioredis";
 import Redlock from "redlock";
 import scheduler from "node-schedule";
 import { AbstractDbAdapter } from "@clairejs/orm";
-import assert from "assert";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 var CommunicationMessage;
@@ -20,7 +19,6 @@ var CommunicationMessage;
     CommunicationMessage["SCHEDULE_JOB"] = "SCHEDULE_JOB";
     CommunicationMessage["REMOVE_JOB"] = "REMOVE_JOB";
     CommunicationMessage["SYNC_JOB"] = "SYNC_JOB";
-    CommunicationMessage["NOTIFY"] = "NOTIFY";
 })(CommunicationMessage || (CommunicationMessage = {}));
 let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
     logger;
@@ -30,13 +28,11 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
     jobRepo;
     lockMutexKey;
     holdMutexKey;
-    uniqueIdKey;
     multiClientChannel;
     keyRetentionDurationSeconds;
     intervals = [];
     mutexHoldInterval;
     isActive = false;
-    notifyResolver = {};
     jobHolder = {};
     constructor(logger, db, redisClient, subscribeClient, jobRepo, 
     /**
@@ -47,10 +43,6 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
      * Redis key to hold active scheduler role
      */
     holdMutexKey, 
-    /**
-     * Redis key to get unique incremental id
-     */
-    uniqueIdKey, 
     /**
      * The channel for communication between passive and active schedulers
      */
@@ -59,7 +51,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
      * The time to lock active scheduler
      */
     keyRetentionDurationSeconds = 30) {
-        super(logger, db);
+        super(logger, db, jobRepo);
         this.logger = logger;
         this.db = db;
         this.redisClient = redisClient;
@@ -67,26 +59,20 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         this.jobRepo = jobRepo;
         this.lockMutexKey = lockMutexKey;
         this.holdMutexKey = holdMutexKey;
-        this.uniqueIdKey = uniqueIdKey;
         this.multiClientChannel = multiClientChannel;
         this.keyRetentionDurationSeconds = keyRetentionDurationSeconds;
     }
-    sendJob(type, messageId, data) {
-        this.subscribeClient.publish(this.multiClientChannel, JSON.stringify({ type, messageId, data }));
+    sendJob(type, data) {
+        this.subscribeClient.publish(this.multiClientChannel, JSON.stringify({ type, data }));
     }
-    async processMessage(type, messageId, data) {
+    async processMessage(type, data) {
         switch (type) {
             case CommunicationMessage.SYNC_JOB:
-                await this.syncJobs();
-                this.sendJob(CommunicationMessage.NOTIFY, messageId);
-                break;
-            case CommunicationMessage.NOTIFY:
-                const resolver = this.notifyResolver[messageId];
-                if (!resolver) {
-                    //-- resolver not found, ignore
+                if (!this.isActive) {
+                    //-- not active scheduler, ignore
                     return;
                 }
-                resolver(data);
+                await this.syncJobs();
                 break;
             case CommunicationMessage.SCHEDULE_JOB:
                 if (!this.isActive) {
@@ -94,8 +80,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                     return;
                 }
                 const jobInfo = data;
-                const scheduledId = await this.scheduleJobAt(jobInfo);
-                this.sendJob(CommunicationMessage.NOTIFY, messageId, scheduledId);
+                await this.scheduleJob(jobInfo);
                 break;
             case CommunicationMessage.REMOVE_JOB:
                 if (!this.isActive) {
@@ -103,8 +88,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                     return;
                 }
                 const jobId = data;
-                await this.removeJob(jobId);
-                this.sendJob(CommunicationMessage.NOTIFY, messageId);
+                await this.disableJob(jobId);
                 break;
             default:
                 this.logger.error(`Not recognize message type ${type}`);
@@ -119,10 +103,6 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         await this.redisClient.setex(this.holdMutexKey, this.keyRetentionDurationSeconds, 1);
         this.logger.debug("Scheduler extends mutex key");
     }
-    async afterJob({ at, ...job }, tx) {
-        assert.ok(at);
-        await this.jobRepo.saveJob({ ...job, at }, tx);
-    }
     async init() {
         this.logger.debug("LocalJobScheduler init");
         //-- subscribe to multi client channel
@@ -131,7 +111,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             if (channel === this.multiClientChannel) {
                 //-- process message
                 const payload = JSON.parse(message);
-                this.processMessage(payload.type, payload.messageId, payload.data).catch((err) => this.logger.error(`Fail to process message, ${payload}`, err));
+                this.processMessage(payload.type, payload.data).catch((err) => this.logger.error(`Fail to process message, ${payload}`, err));
             }
         });
         await this.subscribeClient.subscribe(this.multiClientChannel);
@@ -162,67 +142,42 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         }
         this.logger.debug("LocalJobScheduler exit");
     }
-    isActiveScheduler() {
-        return this.isActive;
-    }
-    async getAllScheduledJobs() {
-        return Object.values(this.jobHolder)
-            .filter((j) => !!j?.jobInfo)
-            .map((info) => info?.jobInfo);
-    }
     async syncJobs() {
         if (this.isActive) {
             //-- schedule all cron & interval jobs
-            const allJobs = await this.getAvailableJobInfo();
+            const allJobs = await this.getCurrentJobHandlers();
             for (const job of allJobs) {
                 if (job.cron) {
                     await this.scheduleJob(job);
                 }
             }
-            //-- re-schedule jobs that are stored in repo
-            const allPersistedJobs = await this.jobRepo.getJobs();
+            //-- re-schedule "at" jobs that are stored in repo
+            const allPersistedJobs = await this.jobRepo.getJobs({ _neq: { disabled: true, at: undefined } });
             //-- run job anyway, expired job will be removed then
             for (const job of allPersistedJobs) {
                 await this.scheduleJob(job);
             }
         }
         else {
-            const uniqueMessageId = await this.redisClient.incr(this.uniqueIdKey);
-            return new Promise((resolve) => {
-                this.notifyResolver[uniqueMessageId] = resolve;
-                this.sendJob(CommunicationMessage.SYNC_JOB, uniqueMessageId);
-            });
+            this.sendJob(CommunicationMessage.SYNC_JOB);
         }
         return;
     }
-    async scheduleJob(jobInfo, tx) {
+    async _scheduleJob(jobInfo) {
         if (this.isActive) {
             //-- case each job type
             if (jobInfo.at) {
-                //-- create new schedule job
-                const id = jobInfo.id ||
-                    (await this.jobRepo.saveJob({
-                        jobName: jobInfo.jobName,
-                        params: jobInfo.params,
-                        at: jobInfo.at,
-                    }, tx));
                 //-- use the lib
-                const scheduledJob = { ...jobInfo, id };
                 const timeout = setTimeout(() => {
-                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
+                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.jobId}`, err));
                 }, new Date(jobInfo.at).getTime() - Date.now());
-                this.jobHolder[id] = { jobCanceler: () => clearTimeout(timeout), jobInfo: { ...jobInfo, id } };
-                return id;
+                this.jobHolder[jobInfo.jobId] = { jobCanceler: () => clearTimeout(timeout), jobInfo };
             }
             else if (jobInfo.cron) {
-                const id = jobInfo.jobName;
-                //-- set cron and does not need to persist
-                const scheduledJob = { ...jobInfo, id };
                 const job = scheduler.scheduleJob(jobInfo.cron, () => {
-                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
+                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.jobId}`, err));
                 });
-                this.jobHolder[id] = { jobCanceler: () => job.cancel(), jobInfo: { ...jobInfo, id } };
-                return id;
+                this.jobHolder[jobInfo.jobId] = { jobCanceler: () => job.cancel(), jobInfo };
             }
             else {
                 throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
@@ -230,31 +185,21 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         }
         else {
             //-- get unique message id
-            const uniqueMessageId = await this.redisClient.incr(this.uniqueIdKey);
-            return new Promise((resolve) => {
-                this.notifyResolver[uniqueMessageId] = resolve;
-                this.sendJob(CommunicationMessage.SCHEDULE_JOB, uniqueMessageId, jobInfo);
-            });
+            this.sendJob(CommunicationMessage.SCHEDULE_JOB, jobInfo);
         }
     }
-    async removeJob(id, tx) {
+    async cancelJob(jobId) {
         if (this.isActive) {
             //-- remove from holder
-            const job = this.jobHolder[id];
+            const job = this.jobHolder[jobId];
             if (job) {
                 job.jobCanceler();
-                this.jobHolder[id] = undefined;
+                this.jobHolder[jobId] = undefined;
             }
-            //-- remove from persistence
-            await this.jobRepo.removeJobById(id, tx);
         }
         else {
             //-- get unique message id
-            const uniqueMessageId = await this.redisClient.incr(this.uniqueIdKey);
-            return new Promise((resolve) => {
-                this.notifyResolver[uniqueMessageId] = resolve;
-                this.sendJob(CommunicationMessage.REMOVE_JOB, uniqueMessageId, id);
-            });
+            this.sendJob(CommunicationMessage.REMOVE_JOB, jobId);
         }
     }
 };
@@ -265,6 +210,6 @@ LocalJobScheduler = __decorate([
         AbstractDbAdapter,
         Redis,
         Redis,
-        AbstractJobRepository, String, String, String, String, Number])
+        AbstractJobRepository, String, String, String, Number])
 ], LocalJobScheduler);
 export { LocalJobScheduler };

package/dist/job/decorators.d.ts

@@ -1,6 +1,7 @@
+import { JobRetryOptions } from "./interfaces";
 import { AbstractJobController } from "./AbstractJobController";
 import { JobHandlerFn } from "./AbstractJobScheduler";
 type Descriptor<T> = Omit<TypedPropertyDescriptor<T>, "set">;
-export declare const CronJob: (jobName: string, cron: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T, _descriptor: Descriptor<JobHandlerFn>) => void;
+export declare const CronJob: (jobName: string, cron: string, retryOptions?: JobRetryOptions) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T, _descriptor: Descriptor<JobHandlerFn>) => void;
 export declare const CustomJob: (jobName: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T, _descriptor: Descriptor<JobHandlerFn>) => void;
 export {};

package/dist/job/decorators.js

@@ -1,13 +1,5 @@
 import { Errors, initObjectMetadata } from "@clairejs/core";
-export const CronJob = (
-/**
- * Unique name of job
- */
-jobName, 
-/**
- * Cron expression
- */
-cron) => (prototype, propertyKey, _descriptor) => {
+export const CronJob = (jobName, cron, retryOptions) => (prototype, propertyKey, _descriptor) => {
     const metadata = initObjectMetadata(prototype);
     if (!metadata.jobs) {
         metadata.jobs = [];
@@ -18,6 +10,7 @@ cron) => (prototype, propertyKey, _descriptor) => {
     }
     metadata.jobs.push({
         jobName,
+        retryOptions,
         cron,
         handlerName: propertyKey,
     });

package/dist/job/default-job-repo.d.ts

@@ -1,12 +1,13 @@
 import { AbstractModel, Constructor } from "@clairejs/core";
-import { type ITransaction, AbstractDbAdapter } from "@clairejs/orm";
-import { CustomJobInfo } from "./interfaces";
+import { type ITransaction, AbstractDbAdapter, GetManyOptions, QueryCondition } from "@clairejs/orm";
+import { AbstractJob } from "./interfaces";
 import { AbstractJobRepository } from "./AbstractJobRepository";
-export declare class DefaultJobRepository<T extends CustomJobInfo & AbstractModel> extends AbstractJobRepository<T> {
+export declare class DefaultJobRepository<T extends AbstractJob & AbstractModel> extends AbstractJobRepository<T> {
     protected readonly model: Constructor<T>;
     protected db: AbstractDbAdapter;
     constructor(model: Constructor<T>, db: AbstractDbAdapter);
-    getJobs(): Promise<T[]>;
-    saveJob({ id, ...jobInfo }: T, tx?: ITransaction): Promise<string>;
-    removeJobById(id: string, tx?: ITransaction): Promise<void>;
+    getJobs(query?: QueryCondition<T>, options?: GetManyOptions<T, keyof T>): Promise<T[]>;
+    insertJob({ jobId, ...jobInfo }: Partial<T>, tx?: ITransaction): Promise<string>;
+    removeJobById(jobId: string, tx?: ITransaction): Promise<void>;
+    updateJobById(jobId: string, update: Partial<Omit<T, "jobId">>, tx?: ITransaction): Promise<void>;
 }

package/dist/job/default-job-repo.js

@@ -7,23 +7,25 @@ export class DefaultJobRepository extends AbstractJobRepository {
         this.model = model;
         this.db = db;
     }
-    async getJobs() {
-        const jobs = await this.db.use(this.model).getRecords();
-        return jobs;
+    async getJobs(query, options) {
+        return await this.db.use(this.model).getRecords(query, options);
     }
-    async saveJob({ id, ...jobInfo }, tx) {
-        if (id) {
+    async insertJob({ jobId, ...jobInfo }, tx) {
+        if (jobId) {
             //-- update
-            await this.db.use(this.model, tx).updateById(id, jobInfo);
+            await this.db.use(this.model, tx).updateOne({ _eq: { jobId } }, jobInfo);
+            return jobId;
         }
         else {
             //-- create new
             const job = await this.db.use(this.model, tx).createOne(jobInfo);
-            id = job.id;
+            return job.jobId;
         }
-        return id;
     }
-    async removeJobById(id, tx) {
-        await this.db.use(this.model, tx).deleteById(id);
+    async removeJobById(jobId, tx) {
+        await this.db.use(this.model, tx).deleteMany({ _eq: { jobId } });
+    }
+    async updateJobById(jobId, update, tx) {
+        await this.db.use(this.model, tx).updateOne({ _eq: { jobId } }, update);
     }
 }

package/dist/job/interfaces.d.ts

@@ -1,10 +1,19 @@
 import { ObjectMetadata } from "@clairejs/core";
 export declare const CRON_REQUEST_METHOD = "cron";
+export interface JobRetryOptions {
+    retryOnFail?: boolean;
+    maxRetry?: number;
+    retryDelayMs?: number;
+}
 export interface JobInfoMetadata {
     /**
      * Unique name of job
      */
     jobName: string;
+    /**
+     * Retry options
+     */
+    retryOptions?: JobRetryOptions;
     /**
      * Run with cron expression, does not support seconds precision
      */
@@ -21,19 +30,20 @@ export interface JobInfoMetadata {
 export interface JobControllerMetadata extends ObjectMetadata {
     jobs?: JobInfoMetadata[];
 }
-export interface CustomJobInfo {
-    id?: string;
-    jobName: string;
-    at: number;
-    params?: any;
-}
-export interface JobInfo {
-    id?: string;
+export interface JobSchedulePayload extends JobRetryOptions {
+    jobId?: string;
     jobName: string;
     params?: any;
     at?: number;
     cron?: string;
 }
-export interface ScheduledJob extends JobInfo {
-    id: string;
+export interface AbstractJob extends JobSchedulePayload {
+    jobId: string;
+    disabled?: boolean;
+    execCount?: number;
+    failCount?: number;
+    retryCount?: number;
+    lastError?: string;
+    lastRunAt?: number;
+    lastSuccessAt?: number;
 }

package/dist/job/job.d.ts

@@ -1,7 +1,19 @@
 import { AbstractModel } from "@clairejs/core";
-import { CustomJobInfo } from "./interfaces";
-export declare abstract class AbstractJob extends AbstractModel implements CustomJobInfo {
+import { AbstractJob } from "./interfaces";
+export declare abstract class AbstractJobModel extends AbstractModel implements AbstractJob {
+    jobId: string;
     jobName: string;
-    at: number;
+    at?: number;
+    cron?: string;
     params?: any;
+    retryOnFail?: boolean;
+    maxRetry?: number;
+    retryCount?: number;
+    retryDelayMs?: number;
+    disabled?: boolean;
+    execCount?: number;
+    failCount?: number;
+    lastError?: string;
+    lastRunAt?: number;
+    lastSuccessAt?: number;
 }

package/dist/job/job.js

@@ -8,29 +8,93 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { AbstractModel, Column } from "@clairejs/core";
-export class AbstractJob extends AbstractModel {
+export class AbstractJobModel extends AbstractModel {
+    jobId;
     jobName;
     at;
+    cron;
     params;
+    retryOnFail;
+    maxRetry;
+    retryCount;
+    retryDelayMs;
+    disabled;
+    execCount;
+    failCount;
+    lastError;
+    lastRunAt;
+    lastSuccessAt;
 }
+__decorate([
+    Column({
+        description: "Unique id of the job",
+        isRequired: true,
+    }),
+    __metadata("design:type", String)
+], AbstractJobModel.prototype, "jobId", void 0);
 __decorate([
     Column({
         description: "Name of the job",
         isRequired: true,
     }),
     __metadata("design:type", String)
-], AbstractJob.prototype, "jobName", void 0);
+], AbstractJobModel.prototype, "jobName", void 0);
 __decorate([
     Column({
         description: "Unix timestamp this job will be triggered",
-        isRequired: true,
         isTimestamp: true,
     }),
     __metadata("design:type", Number)
-], AbstractJob.prototype, "at", void 0);
+], AbstractJobModel.prototype, "at", void 0);
+__decorate([
+    Column({
+        description: "The cron expression to repeat",
+    }),
+    __metadata("design:type", String)
+], AbstractJobModel.prototype, "cron", void 0);
 __decorate([
     Column({
         description: "The associated params with this job",
     }),
     __metadata("design:type", Object)
-], AbstractJob.prototype, "params", void 0);
+], AbstractJobModel.prototype, "params", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Boolean)
+], AbstractJobModel.prototype, "retryOnFail", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "maxRetry", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "retryCount", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "retryDelayMs", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Boolean)
+], AbstractJobModel.prototype, "disabled", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "execCount", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "failCount", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", String)
+], AbstractJobModel.prototype, "lastError", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "lastRunAt", void 0);
+__decorate([
+    Column({}),
+    __metadata("design:type", Number)
+], AbstractJobModel.prototype, "lastSuccessAt", void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.22.15",
+    "version": "3.23.1",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",