@deenruv/core 1.0.0

package/dist/plugin/default-job-queue-plugin/default-job-queue-plugin.js

@@ -0,0 +1,141 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var DefaultJobQueuePlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultJobQueuePlugin = void 0;
+const plugin_common_module_1 = require("../plugin-common.module");
+const deenruv_plugin_1 = require("../deenruv-plugin");
+const job_record_buffer_entity_1 = require("./job-record-buffer.entity");
+const job_record_entity_1 = require("./job-record.entity");
+const sql_job_buffer_storage_strategy_1 = require("./sql-job-buffer-storage-strategy");
+const sql_job_queue_strategy_1 = require("./sql-job-queue-strategy");
+/**
+ * @description
+ * A plugin which configures Deenruv to use the SQL database to persist the JobQueue jobs using the {@link SqlJobQueueStrategy}. If you add this
+ * plugin to an existing Deenruv installation, you'll need to run a [database migration](/guides/developer-guide/migrations), since this
+ * plugin will add a new "job_record" table to the database.
+ *
+ * @example
+ * ```ts
+ * import { DefaultJobQueuePlugin, DeenruvConfig } from '\@deenruv/core';
+ *
+ * export const config: DeenruvConfig = {
+ *   // Add an instance of the plugin to the plugins array
+ *   plugins: [
+ *     DefaultJobQueuePlugin,
+ *   ],
+ * };
+ * ```
+ *
+ * ## Configuration
+ *
+ * It is possible to configure the behaviour of the {@link SqlJobQueueStrategy} by passing options to the static `init()` function:
+ *
+ * ### pollInterval
+ * The interval in ms between polling for new jobs. The default is 200ms.
+ * Using a longer interval reduces load on the database but results in a slight
+ * delay in processing jobs. For more control, it is possible to supply a function which can specify
+ * a pollInterval based on the queue name:
+ *
+ * @example
+ * ```ts
+ * export const config: DeenruvConfig = {
+ *   plugins: [
+ *     DefaultJobQueuePlugin.init({
+ *       pollInterval: queueName => {
+ *         if (queueName === 'cart-recovery-email') {
+ *           // This queue does not need to be polled so frequently,
+ *           // so we set a longer interval in order to reduce load
+ *           // on the database.
+ *           return 10000;
+ *         }
+ *         return 200;
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ * ### concurrency
+ * The number of jobs to process concurrently per worker. Defaults to 1.
+ *
+ * ### backoffStrategy
+ * Defines the backoff strategy used when retrying failed jobs. In other words, if a job fails
+ * and is configured to be re-tried, how long should we wait before the next attempt?
+ *
+ * By default, a job will be retried as soon as possible, but in some cases this is not desirable. For example,
+ * a job may interact with an unreliable 3rd-party API which is sensitive to too many requests. In this case, an
+ * exponential backoff may be used which progressively increases the delay between each subsequent retry.
+ *
+ * @example
+ * ```ts
+ * export const config: DeenruvConfig = {
+ *   plugins: [
+ *     DefaultJobQueuePlugin.init({
+ *       pollInterval: 5000,
+ *       concurrency: 2
+ *       backoffStrategy: (queueName, attemptsMade, job) => {
+ *         if (queueName === 'transcode-video') {
+ *           // exponential backoff example
+ *           return (attemptsMade ** 2) * 1000;
+ *         }
+ *
+ *         // A default delay for all other queues
+ *         return 1000;
+ *       },
+ *       setRetries: (queueName, job) => {
+ *         if (queueName === 'send-email') {
+ *           // Override the default number of retries
+ *           // for the 'send-email' job because we have
+ *           // a very unreliable email service.
+ *           return 10;
+ *         }
+ *         return job.retries;
+ *       }
+ *     }),
+ *   ],
+ * };
+ * ```
+ *
+ * @docsCategory JobQueue
+ * @docsWeight 0
+ */
+let DefaultJobQueuePlugin = DefaultJobQueuePlugin_1 = class DefaultJobQueuePlugin {
+    static init(options) {
+        DefaultJobQueuePlugin_1.options = options;
+        return DefaultJobQueuePlugin_1;
+    }
+};
+exports.DefaultJobQueuePlugin = DefaultJobQueuePlugin;
+/** @internal */
+DefaultJobQueuePlugin.options = {};
+exports.DefaultJobQueuePlugin = DefaultJobQueuePlugin = DefaultJobQueuePlugin_1 = __decorate([
+    (0, deenruv_plugin_1.DeenruvPlugin)({
+        imports: [plugin_common_module_1.PluginCommonModule],
+        entities: () => DefaultJobQueuePlugin.options.useDatabaseForBuffer === true
+            ? [job_record_entity_1.JobRecord, job_record_buffer_entity_1.JobRecordBuffer]
+            : [job_record_entity_1.JobRecord],
+        configuration: (config) => {
+            var _a;
+            const { pollInterval, concurrency, backoffStrategy, setRetries, gracefulShutdownTimeout, } = (_a = DefaultJobQueuePlugin.options) !== null && _a !== void 0 ? _a : {};
+            config.jobQueueOptions.jobQueueStrategy = new sql_job_queue_strategy_1.SqlJobQueueStrategy({
+                concurrency,
+                pollInterval,
+                backoffStrategy,
+                setRetries,
+                gracefulShutdownTimeout,
+            });
+            if (DefaultJobQueuePlugin.options.useDatabaseForBuffer === true) {
+                config.jobQueueOptions.jobBufferStorageStrategy =
+                    new sql_job_buffer_storage_strategy_1.SqlJobBufferStorageStrategy();
+            }
+            return config;
+        },
+        compatibility: ">0.0.0",
+    })
+], DefaultJobQueuePlugin);
+//# sourceMappingURL=default-job-queue-plugin.js.map

package/dist/plugin/default-job-queue-plugin/default-job-queue-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-job-queue-plugin.js","sourceRoot":"","sources":["../../../src/plugin/default-job-queue-plugin/default-job-queue-plugin.ts"],"names":[],"mappings":";;;;;;;;;;AAIA,kEAA6D;AAC7D,sDAAkD;AAElD,yEAA6D;AAC7D,2DAAgD;AAChD,uFAAgF;AAChF,qEAA+D;AAkF/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyFG;AA8BI,IAAM,qBAAqB,6BAA3B,MAAM,qBAAqB;IAIhC,MAAM,CAAC,IAAI,CAAC,OAA+B;QACzC,uBAAqB,CAAC,OAAO,GAAG,OAAO,CAAC;QACxC,OAAO,uBAAqB,CAAC;IAC/B,CAAC;;AAPU,sDAAqB;AAChC,gBAAgB;AACT,6BAAO,GAA2B,EAAE,AAA7B,CAA8B;gCAFjC,qBAAqB;IA7BjC,IAAA,8BAAa,EAAC;QACb,OAAO,EAAE,CAAC,yCAAkB,CAAC;QAC7B,QAAQ,EAAE,GAAG,EAAE,CACb,qBAAqB,CAAC,OAAO,CAAC,oBAAoB,KAAK,IAAI;YACzD,CAAC,CAAC,CAAC,6BAAS,EAAE,0CAAe,CAAC;YAC9B,CAAC,CAAC,CAAC,6BAAS,CAAC;QACjB,aAAa,EAAE,CAAC,MAAM,EAAE,EAAE;;YACxB,MAAM,EACJ,YAAY,EACZ,WAAW,EACX,eAAe,EACf,UAAU,EACV,uBAAuB,GACxB,GAAG,MAAA,qBAAqB,CAAC,OAAO,mCAAI,EAAE,CAAC;YACxC,MAAM,CAAC,eAAe,CAAC,gBAAgB,GAAG,IAAI,4CAAmB,CAAC;gBAChE,WAAW;gBACX,YAAY;gBACZ,eAAe;gBACf,UAAU;gBACV,uBAAuB;aACxB,CAAC,CAAC;YACH,IAAI,qBAAqB,CAAC,OAAO,CAAC,oBAAoB,KAAK,IAAI,EAAE,CAAC;gBAChE,MAAM,CAAC,eAAe,CAAC,wBAAwB;oBAC7C,IAAI,6DAA2B,EAAE,CAAC;YACtC,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,aAAa,EAAE,QAAQ;KACxB,CAAC;GACW,qBAAqB,CAQjC"}

package/dist/plugin/default-job-queue-plugin/job-record-buffer.entity.d.ts

@@ -0,0 +1,8 @@
+import { DeepPartial } from "@deenruv/common/lib/shared-types";
+import { DeenruvEntity } from "../../entity/base/base.entity";
+import { JobConfig } from "../../job-queue/types";
+export declare class JobRecordBuffer extends DeenruvEntity {
+    constructor(input: DeepPartial<JobRecordBuffer>);
+    bufferId: string;
+    job: JobConfig<any>;
+}

package/dist/plugin/default-job-queue-plugin/job-record-buffer.entity.js

@@ -0,0 +1,33 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobRecordBuffer = void 0;
+const typeorm_1 = require("typeorm");
+const base_entity_1 = require("../../entity/base/base.entity");
+let JobRecordBuffer = class JobRecordBuffer extends base_entity_1.DeenruvEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+exports.JobRecordBuffer = JobRecordBuffer;
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], JobRecordBuffer.prototype, "bufferId", void 0);
+__decorate([
+    (0, typeorm_1.Column)("simple-json"),
+    __metadata("design:type", Object)
+], JobRecordBuffer.prototype, "job", void 0);
+exports.JobRecordBuffer = JobRecordBuffer = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Object])
+], JobRecordBuffer);
+//# sourceMappingURL=job-record-buffer.entity.js.map

package/dist/plugin/default-job-queue-plugin/job-record-buffer.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-record-buffer.entity.js","sourceRoot":"","sources":["../../../src/plugin/default-job-queue-plugin/job-record-buffer.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;AACA,qCAAyC;AAEzC,+DAA8D;AAIvD,IAAM,eAAe,GAArB,MAAM,eAAgB,SAAQ,2BAAa;IAChD,YAAY,KAAmC;QAC7C,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;CAOF,CAAA;AAVY,0CAAe;AAM1B;IADC,IAAA,gBAAM,GAAE;;iDACQ;AAGjB;IADC,IAAA,gBAAM,EAAC,aAAa,CAAC;;4CACF;0BATT,eAAe;IAD3B,IAAA,gBAAM,GAAE;;GACI,eAAe,CAU3B"}

package/dist/plugin/default-job-queue-plugin/job-record.entity.d.ts

@@ -0,0 +1,17 @@
+import { JobState } from "@deenruv/common/lib/generated-types";
+import { DeepPartial } from "@deenruv/common/lib/shared-types";
+import { DeenruvEntity } from "../../entity/base/base.entity";
+export declare class JobRecord extends DeenruvEntity {
+    constructor(input: DeepPartial<JobRecord>);
+    queueName: string;
+    data: any;
+    state: JobState;
+    progress: number;
+    result: any;
+    error: string;
+    startedAt?: Date;
+    settledAt?: Date;
+    isSettled: boolean;
+    retries: number;
+    attempts: number;
+}

package/dist/plugin/default-job-queue-plugin/job-record.entity.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobRecord = void 0;
+const generated_types_1 = require("@deenruv/common/lib/generated-types");
+const typeorm_1 = require("typeorm");
+const base_entity_1 = require("../../entity/base/base.entity");
+let JobRecord = class JobRecord extends base_entity_1.DeenruvEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+exports.JobRecord = JobRecord;
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", String)
+], JobRecord.prototype, "queueName", void 0);
+__decorate([
+    (0, typeorm_1.Column)("simple-json", { nullable: true }),
+    __metadata("design:type", Object)
+], JobRecord.prototype, "data", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar"),
+    __metadata("design:type", String)
+], JobRecord.prototype, "state", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], JobRecord.prototype, "progress", void 0);
+__decorate([
+    (0, typeorm_1.Column)("simple-json", { nullable: true }),
+    __metadata("design:type", Object)
+], JobRecord.prototype, "result", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], JobRecord.prototype, "error", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, precision: 6 }),
+    __metadata("design:type", Date)
+], JobRecord.prototype, "startedAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true, precision: 6 }),
+    __metadata("design:type", Date)
+], JobRecord.prototype, "settledAt", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Boolean)
+], JobRecord.prototype, "isSettled", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], JobRecord.prototype, "retries", void 0);
+__decorate([
+    (0, typeorm_1.Column)(),
+    __metadata("design:type", Number)
+], JobRecord.prototype, "attempts", void 0);
+exports.JobRecord = JobRecord = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Object])
+], JobRecord);
+//# sourceMappingURL=job-record.entity.js.map

package/dist/plugin/default-job-queue-plugin/job-record.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-record.entity.js","sourceRoot":"","sources":["../../../src/plugin/default-job-queue-plugin/job-record.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yEAA+D;AAE/D,qCAAyC;AAEzC,+DAA8D;AAGvD,IAAM,SAAS,GAAf,MAAM,SAAU,SAAQ,2BAAa;IAC1C,YAAY,KAA6B;QACvC,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;CAkCF,CAAA;AArCY,8BAAS;AAMpB;IADC,IAAA,gBAAM,GAAE;;4CACS;AAGlB;IADC,IAAA,gBAAM,EAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;uCAChC;AAGV;IADC,IAAA,gBAAM,EAAC,SAAS,CAAC;;wCACF;AAGhB;IADC,IAAA,gBAAM,GAAE;;2CACQ;AAGjB;IADC,IAAA,gBAAM,EAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;yCAC9B;AAGZ;IADC,IAAA,gBAAM,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;wCACb;AAGd;IADC,IAAA,gBAAM,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;8BAC7B,IAAI;4CAAC;AAGjB;IADC,IAAA,gBAAM,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;8BAC7B,IAAI;4CAAC;AAGjB;IADC,IAAA,gBAAM,GAAE;;4CACU;AAGnB;IADC,IAAA,gBAAM,GAAE;;0CACO;AAGhB;IADC,IAAA,gBAAM,GAAE;;2CACQ;oBApCN,SAAS;IADrB,IAAA,gBAAM,GAAE;;GACI,SAAS,CAqCrB"}

package/dist/plugin/default-job-queue-plugin/sql-job-buffer-storage-strategy.d.ts

@@ -0,0 +1,19 @@
+import { Injector } from "../../common/injector";
+import { Job } from "../../job-queue/job";
+import { JobBufferStorageStrategy } from "../../job-queue/job-buffer/job-buffer-storage-strategy";
+/**
+ * @description
+ * This stores the buffered jobs in the database.
+ */
+export declare class SqlJobBufferStorageStrategy implements JobBufferStorageStrategy {
+    private connection;
+    init(injector: Injector): void;
+    add(bufferId: string, job: Job): Promise<Job>;
+    bufferSize(bufferIds?: string[]): Promise<{
+        [bufferId: string]: number;
+    }>;
+    flush(bufferIds?: string[]): Promise<{
+        [bufferId: string]: Job[];
+    }>;
+    private toJobConfig;
+}

package/dist/plugin/default-job-queue-plugin/sql-job-buffer-storage-strategy.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlJobBufferStorageStrategy = void 0;
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const job_1 = require("../../job-queue/job");
+const job_record_buffer_entity_1 = require("./job-record-buffer.entity");
+/**
+ * @description
+ * This stores the buffered jobs in the database.
+ */
+class SqlJobBufferStorageStrategy {
+    init(injector) {
+        this.connection = injector.get(transactional_connection_1.TransactionalConnection);
+    }
+    async add(bufferId, job) {
+        await this.connection.rawConnection.getRepository(job_record_buffer_entity_1.JobRecordBuffer).save(new job_record_buffer_entity_1.JobRecordBuffer({
+            bufferId,
+            job: this.toJobConfig(job),
+        }));
+        return job;
+    }
+    async bufferSize(bufferIds) {
+        const qb = this.connection.rawConnection
+            .getRepository(job_record_buffer_entity_1.JobRecordBuffer)
+            .createQueryBuilder("record")
+            .select("COUNT(*)", "count")
+            .addSelect("record.bufferId", "bufferId");
+        if (bufferIds === null || bufferIds === void 0 ? void 0 : bufferIds.length) {
+            qb.andWhere("record.bufferId IN (:...bufferIds)", { bufferIds });
+        }
+        const rows = await qb.groupBy("record.bufferId").getRawMany();
+        const result = {};
+        for (const row of rows) {
+            if (bufferIds)
+                result[row.bufferId] = +row.count;
+        }
+        return result;
+    }
+    async flush(bufferIds) {
+        const selectQb = this.connection.rawConnection
+            .getRepository(job_record_buffer_entity_1.JobRecordBuffer)
+            .createQueryBuilder("record");
+        if (bufferIds === null || bufferIds === void 0 ? void 0 : bufferIds.length) {
+            selectQb.where("record.bufferId IN (:...bufferIds)", { bufferIds });
+        }
+        const rows = await selectQb.getMany();
+        const result = {};
+        for (const row of rows) {
+            if (!result[row.bufferId]) {
+                result[row.bufferId] = [];
+            }
+            result[row.bufferId].push(new job_1.Job(row.job));
+        }
+        const deleteQb = this.connection.rawConnection
+            .createQueryBuilder()
+            .delete()
+            .from(job_record_buffer_entity_1.JobRecordBuffer);
+        if (bufferIds === null || bufferIds === void 0 ? void 0 : bufferIds.length) {
+            deleteQb.where("bufferId IN (:...bufferIds)", { bufferIds });
+        }
+        await deleteQb.execute();
+        return result;
+    }
+    toJobConfig(job) {
+        var _a;
+        return Object.assign(Object.assign({}, job), { data: job.data, id: (_a = job.id) !== null && _a !== void 0 ? _a : undefined });
+    }
+}
+exports.SqlJobBufferStorageStrategy = SqlJobBufferStorageStrategy;
+//# sourceMappingURL=sql-job-buffer-storage-strategy.js.map

package/dist/plugin/default-job-queue-plugin/sql-job-buffer-storage-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-job-buffer-storage-strategy.js","sourceRoot":"","sources":["../../../src/plugin/default-job-queue-plugin/sql-job-buffer-storage-strategy.ts"],"names":[],"mappings":"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"}

package/dist/plugin/default-job-queue-plugin/sql-job-queue-strategy.d.ts

@@ -0,0 +1,36 @@
+import { JobListOptions } from "@deenruv/common/lib/generated-types";
+import { ID, PaginatedList } from "@deenruv/common/lib/shared-types";
+import { Injector } from "../../common/injector";
+import { InspectableJobQueueStrategy } from "../../config";
+import { Job, JobData, JobQueueStrategyJobOptions } from "../../job-queue";
+import { PollingJobQueueStrategy } from "../../job-queue/polling-job-queue-strategy";
+/**
+ * @description
+ * A {@link JobQueueStrategy} which uses the configured SQL database to persist jobs in the queue.
+ * This strategy is used by the {@link DefaultJobQueuePlugin}.
+ *
+ * @docsCategory JobQueue
+ */
+export declare class SqlJobQueueStrategy extends PollingJobQueueStrategy implements InspectableJobQueueStrategy {
+    private rawConnection;
+    private connection;
+    private listQueryBuilder;
+    init(injector: Injector): void;
+    destroy(): void;
+    add<Data extends JobData<Data> = object>(job: Job<Data>, jobOptions?: JobQueueStrategyJobOptions<Data>): Promise<Job<Data>>;
+    /**
+     * MySQL & MariaDB store job data as a "text" type which has a limit of 64kb. Going over that limit will cause the job to not be stored.
+     * In order to try to prevent that, this method will truncate any strings in the `data` object over 2kb in size.
+     */
+    private constrainDataSize;
+    next(queueName: string): Promise<Job | undefined>;
+    private getNextAndSetAsRunning;
+    update(job: Job<any>): Promise<void>;
+    findMany(options?: JobListOptions): Promise<PaginatedList<Job>>;
+    findOne(id: ID): Promise<Job | undefined>;
+    findManyById(ids: ID[]): Promise<Job[]>;
+    removeSettledJobs(queueNames?: string[], olderThan?: Date): Promise<number>;
+    private connectionAvailable;
+    private toRecord;
+    private fromRecord;
+}

package/dist/plugin/default-job-queue-plugin/sql-job-queue-strategy.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlJobQueueStrategy = void 0;
+const generated_types_1 = require("@deenruv/common/lib/generated-types");
+const typeorm_1 = require("typeorm");
+const deenruv_logger_1 = require("../../config/logger/deenruv-logger");
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const job_queue_1 = require("../../job-queue");
+const polling_job_queue_strategy_1 = require("../../job-queue/polling-job-queue-strategy");
+const list_query_builder_1 = require("../../service/helpers/list-query-builder/list-query-builder");
+const job_record_entity_1 = require("./job-record.entity");
+/**
+ * @description
+ * A {@link JobQueueStrategy} which uses the configured SQL database to persist jobs in the queue.
+ * This strategy is used by the {@link DefaultJobQueuePlugin}.
+ *
+ * @docsCategory JobQueue
+ */
+class SqlJobQueueStrategy extends polling_job_queue_strategy_1.PollingJobQueueStrategy {
+    init(injector) {
+        this.rawConnection = injector.get(transactional_connection_1.TransactionalConnection).rawConnection;
+        this.connection = injector.get(transactional_connection_1.TransactionalConnection);
+        this.listQueryBuilder = injector.get(list_query_builder_1.ListQueryBuilder);
+        super.init(injector);
+    }
+    destroy() {
+        this.rawConnection = undefined;
+        super.destroy();
+    }
+    async add(job, jobOptions) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        const jobRecordRepository = (jobOptions === null || jobOptions === void 0 ? void 0 : jobOptions.ctx) && this.connection
+            ? this.connection.getRepository(jobOptions.ctx, job_record_entity_1.JobRecord)
+            : this.rawConnection.getRepository(job_record_entity_1.JobRecord);
+        const constrainedData = this.constrainDataSize(job);
+        const newRecord = this.toRecord(job, constrainedData, this.setRetries(job.queueName, job));
+        const record = await jobRecordRepository.save(newRecord);
+        return this.fromRecord(record);
+    }
+    /**
+     * MySQL & MariaDB store job data as a "text" type which has a limit of 64kb. Going over that limit will cause the job to not be stored.
+     * In order to try to prevent that, this method will truncate any strings in the `data` object over 2kb in size.
+     */
+    constrainDataSize(job) {
+        var _a;
+        const type = (_a = this.rawConnection) === null || _a === void 0 ? void 0 : _a.options.type;
+        if (type === "mysql" || type === "mariadb") {
+            const stringified = JSON.stringify(job.data);
+            if (64 * 1024 <= stringified.length) {
+                const truncatedKeys = [];
+                const reduced = JSON.parse(stringified, (key, value) => {
+                    if (typeof value === "string" && 2048 < value.length) {
+                        truncatedKeys.push({ key, size: value.length });
+                        return `[truncated - originally ${value.length} bytes]`;
+                    }
+                    return value;
+                });
+                deenruv_logger_1.Logger.warn(`Job data for "${job.queueName}" is too long to store with the ${type} driver (${Math.round(stringified.length / 1024)}kb).\nThe following keys were truncated: ${truncatedKeys
+                    .map(({ key, size }) => `${key} (${size} bytes)`)
+                    .join(", ")}`);
+                return reduced;
+            }
+        }
+    }
+    async next(queueName) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        const connection = this.rawConnection;
+        const connectionType = this.rawConnection.options.type;
+        const isSQLite = connectionType === "sqlite" ||
+            connectionType === "sqljs" ||
+            connectionType === "better-sqlite3";
+        return new Promise(async (resolve, reject) => {
+            if (isSQLite) {
+                try {
+                    // SQLite driver does not support concurrent transactions. See https://github.com/typeorm/typeorm/issues/1884
+                    const result = await this.getNextAndSetAsRunning(connection.manager, queueName, false);
+                    resolve(result);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }
+            else {
+                // Selecting the next job is wrapped in a transaction so that we can
+                // set a lock on that row and immediately update the status to "RUNNING".
+                // This prevents multiple worker processes from taking the same job when
+                // running concurrent workers.
+                connection
+                    .transaction(async (transactionManager) => {
+                    const result = await this.getNextAndSetAsRunning(transactionManager, queueName, true);
+                    resolve(result);
+                })
+                    .catch((err) => reject(err));
+            }
+        });
+    }
+    async getNextAndSetAsRunning(manager, queueName, setLock, waitingJobIds = []) {
+        const qb = manager
+            .getRepository(job_record_entity_1.JobRecord)
+            .createQueryBuilder("record")
+            .where("record.queueName = :queueName", { queueName })
+            .andWhere(new typeorm_1.Brackets((qb1) => {
+            qb1
+                .where("record.state = :pending", {
+                pending: generated_types_1.JobState.PENDING,
+            })
+                .orWhere("record.state = :retrying", {
+                retrying: generated_types_1.JobState.RETRYING,
+            });
+        }))
+            .orderBy("record.createdAt", "ASC");
+        if (waitingJobIds.length) {
+            qb.andWhere("record.id NOT IN (:...waitingJobIds)", { waitingJobIds });
+        }
+        if (setLock) {
+            qb.setLock("pessimistic_write");
+        }
+        const record = await qb.getOne();
+        if (record) {
+            const job = this.fromRecord(record);
+            if (record.state === generated_types_1.JobState.RETRYING &&
+                typeof this.backOffStrategy === "function") {
+                const msSinceLastFailure = Date.now() - +record.updatedAt;
+                const backOffDelayMs = this.backOffStrategy(queueName, record.attempts, job);
+                if (msSinceLastFailure < backOffDelayMs) {
+                    return await this.getNextAndSetAsRunning(manager, queueName, setLock, [...waitingJobIds, record.id]);
+                }
+            }
+            job.start();
+            record.state = generated_types_1.JobState.RUNNING;
+            await manager.getRepository(job_record_entity_1.JobRecord).save(record, { reload: false });
+            return job;
+        }
+        else {
+            return;
+        }
+    }
+    async update(job) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        await this.rawConnection
+            .getRepository(job_record_entity_1.JobRecord)
+            .createQueryBuilder("job")
+            .update()
+            .set(this.toRecord(job))
+            .where("id = :id", { id: job.id })
+            .andWhere("settledAt IS NULL")
+            .execute();
+    }
+    async findMany(options) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        return this.listQueryBuilder
+            .build(job_record_entity_1.JobRecord, options)
+            .getManyAndCount()
+            .then(([items, totalItems]) => ({
+            items: items.map(this.fromRecord),
+            totalItems,
+        }));
+    }
+    async findOne(id) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        const record = await this.rawConnection
+            .getRepository(job_record_entity_1.JobRecord)
+            .findOne({ where: { id } });
+        if (record) {
+            return this.fromRecord(record);
+        }
+    }
+    async findManyById(ids) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        return this.rawConnection
+            .getRepository(job_record_entity_1.JobRecord)
+            .find({ where: { id: (0, typeorm_1.In)(ids) } })
+            .then((records) => records.map(this.fromRecord));
+    }
+    async removeSettledJobs(queueNames = [], olderThan) {
+        if (!this.connectionAvailable(this.rawConnection)) {
+            throw new Error("Connection not available");
+        }
+        const findOptions = Object.assign(Object.assign({}, (0 < queueNames.length ? { queueName: (0, typeorm_1.In)(queueNames) } : {})), { isSettled: true, settledAt: (0, typeorm_1.LessThan)(olderThan || new Date()) });
+        const toDelete = await this.rawConnection
+            .getRepository(job_record_entity_1.JobRecord)
+            .find({ where: findOptions });
+        const deleteCount = await this.rawConnection
+            .getRepository(job_record_entity_1.JobRecord)
+            .count({ where: findOptions });
+        await this.rawConnection.getRepository(job_record_entity_1.JobRecord).delete(findOptions);
+        return deleteCount;
+    }
+    connectionAvailable(connection) {
+        return !!this.rawConnection && this.rawConnection.isConnected;
+    }
+    toRecord(job, data, retries) {
+        return new job_record_entity_1.JobRecord({
+            id: job.id || undefined,
+            queueName: job.queueName,
+            data: data !== null && data !== void 0 ? data : job.data,
+            state: job.state,
+            progress: job.progress,
+            result: job.result,
+            error: job.error,
+            startedAt: job.startedAt,
+            settledAt: job.settledAt,
+            isSettled: job.isSettled,
+            retries: retries !== null && retries !== void 0 ? retries : job.retries,
+            attempts: job.attempts,
+        });
+    }
+    fromRecord(jobRecord) {
+        return new job_queue_1.Job(jobRecord);
+    }
+}
+exports.SqlJobQueueStrategy = SqlJobQueueStrategy;
+//# sourceMappingURL=sql-job-queue-strategy.js.map