refactor(core): Store JobRecord as regular VendureEntity

packages/asset-server-plugin/e2e/graphql/generated-e2e-asset-server-plugin-types.ts

@@ -1266,25 +1266,25 @@ export type Job = Node & {
     __typename?: 'Job';
     id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
+    startedAt?: Maybe<Scalars['DateTime']>;
+    settledAt?: Maybe<Scalars['DateTime']>;
     queueName: Scalars['String'];
     state: JobState;
     progress: Scalars['Float'];
     data?: Maybe<Scalars['JSON']>;
     result?: Maybe<Scalars['JSON']>;
     error?: Maybe<Scalars['JSON']>;
-    started: Scalars['DateTime'];
-    settled?: Maybe<Scalars['DateTime']>;
     isSettled: Scalars['Boolean'];
     duration: Scalars['Int'];
 };
 
 export type JobFilterParameter = {
     createdAt?: Maybe<DateOperators>;
+    startedAt?: Maybe<DateOperators>;
+    settledAt?: Maybe<DateOperators>;
     queueName?: Maybe<StringOperators>;
     state?: Maybe<StringOperators>;
     progress?: Maybe<NumberOperators>;
-    started?: Maybe<DateOperators>;
-    settled?: Maybe<DateOperators>;
     isSettled?: Maybe<BooleanOperators>;
     duration?: Maybe<NumberOperators>;
 };
@@ -1311,10 +1311,10 @@ export type JobQueue = {
 export type JobSortParameter = {
     id?: Maybe<SortOrder>;
     createdAt?: Maybe<SortOrder>;
+    startedAt?: Maybe<SortOrder>;
+    settledAt?: Maybe<SortOrder>;
     queueName?: Maybe<SortOrder>;
     progress?: Maybe<SortOrder>;
-    started?: Maybe<SortOrder>;
-    settled?: Maybe<SortOrder>;
     duration?: Maybe<SortOrder>;
 };
 

packages/common/src/generated-types.ts

@@ -1262,25 +1262,25 @@ export type Job = Node & {
    __typename?: 'Job';
   id: Scalars['ID'];
   createdAt: Scalars['DateTime'];
+  startedAt?: Maybe<Scalars['DateTime']>;
+  settledAt?: Maybe<Scalars['DateTime']>;
   queueName: Scalars['String'];
   state: JobState;
   progress: Scalars['Float'];
   data?: Maybe<Scalars['JSON']>;
   result?: Maybe<Scalars['JSON']>;
   error?: Maybe<Scalars['JSON']>;
-  started: Scalars['DateTime'];
-  settled?: Maybe<Scalars['DateTime']>;
   isSettled: Scalars['Boolean'];
   duration: Scalars['Int'];
 };
 
 export type JobFilterParameter = {
   createdAt?: Maybe<DateOperators>;
+  startedAt?: Maybe<DateOperators>;
+  settledAt?: Maybe<DateOperators>;
   queueName?: Maybe<StringOperators>;
   state?: Maybe<StringOperators>;
   progress?: Maybe<NumberOperators>;
-  started?: Maybe<DateOperators>;
-  settled?: Maybe<DateOperators>;
   isSettled?: Maybe<BooleanOperators>;
   duration?: Maybe<NumberOperators>;
 };
@@ -1307,10 +1307,10 @@ export type JobQueue = {
 export type JobSortParameter = {
   id?: Maybe<SortOrder>;
   createdAt?: Maybe<SortOrder>;
+  startedAt?: Maybe<SortOrder>;
+  settledAt?: Maybe<SortOrder>;
   queueName?: Maybe<SortOrder>;
   progress?: Maybe<SortOrder>;
-  started?: Maybe<SortOrder>;
-  settled?: Maybe<SortOrder>;
   duration?: Maybe<SortOrder>;
 };
 

packages/core/e2e/graphql/generated-e2e-admin-types.ts

@@ -1266,25 +1266,25 @@ export type Job = Node & {
     __typename?: 'Job';
     id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
+    startedAt?: Maybe<Scalars['DateTime']>;
+    settledAt?: Maybe<Scalars['DateTime']>;
     queueName: Scalars['String'];
     state: JobState;
     progress: Scalars['Float'];
     data?: Maybe<Scalars['JSON']>;
     result?: Maybe<Scalars['JSON']>;
     error?: Maybe<Scalars['JSON']>;
-    started: Scalars['DateTime'];
-    settled?: Maybe<Scalars['DateTime']>;
     isSettled: Scalars['Boolean'];
     duration: Scalars['Int'];
 };
 
 export type JobFilterParameter = {
     createdAt?: Maybe<DateOperators>;
+    startedAt?: Maybe<DateOperators>;
+    settledAt?: Maybe<DateOperators>;
     queueName?: Maybe<StringOperators>;
     state?: Maybe<StringOperators>;
     progress?: Maybe<NumberOperators>;
-    started?: Maybe<DateOperators>;
-    settled?: Maybe<DateOperators>;
     isSettled?: Maybe<BooleanOperators>;
     duration?: Maybe<NumberOperators>;
 };
@@ -1311,10 +1311,10 @@ export type JobQueue = {
 export type JobSortParameter = {
     id?: Maybe<SortOrder>;
     createdAt?: Maybe<SortOrder>;
+    startedAt?: Maybe<SortOrder>;
+    settledAt?: Maybe<SortOrder>;
     queueName?: Maybe<SortOrder>;
     progress?: Maybe<SortOrder>;
-    started?: Maybe<SortOrder>;
-    settled?: Maybe<SortOrder>;
     duration?: Maybe<SortOrder>;
 };
 

packages/core/src/api/schema/admin-api/job.api.graphql

@@ -23,14 +23,14 @@ type JobList implements PaginatedList {
 type Job implements Node {
     id: ID!
     createdAt: DateTime!
+    startedAt: DateTime
+    settledAt: DateTime
     queueName: String!
     state: JobState!
     progress: Float!
     data: JSON
     result: JSON
     error: JSON
-    started: DateTime!
-    settled: DateTime
     isSettled: Boolean!
     duration: Int!
 }

packages/core/src/config/job-queue/job-queue-strategy.ts

@@ -1,6 +1,6 @@
 import { ModuleRef } from '@nestjs/core';
 import { JobListOptions } from '@vendure/common/lib/generated-types';
-import { PaginatedList } from '@vendure/common/lib/shared-types';
+import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
 
 import { Job } from '../../job-queue/job';
 
@@ -60,7 +60,7 @@ export interface JobQueueStrategy {
      * @description
      * Returns a job by its id.
      */
-    findOne(id: string): Promise<Job | undefined>;
+    findOne(id: ID): Promise<Job | undefined>;
 
     /**
      * @description
@@ -72,5 +72,5 @@ export interface JobQueueStrategy {
      * @description
      * Returns an array of jobs for the given ids.
      */
-    findManyById(ids: string[]): Promise<Job[]>;
+    findManyById(ids: ID[]): Promise<Job[]>;
 }

packages/core/src/entity/job-record/job-record.entity.ts

@@ -1,24 +1,15 @@
 import { JobState } from '@vendure/common/lib/generated-types';
 import { DeepPartial } from '@vendure/common/lib/shared-types';
-import { Column, CreateDateColumn, Entity, PrimaryColumn, UpdateDateColumn } from 'typeorm';
+import { Column, Entity } from 'typeorm';
+
+import { VendureEntity } from '../base/base.entity';
 
 @Entity()
-export class JobRecord {
+export class JobRecord extends VendureEntity {
     constructor(input: DeepPartial<JobRecord>) {
-        if (input) {
-            for (const [key, value] of Object.entries(input)) {
-                (this as any)[key] = value;
-            }
-        }
+        super(input);
     }
 
-    @PrimaryColumn()
-    id: string;
-
-    @CreateDateColumn() createdAt: Date;
-
-    @UpdateDateColumn() updatedAt: Date;
-
     @Column()
     queueName: string;
 
@@ -37,11 +28,11 @@ export class JobRecord {
     @Column({ nullable: true })
     error: string;
 
-    @Column({ nullable: true })
-    started?: Date;
+    @Column({ nullable: true, precision: 6 })
+    startedAt?: Date;
 
-    @Column({ nullable: true })
-    settled?: Date;
+    @Column({ nullable: true, precision: 6 })
+    settledAt?: Date;
 
     @Column()
     isSettled: boolean;

packages/core/src/job-queue/job-queue.ts

@@ -50,6 +50,7 @@ export class JobQueue<Data extends JobData<Data> = {}> {
                 const nextJob: Job<Data> | undefined = await this.jobQueueStrategy.next(this.options.name);
                 if (nextJob) {
                     this.activeJobs.push(nextJob);
+                    await this.jobQueueStrategy.update(nextJob);
                     nextJob.on('complete', (job) => this.onFailOrComplete(job));
                     nextJob.on('fail', (job) => this.onFailOrComplete(job));
                     try {
@@ -60,7 +61,6 @@ export class JobQueue<Data extends JobData<Data> = {}> {
                     } catch (err) {
                         nextJob.fail(err);
                     }
-                    await this.jobQueueStrategy.update(nextJob);
                 }
             }
             this.timer = setTimeout(runNextJobs, this.pollInterval);

packages/core/src/job-queue/job.ts

@@ -1,6 +1,5 @@
 import { JobState } from '@vendure/common/lib/generated-types';
-
-import { generatePublicId } from '../common/generate-public-id';
+import { ID } from '@vendure/common/lib/shared-types';
 
 import { JobConfig, JobData } from './types';
 
@@ -33,18 +32,18 @@ export type JobEventListener<T extends JobData<T>> = (job: Job<T>) => void;
  * @docsPage Job
  */
 export class Job<T extends JobData<T> = any> {
-    readonly id: string;
+    readonly id: ID | null;
     readonly queueName: string;
     readonly retries: number;
+    readonly createdAt: Date;
     private readonly _data: T;
-    private readonly created: Date;
     private _state: JobState;
     private _progress: number;
     private _result?: any;
     private _error?: any;
     private _attempts: number;
-    private _started?: Date;
-    private _settled?: Date;
+    private _startedAt?: Date;
+    private _settledAt?: Date;
     private readonly eventListeners: { [type in JobEventType]: Array<JobEventListener<T>> } = {
         start: [],
         complete: [],
@@ -76,20 +75,20 @@ export class Job<T extends JobData<T> = any> {
     }
 
     get isSettled(): boolean {
-        return !!this._settled;
+        return !!this._settledAt;
     }
 
-    get started(): Date | undefined {
-        return this._started;
+    get startedAt(): Date | undefined {
+        return this._startedAt;
     }
 
-    get settled(): Date | undefined {
-        return this._settled;
+    get settledAt(): Date | undefined {
+        return this._settledAt;
     }
 
     get duration(): number {
-        const end = this._settled || new Date();
-        return +end - +(this._started || end);
+        const end = this._settledAt || new Date();
+        return +end - +(this._startedAt || end);
     }
 
     get attempts(): number {
@@ -99,15 +98,16 @@ export class Job<T extends JobData<T> = any> {
     constructor(config: JobConfig<T>) {
         this.queueName = config.queueName;
         this._data = config.data;
-        this.id = config.id || generatePublicId();
+        this.id = config.id || null;
         this._state = config.state || JobState.PENDING;
         this.retries = config.retries || 0;
         this._attempts = config.attempts || 0;
         this._progress = config.progress || 0;
-        this.created = config.created || new Date();
+        this.createdAt = config.createdAt || new Date();
         this._result = config.result;
-        this._started = config.started;
-        this._settled = config.settled;
+        this._error = config.error;
+        this._startedAt = config.startedAt;
+        this._settledAt = config.settledAt;
     }
 
     /**
@@ -118,7 +118,7 @@ export class Job<T extends JobData<T> = any> {
     start() {
         if (this._state === JobState.PENDING || this._state === JobState.RETRYING) {
             this._state = JobState.RUNNING;
-            this._started = new Date();
+            this._startedAt = new Date();
             this._attempts++;
             this.fireEvent('start');
         }
@@ -141,7 +141,7 @@ export class Job<T extends JobData<T> = any> {
         this._result = result;
         this._progress = 100;
         this._state = JobState.COMPLETED;
-        this._settled = new Date();
+        this._settledAt = new Date();
         this.fireEvent('complete');
     }
 
@@ -156,7 +156,7 @@ export class Job<T extends JobData<T> = any> {
             this._state = JobState.RETRYING;
         } else {
             this._state = JobState.FAILED;
-            this._settled = new Date();
+            this._settledAt = new Date();
         }
         this.fireEvent('fail');
     }

packages/core/src/job-queue/sql-job-queue-strategy.ts

@@ -1,7 +1,7 @@
 import { ModuleRef } from '@nestjs/core';
 import { getConnectionToken } from '@nestjs/typeorm';
 import { JobListOptions, JobState } from '@vendure/common/lib/generated-types';
-import { PaginatedList } from '@vendure/common/lib/shared-types';
+import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
 import { Brackets, Connection } from 'typeorm';
 
 import { JobQueueStrategy } from '../config/job-queue/job-queue-strategy';
@@ -56,7 +56,7 @@ export class SqlJobQueueStrategy implements JobQueueStrategy {
         }
     }
 
-    async update(job: Job<{}>): Promise<void> {
+    async update(job: Job<any>): Promise<void> {
         if (!this.connectionAvailable(this.connection)) {
             return;
         }
@@ -79,7 +79,7 @@ export class SqlJobQueueStrategy implements JobQueueStrategy {
             }));
     }
 
-    async findOne(id: string): Promise<Job | undefined> {
+    async findOne(id: ID): Promise<Job | undefined> {
         if (!this.connectionAvailable(this.connection)) {
             return;
         }
@@ -89,7 +89,7 @@ export class SqlJobQueueStrategy implements JobQueueStrategy {
         }
     }
 
-    async findManyById(ids: string[]): Promise<Job[]> {
+    async findManyById(ids: ID[]): Promise<Job[]> {
         if (!this.connectionAvailable(this.connection)) {
             return [];
         }
@@ -112,8 +112,8 @@ export class SqlJobQueueStrategy implements JobQueueStrategy {
             progress: job.progress,
             result: job.result,
             error: job.error,
-            started: job.started,
-            settled: job.settled,
+            startedAt: job.startedAt,
+            settledAt: job.settledAt,
             isSettled: job.isSettled,
             retries: job.retries,
             attempts: job.attempts,
@@ -121,9 +121,6 @@ export class SqlJobQueueStrategy implements JobQueueStrategy {
     }
 
     private fromRecord(jobRecord: JobRecord): Job<any> {
-        return new Job<any>({
-            ...jobRecord,
-            created: jobRecord.createdAt,
-        });
+        return new Job<any>(jobRecord);
     }
 }

packages/core/src/job-queue/testing-job-queue-strategy.ts

@@ -1,6 +1,7 @@
 import { JobListOptions, JobState } from '@vendure/common/lib/generated-types';
-import { PaginatedList } from '@vendure/common/lib/shared-types';
+import { ID, PaginatedList } from '@vendure/common/lib/shared-types';
 
+import { generatePublicId } from '../common/generate-public-id';
 import { JobQueueStrategy } from '../config/job-queue/job-queue-strategy';
 
 import { Job } from './job';
@@ -18,11 +19,12 @@ export class TestingJobQueueStrategy implements JobQueueStrategy {
     }
 
     async add(job: Job): Promise<Job> {
+        (job as any).id = generatePublicId();
         this.jobs.push(job);
         return job;
     }
 
-    async findOne(id: string): Promise<Job | undefined> {
+    async findOne(id: ID): Promise<Job | undefined> {
         return this.jobs.find((j) => j.id === id);
     }
 
@@ -36,8 +38,8 @@ export class TestingJobQueueStrategy implements JobQueueStrategy {
         };
     }
 
-    async findManyById(ids: string[]): Promise<Job[]> {
-        return this.jobs.filter((job) => ids.includes(job.id));
+    async findManyById(ids: ID[]): Promise<Job[]> {
+        return this.jobs.filter((job) => job.id && ids.includes(job.id));
     }
 
     async next(queueName: string): Promise<Job | undefined> {

packages/core/src/job-queue/types.ts

@@ -1,5 +1,5 @@
 import { JobState } from '@vendure/common/lib/generated-types';
-import { JsonCompatible } from '@vendure/common/lib/shared-types';
+import { ID, JsonCompatible } from '@vendure/common/lib/shared-types';
 
 import { Job } from './job';
 
@@ -52,12 +52,12 @@ export interface JobConfig<T extends JobData<T>> {
     data: T;
     retries?: number;
     attempts?: number;
-    id?: string;
+    id?: ID;
     state?: JobState;
     progress?: number;
     result?: any;
     error?: any;
-    created?: Date;
-    started?: Date;
-    settled?: Date;
+    createdAt?: Date;
+    startedAt?: Date;
+    settledAt?: Date;
 }

packages/elasticsearch-plugin/e2e/graphql/generated-e2e-elasticsearch-plugin-types.ts

@@ -1266,25 +1266,25 @@ export type Job = Node & {
     __typename?: 'Job';
     id: Scalars['ID'];
     createdAt: Scalars['DateTime'];
+    startedAt?: Maybe<Scalars['DateTime']>;
+    settledAt?: Maybe<Scalars['DateTime']>;
     queueName: Scalars['String'];
     state: JobState;
     progress: Scalars['Float'];
     data?: Maybe<Scalars['JSON']>;
     result?: Maybe<Scalars['JSON']>;
     error?: Maybe<Scalars['JSON']>;
-    started: Scalars['DateTime'];
-    settled?: Maybe<Scalars['DateTime']>;
     isSettled: Scalars['Boolean'];
     duration: Scalars['Int'];
 };
 
 export type JobFilterParameter = {
     createdAt?: Maybe<DateOperators>;
+    startedAt?: Maybe<DateOperators>;
+    settledAt?: Maybe<DateOperators>;
     queueName?: Maybe<StringOperators>;
     state?: Maybe<StringOperators>;
     progress?: Maybe<NumberOperators>;
-    started?: Maybe<DateOperators>;
-    settled?: Maybe<DateOperators>;
     isSettled?: Maybe<BooleanOperators>;
     duration?: Maybe<NumberOperators>;
 };
@@ -1311,10 +1311,10 @@ export type JobQueue = {
 export type JobSortParameter = {
     id?: Maybe<SortOrder>;
     createdAt?: Maybe<SortOrder>;
+    startedAt?: Maybe<SortOrder>;
+    settledAt?: Maybe<SortOrder>;
     queueName?: Maybe<SortOrder>;
     progress?: Maybe<SortOrder>;
-    started?: Maybe<SortOrder>;
-    settled?: Maybe<SortOrder>;
     duration?: Maybe<SortOrder>;
 };