@tachybase/plugin-print-template 1.3.17 → 1.3.18

package/dist/externalVersion.js

@@ -1,7 +1,7 @@
 module.exports = {
-  "@tachybase/client": "1.3.17",
-  "@tachybase/database": "1.3.17",
-  "@tachybase/server": "1.3.17",
+  "@tachybase/client": "1.3.18",
+  "@tachybase/database": "1.3.18",
+  "@tachybase/server": "1.3.18",
   "koa-bodyparser": "4.4.1",
-  "@tachybase/actions": "1.3.17"
+  "@tachybase/actions": "1.3.18"
 };

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

@@ -22,20 +22,33 @@ class Backoffs {
 }
 exports.Backoffs = Backoffs;
 Backoffs.builtinStrategies = {
-    fixed: function (delay) {
+    fixed: function (delay, jitter = 0) {
         return function () {
-            return delay;
+            if (jitter > 0) {
+                const minDelay = delay * (1 - jitter);
+                return Math.floor(Math.random() * delay * jitter + minDelay);
+            }
+            else {
+                return delay;
+            }
         };
     },
-    exponential: function (delay) {
+    exponential: function (delay, jitter = 0) {
         return function (attemptsMade) {
-            return Math.round(Math.pow(2, attemptsMade - 1) * delay);
+            if (jitter > 0) {
+                const maxDelay = Math.round(Math.pow(2, attemptsMade - 1) * delay);
+                const minDelay = maxDelay * (1 - jitter);
+                return Math.floor(Math.random() * maxDelay * jitter + minDelay);
+            }
+            else {
+                return Math.round(Math.pow(2, attemptsMade - 1) * delay);
+            }
         };
     },
 };
 function lookupStrategy(backoff, customStrategy) {
     if (backoff.type in Backoffs.builtinStrategies) {
-        return Backoffs.builtinStrategies[backoff.type](backoff.delay);
+        return Backoffs.builtinStrategies[backoff.type](backoff.delay, backoff.jitter);
     }
     else if (customStrategy) {
         return customStrategy;

package/dist/node_modules/bullmq/dist/cjs/classes/child-pool.js

@@ -15,7 +15,7 @@ class ChildPool {
             workerThreadsOptions,
         };
     }
-    async retain(processFile, exitHandler) {
+    async retain(processFile) {
         let child = this.getFree(processFile).pop();
         if (child) {
             this.retained[child.pid] = child;
@@ -26,9 +26,14 @@ class ChildPool {
             workerForkOptions: this.opts.workerForkOptions,
             workerThreadsOptions: this.opts.workerThreadsOptions,
         });
-        child.on('exit', exitHandler);
+        child.on('exit', this.remove.bind(this, child));
         try {
             await child.init();
+            // Check status here as well, in case the child exited before we could
+            // retain it.
+            if (child.exitCode !== null || child.signalCode !== null) {
+                throw new Error('Child exited before it could be retained');
+            }
             this.retained[child.pid] = child;
             return child;
         }

package/dist/node_modules/bullmq/dist/cjs/classes/child-processor.js

@@ -10,6 +10,7 @@ var ChildStatus;
     ChildStatus[ChildStatus["Terminating"] = 2] = "Terminating";
     ChildStatus[ChildStatus["Errored"] = 3] = "Errored";
 })(ChildStatus || (ChildStatus = {}));
+const RESPONSE_TIMEOUT = process.env.NODE_ENV === 'test' ? 500 : 5000;
 /**
  * ChildProcessor
  *
@@ -18,8 +19,9 @@ var ChildStatus;
  *
  */
 class ChildProcessor {
-    constructor(send) {
+    constructor(send, receiver) {
         this.send = send;
+        this.receiver = receiver;
     }
     async init(processorFile) {
         let processor;
@@ -107,7 +109,7 @@ class ChildProcessor {
     wrapJob(job, send) {
         const wrappedJob = Object.assign(Object.assign({}, job), { data: JSON.parse(job.data || '{}'), opts: job.opts, returnValue: JSON.parse(job.returnvalue || '{}'), 
             /*
-             * Emulate the real job `updateProgress` function, should works as `progress` function.
+             * Proxy `updateProgress` function, should works as `progress` function.
              */
             async updateProgress(progress) {
                 // Locally store reference to new progress value
@@ -120,7 +122,7 @@ class ChildProcessor {
                 });
             }, 
             /*
-             * Emulate the real job `log` function.
+             * Proxy job `log` function.
              */
             log: async (row) => {
                 await send({
@@ -129,7 +131,7 @@ class ChildProcessor {
                 });
             }, 
             /*
-             * Emulate the real job `moveToDelayed` function.
+             * Proxy `moveToDelayed` function.
              */
             moveToDelayed: async (timestamp, token) => {
                 await send({
@@ -138,7 +140,16 @@ class ChildProcessor {
                 });
             }, 
             /*
-             * Emulate the real job `updateData` function.
+             * Proxy `moveToWait` function.
+             */
+            moveToWait: async (token) => {
+                await send({
+                    cmd: enums_1.ParentCommand.MoveToWait,
+                    value: { token },
+                });
+            }, 
+            /*
+             * Proxy `updateData` function.
              */
             updateData: async (data) => {
                 await send({
@@ -146,9 +157,52 @@ class ChildProcessor {
                     value: data,
                 });
                 wrappedJob.data = data;
+            }, 
+            /**
+             * Proxy `getChildrenValues` function.
+             */
+            getChildrenValues: async () => {
+                const requestId = Math.random().toString(36).substring(2, 15);
+                await send({
+                    requestId,
+                    cmd: enums_1.ParentCommand.GetChildrenValues,
+                });
+                return waitResponse(requestId, this.receiver, RESPONSE_TIMEOUT, 'getChildrenValues');
+            }, 
+            /**
+             * Proxy `getIgnoredChildrenFailures` function.
+             *
+             * This method sends a request to retrieve the failures of ignored children
+             * and waits for a response from the parent process.
+             *
+             * @returns - A promise that resolves with the ignored children failures.
+             * The exact structure of the returned data depends on the parent process implementation.
+             */
+            getIgnoredChildrenFailures: async () => {
+                const requestId = Math.random().toString(36).substring(2, 15);
+                await send({
+                    requestId,
+                    cmd: enums_1.ParentCommand.GetIgnoredChildrenFailures,
+                });
+                return waitResponse(requestId, this.receiver, RESPONSE_TIMEOUT, 'getIgnoredChildrenFailures');
             } });
         return wrappedJob;
     }
 }
 exports.ChildProcessor = ChildProcessor;
+const waitResponse = async (requestId, receiver, timeout, cmd) => {
+    return new Promise((resolve, reject) => {
+        const listener = (msg) => {
+            if (msg.requestId === requestId) {
+                resolve(msg.value);
+                receiver.off('message', listener);
+            }
+        };
+        receiver.on('message', listener);
+        setTimeout(() => {
+            receiver.off('message', listener);
+            reject(new Error(`TimeoutError: ${cmd} timed out in (${timeout}ms)`));
+        }, timeout);
+    });
+};
 //# sourceMappingURL=child-processor.js.map

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

@@ -47,7 +47,9 @@ class Child extends events_1.EventEmitter {
             return this.childProcess.pid;
         }
         else if (this.worker) {
-            return this.worker.threadId;
+            // Worker threads pids can become negative when they are terminated
+            // so we need to use the absolute value to index the retained object
+            return Math.abs(this.worker.threadId);
         }
         else {
             throw new Error('No child process or worker thread');

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./delayed-error"), exports);
-tslib_1.__exportStar(require("./unrecoverable-error"), exports);
 tslib_1.__exportStar(require("./rate-limit-error"), exports);
+tslib_1.__exportStar(require("./unrecoverable-error"), exports);
 tslib_1.__exportStar(require("./waiting-children-error"), exports);
+tslib_1.__exportStar(require("./waiting-error"), exports);
 //# sourceMappingURL=index.js.map

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

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

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

@@ -21,7 +21,12 @@ class FlowProducer extends events_1.EventEmitter {
         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 = new Connection(opts.connection, {
+            shared: (0, utils_1.isRedisInstance)(opts.connection),
+            blocking: false,
+            skipVersionCheck: opts.skipVersionCheck,
+            skipWaitingForReady: opts.skipWaitingForReady,
+        });
         this.connection.on('error', (error) => this.emit('error', error));
         this.connection.on('close', () => {
             if (!this.closing) {
@@ -115,6 +120,7 @@ class FlowProducer extends events_1.EventEmitter {
         const updatedOpts = Object.assign({
             depth: 10,
             maxChildren: 20,
+            prefix: this.opts.prefix,
         }, opts);
         const jobsTree = this.getNode(client, updatedOpts);
         return jobsTree;
@@ -169,7 +175,7 @@ class FlowProducer extends events_1.EventEmitter {
         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) => {
+        return (0, utils_1.trace)(this.telemetry, enums_1.SpanKind.PRODUCER, node.queueName, 'addNode', node.queueName, async (span, srcPropagationMedatada) => {
             var _a, _b;
             span === null || span === void 0 ? void 0 : span.setAttributes({
                 [enums_1.TelemetryAttributes.JobName]: node.name,
@@ -256,19 +262,29 @@ class FlowProducer extends events_1.EventEmitter {
         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({
+            const { processed = {}, unprocessed = [], failed = [], ignored = {}, } = await job.getDependencies({
+                failed: {
+                    count: node.maxChildren,
+                },
                 processed: {
                     count: node.maxChildren,
                 },
                 unprocessed: {
                     count: node.maxChildren,
                 },
+                ignored: {
+                    count: node.maxChildren,
+                },
             });
             const processedKeys = Object.keys(processed);
-            const childrenCount = processedKeys.length + unprocessed.length;
+            const ignoredKeys = Object.keys(ignored);
+            const childrenCount = processedKeys.length +
+                unprocessed.length +
+                ignoredKeys.length +
+                failed.length;
             const newDepth = node.depth - 1;
             if (childrenCount > 0 && newDepth) {
-                const children = await this.getChildren(client, [...processedKeys, ...unprocessed], newDepth, node.maxChildren);
+                const children = await this.getChildren(client, [...processedKeys, ...unprocessed, ...failed, ...ignoredKeys], newDepth, node.maxChildren);
                 return { job, children };
             }
             else {

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

@@ -3,6 +3,7 @@ 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"), exports);
 tslib_1.__exportStar(require("./child-pool"), exports);
 tslib_1.__exportStar(require("./child-processor"), exports);
 tslib_1.__exportStar(require("./errors"), exports);

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

@@ -14,7 +14,7 @@ class JobScheduler extends queue_base_1.QueueBase {
             (opts.settings && opts.settings.repeatStrategy) || exports.defaultRepeatStrategy;
     }
     async upsertJobScheduler(jobSchedulerId, repeatOpts, jobName, jobData, opts, { override, producerId }) {
-        const { every, pattern, offset } = repeatOpts;
+        const { every, limit, pattern, offset } = repeatOpts;
         if (pattern && every) {
             throw new Error('Both .pattern and .every options are defined for this repeatable job');
         }
@@ -36,51 +36,38 @@ class JobScheduler extends queue_base_1.QueueBase {
         // 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()) {
+        if (endDate && now > new Date(endDate).getTime()) {
             return;
         }
+        const prevMillis = opts.prevMillis || 0;
+        now = prevMillis < now ? now : prevMillis;
         // Check if we have a start date for the repeatable job
         const { startDate, immediately } = repeatOpts, filteredRepeatOpts = tslib_1.__rest(repeatOpts, ["startDate", "immediately"]);
+        let startMillis = (now > prevMillis ? now : prevMillis) + (offset || 0);
         if (startDate) {
-            const startMillis = new Date(startDate).getTime();
-            now = startMillis > now ? startMillis : now;
+            startMillis = new Date(startDate).getTime();
+            startMillis = startMillis > now ? startMillis : now;
         }
-        const prevMillis = opts.prevMillis || 0;
-        now = prevMillis < now ? now : prevMillis;
         let nextMillis;
-        let newOffset = offset;
+        let newOffset = null;
         if (every) {
-            const nextSlot = Math.floor(now / every) * every + every;
+            const prevSlot = Math.floor((startMillis - (offset || 0)) / every) * every;
+            newOffset = typeof offset === 'number' ? offset : startMillis - prevSlot;
+            const nextSlot = prevSlot + every;
             if (prevMillis || offset) {
-                nextMillis = nextSlot + (offset || 0);
+                nextMillis = nextSlot;
             }
             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;
+                nextMillis = prevSlot;
             }
         }
         else if (pattern) {
             nextMillis = await this.repeatStrategy(now, repeatOpts, jobName);
+            if (nextMillis < now) {
+                nextMillis = now;
+            }
         }
-        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;
@@ -95,27 +82,42 @@ class JobScheduler extends queue_base_1.QueueBase {
                         };
                     }
                 }
-                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]}`);
+                const mergedOpts = this.getNextJobOpts(nextMillis, jobSchedulerId, Object.assign(Object.assign({}, opts), { repeat: filteredRepeatOpts, telemetry }), iterationCount, newOffset);
+                if (override) {
+                    const jobId = await this.scripts.addJobScheduler(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,
+                        limit,
+                        offset: newOffset,
+                    }, job_1.Job.optsAsJSON(mergedOpts), producerId);
+                    const job = new this.Job(this, jobName, jobData, mergedOpts, jobId);
+                    job.id = jobId;
+                    span === null || span === void 0 ? void 0 : span.setAttributes({
+                        [enums_1.TelemetryAttributes.JobSchedulerId]: jobSchedulerId,
+                        [enums_1.TelemetryAttributes.JobId]: job.id,
+                    });
+                    return job;
+                }
+                else {
+                    const jobId = await this.scripts.updateJobSchedulerNextMillis(jobSchedulerId, nextMillis, JSON.stringify(typeof jobData === 'undefined' ? {} : jobData), job_1.Job.optsAsJSON(mergedOpts), producerId);
+                    if (jobId) {
+                        const job = new this.Job(this, jobName, jobData, mergedOpts, jobId);
+                        job.id = jobId;
+                        span === null || span === void 0 ? void 0 : span.setAttributes({
+                            [enums_1.TelemetryAttributes.JobSchedulerId]: jobSchedulerId,
+                            [enums_1.TelemetryAttributes.JobId]: job.id,
+                        });
+                        return job;
+                    }
                 }
-                // 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) {
+    getNextJobOpts(nextMillis, jobSchedulerId, opts, currentCount, offset) {
+        var _a;
         //
         // Generate unique job id for this iteration.
         //
@@ -124,16 +126,12 @@ class JobScheduler extends queue_base_1.QueueBase {
             nextMillis,
         });
         const now = Date.now();
-        const delay = nextMillis - now;
+        const delay = nextMillis + offset - 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;
+        mergedOpts.repeat = Object.assign(Object.assign({}, opts.repeat), { offset, count: currentCount, endDate: ((_a = opts.repeat) === null || _a === void 0 ? void 0 : _a.endDate)
+                ? new Date(opts.repeat.endDate).getTime()
+                : undefined });
+        return mergedOpts;
     }
     async removeJobScheduler(jobSchedulerId) {
         return this.scripts.removeJobScheduler(jobSchedulerId);
@@ -142,15 +140,43 @@ class JobScheduler extends queue_base_1.QueueBase {
         const jobData = await client.hgetall(this.toKey('repeat:' + key));
         return this.transformSchedulerData(key, jobData, next);
     }
-    async transformSchedulerData(key, jobData, next) {
+    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 });
+            const jobSchedulerData = {
+                key,
+                name: jobData.name,
+                next,
+            };
+            if (jobData.ic) {
+                jobSchedulerData.iterationCount = parseInt(jobData.ic);
+            }
+            if (jobData.limit) {
+                jobSchedulerData.limit = parseInt(jobData.limit);
+            }
+            if (jobData.endDate) {
+                jobSchedulerData.endDate = parseInt(jobData.endDate);
+            }
+            if (jobData.tz) {
+                jobSchedulerData.tz = jobData.tz;
+            }
+            if (jobData.pattern) {
+                jobSchedulerData.pattern = jobData.pattern;
+            }
+            if (jobData.every) {
+                jobSchedulerData.every = parseInt(jobData.every);
+            }
+            if (jobData.offset) {
+                jobSchedulerData.offset = parseInt(jobData.offset);
+            }
+            if (jobData.data || jobData.opts) {
+                jobSchedulerData.template = this.getTemplateFromJSON(jobData.data, jobData.opts);
+            }
+            return jobSchedulerData;
+        }
+        // TODO: remove this check and keyToData as it is here only to support legacy code
+        if (key.includes(':')) {
+            return this.keyToData(key, next);
         }
-        return this.keyToData(key, next);
     }
     keyToData(key, next) {
         const data = key.split(':');