@clairejs/server 3.27.6 → 3.28.1

package/README.md

@@ -1,5 +1,9 @@
 ## Change Log
 
+#### 3.28.1
+
+-   implement new job scheduler
+
 #### 3.27.6
 
 -   fix npm security issues

package/dist/job/AbstractJobScheduler.d.ts

@@ -13,23 +13,19 @@ export declare abstract class AbstractJobScheduler {
     private _jobs;
     constructor(logger: AbstractLogger, db: ITransactionFactory, jobRepo: AbstractJobRepository);
     protected getCurrentJobHandlers(): Promise<JobHandlerMetadata[]>;
-    protected abstract getScheduledJobs(): Promise<AbstractJob[]>;
-    /**
-     * Sync all jobs to running state. This should be called only at init time.
-     */
-    syncJobs(): Promise<void>;
+    scheduleJob(payload: JobSchedulePayload): Promise<string>;
     /**
      * Return unique job id which can then be used to cancel the job
      * @param payload the necessary info to launch the job
      */
-    protected abstract _scheduleJob(payload: JobSchedulePayload): Promise<void>;
-    scheduleJob({ id, ...payload }: JobSchedulePayload): Promise<string>;
+    protected abstract registerJob(payload: AbstractJob): Promise<void>;
     /**
      * Cancel the scheduled job and prevent if from running in the future
      * @param id The job id returned from scheduleJobAt function
      */
     protected abstract cancelJob(id: string): Promise<void>;
-    protected retryJob(payload: AbstractJob): Promise<void>;
+    protected abstract retryJob(job: AbstractJob, at: number): Promise<void>;
+    protected abstract cleanupJob(id: string): Promise<void>;
     /**
      * Remove the scheduled job and prevent if from running in the future
      * @param id The job id returned from scheduleJobAt function
@@ -39,6 +35,6 @@ export declare abstract class AbstractJobScheduler {
      * Execute the scheduled job
      * @param job The schedled job info to execute
      */
-    protected executeJob(job: AbstractJob): Promise<void>;
+    protected executeJob(jobId: string): Promise<void>;
 }
 export {};

package/dist/job/AbstractJobScheduler.js

@@ -1,4 +1,4 @@
-import { diffData, getServiceProvider } from "@clairejs/core";
+import { getServiceProvider } from "@clairejs/core";
 import { AbstractJobController } from "./AbstractJobController";
 export class AbstractJobScheduler {
     logger;
@@ -22,84 +22,11 @@ export class AbstractJobScheduler {
         }
         return this._jobs;
     }
-    /**
-     * Sync all jobs to running state. This should be called only at init time.
-     */
-    async syncJobs() {
-        //-- check jobs
-        const scheduledJobs = await this.getScheduledJobs();
-        const allHandlers = await this.getCurrentJobHandlers();
-        const tx = await this.db.createTransaction();
-        //-- remove job that no more exist
-        const nomoreExistJobs = scheduledJobs.filter((job) => !allHandlers.find((handler) => handler.jobName === job.jobName));
-        for (const job of nomoreExistJobs) {
-            this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.id}`);
-            await this.disableJob(job.id, tx);
-        }
-        if (nomoreExistJobs.length) {
-            this.logger.info(`Cleaned up: ${nomoreExistJobs.length} stale jobs`);
-        }
-        //-- remove scheduled cron jobs that diff the cron expression
-        this.logger.debug("Remove scheduled cron jobs");
-        const scheduledCronJobs = scheduledJobs.filter((j) => j.cron);
-        const updatedScheduledCronJobs = scheduledCronJobs.filter((j) => j.cron && allHandlers.some((job) => job.jobName === j.jobName && job.cron !== j.cron));
-        for (const job of updatedScheduledCronJobs) {
-            await this.disableJob(job.id, tx);
-        }
-        await tx.commit();
-        //-- reschedule new cron jobs and those which are not synced
-        const resyncCronJobs = allHandlers.filter((job) => job.cron &&
-            (updatedScheduledCronJobs.some((j) => j.jobName === job.jobName) ||
-                !scheduledCronJobs.some((j) => j.jobName === job.jobName)));
-        this.logger.debug(`Resync ${resyncCronJobs.length} cron jobs`, resyncCronJobs);
-        const allPersistedJobs = await this.jobRepo.getJobs({ _neq: { disabled: true } });
-        for (const job of resyncCronJobs) {
-            const matchedPersistedJob = allPersistedJobs.find((persistedJob) => persistedJob.jobName === job.jobName && persistedJob.cron === job.cron);
-            await this.scheduleJob({
-                ...matchedPersistedJob,
-                ...job.retryOptions,
-                jobName: job.jobName,
-                cron: job.cron,
-                at: job.at,
-            });
-        }
-        //-- sync "at" jobs
-        const missingScheduledAtJobs = allPersistedJobs.filter((job) => job.at && !scheduledJobs.find((scheduled) => scheduled.id === job.id));
-        for (const job of missingScheduledAtJobs) {
-            await this.scheduleJob(job);
-        }
-    }
-    async scheduleJob({ id, ...payload }) {
-        let jobId = id;
-        const tx = await this.db.createTransaction();
-        if (!jobId && !payload.cron) {
-            jobId = await this.jobRepo.insertJob(payload, tx);
-        }
-        else {
-            const job = jobId
-                ? await this.jobRepo.getJobById(jobId)
-                : await this.jobRepo
-                    .getJobs({ _eq: { jobName: payload.jobName } }, { limit: 1 })
-                    .then((jobs) => jobs[0]);
-            if (!job) {
-                jobId = await this.jobRepo.insertJob(payload, tx);
-            }
-            else {
-                jobId = job.id;
-                const diff = diffData(job, payload);
-                if (diff) {
-                    await this.jobRepo.updateJobById(job.id, payload, tx);
-                }
-            }
-        }
-        await this._scheduleJob({ ...payload, id: jobId });
-        await tx.commit();
+    async scheduleJob(payload) {
+        const jobId = await this.jobRepo.insertJob(payload);
+        await this.registerJob({ ...payload, id: jobId });
         return jobId;
     }
-    async retryJob(payload) {
-        this.logger.debug("Retrying job: ", payload);
-        await this._scheduleJob({ ...payload, id: `${payload.id}-retry-${payload.retryCount}` });
-    }
     /**
      * Remove the scheduled job and prevent if from running in the future
      * @param id The job id returned from scheduleJobAt function
@@ -112,13 +39,18 @@ export class AbstractJobScheduler {
      * Execute the scheduled job
      * @param job The schedled job info to execute
      */
-    async executeJob(job) {
+    async executeJob(jobId) {
+        const job = await this.jobRepo.getJobById(jobId);
+        if (!job) {
+            await this.cancelJob(jobId);
+            return;
+        }
         if (job.disabled) {
             return;
         }
         //-- run job
         const allHandlers = await this.getCurrentJobHandlers();
-        const jobHandler = allHandlers.find((j) => j.jobName === job.jobName);
+        const jobHandler = allHandlers.find((j) => j.jobIdentifier === job.jobName);
         const tx = await this.db.createTransaction();
         if (!jobHandler) {
             this.logger.info(`Disable job with id: ${job.id} as handler is not found`);
@@ -130,7 +62,10 @@ export class AbstractJobScheduler {
                 execCount: (job.execCount || 0) + 1,
             };
             try {
+                this.logger.debug(`Calling job handler for ${job.id}`);
                 await jobHandler.handlerFn(job);
+                this.logger.debug(`Job handler for ${job.id} completed`);
+                await this.cleanupJob(job.id).catch((err) => this.logger.error(`Failed to cleanup job: ${job.id}`, err));
                 //-- job run success, update
                 update.lastSuccessAt = Date.now();
                 //-- reset retry count if this is cron job
@@ -144,21 +79,19 @@ export class AbstractJobScheduler {
                 }
             }
             catch (err) {
+                this.logger.error(`Job handler for: ${job.id} failed`, 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.retryJob({ ...job, ...update, at: Date.now() + (retryDelay < 60000 ? 60000 : retryDelay) });
+                const maxRetry = job.maxRetry || 0;
+                if (maxRetry) {
+                    const currentRetryCount = job.retryCount || 0;
+                    if (currentRetryCount < maxRetry) {
+                        await this.retryJob(job, Date.now() + Math.max(job.retryDelayMs || 0, 60000));
+                        update.retryCount = currentRetryCount + 1;
                     }
                     else {
-                        if (job.cron) {
-                            update.at = undefined;
-                        }
-                        else {
+                        if (job.at) {
                             update.disabled = true;
                             await this.cancelJob(job.id);
                         }
@@ -166,7 +99,6 @@ export class AbstractJobScheduler {
                 }
             }
             await this.jobRepo.updateJobById(job.id, update, tx);
-            Object.assign(job, update);
         }
         await tx.commit();
     }

package/dist/job/AwsJobScheduler.d.ts

@@ -13,10 +13,13 @@ export declare class AwsJobScheduler extends AbstractJobScheduler {
     protected readonly jobNamespace: string;
     protected readonly scheduler: SchedulerClient;
     constructor(logger: AbstractLogger, db: AbstractDbAdapter, jobRepo: AbstractJobRepository, apiLambdaFunctionArn: string, apiLambdaFunctionRoleArn: string, jobNamespace: string);
-    handleCron(jobInfo: AbstractJob): Promise<void>;
+    handleCron(jobInfo: Pick<AbstractJob, "id">): Promise<void>;
     private convertCronToSchedulerExpression;
+    private getJobUniqueName;
     private getOneTimeExpression;
-    protected getScheduledJobs(): Promise<AbstractJob[]>;
-    protected _scheduleJob(jobInfo: AbstractJob): Promise<void>;
+    private removeJobFromScheduler;
+    protected retryJob(job: AbstractJob, at: number): Promise<void>;
+    protected cleanupJob(jobId: string): Promise<void>;
+    protected registerJob(job: AbstractJob): Promise<void>;
     cancelJob(jobId: string): Promise<void>;
 }

package/dist/job/AwsJobScheduler.js

@@ -9,13 +9,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { AbstractLogger, Errors, LogContext } from "@clairejs/core";
 import { AbstractDbAdapter } from "@clairejs/orm";
-import { SchedulerClient, CreateScheduleCommand, DeleteScheduleCommand, GetScheduleCommand, ListSchedulesCommand, ScheduleState, ActionAfterCompletion } from "@aws-sdk/client-scheduler";
+import { SchedulerClient, CreateScheduleCommand, DeleteScheduleCommand, GetScheduleCommand, ScheduleState, UpdateScheduleCommand, } from "@aws-sdk/client-scheduler";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 /**
  * AWS Scheduler API permissions required:
- * scheduler:CreateSchedule, scheduler:DeleteSchedule, scheduler:GetSchedule,
- * scheduler:ListSchedules, scheduler:UpdateSchedule
+ * scheduler:CreateSchedule, scheduler:DeleteSchedule, scheduler:GetSchedule, scheduler:UpdateSchedule
  * Also update Lambda function to allow function invocation from scheduler.amazonaws.com.
  */
 const schedulerGroupName = "default";
@@ -38,7 +37,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     }
     async handleCron(jobInfo) {
         this.logger.debug(`Handle cron`, jobInfo);
-        await this.executeJob(jobInfo);
+        await this.executeJob(jobInfo.id);
     }
     convertCronToSchedulerExpression(cron) {
         // AWS Scheduler uses a different cron format than standard cron
@@ -56,118 +55,95 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         }
         return parts.join(" ");
     }
+    getJobUniqueName(jobId) {
+        return `${this.jobNamespace}${jobId}`;
+    }
     getOneTimeExpression(at) {
         const date = new Date(at);
-        return `at(${date.toISOString().replace(/\.\d{3}Z$/, '')})`;
+        return `at(${date.toISOString().replace(/\.\d{3}Z$/, "")})`;
+    }
+    async removeJobFromScheduler(jobId) {
+        const jobName = this.getJobUniqueName(jobId);
+        const deleteCommand = new DeleteScheduleCommand({
+            Name: jobName,
+            GroupName: schedulerGroupName,
+        });
+        await this.scheduler.send(deleteCommand);
     }
-    async getScheduledJobs() {
-        try {
-            const listCommand = new ListSchedulesCommand({
+    async retryJob(job, at) {
+        const jobName = this.getJobUniqueName(job.id);
+        if (job.at) {
+            //-- update the job
+            const getCommand = new GetScheduleCommand({
+                Name: jobName,
                 GroupName: schedulerGroupName,
-                NamePrefix: this.jobNamespace,
             });
-            const allSchedules = await this.scheduler.send(listCommand);
-            const allJobs = await Promise.all((allSchedules.Schedules || []).map(async (schedule) => {
-                const scheduleName = schedule.Name;
-                try {
-                    const getCommand = new GetScheduleCommand({
-                        Name: scheduleName,
-                        GroupName: schedulerGroupName,
-                    });
-                    const scheduleDetails = await this.scheduler.send(getCommand);
-                    if (!scheduleDetails.Target?.Arn || !scheduleDetails.Target?.Input) {
-                        return undefined;
-                    }
-                    const jobInfo = JSON.parse(scheduleDetails.Target.Input).requestContext.cronScheduler.data;
-                    return jobInfo;
-                }
-                catch (error) {
-                    this.logger.warn(`Failed to get schedule details for ${scheduleName}`, error);
-                    return undefined;
-                }
-            }));
-            return allJobs.flatMap((job) => (job ? [job] : []));
+            const scheduledJob = await this.scheduler.send(getCommand);
+            const updateCommand = new UpdateScheduleCommand({
+                ...scheduledJob,
+                ScheduleExpression: this.getOneTimeExpression(at),
+            });
+            await this.scheduler.send(updateCommand);
         }
-        catch (error) {
-            this.logger.error("Failed to get scheduled jobs", error);
-            return [];
+        else {
+            //-- schedule a new one-time job to re-execute this cron with minus one maxRetry
+            await this.scheduleJob({ ...job, at, maxRetry: (job.maxRetry || 0) - 1 });
         }
     }
-    async _scheduleJob(jobInfo) {
-        this.logger.debug("Scheduling job: ", jobInfo);
-        if (jobInfo.cron || jobInfo.at) {
-            const jobId = `${this.jobNamespace}${jobInfo.id}`;
-            let scheduleExpression;
-            let flexibleTimeWindow;
-            if (jobInfo.at) {
-                scheduleExpression = this.getOneTimeExpression(jobInfo.at);
-                // Add flexible time window for one-time jobs to handle slight delays
-                flexibleTimeWindow = {
-                    Mode: "OFF",
-                };
-            }
-            else if (jobInfo.cron) {
-                // For recurring jobs, use cron() expression
-                const schedulerCron = this.convertCronToSchedulerExpression(jobInfo.cron);
-                scheduleExpression = `cron(${schedulerCron})`;
-                // Add flexible time window for recurring jobs
-                flexibleTimeWindow = {
-                    Mode: "FLEXIBLE",
-                    MaximumWindowInMinutes: 5, // Allow 5-minute window for execution
-                };
-            }
-            else {
-                throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
-            }
-            this.logger.debug("Schedule expression", scheduleExpression);
-            const scheduleParams = {
-                Name: jobId,
-                GroupName: schedulerGroupName,
-                Description: `${jobInfo.jobName} - ${scheduleExpression}`,
-                ScheduleExpression: scheduleExpression,
-                FlexibleTimeWindow: flexibleTimeWindow,
-                Target: {
-                    Arn: this.apiLambdaFunctionArn,
-                    RoleArn: this.apiLambdaFunctionRoleArn,
-                    Input: JSON.stringify({
-                        requestContext: {
-                            cronScheduler: {
-                                data: { ...jobInfo, jobId },
-                            },
-                        },
-                    }),
-                },
-                State: ScheduleState.ENABLED,
-                ActionAfterCompletion: ActionAfterCompletion.DELETE,
+    async cleanupJob(jobId) {
+        return await this.removeJobFromScheduler(jobId);
+    }
+    async registerJob(job) {
+        this.logger.debug("Scheduling job: ", job);
+        const jobName = this.getJobUniqueName(job.id);
+        let scheduleExpression;
+        let flexibleTimeWindow;
+        if (job.at) {
+            scheduleExpression = this.getOneTimeExpression(job.at);
+            // Add flexible time window for one-time jobs to handle slight delays
+            flexibleTimeWindow = {
+                Mode: "OFF",
+            };
+        }
+        else if (job.cron) {
+            // For recurring jobs, use cron() expression
+            const schedulerCron = this.convertCronToSchedulerExpression(job.cron);
+            scheduleExpression = `cron(${schedulerCron})`;
+            // Add flexible time window for recurring jobs
+            flexibleTimeWindow = {
+                Mode: "FLEXIBLE",
+                MaximumWindowInMinutes: 5, // Allow 5-minute window for execution
             };
-            try {
-                const createCommand = new CreateScheduleCommand(scheduleParams);
-                await this.scheduler.send(createCommand);
-                this.logger.debug(`Successfully created schedule: ${jobId}`);
-            }
-            catch (error) {
-                this.logger.error(`Failed to create schedule: ${jobId}`, error);
-                throw error;
-            }
         }
         else {
-            throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
+            throw Errors.SYSTEM_ERROR(`Job does not have time config: ${job.jobName}`);
         }
+        this.logger.debug("Schedule expression", scheduleExpression);
+        const scheduleParams = {
+            Name: jobName,
+            GroupName: schedulerGroupName,
+            Description: `${job.jobName} - ${scheduleExpression}`,
+            ScheduleExpression: scheduleExpression,
+            FlexibleTimeWindow: flexibleTimeWindow,
+            Target: {
+                Arn: this.apiLambdaFunctionArn,
+                RoleArn: this.apiLambdaFunctionRoleArn,
+                Input: JSON.stringify({
+                    requestContext: {
+                        cronScheduler: {
+                            data: { id: job.id },
+                        },
+                    },
+                }),
+            },
+            State: ScheduleState.ENABLED,
+        };
+        const createCommand = new CreateScheduleCommand(scheduleParams);
+        await this.scheduler.send(createCommand);
+        this.logger.debug(`Successfully created schedule: ${jobName}`);
     }
     async cancelJob(jobId) {
-        const scheduleName = `${this.jobNamespace}${jobId}`;
-        try {
-            const deleteCommand = new DeleteScheduleCommand({
-                Name: scheduleName,
-                GroupName: schedulerGroupName,
-            });
-            await this.scheduler.send(deleteCommand);
-            this.logger.debug(`Successfully deleted schedule: ${scheduleName}`);
-        }
-        catch (error) {
-            this.logger.error(`Failed to delete schedule: ${scheduleName}`, error);
-            throw error;
-        }
+        await this.removeJobFromScheduler(jobId);
     }
 };
 AwsJobScheduler = __decorate([

package/dist/job/LocalJobScheduler.d.ts

@@ -50,10 +50,11 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
     private sendJob;
     private processMessage;
     private extendMutexKey;
+    private loadAndActivateJobs;
     init(): Promise<void>;
     exit(): void;
-    protected getScheduledJobs(): Promise<AbstractJob[]>;
-    syncJobs(): Promise<void>;
-    protected _scheduleJob(jobInfo: AbstractJob): Promise<void>;
+    protected retryJob(job: AbstractJob, at: number): Promise<void>;
+    protected cleanupJob(jobId: string): Promise<void>;
+    protected registerJob(job: AbstractJob): Promise<void>;
     protected cancelJob(jobId: string): Promise<void>;
 }

package/dist/job/LocalJobScheduler.js

@@ -18,7 +18,7 @@ var CommunicationMessage;
 (function (CommunicationMessage) {
     CommunicationMessage["SCHEDULE_JOB"] = "SCHEDULE_JOB";
     CommunicationMessage["REMOVE_JOB"] = "REMOVE_JOB";
-    CommunicationMessage["SYNC_JOB"] = "SYNC_JOB";
+    CommunicationMessage["CLEANUP_JOB"] = "CLEANUP_JOB";
 })(CommunicationMessage || (CommunicationMessage = {}));
 let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
     logger;
@@ -66,30 +66,26 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         this.subscribeClient.publish(this.multiClientChannel, JSON.stringify({ type, data }));
     }
     async processMessage(type, data) {
+        if (!this.isActive) {
+            //-- not active scheduler, ignore
+            return;
+        }
         switch (type) {
-            case CommunicationMessage.SYNC_JOB:
-                if (!this.isActive) {
-                    //-- not active scheduler, ignore
-                    return;
-                }
-                await this.syncJobs();
-                break;
-            case CommunicationMessage.SCHEDULE_JOB:
-                if (!this.isActive) {
-                    //-- not active scheduler, ignore
-                    return;
-                }
+            case CommunicationMessage.SCHEDULE_JOB: {
                 const jobInfo = data;
-                await this._scheduleJob(jobInfo);
+                await this.registerJob(jobInfo);
                 break;
-            case CommunicationMessage.REMOVE_JOB:
-                if (!this.isActive) {
-                    //-- not active scheduler, ignore
-                    return;
-                }
+            }
+            case CommunicationMessage.REMOVE_JOB: {
+                const jobId = data;
+                await this.cancelJob(jobId);
+                break;
+            }
+            case CommunicationMessage.CLEANUP_JOB: {
                 const jobId = data;
-                await this.disableJob(jobId);
+                await this.cleanupJob(jobId);
                 break;
+            }
             default:
                 this.logger.error(`Not recognize message type ${type}`);
                 break;
@@ -103,6 +99,13 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         await this.redisClient.setex(this.holdMutexKey, this.keyRetentionDurationSeconds, 1);
         this.logger.debug("Scheduler extends mutex key");
     }
+    //-- load and activate jobs
+    async loadAndActivateJobs() {
+        const jobs = await this.jobRepo.getJobs({ _neq: { disabled: true } });
+        for (const job of jobs) {
+            await this.registerJob(job);
+        }
+    }
     async init() {
         this.logger.debug("LocalJobScheduler init");
         //-- subscribe to multi client channel
@@ -128,6 +131,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             this.mutexHoldInterval = setInterval(() => {
                 this.extendMutexKey();
             }, Math.trunc((this.keyRetentionDurationSeconds * 1000) / 2) + 1);
+            await this.loadAndActivateJobs();
         }
         catch (err) {
             this.logger.info("Failed to lock mutex key, ignore", err);
@@ -142,41 +146,43 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         }
         this.logger.debug("LocalJobScheduler exit");
     }
-    async getScheduledJobs() {
-        return Object.values(this.jobHolder).flatMap((job) => (job?.jobInfo ? [job.jobInfo] : []));
-    }
-    async syncJobs() {
-        if (this.isActive) {
-            await super.syncJobs();
+    async retryJob(job, at) {
+        if (job.at) {
+            //-- just register the job at new timestamp
+            await this.registerJob({ ...job, at });
         }
         else {
-            this.sendJob(CommunicationMessage.SYNC_JOB);
+            //-- schedule a new one-time job to re-execute this cron with minus one maxRetry
+            await this.scheduleJob({ ...job, at, maxRetry: (job.maxRetry || 0) - 1 });
         }
-        return;
     }
-    async _scheduleJob(jobInfo) {
+    async cleanupJob(jobId) {
+        this.jobHolder[jobId] = undefined;
+        this.sendJob(CommunicationMessage.CLEANUP_JOB, jobId);
+    }
+    async registerJob(job) {
         if (this.isActive) {
             //-- case each job type
-            if (jobInfo.at) {
+            if (job.at) {
                 //-- use the lib
                 const timeout = setTimeout(() => {
-                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.id}`, err));
-                }, new Date(jobInfo.at).getTime() - Date.now());
-                this.jobHolder[jobInfo.id] = { jobCanceler: () => clearTimeout(timeout), jobInfo };
+                    this.executeJob(job.id).catch((err) => this.logger.error(`Error execute job ${job.jobName} with id: ${job.id}`, err));
+                }, new Date(job.at).getTime() - Date.now());
+                this.jobHolder[job.id] = { jobCanceler: () => clearTimeout(timeout), job };
             }
-            else if (jobInfo.cron) {
-                const job = scheduler.scheduleJob(jobInfo.cron, () => {
-                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.id}`, err));
+            else if (job.cron) {
+                const scheduledJob = scheduler.scheduleJob(job.cron, () => {
+                    this.executeJob(job.id).catch((err) => this.logger.error(`Error execute job ${job.jobName} with id: ${job.id}`, err));
                 });
-                this.jobHolder[jobInfo.id] = { jobCanceler: () => job.cancel(), jobInfo };
+                this.jobHolder[job.id] = { jobCanceler: () => scheduledJob.cancel(), job };
             }
             else {
-                throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
+                throw Errors.SYSTEM_ERROR(`Job does not have time config: ${job.jobName}`);
             }
         }
         else {
             //-- get unique message id
-            this.sendJob(CommunicationMessage.SCHEDULE_JOB, jobInfo);
+            this.sendJob(CommunicationMessage.SCHEDULE_JOB, job);
         }
     }
     async cancelJob(jobId) {

package/dist/job/decorators.d.ts

@@ -1,7 +1,5 @@
-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, 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 declare const Job: (jobIdentifier: string) => <T extends AbstractJobController>(prototype: T, propertyKey: keyof T, _descriptor: Descriptor<JobHandlerFn>) => void;
 export {};

package/dist/job/decorators.js

@@ -1,31 +1,11 @@
-import { Errors, initObjectMetadata } from "@clairejs/core";
-export const CronJob = (jobName, cron, retryOptions) => (prototype, propertyKey, _descriptor) => {
-    const metadata = initObjectMetadata(prototype);
-    if (!metadata.jobs) {
-        metadata.jobs = [];
-    }
-    //-- validate cron
-    if (cron.split(" ").length !== 5) {
-        throw Errors.SYSTEM_ERROR("Invalid cron expression, expect minute / hour / day / month / day-of-week");
-    }
-    metadata.jobs.push({
-        jobName,
-        retryOptions,
-        cron,
-        handlerName: propertyKey,
-    });
-};
-export const CustomJob = (
-/**
- * Unique name of job
- */
-jobName) => (prototype, propertyKey, _descriptor) => {
+import { initObjectMetadata } from "@clairejs/core";
+export const Job = (jobIdentifier) => (prototype, propertyKey, _descriptor) => {
     const metadata = initObjectMetadata(prototype);
     if (!metadata.jobs) {
         metadata.jobs = [];
     }
     metadata.jobs.push({
-        jobName,
+        jobIdentifier,
         handlerName: propertyKey,
     });
 };

package/dist/job/interfaces.d.ts

@@ -1,37 +1,23 @@
 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
+     * Name of the handler function
      */
-    jobName: string;
-    /**
-     * Retry options
-     */
-    retryOptions?: JobRetryOptions;
-    /**
-     * Run with cron expression, does not support seconds precision
-     */
-    cron?: string;
-    /**
-     * Run at specific timestamp, does not support seconds precision
-     */
-    at?: number;
+    handlerName: string;
     /**
-     * Name of the function handle
+     * Unique identifier of the job
      */
-    handlerName: string;
+    jobIdentifier: string;
 }
 export interface JobControllerMetadata extends ObjectMetadata {
     jobs?: JobInfoMetadata[];
 }
 export interface JobSchedulePayload extends JobRetryOptions {
-    id?: string;
     jobName: string;
     params?: any;
     at?: number;

package/dist/system/LambdaWrapper.js

@@ -106,7 +106,6 @@ export class LambdaWrapper {
                 return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
             }
             if (requestOptions.method === CRON_REQUEST_METHOD) {
-                console.log("handle cron", requestOptions.body);
                 await this.jobScheduler?.handleCron(requestOptions.body);
                 return toApiGatewayFormat({ code: 200, headers: corsHeaders, cookies: {} });
             }

package/package.json

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