agenda 5.0.0 → 6.0.0

package/dist/decorators/register.js

@@ -0,0 +1,139 @@
+import { getControllerMetadata, isJobsController } from './metadata.js';
+/**
+ * Error thrown when attempting to register an invalid jobs controller
+ */
+export class JobsRegistrationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'JobsRegistrationError';
+    }
+}
+/**
+ * Register job handlers from decorated class instances with an Agenda instance.
+ *
+ * This function reads the metadata from classes decorated with `@JobsController`
+ * and registers their methods as job handlers.
+ *
+ * @param agenda - The Agenda instance to register jobs with
+ * @param instances - Array of instantiated job controller classes
+ * @throws {JobsRegistrationError} If a class is not decorated with @JobsController
+ *
+ * @example
+ * ```typescript
+ * import { Agenda, registerJobs } from 'agenda';
+ * import { MongoBackend } from '@agendajs/mongo-backend';
+ * import { EmailJobs } from './jobs/email';
+ * import { ReportJobs } from './jobs/reports';
+ *
+ * const agenda = new Agenda({
+ *   backend: new MongoBackend({ address: 'mongodb://localhost/agenda' })
+ * });
+ *
+ * // Create instances (can inject dependencies via constructor)
+ * const emailJobs = new EmailJobs(emailService);
+ * const reportJobs = new ReportJobs(reportService);
+ *
+ * // Register all job handlers
+ * registerJobs(agenda, [emailJobs, reportJobs]);
+ *
+ * await agenda.start();
+ * ```
+ */
+export function registerJobs(agenda, instances) {
+    const pendingEveryJobs = [];
+    for (const instance of instances) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- instance.constructor is typed as Function
+        const constructor = instance.constructor;
+        // Validate that the class is decorated
+        if (!isJobsController(constructor)) {
+            throw new JobsRegistrationError(`Class "${constructor.name}" is not decorated with @JobsController. ` +
+                'Make sure to add @JobsController() decorator to your class.');
+        }
+        const metadata = getControllerMetadata(constructor);
+        if (!metadata) {
+            continue;
+        }
+        registerJobsFromMetadata(agenda, instance, metadata, pendingEveryJobs);
+    }
+    // Schedule @Every jobs after agenda starts
+    if (pendingEveryJobs.length > 0) {
+        scheduleEveryJobsOnReady(agenda, pendingEveryJobs);
+    }
+}
+/**
+ * Register jobs from a single controller's metadata
+ */
+function registerJobsFromMetadata(agenda, instance, metadata, pendingEveryJobs) {
+    const namespace = metadata.namespace;
+    for (const [methodName, jobMeta] of metadata.jobs) {
+        const jobName = buildJobName(namespace, jobMeta.options.name || methodName);
+        // Bind the method to the instance
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Dynamic method access requires any
+        const handler = instance[methodName].bind(instance);
+        // Create an async wrapper that matches Agenda's expected signature
+        const wrappedHandler = async (job) => {
+            await handler(job);
+        };
+        // Register the job definition with Agenda
+        agenda.define(jobName, wrappedHandler, {
+            concurrency: jobMeta.options.concurrency,
+            lockLifetime: jobMeta.options.lockLifetime,
+            lockLimit: jobMeta.options.lockLimit,
+            priority: jobMeta.options.priority
+        });
+        // Queue @Every jobs for scheduling after start
+        if (jobMeta.type === 'every' && jobMeta.interval !== undefined) {
+            pendingEveryJobs.push({
+                jobName,
+                interval: jobMeta.interval,
+                options: jobMeta.options
+            });
+        }
+    }
+}
+/**
+ * Build the full job name with optional namespace prefix
+ */
+function buildJobName(namespace, name) {
+    return namespace ? `${namespace}.${name}` : name;
+}
+/**
+ * Schedule @Every jobs when Agenda emits the 'ready' event
+ */
+function scheduleEveryJobsOnReady(agenda, pendingJobs) {
+    const scheduleJobs = async () => {
+        for (const pending of pendingJobs) {
+            await agenda.every(pending.interval, pending.jobName, undefined, {
+                timezone: pending.options.timezone,
+                skipImmediate: pending.options.skipImmediate
+            });
+        }
+    };
+    // If agenda is already started, schedule immediately
+    // Otherwise, wait for the 'ready' event
+    agenda.once('ready', () => {
+        scheduleJobs().catch(err => {
+            agenda.emit('error', err);
+        });
+    });
+}
+/**
+ * Get information about registered jobs from decorated classes.
+ * Useful for debugging and introspection.
+ *
+ * @param instances - Array of job controller instances
+ * @returns Array of job registration info
+ */
+export function getRegisteredJobsInfo(instances) {
+    return instances.map(instance => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- instance.constructor is typed as Function
+        const constructor = instance.constructor;
+        const metadata = getControllerMetadata(constructor);
+        return {
+            className: constructor.name,
+            namespace: metadata?.namespace,
+            jobs: metadata ? Array.from(metadata.jobs.values()) : []
+        };
+    });
+}
+//# sourceMappingURL=register.js.map

package/dist/decorators/register.js.map

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

package/dist/index.d.ts

@@ -1,8 +1,359 @@
-export * from "./agenda";
-export * from "./job";
-export { DefineOptions, JobPriority, Processor } from "./agenda/define";
-export { JobOptions } from "./job/repeat-every";
-import { Agenda } from "./agenda";
-export { Agenda };
-export default Agenda;
-//# sourceMappingURL=index.d.ts.map
+import { EventEmitter } from 'events';
+import { ForkOptions } from 'child_process';
+import type { JobDefinition } from './types/JobDefinition.js';
+import type { AgendaConfig } from './types/AgendaConfig.js';
+import type { AgendaBackend } from './types/AgendaBackend.js';
+import type { NotificationChannel } from './types/NotificationChannel.js';
+import type { JobRepository } from './types/JobRepository.js';
+import type { AgendaStatus } from './types/AgendaStatus.js';
+import type { JobsQueryOptions, JobsResult, JobsOverview } from './types/JobQuery.js';
+import type { RemoveJobsOptions } from './types/JobRepository.js';
+import { Job, JobWithId } from './Job.js';
+import { JobPriority } from './utils/priority.js';
+/**
+ * Agenda configuration options
+ */
+export interface AgendaOptions {
+    /** Unified backend for storage and optionally notifications */
+    backend: AgendaBackend;
+    /** Name to identify this agenda instance */
+    name?: string;
+    /** Default number of concurrent jobs per job type */
+    defaultConcurrency?: number;
+    /** How often to poll for new jobs (string like '5 seconds' or milliseconds) */
+    processEvery?: string | number;
+    /** Maximum number of concurrent jobs globally */
+    maxConcurrency?: number;
+    /** Default max locked jobs per job type */
+    defaultLockLimit?: number;
+    /** Global max locked jobs */
+    lockLimit?: number;
+    /** Default lock lifetime in milliseconds */
+    defaultLockLifetime?: number;
+    /** Fork helper configuration for sandboxed workers */
+    forkHelper?: {
+        path: string;
+        options?: ForkOptions;
+    };
+    /** Whether this is a forked worker instance */
+    forkedWorker?: boolean;
+    /**
+     * Override notification channel from backend.
+     * Use this to mix storage from one system with notifications from another.
+     * e.g., MongoDB storage + Redis notifications
+     */
+    notificationChannel?: NotificationChannel;
+}
+/**
+ * Details provided when a job is scheduled for retry
+ */
+export interface RetryDetails {
+    /** The retry attempt number (1-based) */
+    attempt: number;
+    /** Delay in milliseconds before the retry */
+    delay: number;
+    /** When the retry will be executed */
+    nextRunAt: Date;
+    /** The error that caused the failure */
+    error: Error;
+}
+/**
+ * Event names that Agenda emits
+ */
+export type AgendaEventName = 'ready' | 'error' | 'fail' | 'success' | 'start' | 'complete' | 'retry' | 'retry exhausted' | `fail:${string}` | `success:${string}` | `start:${string}` | `complete:${string}` | `retry:${string}` | `retry exhausted:${string}`;
+/**
+ * @class
+ */
+export declare class Agenda extends EventEmitter {
+    readonly attrs: AgendaConfig;
+    readonly forkedWorker?: boolean;
+    readonly forkHelper?: {
+        path: string;
+        options?: ForkOptions;
+    };
+    private backend;
+    db: JobRepository;
+    private notificationChannel?;
+    on(event: 'ready', listener: () => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'fail', listener: (error: Error, job: JobWithId) => void): this;
+    on(event: 'success', listener: (job: JobWithId) => void): this;
+    on(event: 'start', listener: (job: JobWithId) => void): this;
+    on(event: 'complete', listener: (job: JobWithId) => void): this;
+    on(event: 'retry', listener: (job: JobWithId, details: RetryDetails) => void): this;
+    on(event: 'retry exhausted', listener: (error: Error, job: JobWithId) => void): this;
+    on(event: `fail:${string}`, listener: (error: Error, job: JobWithId) => void): this;
+    on(event: `success:${string}`, listener: (job: JobWithId) => void): this;
+    on(event: `start:${string}`, listener: (job: JobWithId) => void): this;
+    on(event: `complete:${string}`, listener: (job: JobWithId) => void): this;
+    on(event: `retry:${string}`, listener: (job: JobWithId, details: RetryDetails) => void): this;
+    on(event: `retry exhausted:${string}`, listener: (error: Error, job: JobWithId) => void): this;
+    readonly definitions: {
+        [name: string]: JobDefinition;
+    };
+    private jobProcessor?;
+    readonly ready: Promise<void>;
+    isActiveJobProcessor(): boolean;
+    runForkedJob(jobId: string): Promise<void>;
+    getRunningStats(fullDetails?: boolean): Promise<AgendaStatus>;
+    /**
+     * @param config - Agenda configuration with backend
+     * @param cb - Optional callback after Agenda is ready
+     */
+    constructor(config: AgendaOptions, cb?: (error?: Error) => void);
+    /**
+     * Cancels any jobs matching the passed options, and removes them from the database.
+     * @param options Options for which jobs to cancel
+     */
+    cancel(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Disables any jobs matching the passed options, preventing them from being run.
+     * @param options Options for which jobs to disable
+     * @returns Number of jobs disabled
+     */
+    disable(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Enables any jobs matching the passed options, allowing them to be run.
+     * @param options Options for which jobs to enable
+     * @returns Number of jobs enabled
+     */
+    enable(options: RemoveJobsOptions): Promise<number>;
+    /**
+     * Set name of queue
+     * @param name
+     */
+    name(name: string): Agenda;
+    /**
+     * Set the time how often the job processor checks for new jobs to process
+     * @param time
+     */
+    processEvery(time: string | number): Agenda;
+    /**
+     * Set the concurrency for jobs (globally), type does not matter
+     * @param num
+     */
+    maxConcurrency(num: number): Agenda;
+    /**
+     * Set the default concurrency for each job
+     * @param num number of max concurrency
+     */
+    defaultConcurrency(num: number): Agenda;
+    /**
+     * Set the default amount jobs that are allowed to be locked at one time (GLOBAL)
+     * @param num
+     */
+    lockLimit(num: number): Agenda;
+    /**
+     * Set default lock limit per job type
+     * @param num
+     */
+    defaultLockLimit(num: number): Agenda;
+    /**
+     * Set the default lock time (in ms)
+     * Default is 10 * 60 * 1000 ms (10 minutes)
+     * @param ms
+     */
+    defaultLockLifetime(ms: number): Agenda;
+    /**
+     * Set a notification channel for real-time job notifications
+     * @param channel - The notification channel implementation
+     */
+    notifyVia(channel: NotificationChannel): Agenda;
+    /**
+     * Check if a notification channel is configured
+     */
+    hasNotificationChannel(): boolean;
+    /**
+     * Publish a job notification to the notification channel
+     * @internal
+     */
+    publishJobNotification(job: Job): Promise<void>;
+    /**
+     * Query jobs with database-agnostic options.
+     * Returns jobs with computed states and supports filtering by state.
+     *
+     * @param options - Query options (name, state, search, pagination)
+     * @returns Jobs with computed states and total count
+     */
+    queryJobs(options?: JobsQueryOptions): Promise<JobsResult>;
+    /**
+     * Get overview statistics for jobs grouped by name.
+     * Returns counts of jobs in each state for each job name.
+     *
+     * @returns Array of job overviews with state counts
+     */
+    getJobsOverview(): Promise<JobsOverview[]>;
+    /**
+     * Removes all jobs from queue
+     * @note: Only use after defining your jobs
+     */
+    purge(): Promise<number>;
+    /**
+     * Setup definition for job
+     * Method is used by consumers of lib to setup their functions
+     * BREAKING CHANGE in v4: options moved from 2nd to 3rd parameter!
+     * @param name
+     * @param processor
+     * @param options
+     */
+    define<DATA = any>(name: string, processor: (agendaJob: Job<DATA>, done: (error?: Error) => void) => void, options?: Partial<Pick<JobDefinition, 'lockLimit' | 'lockLifetime' | 'concurrency' | 'backoff'>> & {
+        priority?: JobPriority;
+    }): void;
+    define<DATA = any>(name: string, processor: (agendaJob: Job<DATA>) => Promise<void>, options?: Partial<Pick<JobDefinition, 'lockLimit' | 'lockLifetime' | 'concurrency' | 'backoff'>> & {
+        priority?: JobPriority;
+    }): void;
+    /**
+     * Internal helper method that uses createJob to create jobs for an array of names
+     * @param names - Job names to schedule
+     * @param createJob - Factory function to create each job
+     * @returns Array of created jobs
+     */
+    private createJobs;
+    /**
+     * Given a name and some data, create a new job
+     * @param name
+     */
+    create(name: string): Job<void>;
+    create<DATA = unknown>(name: string, data: DATA): Job<DATA>;
+    /**
+     * Creates a scheduled job with given interval and name/names of the job to run
+     * @param interval
+     * @param names
+     * @param data
+     * @param options
+     */
+    every(interval: string | number, names: string[], data?: undefined, options?: {
+        timezone?: string;
+        skipImmediate?: boolean;
+        forkMode?: boolean;
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<void>[]>;
+    every(interval: string | number, name: string, data?: undefined, options?: {
+        timezone?: string;
+        skipImmediate?: boolean;
+        forkMode?: boolean;
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<void>>;
+    every<DATA = unknown>(interval: string | number, names: string[], data: DATA, options?: {
+        timezone?: string;
+        skipImmediate?: boolean;
+        forkMode?: boolean;
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>[]>;
+    every<DATA = unknown>(interval: string | number, name: string, data: DATA, options?: {
+        timezone?: string;
+        skipImmediate?: boolean;
+        forkMode?: boolean;
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>>;
+    /**
+     * Schedule a job or jobs at a specific time
+     * @param when
+     * @param names
+     * @param data
+     * @param options
+     */
+    schedule<DATA = void>(when: string | Date, names: string[], data?: undefined, options?: {
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>[]>;
+    schedule<DATA = void>(when: string | Date, names: string, data?: undefined, options?: {
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>>;
+    schedule<DATA = unknown>(when: string | Date, names: string[], data: DATA, options?: {
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>[]>;
+    schedule<DATA = unknown>(when: string | Date, name: string, data: DATA, options?: {
+        startDate?: Date | string;
+        endDate?: Date | string;
+        skipDays?: number[];
+    }): Promise<Job<DATA>>;
+    /**
+     * Create a job for this exact moment
+     * @param name
+     */
+    now<DATA = void>(name: string): Promise<Job<DATA>>;
+    now<DATA = unknown>(name: string, data: DATA): Promise<Job<DATA>>;
+    /**
+     * Create a debounced job that combines rapid submissions into a single execution.
+     * Requires a unique key to identify which jobs should be debounced together.
+     *
+     * @param name - Job name
+     * @param data - Job data
+     * @param uniqueKey - Unique constraint to identify jobs (e.g., { 'data.userId': 123 })
+     * @param debounceMs - Debounce delay in milliseconds
+     * @param options - Optional debounce options (maxWait, strategy)
+     *
+     * @example
+     * ```ts
+     * // Debounce search index updates by entity type
+     * await agenda.nowDebounced(
+     *   'updateSearchIndex',
+     *   { entityType: 'products' },
+     *   { 'data.entityType': 'products' },
+     *   2000
+     * );
+     *
+     * // With maxWait to guarantee execution within 30s
+     * await agenda.nowDebounced(
+     *   'syncUser',
+     *   { userId: 123 },
+     *   { 'data.userId': 123 },
+     *   5000,
+     *   { maxWait: 30000 }
+     * );
+     * ```
+     */
+    nowDebounced<DATA = unknown>(name: string, data: DATA, uniqueKey: Record<string, unknown>, debounceMs: number, options?: {
+        maxWait?: number;
+        strategy?: 'trailing' | 'leading';
+    }): Promise<Job<DATA>>;
+    /**
+     * Starts processing jobs using processJobs() methods, storing an interval ID
+     * This method will only resolve if a db has been set up beforehand.
+     */
+    start(): Promise<void>;
+    /**
+     * Clear the interval that processes the jobs and unlocks all currently locked jobs
+     * @param closeConnection - Whether to close the database connection.
+     *   Defaults to backend.ownsConnection (true if backend created the connection,
+     *   false if connection was passed in by user).
+     */
+    stop(closeConnection?: boolean): Promise<void>;
+    /**
+     * Waits for all currently running jobs to finish before stopping.
+     * This allows for a graceful shutdown where jobs complete their work.
+     * Unlike stop(), this method waits for running jobs to complete instead of unlocking them.
+     * @param closeConnection - Whether to close the database connection.
+     *   Defaults to backend.ownsConnection (true if backend created the connection,
+     *   false if connection was passed in by user).
+     */
+    drain(closeConnection?: boolean): Promise<void>;
+}
+export * from './types/AgendaConfig.js';
+export * from './types/JobDefinition.js';
+export * from './types/JobParameters.js';
+export * from './types/DbOptions.js';
+export * from './Job.js';
+export * from './types/JobQuery.js';
+export * from './types/JobRepository.js';
+export * from './types/NotificationChannel.js';
+export * from './types/AgendaBackend.js';
+export * from './types/AgendaStatus.js';
+export * from './notifications/index.js';
+export { applyAllDateConstraints, applyDateRangeConstraints, applySkipDays, shouldSkipDay, isWithinDateRange } from './utils/dateConstraints.js';
+export * from './decorators/index.js';
+export { backoffStrategies, constant, linear, exponential, combine, when, type BackoffStrategy, type BackoffContext, type BackoffOptions, type ExponentialBackoffOptions, type LinearBackoffOptions } from './utils/backoff.js';