@tachybase/plugin-adapter-bullmq 0.23.8

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

@@ -0,0 +1,216 @@
+import { __rest } from "tslib";
+import { parseExpression } from 'cron-parser';
+import { Job } from './job';
+import { QueueBase } from './queue-base';
+import { SpanKind, TelemetryAttributes } from '../enums';
+import { array2obj } from '../utils';
+export class JobScheduler extends QueueBase {
+    constructor(name, opts, Connection) {
+        super(name, opts, Connection);
+        this.repeatStrategy =
+            (opts.settings && opts.settings.repeatStrategy) || 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 = __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.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(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({
+                    [TelemetryAttributes.JobSchedulerId]: jobSchedulerId,
+                    [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 ? array2obj(rawJobData) : null, next ? parseInt(next) : null);
+    }
+    getTemplateFromJSON(rawData, rawOpts) {
+        const template = {};
+        if (rawData) {
+            template.data = JSON.parse(rawData);
+        }
+        if (rawOpts) {
+            template.opts = 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}`;
+    }
+}
+export const defaultRepeatStrategy = (millis, opts) => {
+    const { pattern } = opts;
+    const currentDate = new Date(millis);
+    const interval = 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
+    }
+};
+//# sourceMappingURL=job-scheduler.js.map

package/dist/node_modules/bullmq/dist/esm/classes/job.d.ts

@@ -0,0 +1,425 @@
+import { BulkJobOptions, DependenciesOpts, JobJson, JobJsonRaw, MinimalJob, MoveToWaitingChildrenOpts, ParentKeys, ParentOpts, RedisClient } from '../interfaces';
+import { FinishedStatus, JobsOptions, JobState, JobJsonSandbox, MinimalQueue, RedisJobOptions } from '../types';
+import { Scripts } from './scripts';
+import type { QueueEvents } from './queue-events';
+export declare const PRIORITY_LIMIT: number;
+/**
+ * Job
+ *
+ * This class represents a Job in the queue. Normally job are implicitly created when
+ * you add a job to the queue with methods such as Queue.addJob( ... )
+ *
+ * A Job instance is also passed to the Worker's process function.
+ *
+ * @class Job
+ */
+export declare class Job<DataType = any, ReturnType = any, NameType extends string = string> implements MinimalJob<DataType, ReturnType, NameType> {
+    protected queue: MinimalQueue;
+    /**
+     * The name of the Job
+     */
+    name: NameType;
+    /**
+     * The payload for this job.
+     */
+    data: DataType;
+    /**
+     * The options object for this job.
+     */
+    opts: JobsOptions;
+    id?: string;
+    /**
+     * It includes the prefix, the namespace separator :, and queue name.
+     * @see https://www.gnu.org/software/gawk/manual/html_node/Qualified-Names.html
+     */
+    readonly queueQualifiedName: string;
+    /**
+     * The progress a job has performed so far.
+     * @defaultValue 0
+     */
+    progress: number | object;
+    /**
+     * The value returned by the processor when processing this job.
+     * @defaultValue null
+     */
+    returnvalue: ReturnType;
+    /**
+     * Stacktrace for the error (for failed jobs).
+     * @defaultValue null
+     */
+    stacktrace: string[];
+    /**
+     * An amount of milliseconds to wait until this job can be processed.
+     * @defaultValue 0
+     */
+    delay: number;
+    /**
+     * Ranges from 0 (highest priority) to 2 097 152 (lowest priority). Note that
+     * using priorities has a slight impact on performance,
+     * so do not use it if not required.
+     * @defaultValue 0
+     */
+    priority: number;
+    /**
+     * Timestamp when the job was created (unless overridden with job options).
+     */
+    timestamp: number;
+    /**
+     * Number of attempts when job is moved to active.
+     * @defaultValue 0
+     */
+    attemptsStarted: number;
+    /**
+     * Number of attempts after the job has failed.
+     * @defaultValue 0
+     */
+    attemptsMade: number;
+    /**
+     * Reason for failing.
+     */
+    failedReason: string;
+    /**
+     * Timestamp for when the job finished (completed or failed).
+     */
+    finishedOn?: number;
+    /**
+     * Timestamp for when the job was processed.
+     */
+    processedOn?: number;
+    /**
+     * Fully qualified key (including the queue prefix) pointing to the parent of this job.
+     */
+    parentKey?: string;
+    /**
+     * Object that contains parentId (id) and parent queueKey.
+     */
+    parent?: ParentKeys;
+    /**
+     * Debounce identifier.
+     * @deprecated use deduplicationId
+     */
+    debounceId?: string;
+    /**
+     * Deduplication identifier.
+     */
+    deduplicationId?: string;
+    /**
+     * Base repeat job key.
+     */
+    repeatJobKey?: string;
+    /**
+     * Produced next repetable job Id.
+     *
+     */
+    nextRepeatableJobId?: string;
+    /**
+     * The token used for locking this job.
+     */
+    token?: string;
+    /**
+     * The worker name that is processing or processed this job.
+     */
+    processedBy?: string;
+    protected toKey: (type: string) => string;
+    protected discarded: boolean;
+    protected scripts: Scripts;
+    constructor(queue: MinimalQueue, 
+    /**
+     * The name of the Job
+     */
+    name: NameType, 
+    /**
+     * The payload for this job.
+     */
+    data: DataType, 
+    /**
+     * The options object for this job.
+     */
+    opts?: JobsOptions, id?: string);
+    /**
+     * Creates a new job and adds it to the queue.
+     *
+     * @param queue - the queue where to add the job.
+     * @param name - the name of the job.
+     * @param data - the payload of the job.
+     * @param opts - the options bag for this job.
+     * @returns
+     */
+    static create<T = any, R = any, N extends string = string>(queue: MinimalQueue, name: N, data: T, opts?: JobsOptions): Promise<Job<T, R, N>>;
+    /**
+     * Creates a bulk of jobs and adds them atomically to the given queue.
+     *
+     * @param queue -the queue were to add the jobs.
+     * @param jobs - an array of jobs to be added to the queue.
+     * @returns
+     */
+    static createBulk<T = any, R = any, N extends string = string>(queue: MinimalQueue, jobs: {
+        name: N;
+        data: T;
+        opts?: BulkJobOptions;
+    }[]): Promise<Job<T, R, N>[]>;
+    /**
+     * Instantiates a Job from a JobJsonRaw object (coming from a deserialized JSON object)
+     *
+     * @param queue - the queue where the job belongs to.
+     * @param json - the plain object containing the job.
+     * @param jobId - an optional job id (overrides the id coming from the JSON object)
+     * @returns
+     */
+    static fromJSON<T = any, R = any, N extends string = string>(queue: MinimalQueue, json: JobJsonRaw, jobId?: string): Job<T, R, N>;
+    protected setScripts(): void;
+    static optsFromJSON(rawOpts?: string): JobsOptions;
+    /**
+     * Fetches a Job from the queue given the passed job id.
+     *
+     * @param queue - the queue where the job belongs to.
+     * @param jobId - the job id.
+     * @returns
+     */
+    static fromId<T = any, R = any, N extends string = string>(queue: MinimalQueue, jobId: string): Promise<Job<T, R, N> | undefined>;
+    /**
+     * addJobLog
+     *
+     * @param queue Queue instance
+     * @param jobId Job id
+     * @param logRow Log row
+     * @param keepLogs optional maximum number of logs to keep
+     *
+     * @returns The total number of log entries for this job so far.
+     */
+    static addJobLog(queue: MinimalQueue, jobId: string, logRow: string, keepLogs?: number): Promise<number>;
+    toJSON(): Omit<this, "toJSON" | "scripts" | "changeDelay" | "changePriority" | "extendLock" | "getState" | "moveToDelayed" | "moveToWaitingChildren" | "promote" | "removeChildDependency" | "updateData" | "updateProgress" | "discard" | "addJob" | "prefix" | "queue" | "asJSON" | "asJSONSandbox" | "log" | "clearLogs" | "remove" | "moveToCompleted" | "moveToFailed" | "isCompleted" | "isFailed" | "isDelayed" | "isWaitingChildren" | "isActive" | "isWaiting" | "queueName" | "getChildrenValues" | "getFailedChildrenValues" | "getDependencies" | "getDependenciesCount" | "waitUntilFinished" | "retry">;
+    /**
+     * Prepares a job to be serialized for storage in Redis.
+     * @returns
+     */
+    asJSON(): JobJson;
+    static optsAsJSON(opts?: JobsOptions): RedisJobOptions;
+    /**
+     * Prepares a job to be passed to Sandbox.
+     * @returns
+     */
+    asJSONSandbox(): JobJsonSandbox;
+    /**
+     * Updates a job's data
+     *
+     * @param data - the data that will replace the current jobs data.
+     */
+    updateData(data: DataType): Promise<void>;
+    /**
+     * Updates a job's progress
+     *
+     * @param progress - number or object to be saved as progress.
+     */
+    updateProgress(progress: number | object): Promise<void>;
+    /**
+     * Logs one row of log data.
+     *
+     * @param logRow - string with log data to be logged.
+     * @returns The total number of log entries for this job so far.
+     */
+    log(logRow: string): Promise<number>;
+    /**
+     * Removes child dependency from parent when child is not yet finished
+     *
+     * @returns True if the relationship existed and if it was removed.
+     */
+    removeChildDependency(): Promise<boolean>;
+    /**
+     * Clears job's logs
+     *
+     * @param keepLogs - the amount of log entries to preserve
+     */
+    clearLogs(keepLogs?: number): Promise<void>;
+    /**
+     * Completely remove the job from the queue.
+     * Note, this call will throw an exception if the job
+     * is being processed when the call is performed.
+     *
+     * @param opts - Options to remove a job
+     */
+    remove({ removeChildren }?: {
+        removeChildren?: boolean;
+    }): Promise<void>;
+    /**
+     * Extend the lock for this job.
+     *
+     * @param token - unique token for the lock
+     * @param duration - lock duration in milliseconds
+     */
+    extendLock(token: string, duration: number): Promise<number>;
+    /**
+     * Moves a job to the completed queue.
+     * Returned job to be used with Queue.prototype.nextJobFromJobData.
+     *
+     * @param returnValue - The jobs success message.
+     * @param token - Worker token used to acquire completed job.
+     * @param fetchNext - True when wanting to fetch the next job.
+     * @returns Returns the jobData of the next job in the waiting queue or void.
+     */
+    moveToCompleted(returnValue: ReturnType, token: string, fetchNext?: boolean): Promise<void | any[]>;
+    private shouldRetryJob;
+    /**
+     * Moves a job to the failed queue.
+     *
+     * @param err - the jobs error message.
+     * @param token - token to check job is locked by current worker
+     * @param fetchNext - true when wanting to fetch the next job
+     * @returns Returns the jobData of the next job in the waiting queue or void.
+     */
+    moveToFailed<E extends Error>(err: E, token: string, fetchNext?: boolean): Promise<void | any[]>;
+    private getSpanOperation;
+    /**
+     * @returns true if the job has completed.
+     */
+    isCompleted(): Promise<boolean>;
+    /**
+     * @returns true if the job has failed.
+     */
+    isFailed(): Promise<boolean>;
+    /**
+     * @returns true if the job is delayed.
+     */
+    isDelayed(): Promise<boolean>;
+    /**
+     * @returns true if the job is waiting for children.
+     */
+    isWaitingChildren(): Promise<boolean>;
+    /**
+     * @returns true of the job is active.
+     */
+    isActive(): Promise<boolean>;
+    /**
+     * @returns true if the job is waiting.
+     */
+    isWaiting(): Promise<boolean>;
+    /**
+     * @returns the queue name this job belongs to.
+     */
+    get queueName(): string;
+    /**
+     * @returns the prefix that is used.
+     */
+    get prefix(): string;
+    /**
+     * Get current state.
+     *
+     * @returns Returns one of these values:
+     * 'completed', 'failed', 'delayed', 'active', 'waiting', 'waiting-children', 'unknown'.
+     */
+    getState(): Promise<JobState | 'unknown'>;
+    /**
+     * Change delay of a delayed job.
+     *
+     * @param delay - milliseconds to be added to current time.
+     * @returns void
+     */
+    changeDelay(delay: number): Promise<void>;
+    /**
+     * Change job priority.
+     *
+     * @param opts - options containing priority and lifo values.
+     * @returns void
+     */
+    changePriority(opts: {
+        priority?: number;
+        lifo?: boolean;
+    }): Promise<void>;
+    /**
+     * Get this jobs children result values if any.
+     *
+     * @returns Object mapping children job keys with their values.
+     */
+    getChildrenValues<CT = any>(): Promise<{
+        [jobKey: string]: CT;
+    }>;
+    /**
+     * Get this jobs children failure values if any.
+     *
+     * @returns Object mapping children job keys with their failure values.
+     */
+    getFailedChildrenValues(): Promise<{
+        [jobKey: string]: string;
+    }>;
+    /**
+     * Get children job keys if this job is a parent and has children.
+     * @remarks
+     * Count options before Redis v7.2 works as expected with any quantity of entries
+     * on processed/unprocessed dependencies, since v7.2 you must consider that count
+     * won't have any effect until processed/unprocessed dependencies have a length
+     * greater than 127
+     * @see https://redis.io/docs/management/optimization/memory-optimization/#redis--72
+     * @returns dependencies separated by processed and unprocessed.
+     */
+    getDependencies(opts?: DependenciesOpts): Promise<{
+        nextProcessedCursor?: number;
+        processed?: Record<string, any>;
+        nextUnprocessedCursor?: number;
+        unprocessed?: string[];
+    }>;
+    /**
+     * Get children job counts if this job is a parent and has children.
+     *
+     * @returns dependencies count separated by processed and unprocessed.
+     */
+    getDependenciesCount(opts?: {
+        processed?: boolean;
+        unprocessed?: boolean;
+    }): Promise<{
+        processed?: number;
+        unprocessed?: number;
+    }>;
+    /**
+     * Returns a promise the resolves when the job has completed (containing the return value of the job),
+     * or rejects when the job has failed (containing the failedReason).
+     *
+     * @param queueEvents - Instance of QueueEvents.
+     * @param ttl - Time in milliseconds to wait for job to finish before timing out.
+     */
+    waitUntilFinished(queueEvents: QueueEvents, ttl?: number): Promise<ReturnType>;
+    /**
+     * Moves the job to the delay set.
+     *
+     * @param timestamp - timestamp when the job should be moved back to "wait"
+     * @param token - token to check job is locked by current worker
+     * @returns
+     */
+    moveToDelayed(timestamp: number, token?: string): Promise<void>;
+    /**
+     * Moves the job to the waiting-children set.
+     *
+     * @param token - Token to check job is locked by current worker
+     * @param opts - The options bag for moving a job to waiting-children.
+     * @returns true if the job was moved
+     */
+    moveToWaitingChildren(token: string, opts?: MoveToWaitingChildrenOpts): Promise<boolean>;
+    /**
+     * Promotes a delayed job so that it starts to be processed as soon as possible.
+     */
+    promote(): Promise<void>;
+    /**
+     * Attempts to retry the job. Only a job that has failed or completed can be retried.
+     *
+     * @param state - completed / failed
+     * @returns If resolved and return code is 1, then the queue emits a waiting event
+     * otherwise the operation was not a success and throw the corresponding error. If the promise
+     * rejects, it indicates that the script failed to execute
+     */
+    retry(state?: FinishedStatus): Promise<void>;
+    /**
+     * Marks a job to not be retried if it fails (even if attempts has been configured)
+     */
+    discard(): void;
+    private isInZSet;
+    private isInList;
+    /**
+     * Adds the job to Redis.
+     *
+     * @param client -
+     * @param parentOpts -
+     * @returns
+     */
+    addJob(client: RedisClient, parentOpts?: ParentOpts): Promise<string>;
+    protected validateOptions(jobData: JobJson): void;
+    protected updateStacktrace(err: Error): void;
+}