duron 0.1.0

package/dist/adapters/schemas.js

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+import { JOB_STATUSES, STEP_STATUSES } from '../constants.js';
+export const JobStatusSchema = z.enum(JOB_STATUSES);
+export const StepStatusSchema = z.enum(STEP_STATUSES);
+const DateSchema = z.union([
+    z.date(),
+    z.string().transform((str) => new Date(str)),
+    z.number().transform((num) => new Date(num)),
+]);
+export const SerializableErrorSchema = z.object({
+    name: z.string(),
+    message: z.string(),
+    cause: z.any().optional(),
+    stack: z.string().optional(),
+});
+export const JobSchema = z.object({
+    id: z.string(),
+    actionName: z.string(),
+    groupKey: z.string(),
+    input: z.any(),
+    output: z.any().nullable(),
+    error: z.any().nullable(),
+    status: JobStatusSchema,
+    timeoutMs: z.coerce.number(),
+    expiresAt: DateSchema.nullable(),
+    startedAt: DateSchema.nullable().default(null),
+    finishedAt: DateSchema.nullable().default(null),
+    createdAt: DateSchema,
+    updatedAt: DateSchema,
+    concurrencyLimit: z.coerce.number(),
+});
+export const JobStepSchema = z.object({
+    id: z.string(),
+    jobId: z.string(),
+    name: z.string(),
+    output: z.any().nullable().default(null),
+    status: StepStatusSchema,
+    error: z.any().nullable().default(null),
+    startedAt: DateSchema,
+    finishedAt: DateSchema.nullable().default(null),
+    timeoutMs: z.coerce.number(),
+    expiresAt: DateSchema.nullable().default(null),
+    retriesLimit: z.coerce.number(),
+    retriesCount: z.coerce.number(),
+    delayedMs: z.coerce.number().nullable().default(null),
+    historyFailedAttempts: z.record(z.string(), z.object({ failedAt: DateSchema, error: SerializableErrorSchema, delayedMs: z.coerce.number() })),
+    createdAt: DateSchema,
+    updatedAt: DateSchema,
+});
+export const JobStepWithoutOutputSchema = JobStepSchema.omit({ output: true });
+export const SortOrderSchema = z.enum(['asc', 'desc']);
+export const JobSortFieldSchema = z.enum(['createdAt', 'startedAt', 'finishedAt', 'status', 'actionName', 'expiresAt']);
+export const JobSortSchema = z.object({
+    field: JobSortFieldSchema,
+    order: SortOrderSchema,
+});
+export const JobFiltersSchema = z.object({
+    status: z.union([JobStatusSchema, z.array(JobStatusSchema)]).optional(),
+    actionName: z.union([z.string(), z.array(z.string())]).optional(),
+    groupKey: z.union([z.string(), z.array(z.string())]).optional(),
+    ownerId: z.union([z.string(), z.array(z.string())]).optional(),
+    createdAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+    startedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+    finishedAt: z.union([DateSchema, z.array(DateSchema).length(2)]).optional(),
+    updatedAfter: DateSchema.optional(),
+    inputFilter: z.record(z.string(), z.any()).optional(),
+    outputFilter: z.record(z.string(), z.any()).optional(),
+    search: z.string().optional(),
+});
+export const GetJobsOptionsSchema = z.object({
+    page: z.number().int().positive().optional(),
+    pageSize: z.number().int().positive().optional(),
+    filters: JobFiltersSchema.optional(),
+    sort: z.union([JobSortSchema, z.array(JobSortSchema)]).optional(),
+});
+export const GetJobStepsOptionsSchema = z.object({
+    jobId: z.string(),
+    page: z.number().int().positive().optional(),
+    pageSize: z.number().int().positive().optional(),
+    search: z.string().optional(),
+    updatedAfter: DateSchema.optional(),
+});
+export const CreateJobOptionsSchema = z.object({
+    queue: z.string(),
+    groupKey: z.string(),
+    checksum: z.string(),
+    input: z.any(),
+    timeoutMs: z.number(),
+    concurrencyLimit: z.number(),
+});
+export const RecoverJobsOptionsSchema = z.object({
+    checksums: z.array(z.string()),
+    multiProcessMode: z.boolean().optional(),
+    processTimeout: z.number().optional(),
+});
+export const FetchOptionsSchema = z.object({
+    batch: z.number(),
+});
+export const CompleteJobOptionsSchema = z.object({
+    jobId: z.string(),
+    output: z.any(),
+});
+export const FailJobOptionsSchema = z.object({
+    jobId: z.string(),
+    error: z.any(),
+});
+export const CancelJobOptionsSchema = z.object({
+    jobId: z.string(),
+});
+export const RetryJobOptionsSchema = z.object({
+    jobId: z.string(),
+});
+export const DeleteJobOptionsSchema = z.object({
+    jobId: z.string(),
+});
+export const DeleteJobsOptionsSchema = GetJobsOptionsSchema.optional();
+export const CreateOrRecoverJobStepOptionsSchema = z.object({
+    jobId: z.string(),
+    name: z.string(),
+    timeoutMs: z.number(),
+    retriesLimit: z.number(),
+});
+export const CompleteJobStepOptionsSchema = z.object({
+    stepId: z.string(),
+    output: z.any(),
+});
+export const FailJobStepOptionsSchema = z.object({
+    stepId: z.string(),
+    error: z.any(),
+});
+export const DelayJobStepOptionsSchema = z.object({
+    stepId: z.string(),
+    delayMs: z.number(),
+    error: z.any(),
+});
+export const CancelJobStepOptionsSchema = z.object({
+    stepId: z.string(),
+});
+export const CreateOrRecoverJobStepResultSchema = z.object({
+    id: z.string(),
+    status: StepStatusSchema,
+    retriesLimit: z.number(),
+    retriesCount: z.number(),
+    timeoutMs: z.number(),
+    error: z.any().nullable(),
+    output: z.any().nullable(),
+    isNew: z.boolean(),
+});
+export const JobIdResultSchema = z.union([z.string(), z.null()]);
+export const BooleanResultSchema = z.boolean();
+export const NumberResultSchema = z.number();
+export const JobsArrayResultSchema = z.array(JobSchema);
+export const CreateOrRecoverJobStepResultNullableSchema = z.union([CreateOrRecoverJobStepResultSchema, z.null()]);
+export const GetJobsResultSchema = z.object({
+    jobs: z.array(JobSchema),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+});
+export const GetJobStepsResultSchema = z.object({
+    steps: z.array(JobStepWithoutOutputSchema),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+});
+export const ActionStatsSchema = z.object({
+    name: z.string(),
+    lastJobCreated: DateSchema.nullable(),
+    active: z.number().int().nonnegative(),
+    completed: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    cancelled: z.number().int().nonnegative(),
+});
+export const GetActionsResultSchema = z.object({
+    actions: z.array(ActionStatsSchema),
+});
+export const JobStatusResultSchema = z.object({
+    status: JobStatusSchema,
+    updatedAt: DateSchema,
+});
+export const JobStepStatusResultSchema = z.object({
+    status: StepStatusSchema,
+    updatedAt: DateSchema,
+});

package/dist/client.d.ts

@@ -0,0 +1,85 @@
+import pino, { type Logger } from 'pino';
+import * as z from 'zod';
+import type { Action } from './action.js';
+import type { Adapter, GetActionsResult, GetJobStepsOptions, GetJobStepsResult, GetJobsOptions, GetJobsResult, Job, JobStep } from './adapters/adapter.js';
+import type { JobStatusResult, JobStepStatusResult } from './adapters/schemas.js';
+declare const BaseOptionsSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    syncPattern: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"pull">, z.ZodLiteral<"push">, z.ZodLiteral<"hybrid">, z.ZodLiteral<false>]>>;
+    pullInterval: z.ZodDefault<z.ZodNumber>;
+    batchSize: z.ZodDefault<z.ZodNumber>;
+    actionConcurrencyLimit: z.ZodDefault<z.ZodNumber>;
+    groupConcurrencyLimit: z.ZodDefault<z.ZodNumber>;
+    migrateOnStart: z.ZodDefault<z.ZodBoolean>;
+    recoverJobsOnStart: z.ZodDefault<z.ZodBoolean>;
+    multiProcessMode: z.ZodDefault<z.ZodBoolean>;
+    processTimeout: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export interface ClientOptions<TActions extends Record<string, Action<any, any, TVariables>>, TVariables = Record<string, unknown>> extends z.input<typeof BaseOptionsSchema> {
+    database: Adapter;
+    actions?: TActions;
+    logger?: Logger | 'fatal' | 'error' | 'warn' | 'info' | 'debug' | 'trace' | 'silent';
+    variables?: TVariables;
+}
+interface FetchOptions {
+    batchSize?: number;
+}
+export declare class Client<TActions extends Record<string, Action<any, any, TVariables>>, TVariables = Record<string, unknown>> {
+    #private;
+    constructor(options: ClientOptions<TActions, TVariables>);
+    get logger(): pino.Logger;
+    getConfig(): {
+        actions: TActions | null;
+        variables: Record<string, unknown>;
+        syncPattern: false | "push" | "pull" | "hybrid";
+        pullInterval: number;
+        batchSize: number;
+        actionConcurrencyLimit: number;
+        groupConcurrencyLimit: number;
+        migrateOnStart: boolean;
+        recoverJobsOnStart: boolean;
+        multiProcessMode: boolean;
+        processTimeout: number;
+        id?: string | undefined;
+    };
+    runAction<TActionName extends keyof TActions>(actionName: TActionName, input?: NonNullable<TActions[TActionName]['input']> extends z.ZodObject ? z.input<NonNullable<TActions[TActionName]['input']>> : never): Promise<string>;
+    fetch(options: FetchOptions): Promise<{
+        id: string;
+        actionName: string;
+        groupKey: string;
+        input: any;
+        output: any;
+        error: any;
+        status: "created" | "active" | "completed" | "failed" | "cancelled";
+        timeoutMs: number;
+        expiresAt: Date | null;
+        startedAt: Date | null;
+        finishedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+        concurrencyLimit: number;
+    }[]>;
+    cancelJob(jobId: string): Promise<boolean>;
+    retryJob(jobId: string): Promise<string | null>;
+    deleteJob(jobId: string): Promise<boolean>;
+    deleteJobs(options?: GetJobsOptions): Promise<number>;
+    getJobById(jobId: string): Promise<Job | null>;
+    getJobSteps(options: GetJobStepsOptions): Promise<GetJobStepsResult>;
+    getJobs(options?: GetJobsOptions): Promise<GetJobsResult>;
+    getJobStepById(stepId: string): Promise<JobStep | null>;
+    getJobStatus(jobId: string): Promise<JobStatusResult | null>;
+    getJobStepStatus(stepId: string): Promise<JobStepStatusResult | null>;
+    waitForJob(jobId: string, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+    }): Promise<Job | null>;
+    getActions(): Promise<GetActionsResult>;
+    getActionsMetadata(): Promise<Array<{
+        name: string;
+        mockInput: any;
+    }>>;
+    start(): Promise<boolean>;
+    stop(): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,416 @@
+import pino, {} from 'pino';
+import { zocker } from 'zocker';
+import * as z from 'zod';
+import { ActionManager } from './action-manager.js';
+import { JOB_STATUS_CANCELLED, JOB_STATUS_COMPLETED, JOB_STATUS_FAILED } from './constants.js';
+const BaseOptionsSchema = z.object({
+    id: z.string().optional(),
+    syncPattern: z.union([z.literal('pull'), z.literal('push'), z.literal('hybrid'), z.literal(false)]).default('hybrid'),
+    pullInterval: z.number().default(5_000),
+    batchSize: z.number().default(10),
+    actionConcurrencyLimit: z.number().default(100),
+    groupConcurrencyLimit: z.number().default(10),
+    migrateOnStart: z.boolean().default(true),
+    recoverJobsOnStart: z.boolean().default(true),
+    multiProcessMode: z.boolean().default(false),
+    processTimeout: z.number().default(5 * 60 * 1000),
+});
+export class Client {
+    #options;
+    #id;
+    #actions;
+    #database;
+    #variables;
+    #logger;
+    #started = false;
+    #stopped = false;
+    #starting = null;
+    #stopping = null;
+    #pullInterval = null;
+    #actionManagers = new Map();
+    #mockInputSchemas = new Map();
+    #pendingJobWaits = new Map();
+    #jobStatusListenerSetup = false;
+    constructor(options) {
+        this.#options = BaseOptionsSchema.parse(options);
+        this.#id = options.id ?? globalThis.crypto.randomUUID();
+        this.#database = options.database;
+        this.#actions = options.actions ?? null;
+        this.#variables = options?.variables ?? {};
+        this.#logger = this.#normalizeLogger(options?.logger);
+        this.#database.setId(this.#id);
+        this.#database.setLogger(this.#logger);
+    }
+    #normalizeLogger(logger) {
+        let pinoInstance = null;
+        if (!logger) {
+            pinoInstance = pino({ level: 'error' });
+        }
+        else if (typeof logger === 'string') {
+            pinoInstance = pino({ level: logger });
+        }
+        else {
+            pinoInstance = logger;
+        }
+        return pinoInstance.child({ duron: this.#id });
+    }
+    get logger() {
+        return this.#logger;
+    }
+    getConfig() {
+        return {
+            ...this.#options,
+            actions: this.#actions,
+            variables: this.#variables,
+        };
+    }
+    async runAction(actionName, input) {
+        await this.start();
+        const action = this.#actions?.[actionName];
+        if (!action) {
+            throw new Error(`Action ${String(actionName)} not found`);
+        }
+        let validatedInput = input ?? {};
+        if (action.input) {
+            validatedInput = action.input.parse(validatedInput, {
+                error: () => 'Error parsing action input',
+                reportInput: true,
+            });
+        }
+        const concurrencyCtx = {
+            input: validatedInput,
+            var: this.#variables,
+        };
+        let groupKey = '@default';
+        if (action.groups?.groupKey) {
+            groupKey = await action.groups.groupKey(concurrencyCtx);
+        }
+        let concurrencyLimit = this.#options.groupConcurrencyLimit;
+        if (action.groups?.concurrency) {
+            concurrencyLimit = await action.groups.concurrency(concurrencyCtx);
+        }
+        const jobId = await this.#database.createJob({
+            queue: action.name,
+            groupKey,
+            input: validatedInput,
+            timeoutMs: action.expire,
+            checksum: action.checksum,
+            concurrencyLimit,
+        });
+        if (!jobId) {
+            throw new Error(`Failed to create job for action ${String(actionName)}`);
+        }
+        this.#logger.debug({ jobId, actionName: String(actionName), groupKey }, '[Duron] Action sent/created');
+        return jobId;
+    }
+    async fetch(options) {
+        await this.start();
+        if (!this.#actions) {
+            return [];
+        }
+        const jobs = await this.#database.fetch({
+            batch: options.batchSize ?? this.#options.batchSize,
+        });
+        for (const job of jobs) {
+            this.#executeJob(job);
+        }
+        return jobs;
+    }
+    async cancelJob(jobId) {
+        await this.start();
+        let cancelled = false;
+        for (const manager of this.#actionManagers.values()) {
+            cancelled = manager.cancelJob(jobId);
+            if (cancelled) {
+                break;
+            }
+        }
+        if (!cancelled) {
+            await this.#database.cancelJob({ jobId });
+        }
+        return cancelled;
+    }
+    async retryJob(jobId) {
+        await this.start();
+        return this.#database.retryJob({ jobId });
+    }
+    async deleteJob(jobId) {
+        await this.start();
+        return this.#database.deleteJob({ jobId });
+    }
+    async deleteJobs(options) {
+        await this.start();
+        return this.#database.deleteJobs(options);
+    }
+    async getJobById(jobId) {
+        await this.start();
+        return this.#database.getJobById(jobId);
+    }
+    async getJobSteps(options) {
+        await this.start();
+        return this.#database.getJobSteps(options);
+    }
+    async getJobs(options) {
+        await this.start();
+        return this.#database.getJobs(options);
+    }
+    async getJobStepById(stepId) {
+        await this.start();
+        return this.#database.getJobStepById(stepId);
+    }
+    async getJobStatus(jobId) {
+        await this.start();
+        return this.#database.getJobStatus(jobId);
+    }
+    async getJobStepStatus(stepId) {
+        await this.start();
+        return this.#database.getJobStepStatus(stepId);
+    }
+    async waitForJob(jobId, options) {
+        await this.start();
+        const existingJobStatus = await this.getJobStatus(jobId);
+        if (existingJobStatus) {
+            const terminalStatuses = [JOB_STATUS_COMPLETED, JOB_STATUS_FAILED, JOB_STATUS_CANCELLED];
+            if (terminalStatuses.includes(existingJobStatus.status)) {
+                const job = await this.getJobById(jobId);
+                if (!job) {
+                    return null;
+                }
+                return job;
+            }
+        }
+        this.#setupJobStatusListener();
+        return new Promise((resolve) => {
+            if (options?.signal?.aborted) {
+                resolve(null);
+                return;
+            }
+            let timeoutId;
+            let abortHandler;
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    this.#removeJobWait(jobId, resolve);
+                    resolve(null);
+                }, options.timeout);
+            }
+            if (options?.signal) {
+                abortHandler = () => {
+                    this.#removeJobWait(jobId, resolve);
+                    resolve(null);
+                };
+                options.signal.addEventListener('abort', abortHandler);
+            }
+            if (!this.#pendingJobWaits.has(jobId)) {
+                this.#pendingJobWaits.set(jobId, new Set());
+            }
+            this.#pendingJobWaits.get(jobId).add({
+                resolve,
+                timeoutId,
+                signal: options?.signal,
+                abortHandler,
+            });
+        });
+    }
+    async getActions() {
+        await this.start();
+        return this.#database.getActions();
+    }
+    async getActionsMetadata() {
+        await this.start();
+        if (!this.#actions) {
+            return [];
+        }
+        return Object.values(this.#actions).map((action) => {
+            let mockInput = {};
+            if (action.input) {
+                if (!this.#mockInputSchemas.has(action.name)) {
+                    this.#mockInputSchemas.set(action.name, zocker(action.input)
+                        .override(z.ZodString, 'string')
+                        .generate());
+                }
+                mockInput = this.#mockInputSchemas.get(action.name);
+            }
+            return {
+                name: action.name,
+                mockInput,
+            };
+        });
+    }
+    async start() {
+        if (this.#stopping || this.#stopped) {
+            return false;
+        }
+        if (this.#started) {
+            return true;
+        }
+        if (this.#starting) {
+            return this.#starting;
+        }
+        this.#starting = (async () => {
+            const dbStarted = await this.#database.start();
+            if (!dbStarted) {
+                return false;
+            }
+            if (this.#actions) {
+                if (this.#options.recoverJobsOnStart) {
+                    await this.#database.recoverJobs({
+                        checksums: Object.values(this.#actions).map((action) => action.checksum),
+                        multiProcessMode: this.#options.multiProcessMode,
+                        processTimeout: this.#options.processTimeout,
+                    });
+                }
+                if (this.#options.syncPattern === 'pull' || this.#options.syncPattern === 'hybrid') {
+                    this.#startPullLoop();
+                }
+                if (this.#options.syncPattern === 'push' || this.#options.syncPattern === 'hybrid') {
+                    this.#setupPushListener();
+                }
+            }
+            this.#started = true;
+            this.#starting = null;
+            return true;
+        })();
+        return this.#starting;
+    }
+    async stop() {
+        if (this.#stopped) {
+            return true;
+        }
+        if (this.#stopping) {
+            return this.#stopping;
+        }
+        this.#stopping = (async () => {
+            if (this.#pullInterval) {
+                clearTimeout(this.#pullInterval);
+                this.#pullInterval = null;
+            }
+            for (const waits of this.#pendingJobWaits.values()) {
+                for (const wait of waits) {
+                    if (wait.timeoutId) {
+                        clearTimeout(wait.timeoutId);
+                    }
+                    if (wait.signal && wait.abortHandler) {
+                        wait.signal.removeEventListener('abort', wait.abortHandler);
+                    }
+                    wait.resolve(null);
+                }
+            }
+            this.#pendingJobWaits.clear();
+            await Promise.all(Array.from(this.#actionManagers.values()).map(async (manager) => {
+                await manager.stop();
+            }));
+            const dbStopped = await this.#database.stop();
+            if (!dbStopped) {
+                return false;
+            }
+            this.#stopped = true;
+            this.#stopping = null;
+            return true;
+        })();
+        return this.#stopping;
+    }
+    #setupJobStatusListener() {
+        if (this.#jobStatusListenerSetup) {
+            return;
+        }
+        this.#jobStatusListenerSetup = true;
+        this.#database.on('job-status-changed', async (event) => {
+            const pendingWaits = this.#pendingJobWaits.get(event.jobId);
+            if (!pendingWaits || pendingWaits.size === 0) {
+                return;
+            }
+            const job = await this.getJobById(event.jobId);
+            const waitsToResolve = Array.from(pendingWaits);
+            this.#pendingJobWaits.delete(event.jobId);
+            for (const wait of waitsToResolve) {
+                if (wait.timeoutId) {
+                    clearTimeout(wait.timeoutId);
+                }
+                if (wait.signal && wait.abortHandler) {
+                    wait.signal.removeEventListener('abort', wait.abortHandler);
+                }
+                wait.resolve(job);
+            }
+        });
+    }
+    #removeJobWait(jobId, resolve) {
+        const pendingWaits = this.#pendingJobWaits.get(jobId);
+        if (!pendingWaits) {
+            return;
+        }
+        for (const wait of pendingWaits) {
+            if (wait.resolve === resolve) {
+                if (wait.timeoutId) {
+                    clearTimeout(wait.timeoutId);
+                }
+                if (wait.signal && wait.abortHandler) {
+                    wait.signal.removeEventListener('abort', wait.abortHandler);
+                }
+                pendingWaits.delete(wait);
+                break;
+            }
+        }
+        if (pendingWaits.size === 0) {
+            this.#pendingJobWaits.delete(jobId);
+        }
+    }
+    #executeJob(job) {
+        if (!this.#actions) {
+            return;
+        }
+        const action = Object.values(this.#actions).find((a) => a.name === job.actionName);
+        if (!action) {
+            const error = { name: 'ActionNotFoundError', message: `Action "${job.actionName}" not found for job ${job.id}` };
+            this.#logger.warn({ jobId: job.id, actionName: job.actionName }, `[Duron] Action not found for job ${job.id}`);
+            this.#database.failJob({ jobId: job.id, error }).catch((dbError) => {
+                this.#logger.error({ error: dbError, jobId: job.id }, `[Duron] Error failing job ${job.id}`);
+            });
+            return;
+        }
+        let actionManager = this.#actionManagers.get(action.name);
+        if (!actionManager) {
+            actionManager = new ActionManager({
+                action,
+                database: this.#database,
+                variables: this.#variables,
+                logger: this.#logger,
+                concurrencyLimit: this.#options.actionConcurrencyLimit,
+            });
+            this.#actionManagers.set(action.name, actionManager);
+        }
+        actionManager.push(job).catch((err) => {
+            this.#logger.error({ err, jobId: job.id, actionName: action.name }, `[Duron] Error executing job ${job.id} for action ${action.name}`);
+        });
+    }
+    #startPullLoop() {
+        if (this.#pullInterval) {
+            return;
+        }
+        const pull = async () => {
+            if (this.#stopped) {
+                return;
+            }
+            try {
+                await this.fetch({
+                    batchSize: this.#options.batchSize,
+                });
+            }
+            catch (error) {
+                this.#logger.error({ error }, '[Duron] [PullLoop] Error in pull loop');
+            }
+            if (!this.#stopped) {
+                this.#pullInterval = setTimeout(pull, this.#options.pullInterval);
+            }
+        };
+        pull();
+    }
+    #setupPushListener() {
+        this.#database.on('job-available', async () => {
+            this.fetch({
+                batchSize: 1,
+            }).catch((error) => {
+                this.#logger.error({ error }, '[Duron] [PushListener] Error fetching job');
+            });
+        });
+    }
+}