sidekiq-ts 1.0.0

package/dist/iterable.js

@@ -0,0 +1,298 @@
+import { ITERATION_STATE_FLUSH_INTERVAL_SECONDS, ITERATION_STATE_TTL_SECONDS, } from "./iterable-constants.js";
+import { IterableAbort, IterableInterrupted } from "./iterable-errors.js";
+import { Job } from "./job.js";
+import { dumpJson, loadJson } from "./json.js";
+import { Sidekiq } from "./sidekiq.js";
+const freezeValue = (value) => {
+    if (value && typeof value === "object") {
+        return Object.freeze(value);
+    }
+    return value;
+};
+export class IterableJob extends Job {
+    executions = 0;
+    cursorValue = null;
+    startTime = 0;
+    runtimeSeconds = 0;
+    argsValue = null;
+    cancelledValue = null;
+    currentObjectValue = null;
+    static abort() {
+        throw new IterableAbort();
+    }
+    get currentObject() {
+        return this.currentObjectValue;
+    }
+    arguments() {
+        return this.argsValue;
+    }
+    cursor() {
+        return freezeValue(this.cursorValue);
+    }
+    async cancel() {
+        if (await this.isCancelled()) {
+            return true;
+        }
+        if (!this.jid) {
+            return false;
+        }
+        const redis = await Sidekiq.defaultConfiguration.getRedisClient();
+        const key = this.iterationKey();
+        const now = Math.floor(Date.now() / 1000);
+        const pipeline = redis.multi();
+        pipeline.hSetNX(key, "cancelled", String(now));
+        pipeline.hGet(key, "cancelled");
+        pipeline.expire(key, ITERATION_STATE_TTL_SECONDS, "NX");
+        const result = await pipeline.exec();
+        const cancelled = result?.[1] ?? null;
+        this.cancelledValue = cancelled ? Number(cancelled) : null;
+        return Boolean(this.cancelledValue);
+    }
+    cancelled() {
+        return Boolean(this.cancelledValue);
+    }
+    // biome-ignore lint/suspicious/useAwait: lifecycle hook may be overridden with async implementation
+    async onStart() {
+        return undefined;
+    }
+    // biome-ignore lint/suspicious/useAwait: lifecycle hook may be overridden with async implementation
+    async onResume() {
+        return undefined;
+    }
+    // biome-ignore lint/suspicious/useAwait: lifecycle hook may be overridden with async implementation
+    async onStop() {
+        return undefined;
+    }
+    // biome-ignore lint/suspicious/useAwait: lifecycle hook may be overridden with async implementation
+    async onCancel() {
+        return undefined;
+    }
+    // biome-ignore lint/suspicious/useAwait: lifecycle hook may be overridden with async implementation
+    async onComplete() {
+        return undefined;
+    }
+    async aroundIteration(fn) {
+        await fn();
+    }
+    buildEnumerator(..._args) {
+        throw new Error(`${this.constructor.name} must implement a 'buildEnumerator' method`);
+    }
+    eachIteration(_item, ..._args) {
+        throw new Error(`${this.constructor.name} must implement an 'eachIteration' method`);
+    }
+    arrayEnumerator(array, cursor) {
+        if (!Array.isArray(array)) {
+            throw new Error("array must be an Array");
+        }
+        let index = cursor ?? 0;
+        const iterator = {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next() {
+                if (index >= array.length) {
+                    return { done: true, value: undefined };
+                }
+                const value = array[index];
+                const cursor = index;
+                index += 1;
+                return { done: false, value: [value, cursor] };
+            },
+        };
+        return iterator;
+    }
+    iterationKey() {
+        return `it-${this.jid ?? ""}`;
+    }
+    async perform(...args) {
+        this.argsValue = Object.freeze([...args]);
+        await this.fetchPreviousIterationState();
+        this.executions += 1;
+        this.startTime = this.monoNow();
+        const enumerator = this.buildEnumerator(...args, {
+            cursor: this.cursorValue,
+        });
+        if (!enumerator) {
+            this.logger().info(() => "'buildEnumerator' returned nil, skipping the job.");
+            return;
+        }
+        const iterator = this.assertEnumerator(enumerator);
+        if (this.executions === 1) {
+            await this.onStart();
+        }
+        else {
+            await this.onResume();
+        }
+        let completed = null;
+        try {
+            completed = await this.iterateWithEnumerator(iterator, args);
+        }
+        catch (error) {
+            if (error instanceof IterableAbort) {
+                completed = null;
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            await this.onStop();
+        }
+        const finished = this.handleCompleted(completed);
+        if (finished) {
+            await this.onComplete();
+            await this.cleanup();
+        }
+        else {
+            await this.reenqueueIterationJob();
+        }
+    }
+    async isCancelled() {
+        if (!this.jid) {
+            return false;
+        }
+        const redis = await Sidekiq.defaultConfiguration.getRedisClient();
+        const cancelled = await redis.hGet(this.iterationKey(), "cancelled");
+        this.cancelledValue = cancelled ? Number(cancelled) : null;
+        return Boolean(this.cancelledValue);
+    }
+    async fetchPreviousIterationState() {
+        if (!this.jid) {
+            return;
+        }
+        const redis = await Sidekiq.defaultConfiguration.getRedisClient();
+        const state = await redis.hGetAll(this.iterationKey());
+        if (Object.keys(state).length === 0) {
+            return;
+        }
+        this.executions = Number(state.ex ?? 0);
+        this.cursorValue = state.c ? loadJson(state.c) : null;
+        this.runtimeSeconds = Number(state.rt ?? 0);
+    }
+    async iterateWithEnumerator(iterator, args) {
+        if (await this.isCancelled()) {
+            await this.onCancel();
+            this.logger().info(() => "Job cancelled");
+            return true;
+        }
+        const timeLimit = Sidekiq.defaultConfiguration.timeout;
+        let foundRecord = false;
+        let stateFlushedAt = this.monoNow();
+        try {
+            for (let next = iterator.next(); !next.done; next = iterator.next()) {
+                const [object, cursor] = next.value;
+                foundRecord = true;
+                this.cursorValue = cursor;
+                this.currentObjectValue = object;
+                const interruptJob = this.interrupted() || this.shouldInterrupt();
+                if (this.monoNow() - stateFlushedAt >=
+                    ITERATION_STATE_FLUSH_INTERVAL_SECONDS ||
+                    interruptJob) {
+                    const cancelled = await this.flushState();
+                    stateFlushedAt = this.monoNow();
+                    if (cancelled) {
+                        this.cancelledValue = cancelled;
+                        await this.onCancel();
+                        this.logger().info(() => "Job cancelled");
+                        return true;
+                    }
+                }
+                if (interruptJob) {
+                    return false;
+                }
+                await this.verifyIterationTime(timeLimit, async () => {
+                    await this.aroundIteration(async () => {
+                        try {
+                            await this.eachIteration(object, ...args);
+                        }
+                        catch (error) {
+                            await this.flushState();
+                            throw error;
+                        }
+                    });
+                });
+            }
+            if (!foundRecord) {
+                this.logger().debug("Enumerator found nothing to iterate!");
+            }
+            return true;
+        }
+        finally {
+            this.runtimeSeconds += this.monoNow() - this.startTime;
+        }
+    }
+    async verifyIterationTime(timeLimitSeconds, fn) {
+        const start = this.monoNow();
+        await fn();
+        const total = this.monoNow() - start;
+        if (timeLimitSeconds > 0 && total > timeLimitSeconds) {
+            this.logger().warn(() => `Iteration took longer (${total.toFixed(2)}) than Sidekiq's shutdown timeout (${timeLimitSeconds}).`);
+        }
+    }
+    async reenqueueIterationJob() {
+        await this.flushState();
+        this.logger().debug(() => `Interrupting job (cursor=${String(this.cursorValue)})`);
+        throw new IterableInterrupted();
+    }
+    assertEnumerator(source) {
+        if (Array.isArray(source)) {
+            throw new Error(`buildEnumerator must return an Iterator, but returned ${source.constructor.name}.`);
+        }
+        if (typeof source.next ===
+            "function") {
+            return source;
+        }
+        const iterable = source;
+        if (iterable && typeof iterable[Symbol.iterator] === "function") {
+            return iterable[Symbol.iterator]();
+        }
+        const typeName = source && typeof source === "object"
+            ? (source.constructor?.name ??
+                "Object")
+            : typeof source;
+        throw new Error(`buildEnumerator must return an Iterator, but returned ${typeName}.`);
+    }
+    shouldInterrupt() {
+        const maxRuntime = Sidekiq.defaultConfiguration.maxIterationRuntime;
+        return Boolean(maxRuntime && this.monoNow() - this.startTime > maxRuntime);
+    }
+    async flushState() {
+        if (!this.jid) {
+            return null;
+        }
+        const redis = await Sidekiq.defaultConfiguration.getRedisClient();
+        const key = this.iterationKey();
+        const state = {
+            ex: String(this.executions),
+            c: dumpJson(this.cursorValue),
+            rt: String(this.runtimeSeconds),
+        };
+        const pipeline = redis.multi();
+        pipeline.hSet(key, state);
+        pipeline.expire(key, ITERATION_STATE_TTL_SECONDS, "NX");
+        pipeline.hGet(key, "cancelled");
+        const result = await pipeline.exec();
+        const cancelled = result?.[2] ?? null;
+        return cancelled ? Number(cancelled) : null;
+    }
+    async cleanup() {
+        this.logger().debug(() => `Completed iteration. executions=${this.executions} runtime=${this.runtimeSeconds.toFixed(3)}`);
+        if (!this.jid) {
+            return;
+        }
+        const redis = await Sidekiq.defaultConfiguration.getRedisClient();
+        await redis.unlink(this.iterationKey());
+    }
+    handleCompleted(completed) {
+        if (completed === null || completed === true) {
+            return true;
+        }
+        if (completed === false) {
+            return false;
+        }
+        throw new Error(`Unexpected completion value: ${String(completed)}`);
+    }
+    monoNow() {
+        return Number(process.hrtime.bigint()) / 1_000_000_000;
+    }
+}

package/dist/job-logger.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from "./config.js";
+import type { JobLogger, JobPayload } from "./types.js";
+export declare class DefaultJobLogger implements JobLogger {
+    private readonly config;
+    private readonly skip;
+    constructor(config: Config);
+    prepare<T>(payload: JobPayload, fn: () => Promise<T> | T): Promise<T>;
+    call<T>(payload: JobPayload, queue: string, fn: () => Promise<T> | T): Promise<T>;
+    private log;
+    private resolveLevel;
+}
+//# sourceMappingURL=job-logger.d.ts.map

package/dist/job-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-logger.d.ts","sourceRoot":"","sources":["../src/job-logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExD,qBAAa,gBAAiB,YAAW,SAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;gBAEnB,MAAM,EAAE,MAAM;IAKpB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAiBrE,IAAI,CAAC,CAAC,EACV,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GACvB,OAAO,CAAC,CAAC,CAAC;IAcb,OAAO,CAAC,GAAG;IAqBX,OAAO,CAAC,YAAY;CAerB"}

package/dist/job-logger.js

@@ -0,0 +1,64 @@
+import { Context } from "./context.js";
+export class DefaultJobLogger {
+    config;
+    skip;
+    constructor(config) {
+        this.config = config;
+        this.skip = Boolean(this.config.skipDefaultJobLogging);
+    }
+    async prepare(payload, fn) {
+        const klass = payload.wrapped ?? payload.class;
+        const context = {
+            jid: payload.jid,
+            class: typeof klass === "string" ? klass : String(klass),
+        };
+        for (const attr of this.config.loggedJobAttributes) {
+            const value = payload[attr];
+            if (value !== undefined) {
+                context[attr] = value;
+            }
+        }
+        return await Context.with(context, fn);
+    }
+    async call(payload, queue, fn) {
+        const start = process.hrtime.bigint();
+        Context.add("queue", queue);
+        this.log("info", payload, queue, "start");
+        try {
+            const result = await fn();
+            this.log("info", payload, queue, "done", start);
+            return result;
+        }
+        catch (error) {
+            this.log("warn", payload, queue, "fail", start);
+            throw error;
+        }
+    }
+    log(fallbackLevel, payload, _queue, phase, start) {
+        if (this.skip) {
+            return;
+        }
+        const elapsed = start
+            ? Number((process.hrtime.bigint() - start) / 1000000n) / 1000
+            : null;
+        const level = this.resolveLevel(payload.log_level) ?? fallbackLevel;
+        const logger = this.config.logger;
+        if (elapsed !== null) {
+            Context.add("elapsed", Number(elapsed.toFixed(3)));
+        }
+        logger[level](() => phase);
+    }
+    resolveLevel(level) {
+        if (!level) {
+            return null;
+        }
+        const normalized = level.toLowerCase();
+        if (normalized === "debug" ||
+            normalized === "info" ||
+            normalized === "warn" ||
+            normalized === "error") {
+            return normalized;
+        }
+        return null;
+    }
+}

package/dist/job-util.d.ts

@@ -0,0 +1,8 @@
+import type { JobOptions, JobPayload, StrictArgsMode } from "./types.js";
+export declare const TRANSIENT_ATTRIBUTES: string[];
+export declare const nowInMillis: () => number;
+export declare const generateJid: () => string;
+export declare const validateItem: (item: JobPayload) => void;
+export declare const normalizeItem: (item: JobPayload, defaultOptions: JobOptions) => JobPayload;
+export declare const verifyJson: (args: unknown[], mode: StrictArgsMode) => void;
+//# sourceMappingURL=job-util.d.ts.map

package/dist/job-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-util.d.ts","sourceRoot":"","sources":["../src/job-util.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,UAAU,EACV,UAAU,EACV,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,oBAAoB,EAAE,MAAM,EAAO,CAAC;AAIjD,eAAO,MAAM,WAAW,QAAO,MAAoB,CAAC;AAEpD,eAAO,MAAM,WAAW,QAAO,MAAyC,CAAC;AAiBzE,eAAO,MAAM,YAAY,GAAI,MAAM,UAAU,KAAG,IAmC/C,CAAC;AAeF,eAAO,MAAM,aAAa,GACxB,MAAM,UAAU,EAChB,gBAAgB,UAAU,KACzB,UA2CF,CAAC;AAyDF,eAAO,MAAM,UAAU,GAAI,MAAM,OAAO,EAAE,EAAE,MAAM,cAAc,KAAG,IAgBlE,CAAC"}

package/dist/job-util.js

@@ -0,0 +1,158 @@
+import { randomBytes } from "node:crypto";
+import { registerJob } from "./registry.js";
+export const TRANSIENT_ATTRIBUTES = [];
+const MAX_RETRY_FOR_SECONDS = 1_000_000_000;
+export const nowInMillis = () => Date.now();
+export const generateJid = () => randomBytes(12).toString("hex");
+const className = (klass) => {
+    if (typeof klass === "string") {
+        return klass;
+    }
+    const name = klass?.name;
+    if (!name) {
+        throw new Error("Job class must have a name");
+    }
+    return name;
+};
+const isJobClassLike = (value) => typeof value === "function" ||
+    (typeof value === "object" && value !== null && "name" in value);
+export const validateItem = (item) => {
+    if (!item || typeof item !== "object") {
+        throw new Error(`Job must be an object with 'class' and 'args' keys: ${item}`);
+    }
+    if (!("class" in item && "args" in item)) {
+        throw new Error(`Job must include 'class' and 'args': ${JSON.stringify(item)}`);
+    }
+    if (!Array.isArray(item.args)) {
+        throw new Error(`Job args must be an Array: ${JSON.stringify(item)}`);
+    }
+    if (!isJobClassLike(item.class) && typeof item.class !== "string") {
+        throw new Error(`Job class must be a class or string name: ${JSON.stringify(item)}`);
+    }
+    if (item.at !== undefined && typeof item.at !== "number") {
+        throw new Error(`Job 'at' must be a number timestamp: ${JSON.stringify(item)}`);
+    }
+    if (item.tags && !Array.isArray(item.tags)) {
+        throw new Error(`Job tags must be an Array: ${JSON.stringify(item)}`);
+    }
+    if (typeof item.retry_for === "number" &&
+        item.retry_for > MAX_RETRY_FOR_SECONDS) {
+        throw new Error(`retry_for must be a relative amount of time: ${JSON.stringify(item)}`);
+    }
+};
+const normalizedHash = (itemClass, defaultOptions) => {
+    if (typeof itemClass === "function") {
+        const klass = itemClass;
+        if (klass.getSidekiqOptions) {
+            return klass.getSidekiqOptions();
+        }
+    }
+    return defaultOptions;
+};
+export const normalizeItem = (item, defaultOptions) => {
+    validateItem(item);
+    let defaults = normalizedHash(item.class, defaultOptions);
+    if (item.wrapped && typeof item.wrapped !== "string") {
+        const wrapped = item.wrapped;
+        if (wrapped.getSidekiqOptions) {
+            defaults = {
+                ...defaults,
+                ...wrapped.getSidekiqOptions(),
+            };
+        }
+        else {
+            // fall through without overriding defaults
+        }
+    }
+    const merged = {
+        ...defaults,
+        ...item,
+    };
+    if (!merged.queue || merged.queue === "") {
+        throw new Error("Job must include a valid queue name");
+    }
+    for (const key of TRANSIENT_ATTRIBUTES) {
+        merged[key] = undefined;
+    }
+    merged.jid = merged.jid ?? generateJid();
+    if (typeof merged.class === "function") {
+        registerJob(merged.class);
+    }
+    merged.class = className(merged.class);
+    if (merged.wrapped) {
+        merged.wrapped = className(merged.wrapped);
+    }
+    merged.queue = String(merged.queue);
+    if (typeof merged.retry_for === "number") {
+        merged.retry_for = Math.trunc(merged.retry_for);
+    }
+    merged.created_at = merged.created_at ?? nowInMillis();
+    return merged;
+};
+const isPlainObject = (value) => {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+};
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: type checking for JSON requires many cases
+const jsonUnsafe = (value) => {
+    if (value === null) {
+        return null;
+    }
+    const valueType = typeof value;
+    if (valueType === "string" || valueType === "boolean") {
+        return null;
+    }
+    if (valueType === "number") {
+        return Number.isFinite(value) ? null : value;
+    }
+    if (valueType === "undefined" ||
+        valueType === "bigint" ||
+        valueType === "symbol") {
+        return value;
+    }
+    if (valueType === "function") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const unsafe = jsonUnsafe(entry);
+            if (unsafe !== null) {
+                return unsafe;
+            }
+        }
+        return null;
+    }
+    if (isPlainObject(value)) {
+        const keys = Reflect.ownKeys(value);
+        for (const key of keys) {
+            if (typeof key !== "string") {
+                return key;
+            }
+            const unsafe = jsonUnsafe(value[key]);
+            if (unsafe !== null) {
+                return unsafe;
+            }
+        }
+        return null;
+    }
+    return value;
+};
+export const verifyJson = (args, mode) => {
+    if (mode === "none") {
+        return;
+    }
+    const unsafe = jsonUnsafe(args);
+    if (unsafe === null) {
+        return;
+    }
+    const message = "Job arguments must be native JSON types, " +
+        `but ${String(unsafe)} is a ${typeof unsafe}. ` +
+        "See https://github.com/sidekiq/sidekiq/wiki/Best-Practices";
+    if (mode === "raise") {
+        throw new Error(message);
+    }
+    console.warn(message);
+};

package/dist/job.d.ts

@@ -0,0 +1,73 @@
+import type { BulkOptions, JobOptions, JobPayload, JobSetterOptions } from "./types.js";
+export type JobConstructor<TArgs extends unknown[] = unknown[]> = {
+    new (): Job<TArgs>;
+    name: string;
+    sidekiqOptions?: JobOptions;
+    sidekiqRetryIn?: RetryInHandler;
+    sidekiqRetriesExhausted?: RetriesExhaustedHandler;
+    getSidekiqOptions(): JobOptions;
+    setSidekiqOptions(options: JobOptions): void;
+    queueAs(queue: string): void;
+    retryIn(handler: RetryInHandler): void;
+    retriesExhausted(handler: RetriesExhaustedHandler): void;
+    set(options: JobSetterOptions): JobSetter<TArgs>;
+    performAsync(...args: TArgs): Promise<string | null>;
+    performIn(interval: number, ...args: TArgs): Promise<string | null>;
+    performAt(timestamp: number, ...args: TArgs): Promise<string | null>;
+    performBulk(args: TArgs[], options?: BulkOptions): Promise<(string | null)[]>;
+    performInline(...args: TArgs): Promise<boolean | null>;
+    jobs(): JobPayload[];
+    clear(): void;
+    drain(): Promise<void>;
+    performOne(): Promise<void>;
+    processJob(payload: JobPayload): Promise<void>;
+    clientPush(item: JobPayload): Promise<string | null>;
+};
+type JobClass = abstract new () => Job<any>;
+type JobArgsFromClass<T> = T extends {
+    new (): Job<infer TArgs>;
+} ? TArgs : unknown[];
+export declare abstract class Job<TArgs extends unknown[] = unknown[]> {
+    jid?: string;
+    _context?: {
+        stopping: () => boolean;
+    };
+    static getSidekiqOptions(this: JobConstructor): JobOptions;
+    static setSidekiqOptions(this: JobConstructor, options: JobOptions): void;
+    static queueAs(this: JobConstructor, queue: string): void;
+    static retryIn(this: JobConstructor, handler: RetryInHandler): void;
+    static retriesExhausted(this: JobConstructor, handler: RetriesExhaustedHandler): void;
+    static set<TClass extends JobClass>(this: TClass, options: JobSetterOptions): JobSetter<JobArgsFromClass<TClass>>;
+    static performAsync<TClass extends JobClass>(this: TClass, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
+    static performIn<TClass extends JobClass>(this: TClass, interval: number, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
+    static performAt<TClass extends JobClass>(this: TClass, timestamp: number, ...args: JobArgsFromClass<TClass>): Promise<string | null>;
+    static performBulk<TClass extends JobClass>(this: TClass, args: JobArgsFromClass<TClass>[], options?: BulkOptions): Promise<(string | null)[]>;
+    static performInline<TClass extends JobClass>(this: TClass, ...args: JobArgsFromClass<TClass>): Promise<boolean | null>;
+    static jobs(this: JobConstructor | typeof Job): JobPayload[];
+    static clear(this: JobConstructor): void;
+    static drain(this: JobConstructor): Promise<void>;
+    static performOne(this: JobConstructor): Promise<void>;
+    static processJob(this: JobConstructor, payload: JobPayload): Promise<void>;
+    static clearAll(): void;
+    static drainAll(): Promise<void>;
+    static clientPush(this: JobConstructor, item: JobPayload): Promise<string | null>;
+    logger(): import("./logger.js").Logger;
+    interrupted(): boolean;
+    abstract perform(...args: TArgs): Promise<void> | void;
+}
+export type RetryInHandler = (count: number, error: Error, payload: JobPayload) => number | "discard" | "kill" | "default";
+export type RetriesExhaustedHandler = (payload: JobPayload, error: Error) => "discard" | undefined;
+export declare class JobSetter<TArgs extends unknown[] = unknown[]> {
+    private readonly klass;
+    private options;
+    constructor(klass: JobConstructor<TArgs>, options: JobSetterOptions);
+    set(options: JobSetterOptions): JobSetter<TArgs>;
+    performAsync(...args: TArgs): Promise<string | null>;
+    performInline(...args: TArgs): Promise<boolean | null>;
+    performBulk(args: TArgs[], options?: BulkOptions): Promise<(string | null)[]>;
+    performIn(interval: number, ...args: TArgs): Promise<string | null>;
+    performAt(timestamp: number, ...args: TArgs): Promise<string | null>;
+    private at;
+}
+export {};
+//# sourceMappingURL=job.d.ts.map

package/dist/job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../src/job.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,WAAW,EACX,UAAU,EACV,UAAU,EACV,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAKpB,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,IAAI;IAChE,QAAQ,GAAG,CAAC,KAAK,CAAC,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;IAClD,iBAAiB,IAAI,UAAU,CAAC;IAChC,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAC7C,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACzD,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;IACjD,YAAY,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrD,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACpE,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACrE,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9E,aAAa,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IACvD,IAAI,IAAI,UAAU,EAAE,CAAC;IACrB,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/C,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACtD,CAAC;AAIF,KAAK,QAAQ,GAAG,QAAQ,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC;AAC5C,KAAK,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,GAAG,CAAC,MAAM,KAAK,CAAC,CAAA;CAAE,GAC7D,KAAK,GACL,OAAO,EAAE,CAAC;AAEd,8BAAsB,GAAG,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;KAAE,CAAC;IAEvC,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU;IAY1D,MAAM,CAAC,iBAAiB,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,UAAU,GAAG,IAAI;IASzE,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzD,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI;IAInE,MAAM,CAAC,gBAAgB,CACrB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,uBAAuB,GAC/B,IAAI;IAIP,MAAM,CAAC,GAAG,CAAC,MAAM,SAAS,QAAQ,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,GACxB,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAOtC,MAAM,CAAC,YAAY,CAAC,MAAM,SAAS,QAAQ,EACzC,IAAI,EAAE,MAAM,EACZ,GAAG,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAOzB,MAAM,CAAC,SAAS,CAAC,MAAM,SAAS,QAAQ,EACtC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,GAAG,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAOzB,MAAM,CAAC,SAAS,CAAC,MAAM,SAAS,QAAQ,EACtC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,GAAG,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAOzB,MAAM,CAAC,WAAW,CAAC,MAAM,SAAS,QAAQ,EACxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAAE,EAChC,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAO7B,MAAM,CAAC,aAAa,CAAC,MAAM,SAAS,QAAQ,EAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAChC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAO1B,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,GAAG,GAAG,UAAU,EAAE;IAO5D,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;WAK3B,KAAK,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;WAY1C,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;WAS/C,UAAU,CACrB,IAAI,EAAE,cAAc,EACpB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC;IAchB,MAAM,CAAC,QAAQ,IAAI,IAAI;WAIV,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IActC,MAAM,CAAC,UAAU,CACf,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAQzB,MAAM;IAIN,WAAW,IAAI,OAAO;IAItB,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;CACvD;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,UAAU,KAChB,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7C,MAAM,MAAM,uBAAuB,GAAG,CACpC,OAAO,EAAE,UAAU,EACnB,KAAK,EAAE,KAAK,KACT,SAAS,GAAG,SAAS,CAAC;AAE3B,qBAAa,SAAS,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE;IACxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,OAAO,CAAmB;gBAEtB,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,gBAAgB;IAYnE,GAAG,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAAC,KAAK,CAAC;IAe1C,YAAY,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAYpD,aAAa,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAe5D,WAAW,CACT,IAAI,EAAE,KAAK,EAAE,EACb,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IAgB7B,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAInE,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIpE,OAAO,CAAC,EAAE;CAWX"}