@cadence-mq/core/dist/index.d.ts

Modern, type-safe, and performant task queue for Node.js

import { Expand } from "@corentinth/chisels";
import * as _standard_schema_spec4 from "@standard-schema/spec";
import { StandardSchemaV1 } from "@standard-schema/spec";

//#region src/workers/workers.types.d.ts
type WorkerEvents = {
  'job.started': {
    jobId: string;
  };
  'job.completed': {
    jobId: string;
    result: unknown;
  };
  'job.failed': {
    jobId: string;
    error: Error | undefined;
  };
  'job.rescheduled': {
    jobId: string;
    nextDate: Date;
    error: Error | undefined;
  };
  'job.deleted': {
    jobId: string;
  };
  'task.not-found': {
    taskName: string;
  };
};
//#endregion
//#region src/jobs/jobs.types.d.ts
type JsonSerializable = string | number | boolean | null | undefined | JsonSerializable[] | {
  [key: string]: JsonSerializable;
};
type JobData = JsonSerializable;
type JobResult = JsonSerializable;
type JobStatus = 'pending' | 'processing' | 'completed' | 'failed';
type Job = {
  id: string;
  taskName: string;
  status: JobStatus;
  error?: string;
  startedAt?: Date;
  completedAt?: Date;
  maxRetries?: number;
  data?: JobData;
  result?: JobResult;
  scheduledAt: Date;
  cron?: string;
  createdAt: Date;
  deleteJobOnCompletion: boolean;
};
type JobUpdate = Expand<Partial<Pick<Job, 'status' | 'error' | 'result' | 'startedAt' | 'completedAt' | 'maxRetries' | 'data' | 'cron' | 'scheduledAt' | 'deleteJobOnCompletion'>>>;
type JobRepositoryDriver = {
  saveJob: (arg: {
    job: Job;
    now?: Date;
  }) => Promise<void>;
  updateJob: (arg: {
    jobId: string;
    values: JobUpdate;
    now?: Date;
  }) => Promise<void>;
  getNextJobAndMarkAsProcessing: (arg: {
    abortSignal: AbortSignal;
    now?: Date;
  }) => Promise<{
    job: Job;
  }>;
  getJob: (arg: {
    jobId: string;
  }) => Promise<{
    job: Job | null;
  }>;
  getJobCount: (arg?: {
    filter?: {
      status?: JobStatus;
    };
  }) => Promise<{
    count: number;
  }>;
  deleteJob: (arg: {
    jobId: string;
  }) => Promise<void>;
};
//# sourceMappingURL=jobs.types.d.ts.map
//#endregion
//#region src/tasks/tasks.types.d.ts
type TaskOptions = {
  maxRetries?: number;
  retryBackoff?: 'linear' | 'exponential' | ((args: {
    attempt: number;
  }) => number);
};
type TaskDefinition<ArgsSchema extends StandardSchemaV1 = StandardSchemaV1, TResult = JobResult> = {
  taskName: string;
  options?: TaskOptions;
  schema?: {
    data?: ArgsSchema;
  };
  handler: (args: {
    data: StandardSchemaV1.InferOutput<ArgsSchema>;
    context: TaskContext;
  }) => Promise<TResult | undefined | void>;
};
type TaskContext = {
  workerId: string;
};
//# sourceMappingURL=tasks.types.d.ts.map
//#endregion
//#region src/tasks/task-definition.registry.d.ts
type TaskDefinitionRegistry = ReturnType<typeof createTaskRegistry>;
declare function createTaskRegistry(): {
  registerTask: <T extends StandardSchemaV1>(taskDefinition: TaskDefinition<T>) => void;
  getTask: ({
    taskName
  }: {
    taskName: string;
  }) => {
    taskDefinition: TaskDefinition | undefined;
  };
  getTaskOrThrow: ({
    taskName
  }: {
    taskName: string;
  }) => {
    taskDefinition: TaskDefinition;
  };
};
//# sourceMappingURL=task-definition.registry.d.ts.map
//#endregion
//#region src/scheduler/scheduler.d.ts
declare function scheduleJob({
  taskName,
  data,
  now,
  scheduledAt,
  maxRetries,
  deleteJobOnCompletion,
  driver,
  taskRegistry,
  generateJobId
}: {
  taskName: string;
  data?: JobData;
  scheduledAt?: Date;
  now?: Date;
  maxRetries?: number;
  deleteJobOnCompletion?: boolean;
  driver: JobRepositoryDriver;
  taskRegistry?: TaskDefinitionRegistry;
  generateJobId?: () => string;
}): Promise<{
  jobId: string;
}>;
declare function schedulePeriodicJob({
  scheduleId: jobId,
  cron,
  taskName,
  data,
  now,
  maxRetries,
  driver,
  taskRegistry,
  immediate
}: {
  scheduleId: string;
  cron: string;
  taskName: string;
  data?: JobData;
  now?: Date;
  maxRetries?: number;
  driver: JobRepositoryDriver;
  taskRegistry?: TaskDefinitionRegistry;
  immediate?: boolean;
}): Promise<{
  jobId: string;
}>;
declare function createScheduler({
  driver,
  taskRegistry,
  generateJobId
}: {
  driver: JobRepositoryDriver;
  taskRegistry: TaskDefinitionRegistry;
  generateJobId?: () => string;
}): (args: Omit<Parameters<typeof scheduleJob>[0], "driver" | "taskRegistry" | "generateJobId">) => Promise<{
  jobId: string;
}>;
//#endregion
//#region src/logger/logger.types.d.ts
type CadenceLoggerArgs = [data: Record<string, unknown>, message: string] | [message: string];
type CadenceLogger = {
  debug: (...args: CadenceLoggerArgs) => void;
  info: (...args: CadenceLoggerArgs) => void;
  warn: (...args: CadenceLoggerArgs) => void;
  error: (...args: CadenceLoggerArgs) => void;
};
//# sourceMappingURL=logger.types.d.ts.map
//#endregion
//#region src/cadence/cadence.factory.d.ts
type CadenceInstance = ReturnType<typeof createCadence>;
declare function createCadence({
  driver,
  generateJobId,
  taskRegistry,
  logger
}: {
  driver: JobRepositoryDriver;
  generateJobId?: () => string;
  taskRegistry?: TaskDefinitionRegistry;
  logger?: Partial<CadenceLogger>;
}): {
  createWorker: (instanceArgs: {
    workerId: string;
    getNow?: () => Date;
    logger?: Partial<CadenceLogger>;
  }) => {
    start: () => void;
    getStatus: () => "running" | "stopped" | "stopping" | "paused";
    on: <TEvent extends keyof WorkerEvents>(event: TEvent, listener: (data: WorkerEvents[TEvent]) => void) => void;
  };
  scheduleJob: (args: Omit<Parameters<typeof scheduleJob>[0], "driver" | "taskRegistry" | "generateJobId">) => Promise<{
    jobId: string;
  }>;
  schedulePeriodicJob: (args: Omit<Parameters<typeof schedulePeriodicJob>[0], "driver" | "taskRegistry">) => Promise<{
    jobId: string;
  }>;
  registerTask: <T extends _standard_schema_spec4.StandardSchemaV1>(taskDefinition: TaskDefinition<T>) => void;
  getJob: (arg: {
    jobId: string;
  }) => Promise<{
    job: Job | null;
  }>;
  getJobCount: (arg?: {
    filter?: {
      status?: JobStatus;
    };
  }) => Promise<{
    count: number;
  }>;
  deleteJob: (arg: {
    jobId: string;
  }) => Promise<void>;
  getTaskRegistry: () => {
    registerTask: <T extends _standard_schema_spec4.StandardSchemaV1>(taskDefinition: TaskDefinition<T>) => void;
    getTask: ({
      taskName
    }: {
      taskName: string;
    }) => {
      taskDefinition: TaskDefinition | undefined;
    };
    getTaskOrThrow: ({
      taskName
    }: {
      taskName: string;
    }) => {
      taskDefinition: TaskDefinition;
    };
  };
  getDriver: () => JobRepositoryDriver;
};
//# sourceMappingURL=cadence.factory.d.ts.map
//#endregion
//#region src/errors/errors.models.d.ts
declare class CadenceError extends Error {
  isCadenceError: boolean;
  code: string;
  constructor({
    message,
    cause,
    code
  }: {
    message: string;
    cause?: unknown;
    code: string;
  });
}
declare function isCadenceError(error: unknown): error is CadenceError;
declare function createError({
  message,
  cause,
  code
}: {
  message: string;
  cause?: unknown;
  code: string;
}): CadenceError;
declare function createErrorFactory(factorySettings: {
  code: string;
  message: string;
}): (instanceSettings?: {
  cause?: unknown;
  message?: string;
  code?: string;
}) => CadenceError;
//# sourceMappingURL=errors.models.d.ts.map
//#endregion
//#region src/errors/errors.definitions.d.ts
declare const createJobWithSameIdExistsError: (instanceSettings?: {
  cause?: unknown;
  message?: string;
  code?: string;
}) => CadenceError;
declare const createJobNotFoundError: (instanceSettings?: {
  cause?: unknown;
  message?: string;
  code?: string;
}) => CadenceError;
//#endregion
//#region src/workers/workers.factory.d.ts
declare function createWorker({
  driver,
  taskRegistry,
  workerId,
  getNow,
  logger
}: {
  driver: JobRepositoryDriver;
  taskRegistry: TaskDefinitionRegistry;
  workerId: string;
  getNow?: () => Date;
  logger?: Partial<CadenceLogger>;
}): {
  start: () => void;
  getStatus: () => "running" | "stopped" | "stopping" | "paused";
  on: <TEvent extends keyof WorkerEvents>(event: TEvent, listener: (data: WorkerEvents[TEvent]) => void) => void;
};
//#endregion
export { CadenceInstance, CadenceLogger, CadenceLoggerArgs, Job, JobData, JobRepositoryDriver, JobStatus, JobUpdate, JsonSerializable, TaskDefinitionRegistry, createCadence, createError, createErrorFactory, createJobNotFoundError, createJobWithSameIdExistsError, createScheduler, createTaskRegistry, createWorker, isCadenceError, scheduleJob };
//# sourceMappingURL=index.d.ts.map