@clairejs/server 3.23.2 → 3.23.4

package/README.md

@@ -1,7 +1,9 @@
 ## Change Log
 
-#### 3.23.2
+#### 3.23.4
 
+-   fix abstract job scheduler & job model
+-   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, "id" | "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,40 @@ 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.jobName } }, { 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 +70,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 || job.id, 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 +109,12 @@ export class AbstractJobScheduler {
                         }
                         else {
                             update.disabled = true;
-                            await this.cancelJob(job.jobId || job.id);
+                            await this.cancelJob(job.id);
                         }
                     }
                 }
             }
-            await this.jobRepo.updateJobById(job.jobId || job.id, 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 || job.id);
+            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 || j.id)));
+            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

@@ -152,7 +152,6 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                         ...job.retryOptions,
                         jobName: job.jobName,
                         cron: job.cron,
-                        jobId: job.jobName,
                     });
                 }
             }
@@ -174,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 || jobInfo.id] = { 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 || jobInfo.id] = { 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

@@ -8,6 +8,7 @@ export declare class DefaultJobRepository<T extends AbstractJob & AbstractModel>
     constructor(model: Constructor<T>, db: AbstractDbAdapter);
     getJobs(query?: QueryCondition<T>, options?: GetManyOptions<T, keyof T>): Promise<T[]>;
     insertJob(jobInfo: Partial<T>, tx?: ITransaction): Promise<string>;
-    removeJobById(jobId: string, tx?: ITransaction): Promise<void>;
-    updateJobById(jobId: string, update: Partial<Omit<T, "id" | "jobId">>, tx?: ITransaction): Promise<void>;
+    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

@@ -14,14 +14,15 @@ export class DefaultJobRepository extends AbstractJobRepository {
         const model = new this.model();
         Object.assign(model, jobInfo);
         const job = await this.db.use(this.model, tx).createOne(model);
-        return job.jobId || job.id;
+        return job.id;
     }
-    async removeJobById(jobId, tx) {
-        await this.db.use(this.model, tx).deleteMany({ _or: [{ _eq: { jobId } }, { _eq: { id: 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({ _or: [{ _eq: { jobId } }, { _eq: { id: 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,7 +31,7 @@ export interface JobControllerMetadata extends ObjectMetadata {
     jobs?: JobInfoMetadata[];
 }
 export interface JobSchedulePayload extends JobRetryOptions {
-    jobId?: string;
+    id?: string;
     jobName: string;
     params?: any;
     at?: 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,12 +24,6 @@ export class AbstractJobModel extends AbstractModel {
     lastRunAt;
     lastSuccessAt;
 }
-__decorate([
-    Column({
-        description: "Unique id of the job",
-    }),
-    __metadata("design:type", String)
-], AbstractJobModel.prototype, "jobId", void 0);
 __decorate([
     Column({
         description: "Name of the job",
@@ -90,10 +83,14 @@ __decorate([
     __metadata("design:type", String)
 ], AbstractJobModel.prototype, "lastError", void 0);
 __decorate([
-    Column({}),
+    Column({
+        isTimestamp: true,
+    }),
     __metadata("design:type", Number)
 ], AbstractJobModel.prototype, "lastRunAt", void 0);
 __decorate([
-    Column({}),
+    Column({
+        isTimestamp: true,
+    }),
     __metadata("design:type", Number)
 ], AbstractJobModel.prototype, "lastSuccessAt", void 0);

package/package.json

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