@tachybase/plugin-adapter-bullmq 0.23.8

package/dist/node_modules/bullmq/dist/cjs/classes/errors/rate-limit-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitError = exports.RATE_LIMIT_ERROR = void 0;
+exports.RATE_LIMIT_ERROR = 'bullmq:rateLimitExceeded';
+/**
+ * RateLimitError
+ *
+ * Error to be thrown when queue reaches a rate limit.
+ *
+ */
+class RateLimitError extends Error {
+    constructor(message = exports.RATE_LIMIT_ERROR) {
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+//# sourceMappingURL=rate-limit-error.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/errors/unrecoverable-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnrecoverableError = exports.UNRECOVERABLE_ERROR = void 0;
+exports.UNRECOVERABLE_ERROR = 'bullmq:unrecoverable';
+/**
+ * UnrecoverableError
+ *
+ * Error to move a job to failed even if the attemptsMade
+ * are lower than the expected limit.
+ *
+ */
+class UnrecoverableError extends Error {
+    constructor(message = exports.UNRECOVERABLE_ERROR) {
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.UnrecoverableError = UnrecoverableError;
+//# sourceMappingURL=unrecoverable-error.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/errors/waiting-children-error.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitingChildrenError = exports.WAITING_CHILDREN_ERROR = void 0;
+exports.WAITING_CHILDREN_ERROR = 'bullmq:movedToWaitingChildren';
+/**
+ * WaitingChildrenError
+ *
+ * Error to be thrown when job is moved to waiting-children state
+ * from job in active state.
+ *
+ */
+class WaitingChildrenError extends Error {
+    constructor(message = exports.WAITING_CHILDREN_ERROR) {
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.WaitingChildrenError = WaitingChildrenError;
+//# sourceMappingURL=waiting-children-error.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/flow-producer.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowProducer = void 0;
+const events_1 = require("events");
+const uuid_1 = require("uuid");
+const utils_1 = require("../utils");
+const job_1 = require("./job");
+const queue_keys_1 = require("./queue-keys");
+const redis_connection_1 = require("./redis-connection");
+const enums_1 = require("../enums");
+/**
+ * This class allows to add jobs with dependencies between them in such
+ * a way that it is possible to build complex flows.
+ * Note: A flow is a tree-like structure of jobs that depend on each other.
+ * Whenever the children of a given parent are completed, the parent
+ * will be processed, being able to access the children's result data.
+ * All Jobs can be in different queues, either children or parents,
+ */
+class FlowProducer extends events_1.EventEmitter {
+    constructor(opts = { connection: {} }, Connection = redis_connection_1.RedisConnection) {
+        super();
+        this.opts = opts;
+        this.opts = Object.assign({ prefix: 'bull' }, opts);
+        this.connection = new Connection(opts.connection, (0, utils_1.isRedisInstance)(opts.connection), false, opts.skipVersionCheck);
+        this.connection.on('error', (error) => this.emit('error', error));
+        this.connection.on('close', () => {
+            if (!this.closing) {
+                this.emit('ioredis:close');
+            }
+        });
+        this.queueKeys = new queue_keys_1.QueueKeys(opts.prefix);
+        if (opts === null || opts === void 0 ? void 0 : opts.telemetry) {
+            this.telemetry = opts.telemetry;
+        }
+    }
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    off(eventName, listener) {
+        super.off(eventName, listener);
+        return this;
+    }
+    on(event, listener) {
+        super.on(event, listener);
+        return this;
+    }
+    once(event, listener) {
+        super.once(event, listener);
+        return this;
+    }
+    /**
+     * Returns a promise that resolves to a redis client. Normally used only by subclasses.
+     */
+    get client() {
+        return this.connection.client;
+    }
+    /**
+     * Helper to easily extend Job class calls.
+     */
+    get Job() {
+        return job_1.Job;
+    }
+    waitUntilReady() {
+        return this.client;
+    }
+    /**
+     * Adds a flow.
+     *
+     * This call would be atomic, either it fails and no jobs will
+     * be added to the queues, or it succeeds and all jobs will be added.
+     *
+     * @param flow - an object with a tree-like structure where children jobs
+     * will be processed before their parents.
+     * @param opts - options that will be applied to the flow object.
+     */
+    async add(flow, opts) {
+        var _a;
+        if (this.closing) {
+            return;
+        }
+        const client = await this.connection.client;
+        const multi = client.multi();
+        const parentOpts = (_a = flow === null || flow === void 0 ? void 0 : flow.opts) === null || _a === void 0 ? void 0 : _a.parent;
+        const parentKey = (0, utils_1.getParentKey)(parentOpts);
+        const parentDependenciesKey = parentKey
+            ? `${parentKey}:dependencies`
+            : undefined;
+        return (0, utils_1.trace)(this.telemetry, enums_1.SpanKind.PRODUCER, flow.queueName, 'addFlow', flow.queueName, async (span) => {
+            span === null || span === void 0 ? void 0 : span.setAttributes({
+                [enums_1.TelemetryAttributes.FlowName]: flow.name,
+            });
+            const jobsTree = await this.addNode({
+                multi,
+                node: flow,
+                queuesOpts: opts === null || opts === void 0 ? void 0 : opts.queuesOptions,
+                parent: {
+                    parentOpts,
+                    parentDependenciesKey,
+                },
+            });
+            await multi.exec();
+            return jobsTree;
+        });
+    }
+    /**
+     * Get a flow.
+     *
+     * @param opts - an object with options for getting a JobNode.
+     */
+    async getFlow(opts) {
+        if (this.closing) {
+            return;
+        }
+        const client = await this.connection.client;
+        const updatedOpts = Object.assign({
+            depth: 10,
+            maxChildren: 20,
+        }, opts);
+        const jobsTree = this.getNode(client, updatedOpts);
+        return jobsTree;
+    }
+    /**
+     * Adds multiple flows.
+     *
+     * A flow is a tree-like structure of jobs that depend on each other.
+     * Whenever the children of a given parent are completed, the parent
+     * will be processed, being able to access the children's result data.
+     *
+     * All Jobs can be in different queues, either children or parents,
+     * however this call would be atomic, either it fails and no jobs will
+     * be added to the queues, or it succeeds and all jobs will be added.
+     *
+     * @param flows - an array of objects with a tree-like structure where children jobs
+     * will be processed before their parents.
+     */
+    async addBulk(flows) {
+        if (this.closing) {
+            return;
+        }
+        const client = await this.connection.client;
+        const multi = client.multi();
+        return (0, utils_1.trace)(this.telemetry, enums_1.SpanKind.PRODUCER, '', 'addBulkFlows', '', async (span) => {
+            span === null || span === void 0 ? void 0 : span.setAttributes({
+                [enums_1.TelemetryAttributes.BulkCount]: flows.length,
+                [enums_1.TelemetryAttributes.BulkNames]: flows
+                    .map(flow => flow.name)
+                    .join(','),
+            });
+            const jobsTrees = await this.addNodes(multi, flows);
+            await multi.exec();
+            return jobsTrees;
+        });
+    }
+    /**
+     * Add a node (job) of a flow to the queue. This method will recursively
+     * add all its children as well. Note that a given job can potentially be
+     * a parent and a child job at the same time depending on where it is located
+     * in the tree hierarchy.
+     *
+     * @param multi - ioredis ChainableCommander
+     * @param node - the node representing a job to be added to some queue
+     * @param parent - parent data sent to children to create the "links" to their parent
+     * @returns
+     */
+    async addNode({ multi, node, parent, queuesOpts, }) {
+        var _a, _b;
+        const prefix = node.prefix || this.opts.prefix;
+        const queue = this.queueFromNode(node, new queue_keys_1.QueueKeys(prefix), prefix);
+        const queueOpts = queuesOpts && queuesOpts[node.queueName];
+        const jobsOpts = (_a = queueOpts === null || queueOpts === void 0 ? void 0 : queueOpts.defaultJobOptions) !== null && _a !== void 0 ? _a : {};
+        const jobId = ((_b = node.opts) === null || _b === void 0 ? void 0 : _b.jobId) || (0, uuid_1.v4)();
+        return (0, utils_1.trace)(this.telemetry, enums_1.SpanKind.PRODUCER, node.name, 'addNode', node.queueName, async (span, srcPropagationMedatada) => {
+            var _a, _b;
+            span === null || span === void 0 ? void 0 : span.setAttributes({
+                [enums_1.TelemetryAttributes.JobName]: node.name,
+                [enums_1.TelemetryAttributes.JobId]: jobId,
+            });
+            const opts = node.opts;
+            let telemetry = opts === null || opts === void 0 ? void 0 : opts.telemetry;
+            if (srcPropagationMedatada && opts) {
+                const omitContext = (_a = opts.telemetry) === null || _a === void 0 ? void 0 : _a.omitContext;
+                const telemetryMetadata = ((_b = opts.telemetry) === null || _b === void 0 ? void 0 : _b.metadata) ||
+                    (!omitContext && srcPropagationMedatada);
+                if (telemetryMetadata || omitContext) {
+                    telemetry = {
+                        metadata: telemetryMetadata,
+                        omitContext,
+                    };
+                }
+            }
+            const job = new this.Job(queue, node.name, node.data, Object.assign(Object.assign(Object.assign({}, jobsOpts), opts), { parent: parent === null || parent === void 0 ? void 0 : parent.parentOpts, telemetry }), jobId);
+            const parentKey = (0, utils_1.getParentKey)(parent === null || parent === void 0 ? void 0 : parent.parentOpts);
+            if (node.children && node.children.length > 0) {
+                // Create the parent job, it will be a job in status "waiting-children".
+                const parentId = jobId;
+                const queueKeysParent = new queue_keys_1.QueueKeys(node.prefix || this.opts.prefix);
+                const waitChildrenKey = queueKeysParent.toKey(node.queueName, 'waiting-children');
+                await job.addJob(multi, {
+                    parentDependenciesKey: parent === null || parent === void 0 ? void 0 : parent.parentDependenciesKey,
+                    waitChildrenKey,
+                    parentKey,
+                });
+                const parentDependenciesKey = `${queueKeysParent.toKey(node.queueName, parentId)}:dependencies`;
+                const children = await this.addChildren({
+                    multi,
+                    nodes: node.children,
+                    parent: {
+                        parentOpts: {
+                            id: parentId,
+                            queue: queueKeysParent.getQueueQualifiedName(node.queueName),
+                        },
+                        parentDependenciesKey,
+                    },
+                    queuesOpts,
+                });
+                return { job, children };
+            }
+            else {
+                await job.addJob(multi, {
+                    parentDependenciesKey: parent === null || parent === void 0 ? void 0 : parent.parentDependenciesKey,
+                    parentKey,
+                });
+                return { job };
+            }
+        });
+    }
+    /**
+     * Adds nodes (jobs) of multiple flows to the queue. This method will recursively
+     * add all its children as well. Note that a given job can potentially be
+     * a parent and a child job at the same time depending on where it is located
+     * in the tree hierarchy.
+     *
+     * @param multi - ioredis ChainableCommander
+     * @param nodes - the nodes representing jobs to be added to some queue
+     * @returns
+     */
+    addNodes(multi, nodes) {
+        return Promise.all(nodes.map(node => {
+            var _a;
+            const parentOpts = (_a = node === null || node === void 0 ? void 0 : node.opts) === null || _a === void 0 ? void 0 : _a.parent;
+            const parentKey = (0, utils_1.getParentKey)(parentOpts);
+            const parentDependenciesKey = parentKey
+                ? `${parentKey}:dependencies`
+                : undefined;
+            return this.addNode({
+                multi,
+                node,
+                parent: {
+                    parentOpts,
+                    parentDependenciesKey,
+                },
+            });
+        }));
+    }
+    async getNode(client, node) {
+        const queue = this.queueFromNode(node, new queue_keys_1.QueueKeys(node.prefix), node.prefix);
+        const job = await this.Job.fromId(queue, node.id);
+        if (job) {
+            const { processed = {}, unprocessed = [] } = await job.getDependencies({
+                processed: {
+                    count: node.maxChildren,
+                },
+                unprocessed: {
+                    count: node.maxChildren,
+                },
+            });
+            const processedKeys = Object.keys(processed);
+            const childrenCount = processedKeys.length + unprocessed.length;
+            const newDepth = node.depth - 1;
+            if (childrenCount > 0 && newDepth) {
+                const children = await this.getChildren(client, [...processedKeys, ...unprocessed], newDepth, node.maxChildren);
+                return { job, children };
+            }
+            else {
+                return { job };
+            }
+        }
+    }
+    addChildren({ multi, nodes, parent, queuesOpts }) {
+        return Promise.all(nodes.map(node => this.addNode({ multi, node, parent, queuesOpts })));
+    }
+    getChildren(client, childrenKeys, depth, maxChildren) {
+        const getChild = (key) => {
+            const [prefix, queueName, id] = key.split(':');
+            return this.getNode(client, {
+                id,
+                queueName,
+                prefix,
+                depth,
+                maxChildren,
+            });
+        };
+        return Promise.all([...childrenKeys.map(getChild)]);
+    }
+    /**
+     * Helper factory method that creates a queue-like object
+     * required to create jobs in any queue.
+     *
+     * @param node -
+     * @param queueKeys -
+     * @returns
+     */
+    queueFromNode(node, queueKeys, prefix) {
+        return {
+            client: this.connection.client,
+            name: node.queueName,
+            keys: queueKeys.getKeys(node.queueName),
+            toKey: (type) => queueKeys.toKey(node.queueName, type),
+            opts: { prefix, connection: {} },
+            qualifiedName: queueKeys.getQueueQualifiedName(node.queueName),
+            closing: this.closing,
+            waitUntilReady: async () => this.connection.client,
+            removeListener: this.removeListener.bind(this),
+            emit: this.emit.bind(this),
+            on: this.on.bind(this),
+            redisVersion: this.connection.redisVersion,
+            trace: async () => { },
+        };
+    }
+    /**
+     *
+     * Closes the connection and returns a promise that resolves when the connection is closed.
+     */
+    async close() {
+        if (!this.closing) {
+            this.closing = this.connection.close();
+        }
+        await this.closing;
+    }
+    /**
+     *
+     * Force disconnects a connection.
+     */
+    disconnect() {
+        return this.connection.disconnect();
+    }
+}
+exports.FlowProducer = FlowProducer;
+//# sourceMappingURL=flow-producer.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./async-fifo-queue"), exports);
+tslib_1.__exportStar(require("./backoffs"), exports);
+tslib_1.__exportStar(require("./child-pool"), exports);
+tslib_1.__exportStar(require("./child-processor"), exports);
+tslib_1.__exportStar(require("./errors"), exports);
+tslib_1.__exportStar(require("./flow-producer"), exports);
+tslib_1.__exportStar(require("./job"), exports);
+tslib_1.__exportStar(require("./job-scheduler"), exports);
+// export * from './main'; this file must not be exported
+// export * from './main-worker'; this file must not be exported
+tslib_1.__exportStar(require("./queue-base"), exports);
+tslib_1.__exportStar(require("./queue-events"), exports);
+tslib_1.__exportStar(require("./queue-events-producer"), exports);
+tslib_1.__exportStar(require("./queue-getters"), exports);
+tslib_1.__exportStar(require("./queue-keys"), exports);
+tslib_1.__exportStar(require("./queue"), exports);
+tslib_1.__exportStar(require("./redis-connection"), exports);
+tslib_1.__exportStar(require("./repeat"), exports);
+tslib_1.__exportStar(require("./sandbox"), exports);
+tslib_1.__exportStar(require("./scripts"), exports);
+tslib_1.__exportStar(require("./worker"), exports);
+//# sourceMappingURL=index.js.map

package/dist/node_modules/bullmq/dist/cjs/classes/job-scheduler.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRepeatStrategy = exports.JobScheduler = void 0;
+const tslib_1 = require("tslib");
+const cron_parser_1 = require("cron-parser");
+const job_1 = require("./job");
+const queue_base_1 = require("./queue-base");
+const enums_1 = require("../enums");
+const utils_1 = require("../utils");
+class JobScheduler extends queue_base_1.QueueBase {
+    constructor(name, opts, Connection) {
+        super(name, opts, Connection);
+        this.repeatStrategy =
+            (opts.settings && opts.settings.repeatStrategy) || exports.defaultRepeatStrategy;
+    }
+    async upsertJobScheduler(jobSchedulerId, repeatOpts, jobName, jobData, opts, { override, producerId }) {
+        const { every, pattern, offset } = repeatOpts;
+        if (pattern && every) {
+            throw new Error('Both .pattern and .every options are defined for this repeatable job');
+        }
+        if (!pattern && !every) {
+            throw new Error('Either .pattern or .every options must be defined for this repeatable job');
+        }
+        if (repeatOpts.immediately && repeatOpts.startDate) {
+            throw new Error('Both .immediately and .startDate options are defined for this repeatable job');
+        }
+        if (repeatOpts.immediately && repeatOpts.every) {
+            console.warn("Using option immediately with every does not affect the job's schedule. Job will run immediately anyway.");
+        }
+        // Check if we reached the limit of the repeatable job's iterations
+        const iterationCount = repeatOpts.count ? repeatOpts.count + 1 : 1;
+        if (typeof repeatOpts.limit !== 'undefined' &&
+            iterationCount > repeatOpts.limit) {
+            return;
+        }
+        // Check if we reached the end date of the repeatable job
+        let now = Date.now();
+        const { endDate } = repeatOpts;
+        if (!(typeof endDate === undefined) && now > new Date(endDate).getTime()) {
+            return;
+        }
+        // Check if we have a start date for the repeatable job
+        const { startDate, immediately } = repeatOpts, filteredRepeatOpts = tslib_1.__rest(repeatOpts, ["startDate", "immediately"]);
+        if (startDate) {
+            const startMillis = new Date(startDate).getTime();
+            now = startMillis > now ? startMillis : now;
+        }
+        const prevMillis = opts.prevMillis || 0;
+        now = prevMillis < now ? now : prevMillis;
+        let nextMillis;
+        let newOffset = offset;
+        if (every) {
+            const nextSlot = Math.floor(now / every) * every + every;
+            if (prevMillis || offset) {
+                nextMillis = nextSlot + (offset || 0);
+            }
+            else {
+                nextMillis = now;
+                newOffset = every - (nextSlot - now);
+                // newOffset should always be positive, but as an extra safety check
+                newOffset = newOffset < 0 ? 0 : newOffset;
+            }
+            if (nextMillis < now) {
+                nextMillis = now;
+            }
+        }
+        else if (pattern) {
+            nextMillis = await this.repeatStrategy(now, repeatOpts, jobName);
+        }
+        const multi = (await this.client).multi();
+        if (nextMillis) {
+            if (override) {
+                this.scripts.addJobScheduler(multi, jobSchedulerId, nextMillis, JSON.stringify(typeof jobData === 'undefined' ? {} : jobData), job_1.Job.optsAsJSON(opts), {
+                    name: jobName,
+                    endDate: endDate ? new Date(endDate).getTime() : undefined,
+                    tz: repeatOpts.tz,
+                    pattern,
+                    every,
+                });
+            }
+            else {
+                this.scripts.updateJobSchedulerNextMillis(multi, jobSchedulerId, nextMillis);
+            }
+            return this.trace(enums_1.SpanKind.PRODUCER, 'add', `${this.name}.${jobName}`, async (span, srcPropagationMedatada) => {
+                var _a, _b;
+                let telemetry = opts.telemetry;
+                if (srcPropagationMedatada) {
+                    const omitContext = (_a = opts.telemetry) === null || _a === void 0 ? void 0 : _a.omitContext;
+                    const telemetryMetadata = ((_b = opts.telemetry) === null || _b === void 0 ? void 0 : _b.metadata) ||
+                        (!omitContext && srcPropagationMedatada);
+                    if (telemetryMetadata || omitContext) {
+                        telemetry = {
+                            metadata: telemetryMetadata,
+                            omitContext,
+                        };
+                    }
+                }
+                const job = this.createNextJob(multi, jobName, nextMillis, jobSchedulerId, Object.assign(Object.assign({}, opts), { repeat: Object.assign(Object.assign({}, filteredRepeatOpts), { offset: newOffset }), telemetry }), jobData, iterationCount, producerId);
+                const results = await multi.exec(); // multi.exec returns an array of results [ err, result ][]
+                // Check if there are any errors
+                const erroredResult = results.find(result => result[0]);
+                if (erroredResult) {
+                    throw new Error(`Error upserting job scheduler ${jobSchedulerId} - ${erroredResult[0]}`);
+                }
+                // Get last result with the job id
+                const lastResult = results.pop();
+                job.id = lastResult[1];
+                span === null || span === void 0 ? void 0 : span.setAttributes({
+                    [enums_1.TelemetryAttributes.JobSchedulerId]: jobSchedulerId,
+                    [enums_1.TelemetryAttributes.JobId]: job.id,
+                });
+                return job;
+            });
+        }
+    }
+    createNextJob(client, name, nextMillis, jobSchedulerId, opts, data, currentCount, 
+    // The job id of the job that produced this next iteration
+    producerId) {
+        //
+        // Generate unique job id for this iteration.
+        //
+        const jobId = this.getSchedulerNextJobId({
+            jobSchedulerId,
+            nextMillis,
+        });
+        const now = Date.now();
+        const delay = nextMillis - now;
+        const mergedOpts = Object.assign(Object.assign({}, opts), { jobId, delay: delay < 0 ? 0 : delay, timestamp: now, prevMillis: nextMillis, repeatJobKey: jobSchedulerId });
+        mergedOpts.repeat = Object.assign(Object.assign({}, opts.repeat), { count: currentCount });
+        const job = new this.Job(this, name, data, mergedOpts, jobId);
+        job.addJob(client);
+        if (producerId) {
+            const producerJobKey = this.toKey(producerId);
+            client.hset(producerJobKey, 'nrjid', job.id);
+        }
+        return job;
+    }
+    async removeJobScheduler(jobSchedulerId) {
+        return this.scripts.removeJobScheduler(jobSchedulerId);
+    }
+    async getSchedulerData(client, key, next) {
+        const jobData = await client.hgetall(this.toKey('repeat:' + key));
+        return this.transformSchedulerData(key, jobData, next);
+    }
+    async transformSchedulerData(key, jobData, next) {
+        if (jobData) {
+            return Object.assign(Object.assign({ key, name: jobData.name, endDate: parseInt(jobData.endDate) || null, tz: jobData.tz || null, pattern: jobData.pattern || null, every: jobData.every || null }, (jobData.data || jobData.opts
+                ? {
+                    template: this.getTemplateFromJSON(jobData.data, jobData.opts),
+                }
+                : {})), { next });
+        }
+        return this.keyToData(key, next);
+    }
+    keyToData(key, next) {
+        const data = key.split(':');
+        const pattern = data.slice(4).join(':') || null;
+        return {
+            key,
+            name: data[0],
+            id: data[1] || null,
+            endDate: parseInt(data[2]) || null,
+            tz: data[3] || null,
+            pattern,
+            next,
+        };
+    }
+    async getScheduler(id) {
+        const [rawJobData, next] = await this.scripts.getJobScheduler(id);
+        return this.transformSchedulerData(id, rawJobData ? (0, utils_1.array2obj)(rawJobData) : null, next ? parseInt(next) : null);
+    }
+    getTemplateFromJSON(rawData, rawOpts) {
+        const template = {};
+        if (rawData) {
+            template.data = JSON.parse(rawData);
+        }
+        if (rawOpts) {
+            template.opts = job_1.Job.optsFromJSON(rawOpts);
+        }
+        return template;
+    }
+    async getJobSchedulers(start = 0, end = -1, asc = false) {
+        const client = await this.client;
+        const jobSchedulersKey = this.keys.repeat;
+        const result = asc
+            ? await client.zrange(jobSchedulersKey, start, end, 'WITHSCORES')
+            : await client.zrevrange(jobSchedulersKey, start, end, 'WITHSCORES');
+        const jobs = [];
+        for (let i = 0; i < result.length; i += 2) {
+            jobs.push(this.getSchedulerData(client, result[i], parseInt(result[i + 1])));
+        }
+        return Promise.all(jobs);
+    }
+    async getSchedulersCount() {
+        const jobSchedulersKey = this.keys.repeat;
+        const client = await this.client;
+        return client.zcard(jobSchedulersKey);
+    }
+    getSchedulerNextJobId({ nextMillis, jobSchedulerId, }) {
+        return `repeat:${jobSchedulerId}:${nextMillis}`;
+    }
+}
+exports.JobScheduler = JobScheduler;
+const defaultRepeatStrategy = (millis, opts) => {
+    const { pattern } = opts;
+    const currentDate = new Date(millis);
+    const interval = (0, cron_parser_1.parseExpression)(pattern, Object.assign(Object.assign({}, opts), { currentDate }));
+    try {
+        if (opts.immediately) {
+            return new Date().getTime();
+        }
+        else {
+            return interval.next().getTime();
+        }
+    }
+    catch (e) {
+        // Ignore error
+    }
+};
+exports.defaultRepeatStrategy = defaultRepeatStrategy;
+//# sourceMappingURL=job-scheduler.js.map