@tachybase/plugin-adapter-bullmq 0.23.8

package/dist/node_modules/bullmq/dist/esm/interfaces/rate-limiter-options.d.ts

@@ -0,0 +1,12 @@
+export interface RateLimiterOptions {
+    /**
+     * Max number of jobs to process in the time period
+     * specified in `duration`.
+     */
+    max: number;
+    /**
+     * Time in milliseconds. During this time, a maximum
+     * of `max` jobs will be processed.
+     */
+    duration: number;
+}

package/dist/node_modules/bullmq/dist/esm/interfaces/rate-limiter-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rate-limiter-options.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/redis-options.d.ts

@@ -0,0 +1,8 @@
+import type * as IORedis from 'ioredis';
+export interface BaseOptions {
+    skipVersionCheck?: boolean;
+    url?: string;
+}
+export type RedisOptions = IORedis.RedisOptions & BaseOptions;
+export type ClusterOptions = IORedis.ClusterOptions & BaseOptions;
+export type ConnectionOptions = RedisOptions | ClusterOptions | IORedis.Redis | IORedis.Cluster;

package/dist/node_modules/bullmq/dist/esm/interfaces/redis-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redis-options.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/redis-streams.d.ts

@@ -0,0 +1,4 @@
+export type StreamName = string;
+export type EntryId = string;
+export type EntryRaw = [EntryId, string[]];
+export type StreamReadRaw = [StreamName, EntryRaw[]][] | null | undefined;

package/dist/node_modules/bullmq/dist/esm/interfaces/redis-streams.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=redis-streams.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/repeat-options.d.ts

@@ -0,0 +1,51 @@
+import { ParserOptions } from 'cron-parser';
+/**
+ * Settings for repeatable jobs
+ *
+ * @see {@link https://docs.bullmq.io/guide/jobs/repeatable}
+ */
+export interface RepeatOptions extends Omit<ParserOptions, 'iterator'> {
+    /**
+     * A repeat pattern
+     */
+    pattern?: string;
+    /**
+     * Custom repeatable key. This is the key that holds the "metadata"
+     * of a given repeatable job. This key is normally auto-generated but
+     * it is sometimes useful to specify a custom key for easier retrieval
+     * of repeatable jobs.
+     */
+    key?: string;
+    /**
+     * Number of times the job should repeat at max.
+     */
+    limit?: number;
+    /**
+     * Repeat after this amount of milliseconds
+     * (`pattern` setting cannot be used together with this setting.)
+     */
+    every?: number;
+    /**
+     * Repeated job should start right now
+     * ( work only with cron settings)
+     */
+    immediately?: boolean;
+    /**
+     * The start value for the repeat iteration count.
+     */
+    count?: number;
+    /**
+     * Offset in milliseconds to affect the next iteration time
+     *
+     * */
+    offset?: number;
+    /**
+     * Internal property to store the previous time the job was executed.
+     */
+    prevMillis?: number;
+    /**
+     * Internal property to store de job id
+     * @deprecated
+     */
+    jobId?: string;
+}

package/dist/node_modules/bullmq/dist/esm/interfaces/repeat-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repeat-options.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/repeatable-job.d.ts

@@ -0,0 +1,10 @@
+export type RepeatableJob = {
+    key: string;
+    name: string;
+    id?: string | null;
+    endDate: number | null;
+    tz: string | null;
+    pattern: string | null;
+    every?: string | null;
+    next?: number;
+};

package/dist/node_modules/bullmq/dist/esm/interfaces/repeatable-job.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repeatable-job.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/repeatable-options.d.ts

@@ -0,0 +1,7 @@
+export type RepeatableOptions = {
+    name: string;
+    endDate?: number;
+    tz?: string;
+    pattern?: string;
+    every?: number;
+};

package/dist/node_modules/bullmq/dist/esm/interfaces/repeatable-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=repeatable-options.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-job-processor.d.ts

@@ -0,0 +1,5 @@
+import { SandboxedJob } from './sandboxed-job';
+/**
+ * @see {@link https://docs.bullmq.io/guide/workers/sandboxed-processors}
+ */
+export type SandboxedJobProcessor<T = any, R = any> = ((job: SandboxedJob<T, R>) => R | PromiseLike<R>) | ((job: SandboxedJob<T, R>, callback: (error: unknown, result: R) => void) => void);

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-job-processor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sandboxed-job-processor.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-job.d.ts

@@ -0,0 +1,13 @@
+import { JobJsonSandbox, JobsOptions } from '../types';
+/**
+ * @see {@link https://docs.bullmq.io/guide/workers/sandboxed-processors}
+ */
+export interface SandboxedJob<T = any, R = any> extends Omit<JobJsonSandbox, 'data' | 'opts' | 'returnValue'> {
+    data: T;
+    opts: JobsOptions;
+    moveToDelayed: (timestamp: number, token?: string) => Promise<void>;
+    log: (row: any) => void;
+    updateData: (data: any) => Promise<void>;
+    updateProgress: (value: object | number) => Promise<void>;
+    returnValue: R;
+}

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-job.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sandboxed-job.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-options.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ForkOptions } from 'child_process';
+import { WorkerOptions as WorkerThreadsOptions } from 'worker_threads';
+export interface SandboxedOptions {
+    /**
+     * Use Worker Threads instead of Child Processes.
+     * Note: This option can only be used when specifying
+     * a file for the processor argument.
+     *
+     * @default false
+     */
+    useWorkerThreads?: boolean;
+    /**
+     * Support passing Worker Fork Options.
+     * Note: This option can only be used when specifying
+     * a file for the processor argument and useWorkerThreads is passed as false (default value).
+     * @see {@link https://nodejs.org/api/child_process.html#child_processforkmodulepath-args-options}
+     */
+    workerForkOptions?: ForkOptions;
+    /**
+     * Support passing Worker Threads Options.
+     * Note: This option can only be used when specifying
+     * a file for the processor argument and useWorkerThreads is passed as true.
+     * @see {@link https://nodejs.org/api/worker_threads.html#new-workerfilename-options}
+     */
+    workerThreadsOptions?: WorkerThreadsOptions;
+}

package/dist/node_modules/bullmq/dist/esm/interfaces/sandboxed-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sandboxed-options.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/telemetry.d.ts

@@ -0,0 +1,150 @@
+import { SpanKind } from '../enums';
+/**
+ * Telemetry interface
+ *
+ * This interface allows third-party libraries to integrate their own telemetry
+ * system. The interface is heavily inspired by OpenTelemetry but it's not
+ * limited to it.
+ *
+ */
+export interface Telemetry<Context = any> {
+    /**
+     * Tracer instance
+     *
+     * The tracer is responsible for creating spans and propagating the context
+     * across the application.
+     */
+    tracer: Tracer<Context>;
+    /**
+     * Context manager instance
+     *
+     * The context manager is responsible for managing the context and propagating
+     * it across the application.
+     */
+    contextManager: ContextManager;
+}
+/**
+ * Context manager interface
+ *
+ * The context manager is responsible for managing the context and propagating
+ * it across the application.
+ */
+export interface ContextManager<Context = any> {
+    /**
+     * Creates a new context and sets it as active for the fn passed as last argument
+     *
+     * @param context -
+     * @param fn -
+     */
+    with<A extends (...args: any[]) => any>(context: Context, fn: A): ReturnType<A>;
+    /**
+     * Returns the active context
+     */
+    active(): Context;
+    /**
+     * Returns a serialized version of the current context. The metadata
+     * is the mechanism used to propagate the context across a distributed
+     * application.
+     *
+     * @param context -
+     */
+    getMetadata(context: Context): string;
+    /**
+     * Creates a new context from a serialized version effectively
+     * linking the new context to the parent context.
+     *
+     * @param activeContext -
+     * @param metadata -
+     */
+    fromMetadata(activeContext: Context, metadata: string): Context;
+}
+/**
+ * Tracer interface
+ *
+ */
+export interface Tracer<Context = any> {
+    /**
+     * startSpan creates a new Span with the given name and options on an optional
+     * context. If the context is not provided, the current active context should be
+     * used.
+     *
+     * @param name -
+     * @param options -
+     * @param context -
+     */
+    startSpan(name: string, options?: SpanOptions, context?: Context): Span;
+}
+export interface SpanOptions {
+    kind: SpanKind;
+}
+/**
+ * Span interface
+ */
+export interface Span<Context = any> {
+    /**
+     * setSpanOnContext sets the span on the context. This is useful when you want
+     * to propagate the span across the application.
+     *
+     * @param ctx
+     */
+    setSpanOnContext(ctx: Context): Context;
+    /**
+     * setAttribute sets an attribute on the span.
+     *
+     * @param ctx
+     */
+    setAttribute(key: string, value: AttributeValue): void;
+    /**
+     * setAttributes sets multiple attributes on the span.
+     *
+     * @param attributes
+     */
+    setAttributes(attributes: Attributes): void;
+    /**
+     * addEvent adds an event to the span.
+     *
+     * @param name
+     * @param attributes
+     */
+    addEvent(name: string, attributes?: Attributes): void;
+    /**
+     * recordException records an exception on the span.
+     *
+     * @param exception
+     * @param time
+     */
+    recordException(exception: Exception, time?: Time): void;
+    /**
+     * end ends the span.
+     *
+     * Note: spans must be ended so that they can be exported.
+     */
+    end(): void;
+}
+export interface Attributes {
+    [attribute: string]: AttributeValue | undefined;
+}
+export type AttributeValue = string | number | boolean | Array<null | undefined | string> | Array<null | undefined | number> | Array<null | undefined | boolean>;
+export type Exception = string | ExceptionType;
+export type ExceptionType = CodeException | MessageException | NameException;
+interface CodeException {
+    code: string | number;
+    name?: string;
+    message?: string;
+    stack?: string;
+}
+interface MessageException {
+    code?: string | number;
+    name?: string;
+    message: string;
+    stack?: string;
+}
+interface NameException {
+    code?: string | number;
+    name: string;
+    message?: string;
+    stack?: string;
+}
+export type Time = HighResolutionTime | number | Date;
+type HighResolutionTime = [number, number];
+export {};

package/dist/node_modules/bullmq/dist/esm/interfaces/telemetry.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=telemetry.js.map

package/dist/node_modules/bullmq/dist/esm/interfaces/worker-options.d.ts

@@ -0,0 +1,133 @@
+import { Job } from '../classes/job';
+import { AdvancedOptions } from './advanced-options';
+import { QueueBaseOptions } from './queue-options';
+import { RateLimiterOptions } from './rate-limiter-options';
+import { MetricsOptions } from './metrics-options';
+import { KeepJobs } from './keep-jobs';
+import { Telemetry } from './telemetry';
+import { SandboxedOptions } from './sandboxed-options';
+/**
+ * An async function that receives `Job`s and handles them.
+ */
+export type Processor<T = any, R = any, N extends string = string> = (job: Job<T, R, N>, token?: string) => Promise<R>;
+export interface WorkerOptions extends QueueBaseOptions, SandboxedOptions {
+    /**
+     * Optional worker name. The name will be stored on every job
+     * processed by this worker instance, and can be used to monitor
+     * which worker is processing or has processed a given job.
+     */
+    name?: string;
+    /**
+     * Condition to start processor at instance creation.
+     *
+     * @default true
+     */
+    autorun?: boolean;
+    /**
+     * Amount of jobs that a single worker is allowed to work on
+     * in parallel.
+     *
+     * @default 1
+     * @see {@link https://docs.bullmq.io/guide/workers/concurrency}
+     */
+    concurrency?: number;
+    /**
+     * Enable rate limiter
+     * @see {@link https://docs.bullmq.io/guide/rate-limiting}
+     */
+    limiter?: RateLimiterOptions;
+    /**
+     * Enable collect metrics.
+     * @see {@link https://docs.bullmq.io/guide/metrics}
+     */
+    metrics?: MetricsOptions;
+    /**
+     * Amount of times a job can be recovered from a stalled state
+     * to the `wait` state. If this is exceeded, the job is moved
+     * to `failed`.
+     *
+     * @default 1
+     */
+    maxStalledCount?: number;
+    /**
+     * Number of milliseconds between stallness checks.
+     *
+     * @default 30000
+     */
+    stalledInterval?: number;
+    /**
+     * You can provide an object specifying max
+     * age and/or count to keep.
+     * Default behavior is to keep the job in the completed set.
+     */
+    removeOnComplete?: KeepJobs;
+    /**
+     * You can provide an object specifying max
+     * age and/or count to keep.
+     * Default behavior is to keep the job in the failed set.
+     */
+    removeOnFail?: KeepJobs;
+    /**
+     *  Skip stalled check for this worker. Note that other workers could still
+     *  perform stalled checkd and move jobs back to wait for jobs being processed
+     *  by this worker.
+     *
+     *  @default false
+     */
+    skipStalledCheck?: boolean;
+    /**
+     *  Skip lock renewal for this worker. If set to true, the lock will expire
+     *  after lockDuration and moved back to the wait queue (if the stalled check is
+     *  not disabled)
+     *
+     *  @default false
+     */
+    skipLockRenewal?: boolean;
+    /**
+     * Number of seconds to long poll for jobs when the queue is empty.
+     *
+     * @default 5
+     */
+    drainDelay?: number;
+    /**
+     * Duration of the lock for the job in milliseconds. The lock represents that
+     * a worker is processing the job. If the lock is lost, the job will be eventually
+     * be picked up by the stalled checker and move back to wait so that another worker
+     * can process it again.
+     *
+     * @default 30000
+     */
+    lockDuration?: number;
+    /**
+     * The time in milliseconds before the lock is automatically renewed.
+     *
+     * It is not recommended to modify this value, which is by default set to
+     * halv the lockDuration value, which is optimal for most use cases.
+     */
+    lockRenewTime?: number;
+    /**
+     * This is an internal option that should not be modified.
+     *
+     * @default 15000
+     */
+    runRetryDelay?: number;
+    /**
+     * More advanced options.
+     */
+    settings?: AdvancedOptions;
+    /**
+     * Use Worker Threads instead of Child Processes.
+     * Note: This option can only be used when specifying
+     * a file for the processor argument.
+     *
+     * @default false
+     */
+    useWorkerThreads?: boolean;
+    /**
+     * Telemetry Addon
+     */
+    telemetry?: Telemetry;
+}
+export interface GetNextJobOptions {
+    block?: boolean;
+}

package/dist/node_modules/bullmq/dist/esm/interfaces/worker-options.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-options.js.map

package/dist/node_modules/bullmq/dist/esm/scripts/addDelayedJob-6.d.ts

@@ -0,0 +1,5 @@
+export declare const addDelayedJob: {
+    name: string;
+    content: string;
+    keys: number;
+};