@clairejs/server 3.16.13 → 3.16.14

package/README.md

@@ -1,7 +1,8 @@
 ## Change Log
 
-#### 3.16.13:
+#### 3.16.14:
 
+-   fix Job repo
 -   fix AbstractJob
 -   fix LocalJobScheduler
 -   add abstract job model, default job repo

package/dist/job/AbstractJobRepository.d.ts

@@ -1,17 +1,18 @@
+import { IQueryProvider } from "@clairejs/orm";
 import { CustomJobInfo } from "./interfaces";
 export declare abstract class AbstractJobRepository {
     /**
      * Return all persisted jobs
      */
-    abstract getJobs(): Promise<CustomJobInfo[]>;
+    abstract getJobs(query: IQueryProvider): Promise<CustomJobInfo[]>;
     /**
      * Save the job info and return a unique id
      * @param jobInfo The custom job info to save
      */
-    abstract saveJob(jobInfo: CustomJobInfo): Promise<string>;
+    abstract saveJob(jobInfo: CustomJobInfo, query: IQueryProvider): Promise<string>;
     /**
      * Remove job info by id
      * @param jobId Unique id of job
      */
-    abstract removeJobById(jobId: string): Promise<void>;
+    abstract removeJobById(jobId: string, query: IQueryProvider): Promise<void>;
 }

package/dist/job/AbstractJobScheduler.d.ts

@@ -1,13 +1,15 @@
 import { AbstractLogger } from "@clairejs/core";
+import { ITransaction, ITransactionFactory } from "@clairejs/orm";
 import { CustomJobInfo, JobInfo, JobInfoMetadata, ScheduledJob } from "./interfaces";
 interface JobHandlerMetadata extends JobInfoMetadata {
-    handlerFn: (params?: any[]) => Promise<void>;
+    handlerFn: (job: ScheduledJob, tx: ITransaction) => Promise<ScheduledJob | undefined>;
 }
 export declare abstract class AbstractJobScheduler {
     protected readonly logger: AbstractLogger;
+    protected readonly db: ITransactionFactory;
     protected abstract isActiveScheduler(): boolean;
     private _jobs;
-    constructor(logger: AbstractLogger);
+    constructor(logger: AbstractLogger, db: ITransactionFactory);
     protected getAvailableJobInfo(): Promise<JobHandlerMetadata[]>;
     abstract getAllScheduledJobs(): Promise<ScheduledJob[]>;
     /**
@@ -15,6 +17,7 @@ export declare abstract class AbstractJobScheduler {
      * @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>;
     /**
      * Sync all jobs to running state. This should be called only at init time.
      */
@@ -26,9 +29,9 @@ export declare abstract class AbstractJobScheduler {
     scheduleJobAt(jobInfo: CustomJobInfo): Promise<string>;
     /**
      * 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
      */
-    abstract removeJob(jobId: string): Promise<void>;
+    abstract removeJob(id: string): Promise<void>;
     /**
      * Execute the scheduled job
      * @param job The schedled job info to execute

package/dist/job/AbstractJobScheduler.js

@@ -2,9 +2,11 @@ import { getServiceProvider } from "@clairejs/core";
 import { AbstractJobController } from "./AbstractJobController";
 export class AbstractJobScheduler {
     logger;
+    db;
     _jobs = null;
-    constructor(logger) {
+    constructor(logger, db) {
         this.logger = logger;
+        this.db = db;
     }
     async getAvailableJobInfo() {
         if (this._jobs === null) {
@@ -33,15 +35,28 @@ export class AbstractJobScheduler {
         //-- run job
         const allJobs = await this.getAvailableJobInfo();
         const jobHandler = allJobs.find((j) => j.jobName === job.jobName);
-        if (jobHandler) {
-            await jobHandler.handlerFn(...(job.params || []));
+        if (!jobHandler) {
+            //-- remove job
+            this.logger.info(`Remove job with id: ${job.id} as handler is not found`);
+            await this.removeJob(job.id);
+            return;
         }
-        if (!jobHandler || job.at) {
-            //-- job not found so we remove it
-            await this.removeJob(job.jobId);
-            this.logger.info(!jobHandler
-                ? `Remove not found job: ${job.jobName}`
-                : `Remove one-time job ${job.jobName} at timestamp ${job.at}`);
+        const tx = await this.db.createTransaction();
+        try {
+            const newJob = await jobHandler.handlerFn({ ...job }, tx);
+            if (job.at) {
+                if (!newJob) {
+                    await this.removeJob(job.id);
+                    this.logger.info(`Remove one-time job ${job.jobName} at timestamp ${job.at}`);
+                }
+                else {
+                    await this.afterJob(newJob, tx);
+                }
+            }
+            await tx.commit();
+        }
+        catch (err) {
+            await tx.rollback();
         }
         return;
     }

package/dist/job/AwsJobScheduler.d.ts

@@ -1,13 +1,16 @@
 import { AbstractLogger } from "@clairejs/core";
+import { AbstractDatabaseAdapter, ITransaction } from "@clairejs/orm";
+import aws from "aws-sdk";
 import Redis from "ioredis";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { JobInfo, ScheduledJob } from "./interfaces";
 export declare class AwsJobScheduler extends AbstractJobScheduler {
-    readonly logger: AbstractLogger;
-    readonly redisClient: Redis;
-    readonly uniqueIdKey: string;
-    readonly apiLambdaFunctionArn: string;
-    readonly stepFunctionName: string;
+    protected readonly logger: AbstractLogger;
+    protected readonly db: AbstractDatabaseAdapter;
+    protected readonly redisClient: Redis;
+    protected readonly uniqueIdKey: string;
+    protected readonly apiLambdaFunctionArn: string;
+    protected readonly stepFunctionName: string;
     /**
      * This IAM role must have following permissions:
      * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
@@ -17,13 +20,13 @@ export declare class AwsJobScheduler extends AbstractJobScheduler {
      * - create event bridge rules, describe rules, remove rule, list and create rule targets
      * - create state machines, list state machines
      */
-    readonly iamRoleArn: string;
-    readonly eventBusName: string;
-    readonly jobNamePrefix: string;
-    readonly oneMinuteRule: string;
-    private eventbridge;
-    private stepfunctions;
-    constructor(logger: AbstractLogger, redisClient: Redis, uniqueIdKey: string, apiLambdaFunctionArn: string, stepFunctionName: string, 
+    protected readonly iamRoleArn: string;
+    protected readonly eventBusName: string;
+    protected readonly jobNamePrefix: string;
+    protected readonly oneMinuteRule: string;
+    protected readonly eventbridge: aws.EventBridge;
+    protected readonly stepfunctions: aws.StepFunctions;
+    constructor(logger: AbstractLogger, db: AbstractDatabaseAdapter, redisClient: Redis, uniqueIdKey: string, apiLambdaFunctionArn: string, stepFunctionName: string, 
     /**
      * This IAM role must have following permissions:
      * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
@@ -36,6 +39,7 @@ export declare class AwsJobScheduler extends AbstractJobScheduler {
     iamRoleArn: string, eventBusName?: string, jobNamePrefix?: string, oneMinuteRule?: string);
     handleInterval(interval: number): Promise<void>;
     handleCron(jobInfo: ScheduledJob): Promise<void>;
+    protected afterJob(_job: ScheduledJob, _tx: ITransaction): Promise<void>;
     private generateCronFromTimestamp;
     protected isActiveScheduler(): boolean;
     getAllScheduledJobs(): Promise<ScheduledJob[]>;

package/dist/job/AwsJobScheduler.js

@@ -8,6 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { AbstractLogger, Errors, LogContext } from "@clairejs/core";
+import { AbstractDatabaseAdapter } from "@clairejs/orm";
 import aws from "aws-sdk";
 import Redis from "ioredis";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
@@ -104,6 +105,7 @@ const oneMinuteFunctionFactory = (lambdaFunctionARN, intervals) => {
 };
 let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     logger;
+    db;
     redisClient;
     uniqueIdKey;
     apiLambdaFunctionArn;
@@ -114,7 +116,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
     oneMinuteRule;
     eventbridge = new aws.EventBridge();
     stepfunctions = new aws.StepFunctions({ apiVersion: "2016-11-23" });
-    constructor(logger, redisClient, uniqueIdKey, apiLambdaFunctionArn, stepFunctionName, 
+    constructor(logger, db, redisClient, uniqueIdKey, apiLambdaFunctionArn, stepFunctionName, 
     /**
      * This IAM role must have following permissions:
      * - trigger any state machine (for one minute rule - as we don't now the state machine ARN until auto creation)
@@ -125,8 +127,9 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
      * - create state machines, list state machines
      */
     iamRoleArn, eventBusName = "default", jobNamePrefix = "claire-aws-job-", oneMinuteRule = "one-minute-step-function-trigger") {
-        super(logger);
+        super(logger, db);
         this.logger = logger;
+        this.db = db;
         this.redisClient = redisClient;
         this.uniqueIdKey = uniqueIdKey;
         this.apiLambdaFunctionArn = apiLambdaFunctionArn;
@@ -140,12 +143,16 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         this.logger.debug(`Handle interval`, interval, typeof interval);
         const allJobs = await this.getAvailableJobInfo();
         const timedJobs = allJobs.filter((job) => job.interval && interval % job.interval === 0);
-        await Promise.all(timedJobs.map((job) => this.executeJob({ ...job, jobId: job.jobName })));
+        await Promise.all(timedJobs.map((job) => this.executeJob({ ...job, id: job.jobName })));
     }
     async handleCron(jobInfo) {
         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 [
@@ -186,7 +193,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         //-- concat with interval jobs because we don't register them
         return allJobs
             .filter((job) => !!job)
-            .concat(availableJobs.filter((j) => j.interval).map((j) => ({ ...j, jobId: j.jobName })));
+            .concat(availableJobs.filter((j) => j.interval).map((j) => ({ ...j, id: j.jobName })));
     }
     async scheduleJob(jobInfo) {
         this.logger.debug("Scheduling job: ", jobInfo);
@@ -245,8 +252,8 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         //-- remove job that no more exist
         const nomoreExistJobs = scheduledJobs.filter((job) => !allJobs.find((j) => j.jobName === job.jobName));
         for (const job of nomoreExistJobs) {
-            this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.jobId}`);
-            await this.removeJob(job.jobId);
+            this.logger.info(`Removing stale job: ${job.jobName} of id: ${job.id}`);
+            await this.removeJob(job.id);
         }
         if (nomoreExistJobs.length) {
             this.logger.info(`Cleaned up: ${nomoreExistJobs.length} stale jobs`);
@@ -254,7 +261,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
         //-- remove scheduled cron jobs
         this.logger.debug("Remove scheduled cron jobs");
         const scheduledCronJobs = scheduledJobs.filter((j) => j.cron);
-        await Promise.all(scheduledCronJobs.map((j) => this.removeJob(j.jobId)));
+        await Promise.all(scheduledCronJobs.map((j) => this.removeJob(j.id)));
         //-- reschedule cron & interval jobs because we might have updated the cron expression / interval value
         const cronJobs = allJobs.filter((job) => job.cron || job.interval);
         this.logger.debug("Scheduling cron & interval jobs");
@@ -265,7 +272,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
                 interval: job.interval,
             });
         }
-        //-- keep at timestamp jobs as is
+        //-- keep "at" jobs as is
     }
     async removeJob(jobId) {
         await this.eventbridge
@@ -400,6 +407,7 @@ let AwsJobScheduler = class AwsJobScheduler extends AbstractJobScheduler {
 AwsJobScheduler = __decorate([
     LogContext(),
     __metadata("design:paramtypes", [AbstractLogger,
+        AbstractDatabaseAdapter,
         Redis, String, String, String, String, Object, Object, Object])
 ], AwsJobScheduler);
 export { AwsJobScheduler };

package/dist/job/LocalJobScheduler.d.ts

@@ -1,10 +1,12 @@
 import { AbstractLogger, IInit } from "@clairejs/core";
 import Redis from "ioredis";
+import { AbstractDatabaseAdapter, ITransaction } from "@clairejs/orm";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { JobInfo, ScheduledJob } from "./interfaces";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 export declare class LocalJobScheduler extends AbstractJobScheduler implements IInit {
     protected readonly logger: AbstractLogger;
+    protected readonly db: AbstractDatabaseAdapter;
     protected readonly redisClient: Redis;
     protected readonly subscribeClient: Redis;
     protected readonly jobRepo: AbstractJobRepository;
@@ -33,7 +35,7 @@ export declare class LocalJobScheduler extends AbstractJobScheduler implements I
     private isActive;
     private notifyResolver;
     private jobHolder;
-    constructor(logger: AbstractLogger, redisClient: Redis, subscribeClient: Redis, jobRepo: AbstractJobRepository, 
+    constructor(logger: AbstractLogger, db: AbstractDatabaseAdapter, redisClient: Redis, subscribeClient: Redis, jobRepo: AbstractJobRepository, 
     /**
      * Redis lock key to select active scheduler
      */
@@ -57,11 +59,12 @@ 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): Promise<string>;
-    removeJob(jobId: string): Promise<void>;
+    removeJob(id: string): Promise<void>;
 }

package/dist/job/LocalJobScheduler.js

@@ -11,9 +11,10 @@ import { AbstractLogger, Errors, Initable, LogContext } from "@clairejs/core";
 import Redis from "ioredis";
 import Redlock from "redlock";
 import scheduler from "node-schedule";
+import { AbstractDatabaseAdapter } from "@clairejs/orm";
+import assert from "assert";
 import { AbstractJobScheduler } from "./AbstractJobScheduler";
 import { AbstractJobRepository } from "./AbstractJobRepository";
-import { clearInterval, clearTimeout } from "timers";
 var CommunicationMessage;
 (function (CommunicationMessage) {
     CommunicationMessage["SCHEDULE_JOB"] = "SCHEDULE_JOB";
@@ -23,6 +24,7 @@ var CommunicationMessage;
 })(CommunicationMessage || (CommunicationMessage = {}));
 let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
     logger;
+    db;
     redisClient;
     subscribeClient;
     jobRepo;
@@ -36,7 +38,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
     isActive = false;
     notifyResolver = {};
     jobHolder = {};
-    constructor(logger, redisClient, subscribeClient, jobRepo, 
+    constructor(logger, db, redisClient, subscribeClient, jobRepo, 
     /**
      * Redis lock key to select active scheduler
      */
@@ -57,8 +59,9 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
      * The time to lock active scheduler
      */
     keyRetentionDurationSecond = 30) {
-        super(logger);
+        super(logger, db);
         this.logger = logger;
+        this.db = db;
         this.redisClient = redisClient;
         this.subscribeClient = subscribeClient;
         this.jobRepo = jobRepo;
@@ -116,6 +119,10 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         await this.redisClient.setex(this.holdMutexKey, this.keyRetentionDurationSecond, 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
@@ -173,7 +180,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
                 }
             }
             //-- re-schedule jobs that are stored in repo
-            const allPersistedJobs = await this.jobRepo.getJobs();
+            const allPersistedJobs = await this.jobRepo.getJobs(this.db);
             //-- run job anyway, expired job will be removed then
             for (const job of allPersistedJobs) {
                 await this.scheduleJob(job);
@@ -193,38 +200,39 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             //-- case each job type
             if (jobInfo.at) {
                 //-- create new schedule job
-                const jobId = await this.jobRepo.saveJob({
-                    jobName: jobInfo.jobName,
-                    params: jobInfo.params,
-                    at: jobInfo.at,
-                });
+                const id = jobInfo.id ||
+                    (await this.jobRepo.saveJob({
+                        jobName: jobInfo.jobName,
+                        params: jobInfo.params,
+                        at: jobInfo.at,
+                    }, this.db));
                 //-- use the lib
-                const scheduledJob = { ...jobInfo, jobId };
+                const scheduledJob = { ...jobInfo, id };
                 const timeout = setTimeout(() => {
-                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.jobId}`, err));
+                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
                 }, new Date(jobInfo.at).getTime() - Date.now());
-                this.jobHolder[jobId] = { jobCanceler: () => clearTimeout(timeout), jobInfo: { ...jobInfo, jobId } };
-                return jobId;
+                this.jobHolder[id] = { jobCanceler: () => clearTimeout(timeout), jobInfo: { ...jobInfo, id } };
+                return id;
             }
             else if (jobInfo.interval) {
-                const jobId = jobInfo.jobName;
+                const id = jobInfo.jobName;
                 //-- set interval and does not need to persist
-                const scheduledJob = { ...jobInfo, jobId };
+                const scheduledJob = { ...jobInfo, id };
                 const interval = setInterval(() => {
-                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.jobId}`, err));
+                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
                 }, jobInfo.interval);
-                this.jobHolder[jobId] = { jobCanceler: () => clearInterval(interval), jobInfo: { ...jobInfo, jobId } };
-                return jobId;
+                this.jobHolder[id] = { jobCanceler: () => clearInterval(interval), jobInfo: { ...jobInfo, id } };
+                return id;
             }
             else if (jobInfo.cron) {
-                const jobId = jobInfo.jobName;
+                const id = jobInfo.jobName;
                 //-- set cron and does not need to persist
-                const scheduledJob = { ...jobInfo, jobId };
+                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.jobId}`, err));
+                    this.executeJob(scheduledJob).catch((err) => this.logger.error(`Error execute job ${scheduledJob.jobName} with id: ${scheduledJob.id}`, err));
                 });
-                this.jobHolder[jobId] = { jobCanceler: () => job.cancel(), jobInfo: { ...jobInfo, jobId } };
-                return jobId;
+                this.jobHolder[id] = { jobCanceler: () => job.cancel(), jobInfo: { ...jobInfo, id } };
+                return id;
             }
             else {
                 throw Errors.SYSTEM_ERROR(`Job does not have time config: ${jobInfo.jobName}`);
@@ -239,24 +247,23 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
             });
         }
     }
-    async removeJob(jobId) {
+    async removeJob(id) {
         if (this.isActive) {
             //-- remove from holder
-            const job = this.jobHolder[jobId];
+            const job = this.jobHolder[id];
             if (job) {
                 job.jobCanceler();
-                this.jobHolder[jobId] = undefined;
+                this.jobHolder[id] = undefined;
             }
             //-- remove from persistence
-            await this.jobRepo.removeJobById(jobId);
-            return;
+            await this.jobRepo.removeJobById(id, this.db);
         }
         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, jobId);
+                this.sendJob(CommunicationMessage.REMOVE_JOB, uniqueMessageId, id);
             });
         }
     }
@@ -265,6 +272,7 @@ LocalJobScheduler = __decorate([
     LogContext(),
     Initable(),
     __metadata("design:paramtypes", [AbstractLogger,
+        AbstractDatabaseAdapter,
         Redis,
         Redis,
         AbstractJobRepository, String, String, String, String, Number])

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

@@ -5,9 +5,8 @@ import { AbstractJobRepository } from "./AbstractJobRepository";
 import { AbstractJob } from "./job";
 export declare class DefaultJobRepository extends AbstractJobRepository {
     protected readonly model: Constructor<AbstractJob>;
-    protected readonly db: IQueryProvider;
-    constructor(model: Constructor<AbstractJob>, db: IQueryProvider);
-    getJobs(): Promise<CustomJobInfo[]>;
-    saveJob(jobInfo: CustomJobInfo): Promise<string>;
-    removeJobById(jobId: string): Promise<void>;
+    constructor(model: Constructor<AbstractJob>);
+    getJobs(query: IQueryProvider): Promise<CustomJobInfo[]>;
+    saveJob({ id, ...jobInfo }: CustomJobInfo, query: IQueryProvider): Promise<string>;
+    removeJobById(jobId: string, query: IQueryProvider): Promise<void>;
 }

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

@@ -2,21 +2,27 @@ import { pickData } from "@clairejs/core";
 import { AbstractJobRepository } from "./AbstractJobRepository";
 export class DefaultJobRepository extends AbstractJobRepository {
     model;
-    db;
-    constructor(model, db) {
+    constructor(model) {
         super();
         this.model = model;
-        this.db = db;
     }
-    async getJobs() {
-        const jobs = await this.db.use(this.model).getRecords();
-        return jobs.map((job) => pickData(job, ["jobName", "at", "params"]));
+    async getJobs(query) {
+        const jobs = await query.use(this.model).getRecords();
+        return jobs.map((job) => pickData(job, ["jobName", "at", "params", "id"]));
     }
-    async saveJob(jobInfo) {
-        const job = await this.db.use(this.model).createOne(jobInfo);
-        return job.id;
+    async saveJob({ id, ...jobInfo }, query) {
+        if (id) {
+            //-- update
+            await query.use(this.model).updateById(id, jobInfo);
+        }
+        else {
+            //-- create new
+            const job = await query.use(this.model).createOne(jobInfo);
+            id = job.id;
+        }
+        return id;
     }
-    async removeJobById(jobId) {
-        await this.db.use(this.model).deleteById(jobId);
+    async removeJobById(jobId, query) {
+        await query.use(this.model).deleteById(jobId);
     }
 }

package/dist/job/interfaces.d.ts

@@ -34,11 +34,13 @@ export interface JobControllerMetadata extends ObjectMetadata {
     jobs?: JobInfoMetadata[];
 }
 export interface CustomJobInfo {
+    id?: string;
     jobName: string;
     at: number;
     params?: any[];
 }
 export interface JobInfo {
+    id?: string;
     jobName: string;
     params?: any[];
     at?: number;
@@ -46,5 +48,5 @@ export interface JobInfo {
     cron?: string;
 }
 export interface ScheduledJob extends JobInfo {
-    jobId: string;
+    id: string;
 }

package/package.json

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