@clairejs/server 3.23.1 → 3.23.3

package/README.md

@@ -1,7 +1,9 @@
 ## Change Log
 
-#### 3.23.1
+#### 3.23.3
 
+-   remove jobId fallback and update schedule job logic
+-   fix fallback jobId by id in AbstractJob
 -   fix retryDelayMs
 -   improve JobScheduler
 

package/dist/job/AbstractJobRepository.d.ts

@@ -10,14 +10,19 @@ export declare abstract class AbstractJobRepository<T extends AbstractJob = Abst
      * @param jobInfo The job info to save
      */
     abstract insertJob(jobInfo: Partial<T>, tx?: ITransaction): Promise<string>;
+    /**
+     * Return the job by its unique id
+     * @param id The unique job id
+     */
+    abstract getJobById(id: string): Promise<AbstractJob | undefined>;
     /**
      * Remove job info by id
-     * @param jobId Unique id of job
+     * @param id Unique id of job
      */
-    abstract removeJobById(jobId: string, tx?: ITransaction): Promise<void>;
+    abstract removeJobById(id: string, tx?: ITransaction): Promise<void>;
     /**
      * Remove job info by id
-     * @param jobId Unique id of job
+     * @param id Unique id of job
      */
-    abstract updateJobById(jobId: string, update: Partial<Omit<T, "jobId">>, tx?: ITransaction): Promise<void>;
+    abstract updateJobById(id: string, update: Partial<Omit<T, "id">>, tx?: ITransaction): Promise<void>;
 }

package/dist/job/AbstractJobScheduler.d.ts

@@ -22,17 +22,17 @@ export declare abstract class AbstractJobScheduler {
      * @param payload the necessary info to launch the job
      */
     protected abstract _scheduleJob(payload: JobSchedulePayload): Promise<void>;
-    scheduleJob({ jobId, ...payload }: JobSchedulePayload): Promise<string>;
+    scheduleJob({ id, ...payload }: JobSchedulePayload): Promise<string>;
     /**
      * Cancel the scheduled job and prevent if from running in the future
      * @param id The job id returned from scheduleJobAt function
      */
-    protected abstract cancelJob(jobId: string): Promise<void>;
+    protected abstract cancelJob(id: string): Promise<void>;
     /**
      * Remove the scheduled job and prevent if from running in the future
-     * @param jobId The job id returned from scheduleJobAt function
+     * @param id The job id returned from scheduleJobAt function
      */
-    disableJob(jobId: string, tx?: ITransaction): Promise<void>;
+    disableJob(id: string, tx?: ITransaction): Promise<void>;
     /**
      * Execute the scheduled job
      * @param job The schedled job info to execute

package/dist/job/AbstractJobScheduler.js

@@ -22,35 +22,38 @@ export class AbstractJobScheduler {
         }
         return this._jobs;
     }
-    async scheduleJob({ jobId, ...payload }) {
-        let uniqueId = jobId;
+    async scheduleJob({ id, ...payload }) {
+        let jobId = id;
         const tx = await this.db.createTransaction();
-        if (!uniqueId) {
-            uniqueId = await this.jobRepo.insertJob(payload, tx);
+        if (!jobId && !payload.cron) {
+            jobId = await this.jobRepo.insertJob(payload, tx);
         }
         else {
-            const [job] = await this.jobRepo.getJobs({ _eq: { jobId: uniqueId } }, { limit: 1 });
+            const job = jobId
+                ? await this.jobRepo.getJobById(jobId)
+                : await this.jobRepo.getJobs({ _eq: { jobName: payload.cron } }, { limit: 1 }).then((jobs) => jobs[0]);
             if (!job) {
-                await this.jobRepo.insertJob({ ...payload, jobId: uniqueId }, tx);
+                jobId = await this.jobRepo.insertJob(payload, tx);
             }
             else {
+                jobId = job.id;
                 const diff = diffData(job, payload);
                 if (diff) {
-                    await this.jobRepo.updateJobById(uniqueId, payload, tx);
+                    await this.jobRepo.updateJobById(job.id, payload, tx);
                 }
             }
         }
-        await this._scheduleJob({ ...payload, jobId: uniqueId });
+        await this._scheduleJob({ ...payload, id: jobId });
         await tx.commit();
-        return uniqueId;
+        return jobId;
     }
     /**
      * Remove the scheduled job and prevent if from running in the future
-     * @param jobId The job id returned from scheduleJobAt function
+     * @param id The job id returned from scheduleJobAt function
      */
-    async disableJob(jobId, tx) {
-        await this.cancelJob(jobId);
-        await this.jobRepo.updateJobById(jobId, { disabled: true }, tx);
+    async disableJob(id, tx) {
+        await this.cancelJob(id);
+        await this.jobRepo.updateJobById(id, { disabled: true }, tx);
     }
     /**
      * Execute the scheduled job
@@ -65,8 +68,8 @@ export class AbstractJobScheduler {
         const jobHandler = allHandlers.find((j) => j.jobName === job.jobName);
         const tx = await this.db.createTransaction();
         if (!jobHandler) {
-            this.logger.info(`Disable job with id: ${job.jobId} as handler is not found`);
-            await this.disableJob(job.jobId, tx);
+            this.logger.info(`Disable job with id: ${job.id} as handler is not found`);
+            await this.disableJob(job.id || job.id, tx);
         }
         else {
             const update = {
@@ -104,12 +107,12 @@ export class AbstractJobScheduler {
                         }
                         else {
                             update.disabled = true;
-                            await this.cancelJob(job.jobId);
+                            await this.cancelJob(job.id);
                         }
                     }
                 }
             }
-            await this.jobRepo.updateJobById(job.jobId, update, tx);
+            await this.jobRepo.updateJobById(job.id, update, tx);
         }
         await tx.commit();
     }

package/dist/job/AwsJobScheduler.js

@@ -77,7 +77,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     async _scheduleJob(jobInfo) {
         this.logger.debug("Scheduling job: ", jobInfo);
         if (jobInfo.cron || jobInfo.at) {
-            const jobId = `${this.jobNamespace}${jobInfo.jobId}`;
+            const jobId = `${this.jobNamespace}${jobInfo.id}`;
             let cronExpression;
             if (jobInfo.at) {
                 cronExpression = this.generateCronFromTimestamp(jobInfo.at);
@@ -132,8 +132,8 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         //-- 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.jobId}`);
-            await this.disableJob(job.jobId);
+            this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.id}`);
+            await this.disableJob(job.id);
         }
         if (nomoreExistJobs.length) {
             this.logger.info(`Cleaned up: ${nomoreExistJobs.length} stale jobs`);
@@ -143,7 +143,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         const scheduledCronJobs = scheduledJobs.filter((j) => 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.disableJob(j.jobId)));
+            await Promise.all(unmatchedCronJobs.map((j) => this.disableJob(j.id)));
         }
         //-- reschedule new cron jobs and those which are not synced
         const resyncCronJobs = allHandlers.filter((job) => job.cron &&

package/dist/job/LocalJobScheduler.js

@@ -148,7 +148,11 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             const allJobs = await this.getCurrentJobHandlers();
             for (const job of allJobs) {
                 if (job.cron) {
-                    await this.scheduleJob(job);
+                    await this.scheduleJob({
+                        ...job.retryOptions,
+                        jobName: job.jobName,
+                        cron: job.cron,
+                    });
                 }
             }
             //-- re-schedule "at" jobs that are stored in repo
@@ -169,15 +173,15 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             if (jobInfo.at) {
                 //-- use the lib
                 const timeout = setTimeout(() => {
-                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.jobId}`, err));
+                    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.jobId] = { jobCanceler: () => clearTimeout(timeout), jobInfo };
+                this.jobHolder[jobInfo.id] = { jobCanceler: () => clearTimeout(timeout), jobInfo };
             }
             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.jobId}`, err));
+                    this.executeJob(jobInfo).catch((err) => this.logger.error(`Error execute job ${jobInfo.jobName} with id: ${jobInfo.id}`, err));
                 });
-                this.jobHolder[jobInfo.jobId] = { jobCanceler: () => job.cancel(), jobInfo };
+                this.jobHolder[jobInfo.id] = { jobCanceler: () => job.cancel(), jobInfo };
             }
             else {
                 throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);

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

@@ -7,7 +7,8 @@ export declare class DefaultJobRepository<T extends AbstractJob & AbstractModel>
     protected db: AbstractDbAdapter;
     constructor(model: Constructor<T>, db: AbstractDbAdapter);
     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>;
+    insertJob(jobInfo: Partial<T>, tx?: ITransaction): Promise<string>;
+    getJobById(id: string): Promise<AbstractJob | undefined>;
+    removeJobById(id: string, tx?: ITransaction): Promise<void>;
+    updateJobById(id: string, update: Partial<Omit<T, "id">>, tx?: ITransaction): Promise<void>;
 }

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

@@ -10,22 +10,19 @@ export class DefaultJobRepository extends AbstractJobRepository {
     async getJobs(query, options) {
         return await this.db.use(this.model).getRecords(query, options);
     }
-    async insertJob({ jobId, ...jobInfo }, tx) {
-        if (jobId) {
-            //-- update
-            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);
-            return job.jobId;
-        }
+    async insertJob(jobInfo, tx) {
+        const model = new this.model();
+        Object.assign(model, jobInfo);
+        const job = await this.db.use(this.model, tx).createOne(model);
+        return job.id;
     }
-    async removeJobById(jobId, tx) {
-        await this.db.use(this.model, tx).deleteMany({ _eq: { jobId } });
+    async getJobById(id) {
+        return await this.db.use(this.model).getById(id);
     }
-    async updateJobById(jobId, update, tx) {
-        await this.db.use(this.model, tx).updateOne({ _eq: { jobId } }, update);
+    async removeJobById(id, tx) {
+        await this.db.use(this.model, tx).deleteById(id);
+    }
+    async updateJobById(id, update, tx) {
+        await this.db.use(this.model, tx).updateById(id, update);
     }
 }

package/dist/job/interfaces.d.ts

@@ -31,14 +31,14 @@ export interface JobControllerMetadata extends ObjectMetadata {
     jobs?: JobInfoMetadata[];
 }
 export interface JobSchedulePayload extends JobRetryOptions {
-    jobId?: string;
+    id?: string;
     jobName: string;
     params?: any;
     at?: number;
     cron?: string;
 }
 export interface AbstractJob extends JobSchedulePayload {
-    jobId: string;
+    id: string;
     disabled?: boolean;
     execCount?: number;
     failCount?: number;

package/dist/job/job.d.ts

@@ -1,7 +1,6 @@
 import { AbstractModel } from "@clairejs/core";
 import { AbstractJob } from "./interfaces";
 export declare abstract class AbstractJobModel extends AbstractModel implements AbstractJob {
-    jobId: string;
     jobName: string;
     at?: number;
     cron?: string;

package/dist/job/job.js

@@ -9,7 +9,6 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { AbstractModel, Column } from "@clairejs/core";
 export class AbstractJobModel extends AbstractModel {
-    jobId;
     jobName;
     at;
     cron;
@@ -25,13 +24,6 @@ export class AbstractJobModel extends AbstractModel {
     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",

package/package.json

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