@holo-js/queue 0.2.6 → 0.3.1

package/dist/chunk-5MPOVBVE.mjs

@@ -0,0 +1,274 @@
+// src/config.ts
+import { registerConfigNormalizer } from "@holo-js/config/registry";
+var DEFAULT_QUEUE_CONNECTION = "sync";
+var DEFAULT_QUEUE_NAME = "default";
+var DEFAULT_QUEUE_RETRY_AFTER = 90;
+var DEFAULT_QUEUE_BLOCK_FOR = 5;
+var DEFAULT_QUEUE_SLEEP = 1;
+var DEFAULT_FAILED_JOBS_CONNECTION = "default";
+var DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
+var DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
+var DEFAULT_REDIS_HOST = "127.0.0.1";
+var DEFAULT_REDIS_PORT = 6379;
+var DEFAULT_REDIS_DB = 0;
+var DEFAULT_QUEUE_CONFIG = Object.freeze({
+  default: DEFAULT_QUEUE_CONNECTION,
+  failed: Object.freeze({
+    driver: "database",
+    connection: DEFAULT_FAILED_JOBS_CONNECTION,
+    table: DEFAULT_FAILED_JOBS_TABLE
+  }),
+  connections: Object.freeze({
+    [DEFAULT_QUEUE_CONNECTION]: Object.freeze({
+      name: DEFAULT_QUEUE_CONNECTION,
+      driver: "sync",
+      queue: DEFAULT_QUEUE_NAME
+    })
+  })
+});
+function parseInteger(value, fallback, label, options = {}) {
+  if (typeof value === "undefined") {
+    return fallback;
+  }
+  const normalized = typeof value === "number" ? value : value.trim();
+  if (typeof normalized === "string" && !/^[+-]?\d+$/.test(normalized)) {
+    throw new Error(`[Holo Queue] ${label} must be an integer.`);
+  }
+  const integer = typeof normalized === "number" ? normalized : Number(normalized);
+  if (!Number.isInteger(integer)) {
+    throw new Error(`[Holo Queue] ${label} must be an integer.`);
+  }
+  if (typeof options.minimum === "number" && integer < options.minimum) {
+    throw new Error(`[Holo Queue] ${label} must be greater than or equal to ${options.minimum}.`);
+  }
+  return integer;
+}
+function normalizeConnectionName(value, label) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`[Holo Queue] ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function normalizeQueueName(value) {
+  return value?.trim() || DEFAULT_QUEUE_NAME;
+}
+function normalizeOptionalRedisString(value) {
+  return value?.trim() || void 0;
+}
+function normalizeSyncConnection(name, config) {
+  return Object.freeze({
+    name,
+    driver: "sync",
+    queue: normalizeQueueName(config.queue)
+  });
+}
+function resolveSharedRedisConnection(redisConfig, connectionName) {
+  const resolvedConnection = redisConfig.connections[connectionName];
+  if (!resolvedConnection) {
+    const availableConnections = Object.keys(redisConfig.connections);
+    throw new Error(
+      `[Holo Queue] Queue Redis connection "${connectionName}" was not found in shared Redis config. Available connections: ${availableConnections.join(", ") || "(none)"}.`
+    );
+  }
+  return resolvedConnection;
+}
+function parseRedisDatabaseFromUrl(url, label) {
+  if (typeof url === "undefined") {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    throw new Error(`[Holo Queue] ${label} is invalid: ${String(error)}`);
+  }
+  if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+    throw new Error(`[Holo Queue] ${label} is invalid: unsupported protocol "${parsed.protocol}".`);
+  }
+  const pathname = parsed.pathname.replace(/^\/+/, "");
+  if (!pathname) {
+    return void 0;
+  }
+  const [databaseSegment] = pathname.split("/");
+  if (!databaseSegment || !/^\d+$/.test(databaseSegment) || pathname !== databaseSegment) {
+    throw new Error(`[Holo Queue] ${label} must include at most one integer database path segment.`);
+  }
+  return Number(databaseSegment);
+}
+function normalizeRedisClusterNodes(connectionName, nodes) {
+  if (!nodes || nodes.length === 0) {
+    return void 0;
+  }
+  return Object.freeze(nodes.map((node, index) => {
+    const label = `queue connection "${connectionName}" redis cluster node ${index + 1}`;
+    const url = normalizeOptionalRedisString(node.url);
+    if (typeof url !== "undefined") {
+      const database = parseRedisDatabaseFromUrl(url, `${label} url`);
+      if (typeof database !== "undefined") {
+        throw new Error(`[Holo Queue] ${label} url cannot include a database path in cluster mode.`);
+      }
+    }
+    return Object.freeze({
+      ...typeof url === "undefined" ? {} : { url },
+      host: normalizeOptionalRedisString(node.host) ?? DEFAULT_REDIS_HOST,
+      port: parseInteger(node.port, DEFAULT_REDIS_PORT, `${label} port`, {
+        minimum: 1
+      })
+    });
+  }));
+}
+function normalizeRedisOptions(connectionName, base, overrides) {
+  const hasTargetOverride = typeof overrides?.url !== "undefined" || typeof overrides?.clusters !== "undefined" || typeof overrides?.host !== "undefined" || typeof overrides?.port !== "undefined";
+  const url = normalizeOptionalRedisString(overrides?.url) ?? (hasTargetOverride ? void 0 : base?.url);
+  const clusters = typeof overrides?.clusters === "undefined" ? hasTargetOverride ? void 0 : base?.clusters : normalizeRedisClusterNodes(connectionName, overrides.clusters);
+  const dbFromUrl = parseRedisDatabaseFromUrl(url, `queue connection "${connectionName}" redis url`);
+  const db = parseInteger(overrides?.db ?? base?.db ?? dbFromUrl, DEFAULT_REDIS_DB, `queue connection "${connectionName}" redis db`, {
+    minimum: 0
+  });
+  if (typeof clusters !== "undefined" && db !== 0) {
+    throw new Error(`[Holo Queue] queue connection "${connectionName}" cannot select redis.db=${db} in cluster mode; Redis Cluster only supports database 0.`);
+  }
+  return Object.freeze({
+    ...typeof url === "undefined" ? {} : { url },
+    ...typeof clusters === "undefined" ? {} : { clusters },
+    host: normalizeOptionalRedisString(overrides?.host) ?? base?.host ?? DEFAULT_REDIS_HOST,
+    port: parseInteger(overrides?.port ?? base?.port, DEFAULT_REDIS_PORT, `queue connection "${connectionName}" redis port`, {
+      minimum: 1
+    }),
+    password: normalizeOptionalRedisString(overrides?.password) ?? base?.password,
+    username: normalizeOptionalRedisString(overrides?.username) ?? base?.username,
+    db
+  });
+}
+function normalizeRedisConnection(name, config, redisConfig) {
+  const explicitConnectionName = config.connection?.trim();
+  const connectionName = explicitConnectionName || redisConfig?.default;
+  if (!connectionName && !config.redis) {
+    throw new Error(
+      `[Holo Queue] Queue Redis connection "${name}" requires a shared Redis config with a default connection or an explicit connection name.`
+    );
+  }
+  if (!redisConfig && !config.redis) {
+    throw new Error(
+      `[Holo Queue] Queue Redis connection "${name}" references shared Redis connection "${connectionName}" but no shared Redis config was provided.`
+    );
+  }
+  const resolvedRedisConnection = redisConfig && connectionName ? resolveSharedRedisConnection(redisConfig, connectionName) : void 0;
+  return Object.freeze({
+    name,
+    driver: "redis",
+    connection: resolvedRedisConnection?.name ?? connectionName ?? name,
+    queue: normalizeQueueName(config.queue),
+    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+      minimum: 0
+    }),
+    blockFor: parseInteger(config.blockFor, DEFAULT_QUEUE_BLOCK_FOR, `queue connection "${name}" blockFor`, {
+      minimum: 0
+    }),
+    redis: normalizeRedisOptions(name, resolvedRedisConnection, config.redis)
+  });
+}
+function normalizeDatabaseConnection(name, config) {
+  return Object.freeze({
+    name,
+    driver: "database",
+    queue: normalizeQueueName(config.queue),
+    retryAfter: parseInteger(config.retryAfter, DEFAULT_QUEUE_RETRY_AFTER, `queue connection "${name}" retryAfter`, {
+      minimum: 0
+    }),
+    sleep: parseInteger(config.sleep, DEFAULT_QUEUE_SLEEP, `queue connection "${name}" sleep`, {
+      minimum: 0
+    }),
+    connection: config.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
+    table: config.table?.trim() || DEFAULT_DATABASE_QUEUE_TABLE
+  });
+}
+function normalizePluginConnection(name, config) {
+  const { driver, queue, ...options } = config;
+  return Object.freeze({
+    ...options,
+    name,
+    driver: normalizeConnectionName(driver, `queue connection "${name}" driver`),
+    queue: normalizeQueueName(queue)
+  });
+}
+function normalizeConnectionConfig(name, config, redisConfig) {
+  switch (config.driver) {
+    case "sync":
+      return normalizeSyncConnection(name, config);
+    case "redis":
+      return normalizeRedisConnection(name, config, redisConfig);
+    case "database":
+      return normalizeDatabaseConnection(name, config);
+    default:
+      return normalizePluginConnection(name, config);
+  }
+}
+function normalizeConnections(connections, redisConfig) {
+  if (!connections || Object.keys(connections).length === 0) {
+    return DEFAULT_QUEUE_CONFIG.connections;
+  }
+  const normalizedEntries = Object.entries(connections).map(([name, config]) => {
+    const normalizedName = normalizeConnectionName(name, "Queue connection name");
+    return [normalizedName, normalizeConnectionConfig(normalizedName, config, redisConfig)];
+  });
+  return Object.freeze(Object.fromEntries(normalizedEntries));
+}
+function normalizeFailedStore(config) {
+  if (config === false) {
+    return false;
+  }
+  const normalized = config ?? DEFAULT_QUEUE_CONFIG.failed;
+  if (normalized.driver && normalized.driver !== "database") {
+    throw new Error(`[Holo Queue] Unsupported failed job store driver "${normalized.driver}".`);
+  }
+  return Object.freeze({
+    driver: "database",
+    connection: normalized.connection?.trim() || DEFAULT_FAILED_JOBS_CONNECTION,
+    table: normalized.table?.trim() || DEFAULT_FAILED_JOBS_TABLE
+  });
+}
+function normalizeQueueConfig(config = {}, redisConfig) {
+  const connections = normalizeConnections(config.connections, redisConfig);
+  const connectionNames = Object.keys(connections);
+  const defaultConnection = config.default?.trim() || connectionNames[0];
+  if (!connections[defaultConnection]) {
+    throw new Error(
+      `[Holo Queue] default queue connection "${defaultConnection}" is not configured. Available connections: ${connectionNames.join(", ")}`
+    );
+  }
+  return Object.freeze({
+    default: defaultConnection,
+    failed: normalizeFailedStore(config.failed),
+    connections
+  });
+}
+var holoQueueDefaults = DEFAULT_QUEUE_CONFIG;
+var queueInternals = {
+  parseInteger
+};
+registerConfigNormalizer({
+  name: "queue",
+  dependencies: ["redis"],
+  normalize(config, context) {
+    return normalizeQueueConfig(config, context.has("redis") ? context.get("redis") : void 0);
+  }
+});
+
+export {
+  DEFAULT_QUEUE_CONNECTION,
+  DEFAULT_QUEUE_NAME,
+  DEFAULT_QUEUE_RETRY_AFTER,
+  DEFAULT_QUEUE_BLOCK_FOR,
+  DEFAULT_QUEUE_SLEEP,
+  DEFAULT_FAILED_JOBS_CONNECTION,
+  DEFAULT_FAILED_JOBS_TABLE,
+  DEFAULT_DATABASE_QUEUE_TABLE,
+  DEFAULT_REDIS_HOST,
+  DEFAULT_REDIS_PORT,
+  DEFAULT_REDIS_DB,
+  normalizeQueueConfig,
+  holoQueueDefaults,
+  queueInternals
+};

package/dist/config-Bleufve4.d.ts

@@ -0,0 +1,394 @@
+type QueueJsonPrimitive = string | number | boolean | null;
+type QueueJsonValue = QueueJsonPrimitive | readonly QueueJsonValue[] | {
+    readonly [key: string]: QueueJsonValue;
+};
+type QueueJobDispatcher = <TPayload extends QueueJsonValue>(jobName: string, payload: TPayload) => QueuePendingDispatch<TPayload>;
+type QueueJobSyncDispatcher = <TPayload extends QueueJsonValue, TResult>(jobName: string, payload: TPayload) => Promise<TResult>;
+declare function setQueueJobDispatcher(dispatcher: QueueJobDispatcher): void;
+declare function setQueueJobSyncDispatcher(dispatcher: QueueJobSyncDispatcher): void;
+declare function setQueueJobDefinitionName(definition: object, name: string): void;
+declare function deleteQueueJobDefinitionName(name: string): void;
+declare function clearQueueJobDefinitionNames(): void;
+declare function resolveQueueJobDefinitionName(definition: object): string;
+declare function dispatchDefinedQueueJob<TPayload extends QueueJsonValue>(definition: object, payload: TPayload): QueuePendingDispatch<TPayload>;
+declare function dispatchDefinedQueueJobSync<TPayload extends QueueJsonValue, TResult>(definition: object, payload: TPayload): Promise<TResult>;
+declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
+declare function normalizeOptionalInteger(value: number | undefined, label: string, options?: {
+    minimum?: number;
+}): number | undefined;
+declare function normalizeBackoff(value: number | readonly number[] | undefined): number | readonly number[] | undefined;
+declare function normalizeOptionalHook<THandler extends (...args: never[]) => unknown>(value: THandler | undefined, label: string): THandler | undefined;
+interface QueueJobContext {
+    readonly jobId: string;
+    readonly jobName: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+    release(delaySeconds?: number): Promise<void>;
+    fail(error: Error): Promise<void>;
+}
+interface QueueJobCompletedHook<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    (payload: TPayload, result: TResult, context: QueueJobContext): void | Promise<void>;
+}
+interface QueueJobFailedHook<TPayload extends QueueJsonValue = QueueJsonValue> {
+    (payload: TPayload, error: Error, context: QueueJobContext): void | Promise<void>;
+}
+interface QueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
+    readonly timeout?: number;
+    readonly onCompleted?: QueueJobCompletedHook<TPayload, TResult>;
+    readonly onFailed?: QueueJobFailedHook<TPayload>;
+    handle(payload: TPayload, context: QueueJobContext): Promise<TResult> | TResult;
+}
+interface DefinedQueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> extends QueueJobDefinition<TPayload, TResult> {
+    dispatch(payload: TPayload): QueuePendingDispatch<TPayload>;
+    dispatchSync(payload: TPayload): Promise<TResult>;
+}
+interface QueueJobEnvelope<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly id: string;
+    readonly name: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly payload: TPayload;
+    readonly attempts: number;
+    readonly maxAttempts: number;
+    readonly availableAt?: number;
+    readonly createdAt: number;
+}
+type QueueDelayValue = number | Date;
+interface QueueDispatchOptions {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly delay?: QueueDelayValue;
+}
+interface QueueDispatchResult {
+    readonly jobId: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly synchronous: boolean;
+}
+interface QueueDispatchCompletedHook {
+    (result: QueueDispatchResult): void | Promise<void>;
+}
+interface QueueDispatchFailedHook {
+    (error: unknown): void | Promise<void>;
+}
+interface QueueDriverDispatchResult<TResult = unknown> {
+    readonly jobId: string;
+    readonly synchronous: boolean;
+    readonly result?: TResult;
+}
+interface QueueRegisteredJob<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> {
+    readonly name: string;
+    readonly sourcePath?: string;
+    readonly definition: QueueJobDefinition<TPayload, TResult>;
+}
+interface HoloQueueJobRegistry {
+}
+type KnownQueueJobName = Extract<keyof HoloQueueJobRegistry, string>;
+type DynamicQueueJobName<TJobName extends string> = [KnownQueueJobName] extends [never] ? TJobName : TJobName extends KnownQueueJobName ? never : KnownQueueJobName extends TJobName ? never : TJobName;
+type ResolveRegisteredQueueJobDefinition<TJobName extends string> = TJobName extends KnownQueueJobName ? HoloQueueJobRegistry[TJobName] extends QueueJobDefinition<infer TPayload, infer TResult> ? QueueJobDefinition<TPayload, TResult> : QueueJobDefinition : QueueJobDefinition;
+type ExportedQueueJobDefinition<TValue> = TValue extends QueueJobDefinition<infer TPayload, infer TResult> ? QueueJobDefinition<TPayload, TResult> : QueueJobDefinition;
+type QueuePayloadFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<infer TPayload, infer _TResult> ? TPayload : QueueJsonValue;
+type QueueResultFor<TJobName extends string> = ResolveRegisteredQueueJobDefinition<TJobName> extends QueueJobDefinition<infer _TPayload, infer TResult> ? TResult : unknown;
+interface RegisterQueueJobOptions {
+    readonly name?: string;
+    readonly sourcePath?: string;
+    readonly replaceExisting?: boolean;
+}
+type RegisterableQueueJobDefinition<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown> = QueueJobDefinition<TPayload, TResult>;
+interface QueuePendingDispatch<TPayload extends QueueJsonValue = QueueJsonValue> extends PromiseLike<QueueDispatchResult> {
+    onConnection(name: string): QueuePendingDispatch<TPayload>;
+    onQueue(name: string): QueuePendingDispatch<TPayload>;
+    delay(value: QueueDelayValue): QueuePendingDispatch<TPayload>;
+    onComplete(callback: QueueDispatchCompletedHook): QueuePendingDispatch<TPayload>;
+    onFailed(callback: QueueDispatchFailedHook): QueuePendingDispatch<TPayload>;
+    then<TResult1 = QueueDispatchResult, TResult2 = never>(onfulfilled?: ((value: QueueDispatchResult) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<QueueDispatchResult | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<QueueDispatchResult>;
+    dispatch(): Promise<QueueDispatchResult>;
+}
+interface QueueConnectionFacade {
+    readonly name: string;
+    dispatch<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>, options?: QueueDispatchOptions): QueuePendingDispatch<QueuePayloadFor<TJobName>>;
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, const TJobName extends string = string>(jobName: TJobName & DynamicQueueJobName<TJobName>, payload: TPayload, options?: QueueDispatchOptions): QueuePendingDispatch<TPayload>;
+    dispatchSync<TJobName extends KnownQueueJobName>(jobName: TJobName, payload: QueuePayloadFor<TJobName>): Promise<QueueResultFor<TJobName>>;
+    dispatchSync<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown, const TJobName extends string = string>(jobName: TJobName & DynamicQueueJobName<TJobName>, payload: TPayload): Promise<TResult>;
+}
+interface QueueEnqueueResult {
+    readonly jobId: string;
+}
+interface QueueReserveInput {
+    readonly queueNames?: readonly string[];
+    readonly workerId?: string;
+    readonly timeout?: number;
+}
+interface QueueReservedJob<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly reservationId: string;
+    readonly envelope: QueueJobEnvelope<TPayload>;
+    readonly reservedAt: number;
+}
+interface QueueReleaseOptions {
+    readonly delaySeconds?: number;
+}
+interface QueueClearInput {
+    readonly queueNames?: readonly string[];
+}
+interface QueueJobContextOverrides {
+    readonly maxAttempts?: number;
+    shouldSkipLifecycleHooks?(): boolean;
+    release?(delaySeconds?: number): Promise<void>;
+    fail?(error: Error): Promise<void>;
+}
+interface QueueDriverFactoryContext {
+    execute<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<TResult>;
+}
+interface QueueDriverBase {
+    readonly name: string;
+    readonly driver: NormalizedQueueConnectionConfig['driver'];
+    readonly mode: 'sync' | 'async';
+    dispatch<TPayload extends QueueJsonValue = QueueJsonValue, TResult = unknown>(job: QueueJobEnvelope<TPayload>): Promise<QueueDriverDispatchResult<TResult>>;
+    clear(input?: QueueClearInput): Promise<number>;
+    close(): Promise<void>;
+}
+interface QueueAsyncDriver extends QueueDriverBase {
+    readonly mode: 'async';
+    reserve<TPayload extends QueueJsonValue = QueueJsonValue>(input: QueueReserveInput): Promise<QueueReservedJob<TPayload> | null>;
+    acknowledge(job: QueueReservedJob): Promise<void>;
+    release(job: QueueReservedJob, options?: QueueReleaseOptions): Promise<void>;
+    delete(job: QueueReservedJob): Promise<void>;
+}
+interface QueueSyncDriver extends QueueDriverBase {
+    readonly mode: 'sync';
+}
+type QueueDriver = QueueSyncDriver | QueueAsyncDriver;
+interface QueueDriverFactory<TConfig extends NormalizedQueueConnectionConfig = NormalizedQueueConnectionConfig> {
+    readonly driver: TConfig['driver'];
+    create(connection: TConfig, context: QueueDriverFactoryContext): QueueDriver;
+}
+interface QueueRuntimeBinding {
+    readonly config: NormalizedHoloQueueConfig;
+    readonly drivers: ReadonlyMap<string, QueueDriver>;
+}
+interface QueueWorkerOptions {
+    readonly connection?: string;
+    readonly queueNames?: readonly string[];
+    readonly once?: boolean;
+    readonly stopWhenEmpty?: boolean;
+    readonly sleep?: number;
+    readonly tries?: number;
+    readonly timeout?: number;
+    readonly maxJobs?: number;
+    readonly maxTime?: number;
+    readonly workerId?: string;
+    readonly shouldStop?: () => boolean | Promise<boolean>;
+    readonly sleepFn?: (milliseconds: number) => Promise<void>;
+}
+interface QueueWorkerJobEvent {
+    readonly jobId: string;
+    readonly jobName: string;
+    readonly connection: string;
+    readonly queue: string;
+    readonly attempt: number;
+    readonly maxAttempts: number;
+}
+interface QueueWorkerHooks {
+    onJobProcessed?(event: QueueWorkerJobEvent): void | Promise<void>;
+    onJobReleased?(event: QueueWorkerJobEvent & {
+        readonly delaySeconds?: number;
+        readonly error?: Error;
+    }): void | Promise<void>;
+    onJobFailed?(event: QueueWorkerJobEvent & {
+        readonly error: Error;
+    }): void | Promise<void>;
+    onIdle?(): void | Promise<void>;
+}
+interface QueueWorkerRunOptions extends QueueWorkerOptions, QueueWorkerHooks {
+}
+interface QueueWorkerResult {
+    readonly processed: number;
+    readonly released: number;
+    readonly failed: number;
+    readonly stoppedBecause: 'once' | 'empty' | 'max-jobs' | 'max-time' | 'signal';
+}
+interface QueueFailedJobRecord<TPayload extends QueueJsonValue = QueueJsonValue> {
+    readonly id: string;
+    readonly jobId: string;
+    readonly job: QueueJobEnvelope<TPayload>;
+    readonly exception: string;
+    readonly failedAt: number;
+}
+interface QueueFailedJobStore {
+    persistFailedJob(reserved: QueueReservedJob, error: Error): Promise<QueueFailedJobRecord | null>;
+    listFailedJobs(): Promise<readonly QueueFailedJobRecord[]>;
+    retryFailedJobs(identifier: 'all' | string, retry: (record: QueueFailedJobRecord) => Promise<void>): Promise<number>;
+    forgetFailedJob(id: string): Promise<boolean>;
+    flushFailedJobs(): Promise<number>;
+}
+declare function isQueueJobDefinition(value: unknown): value is QueueJobDefinition;
+declare function normalizeQueueJobDefinition<TPayload extends QueueJsonValue, TResult, TJob extends QueueJobDefinition<TPayload, TResult>>(job: TJob): TJob;
+declare function defineJob<TPayload extends QueueJsonValue, TResult = unknown>(job: QueueJobDefinition<TPayload, TResult>): DefinedQueueJobDefinition<TPayload, TResult>;
+interface QueueFailedStoreConfig {
+    readonly driver?: 'database';
+    readonly connection?: string;
+    readonly table?: string;
+}
+interface QueueRedisConnectionConfig {
+    readonly driver: 'redis';
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly retryAfter?: number | string;
+    readonly blockFor?: number | string;
+    readonly redis?: {
+        readonly url?: string;
+        readonly clusters?: readonly {
+            readonly url?: string;
+            readonly host?: string;
+            readonly port?: number | string;
+        }[];
+        readonly host?: string;
+        readonly port?: number | string;
+        readonly password?: string;
+        readonly username?: string;
+        readonly db?: number | string;
+    };
+}
+interface QueueDatabaseConnectionConfig {
+    readonly driver: 'database';
+    readonly queue?: string;
+    readonly retryAfter?: number | string;
+    readonly sleep?: number | string;
+    readonly connection?: string;
+    readonly table?: string;
+}
+interface QueueSyncConnectionConfig {
+    readonly driver: 'sync';
+    readonly queue?: string;
+}
+interface QueuePluginConnectionConfig {
+    readonly driver: string;
+    readonly queue?: string;
+    readonly [key: string]: unknown;
+}
+type QueueConnectionConfig = QueueSyncConnectionConfig | QueueRedisConnectionConfig | QueueDatabaseConnectionConfig | QueuePluginConnectionConfig;
+interface HoloQueueConfig {
+    readonly default?: string;
+    readonly failed?: false | QueueFailedStoreConfig;
+    readonly connections?: Readonly<Record<string, QueueConnectionConfig>>;
+}
+interface NormalizedQueueFailedStoreConfig {
+    readonly driver: 'database';
+    readonly connection: string;
+    readonly table: string;
+}
+interface NormalizedQueueSyncConnectionConfig {
+    readonly name: string;
+    readonly driver: 'sync';
+    readonly queue: string;
+}
+interface NormalizedQueueRedisConnectionConfig {
+    readonly name: string;
+    readonly driver: 'redis';
+    readonly connection: string;
+    readonly queue: string;
+    readonly retryAfter: number;
+    readonly blockFor: number;
+    readonly redis: {
+        readonly url?: string;
+        readonly clusters?: readonly {
+            readonly url?: string;
+            readonly host: string;
+            readonly port: number;
+        }[];
+        readonly host: string;
+        readonly port: number;
+        readonly password?: string;
+        readonly username?: string;
+        readonly db: number;
+    };
+}
+interface QueueSharedRedisConnectionConfig {
+    readonly name: string;
+    readonly url?: string;
+    readonly clusters?: readonly {
+        readonly url?: string;
+        readonly host: string;
+        readonly port: number;
+    }[];
+    readonly host: string;
+    readonly port: number;
+    readonly password?: string;
+    readonly username?: string;
+    readonly db: number;
+}
+interface QueueSharedRedisConfig {
+    readonly default: string;
+    readonly connections: Readonly<Record<string, QueueSharedRedisConnectionConfig>>;
+}
+interface NormalizedQueueDatabaseConnectionConfig {
+    readonly name: string;
+    readonly driver: 'database';
+    readonly queue: string;
+    readonly retryAfter: number;
+    readonly sleep: number;
+    readonly connection: string;
+    readonly table: string;
+}
+interface NormalizedQueuePluginConnectionConfig {
+    readonly name: string;
+    readonly driver: string;
+    readonly queue: string;
+    readonly [key: string]: unknown;
+}
+type NormalizedQueueConnectionConfig = NormalizedQueueSyncConnectionConfig | NormalizedQueueRedisConnectionConfig | NormalizedQueueDatabaseConnectionConfig | NormalizedQueuePluginConnectionConfig;
+interface NormalizedHoloQueueConfig {
+    readonly default: string;
+    readonly failed: false | NormalizedQueueFailedStoreConfig;
+    readonly connections: Readonly<Record<string, NormalizedQueueConnectionConfig>>;
+}
+declare const queueJobInternals: {
+    clearQueueJobDefinitionNames: typeof clearQueueJobDefinitionNames;
+    deleteQueueJobDefinitionName: typeof deleteQueueJobDefinitionName;
+    dispatchDefinedQueueJob: typeof dispatchDefinedQueueJob;
+    dispatchDefinedQueueJobSync: typeof dispatchDefinedQueueJobSync;
+    normalizeQueueJobDefinition: typeof normalizeQueueJobDefinition;
+    normalizeBackoff: typeof normalizeBackoff;
+    normalizeOptionalHook: typeof normalizeOptionalHook;
+    normalizeOptionalInteger: typeof normalizeOptionalInteger;
+    normalizeOptionalString: typeof normalizeOptionalString;
+    resolveQueueJobDefinitionName: typeof resolveQueueJobDefinitionName;
+    setQueueJobDefinitionName: typeof setQueueJobDefinitionName;
+    setQueueJobDispatcher: typeof setQueueJobDispatcher;
+    setQueueJobSyncDispatcher: typeof setQueueJobSyncDispatcher;
+};
+
+declare const DEFAULT_QUEUE_CONNECTION = "sync";
+declare const DEFAULT_QUEUE_NAME = "default";
+declare const DEFAULT_QUEUE_RETRY_AFTER = 90;
+declare const DEFAULT_QUEUE_BLOCK_FOR = 5;
+declare const DEFAULT_QUEUE_SLEEP = 1;
+declare const DEFAULT_FAILED_JOBS_CONNECTION = "default";
+declare const DEFAULT_FAILED_JOBS_TABLE = "failed_jobs";
+declare const DEFAULT_DATABASE_QUEUE_TABLE = "jobs";
+declare const DEFAULT_REDIS_HOST = "127.0.0.1";
+declare const DEFAULT_REDIS_PORT = 6379;
+declare const DEFAULT_REDIS_DB = 0;
+declare function parseInteger(value: number | string | undefined, fallback: number, label: string, options?: {
+    minimum?: number;
+}): number;
+declare function normalizeQueueConfig(config?: HoloQueueConfig, redisConfig?: QueueSharedRedisConfig): NormalizedHoloQueueConfig;
+declare const holoQueueDefaults: Readonly<NormalizedHoloQueueConfig>;
+declare const queueInternals: {
+    parseInteger: typeof parseInteger;
+};
+declare module '@holo-js/config' {
+    interface HoloConfigRegistry {
+        queue: NormalizedHoloQueueConfig;
+    }
+}
+
+export { type QueueDispatchFailedHook as $, type QueueWorkerJobEvent as A, type QueueAsyncDriver as B, type QueueWorkerRunOptions as C, type QueueJobDefinition as D, type QueueWorkerOptions as E, type QueueWorkerResult as F, DEFAULT_DATABASE_QUEUE_TABLE as G, type HoloQueueJobRegistry as H, DEFAULT_FAILED_JOBS_CONNECTION as I, DEFAULT_FAILED_JOBS_TABLE as J, DEFAULT_QUEUE_BLOCK_FOR as K, DEFAULT_QUEUE_CONNECTION as L, DEFAULT_QUEUE_NAME as M, type NormalizedQueueSyncConnectionConfig as N, DEFAULT_QUEUE_RETRY_AFTER as O, DEFAULT_QUEUE_SLEEP as P, type QueueRegisteredJob as Q, type RegisterableQueueJobDefinition as R, type DefinedQueueJobDefinition as S, type ExportedQueueJobDefinition as T, type NormalizedQueueDatabaseConnectionConfig as U, type NormalizedQueueFailedStoreConfig as V, type NormalizedQueuePluginConnectionConfig as W, type NormalizedQueueRedisConnectionConfig as X, type QueueConnectionConfig as Y, type QueueDatabaseConnectionConfig as Z, type QueueDispatchCompletedHook as _, type QueueJsonValue as a, type QueueEnqueueResult as a0, type QueueFailedStoreConfig as a1, type QueuePluginConnectionConfig as a2, type QueueRedisConnectionConfig as a3, type QueueReleaseOptions as a4, type QueueReserveInput as a5, type QueueSharedRedisConnectionConfig as a6, type QueueSyncConnectionConfig as a7, type QueueWorkerHooks as a8, defineJob as a9, holoQueueDefaults as aa, isQueueJobDefinition as ab, normalizeQueueConfig as ac, normalizeQueueJobDefinition as ad, queueInternals as ae, queueJobInternals as af, DEFAULT_REDIS_DB as ag, DEFAULT_REDIS_HOST as ah, DEFAULT_REDIS_PORT as ai, type RegisterQueueJobOptions as b, type QueueDriverFactory as c, type QueueSyncDriver as d, type QueueDriverFactoryContext as e, type QueueJobEnvelope as f, type QueueDriverDispatchResult as g, type QueueConnectionFacade as h, type QueuePayloadFor as i, type QueueDispatchOptions as j, type QueuePendingDispatch as k, type QueueResultFor as l, type HoloQueueConfig as m, type NormalizedHoloQueueConfig as n, type QueueSharedRedisConfig as o, type QueueFailedJobStore as p, type QueueRuntimeBinding as q, type QueueDriver as r, type QueueJobContextOverrides as s, type QueueJobContext as t, type QueueDispatchResult as u, type QueueDelayValue as v, type NormalizedQueueConnectionConfig as w, type QueueFailedJobRecord as x, type QueueReservedJob as y, type QueueClearInput as z };

package/dist/config.d.ts

@@ -0,0 +1 @@
+export { G as DEFAULT_DATABASE_QUEUE_TABLE, I as DEFAULT_FAILED_JOBS_CONNECTION, J as DEFAULT_FAILED_JOBS_TABLE, K as DEFAULT_QUEUE_BLOCK_FOR, L as DEFAULT_QUEUE_CONNECTION, M as DEFAULT_QUEUE_NAME, O as DEFAULT_QUEUE_RETRY_AFTER, P as DEFAULT_QUEUE_SLEEP, ag as DEFAULT_REDIS_DB, ah as DEFAULT_REDIS_HOST, ai as DEFAULT_REDIS_PORT, m as HoloQueueConfig, n as NormalizedHoloQueueConfig, w as NormalizedQueueConnectionConfig, U as NormalizedQueueDatabaseConnectionConfig, V as NormalizedQueueFailedStoreConfig, W as NormalizedQueuePluginConnectionConfig, X as NormalizedQueueRedisConnectionConfig, N as NormalizedQueueSyncConnectionConfig, Y as QueueConnectionConfig, Z as QueueDatabaseConnectionConfig, a1 as QueueFailedStoreConfig, a2 as QueuePluginConnectionConfig, a3 as QueueRedisConnectionConfig, o as QueueSharedRedisConfig, a6 as QueueSharedRedisConnectionConfig, a7 as QueueSyncConnectionConfig, aa as holoQueueDefaults, ac as normalizeQueueConfig, ae as queueInternals } from './config-Bleufve4.js';