@happyvertical/jobs 0.74.8

package/dist/chunks/base-store-DlNksWvQ.js

@@ -0,0 +1,324 @@
+import { createId } from "@happyvertical/utils";
+class ExponentialBackoffStrategy {
+  initialDelay;
+  maxDelay;
+  multiplier;
+  jitter;
+  maxAttempts;
+  constructor(options = {}) {
+    this.initialDelay = options.initialDelay ?? 1e3;
+    this.maxDelay = options.maxDelay ?? 3e5;
+    this.multiplier = options.multiplier ?? 2;
+    this.jitter = options.jitter ?? true;
+    this.maxAttempts = options.maxAttempts ?? null;
+  }
+  shouldRetry(attempt, _error) {
+    if (this.maxAttempts !== null && attempt >= this.maxAttempts) {
+      return { shouldRetry: false, delay: 0 };
+    }
+    let delay = this.initialDelay * this.multiplier ** (attempt - 1);
+    delay = Math.min(delay, this.maxDelay);
+    if (this.jitter) {
+      const jitterRange = delay * 0.25;
+      delay = delay - jitterRange + Math.random() * jitterRange * 2;
+    }
+    return { shouldRetry: true, delay: Math.round(delay) };
+  }
+  toConfig() {
+    return {
+      type: "exponential",
+      config: {
+        initialDelay: this.initialDelay,
+        maxDelay: this.maxDelay,
+        multiplier: this.multiplier,
+        jitter: this.jitter,
+        maxAttempts: this.maxAttempts
+      }
+    };
+  }
+}
+class LinearBackoffStrategy {
+  delay;
+  maxAttempts;
+  constructor(options = {}) {
+    this.delay = options.delay ?? 5e3;
+    this.maxAttempts = options.maxAttempts ?? null;
+  }
+  shouldRetry(attempt, _error) {
+    if (this.maxAttempts !== null && attempt >= this.maxAttempts) {
+      return { shouldRetry: false, delay: 0 };
+    }
+    return { shouldRetry: true, delay: this.delay };
+  }
+  toConfig() {
+    return {
+      type: "linear",
+      config: {
+        delay: this.delay,
+        maxAttempts: this.maxAttempts
+      }
+    };
+  }
+}
+class CustomRetryStrategy {
+  fn;
+  fnString;
+  constructor(fn) {
+    this.fn = fn;
+    this.fnString = fn.toString();
+  }
+  shouldRetry(attempt, error) {
+    return this.fn(attempt, error);
+  }
+  toConfig() {
+    return {
+      type: "custom",
+      config: {
+        fn: this.fnString
+      }
+    };
+  }
+}
+class NoRetryStrategy {
+  shouldRetry(_attempt, _error) {
+    return { shouldRetry: false, delay: 0 };
+  }
+  toConfig() {
+    return {
+      type: "linear",
+      config: { maxAttempts: 1 }
+    };
+  }
+}
+function exponential(options) {
+  return new ExponentialBackoffStrategy(options);
+}
+function linear(options) {
+  return new LinearBackoffStrategy(options);
+}
+function custom(fn) {
+  return new CustomRetryStrategy(fn);
+}
+function noRetry() {
+  return new NoRetryStrategy();
+}
+function fromConfig(config) {
+  switch (config.type) {
+    case "exponential":
+      return new ExponentialBackoffStrategy(
+        config.config
+      );
+    case "linear":
+      return new LinearBackoffStrategy(config.config);
+    case "custom":
+      console.warn(
+        "Custom retry strategy cannot be reconstructed from config, using exponential"
+      );
+      return new ExponentialBackoffStrategy();
+    default:
+      return new ExponentialBackoffStrategy();
+  }
+}
+const DEFAULT_RETRY_STRATEGY = exponential({
+  initialDelay: 1e3,
+  maxDelay: 3e5,
+  multiplier: 2,
+  jitter: true
+});
+const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function validateTableName(tableName) {
+  if (!tableName || tableName.length === 0) {
+    throw new Error("Table name cannot be empty");
+  }
+  if (tableName.length > 128) {
+    throw new Error("Table name cannot exceed 128 characters");
+  }
+  if (!TABLE_NAME_PATTERN.test(tableName)) {
+    throw new Error(
+      `Invalid table name "${tableName}": must contain only alphanumeric characters and underscores, and must start with a letter or underscore`
+    );
+  }
+  return tableName;
+}
+function priorityToNumber(priority) {
+  if (typeof priority === "number") return priority;
+  switch (priority) {
+    case "critical":
+      return 100;
+    case "high":
+      return 75;
+    case "normal":
+      return 50;
+    case "low":
+      return 25;
+    default:
+      return 50;
+  }
+}
+class BaseJobStore {
+  listeners = /* @__PURE__ */ new Set();
+  initialized = false;
+  /**
+   * Create a new job record
+   */
+  createJobRecord(options) {
+    const now = /* @__PURE__ */ new Date();
+    const retryConfig = options.retryStrategy && "toConfig" in options.retryStrategy ? options.retryStrategy.toConfig() : options.retryStrategy ?? DEFAULT_RETRY_STRATEGY.toConfig();
+    return {
+      id: createId(),
+      queue: options.queue ?? "default",
+      payload: options.payload,
+      status: "pending",
+      priority: priorityToNumber(options.priority),
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? 3,
+      runAt: options.runAt ?? now,
+      startedAt: null,
+      completedAt: null,
+      timeout: options.timeout ?? 3e5,
+      timeoutBehavior: options.timeoutBehavior ?? "fail",
+      lastError: null,
+      resultPointer: null,
+      retryStrategy: retryConfig,
+      workerId: null,
+      workerHeartbeat: null,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Emit a job event to all listeners
+   */
+  async emitEvent(type, job, extra) {
+    const event = {
+      type,
+      job,
+      timestamp: /* @__PURE__ */ new Date(),
+      ...extra
+    };
+    const promises = Array.from(this.listeners).map(
+      (listener) => Promise.resolve(listener(event)).catch((err) => {
+        console.error("Job event listener error:", err);
+      })
+    );
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Subscribe to job events
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Build WHERE clause for filters
+   */
+  buildFilterWhere(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter.queue) {
+      conditions.push("queue = ?");
+      params.push(filter.queue);
+    }
+    if (filter.status) {
+      if (Array.isArray(filter.status)) {
+        const placeholders = filter.status.map(() => "?").join(", ");
+        conditions.push(`status IN (${placeholders})`);
+        params.push(...filter.status);
+      } else {
+        conditions.push("status = ?");
+        params.push(filter.status);
+      }
+    }
+    if (filter.objectType) {
+      conditions.push("json_extract(payload, '$.objectType') = ?");
+      params.push(filter.objectType);
+    }
+    if (filter.method) {
+      conditions.push("json_extract(payload, '$.method') = ?");
+      params.push(filter.method);
+    }
+    if (filter.createdAfter) {
+      conditions.push("created_at > ?");
+      params.push(filter.createdAfter.toISOString());
+    }
+    if (filter.createdBefore) {
+      conditions.push("created_at < ?");
+      params.push(filter.createdBefore.toISOString());
+    }
+    return {
+      where: conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "",
+      params
+    };
+  }
+  /**
+   * Build ORDER BY clause for filters
+   */
+  buildOrderBy(filter) {
+    const field = filter.orderBy ?? "createdAt";
+    const dir = filter.orderDir ?? "desc";
+    const fieldMap = {
+      createdAt: "created_at",
+      runAt: "run_at",
+      priority: "priority",
+      attempts: "attempts"
+    };
+    return `ORDER BY ${fieldMap[field] ?? "created_at"} ${dir.toUpperCase()}`;
+  }
+  /**
+   * Build LIMIT/OFFSET clause
+   */
+  buildLimitOffset(filter) {
+    const params = [];
+    let clause = "";
+    if (filter.limit) {
+      clause = "LIMIT ?";
+      params.push(filter.limit);
+      if (filter.offset) {
+        clause += " OFFSET ?";
+        params.push(filter.offset);
+      }
+    }
+    return { clause, params };
+  }
+  /**
+   * Parse a job row from the database
+   */
+  parseJobRow(row) {
+    return {
+      id: row.id,
+      queue: row.queue,
+      payload: typeof row.payload === "string" ? JSON.parse(row.payload) : row.payload,
+      status: row.status,
+      priority: row.priority,
+      attempts: row.attempts,
+      maxAttempts: row.max_attempts,
+      runAt: new Date(row.run_at),
+      startedAt: row.started_at ? new Date(row.started_at) : null,
+      completedAt: row.completed_at ? new Date(row.completed_at) : null,
+      timeout: row.timeout,
+      timeoutBehavior: row.timeout_behavior,
+      lastError: row.last_error,
+      resultPointer: row.result_pointer,
+      retryStrategy: typeof row.retry_strategy === "string" ? JSON.parse(row.retry_strategy) : row.retry_strategy,
+      workerId: row.worker_id,
+      workerHeartbeat: row.worker_heartbeat ? new Date(row.worker_heartbeat) : null,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+}
+export {
+  BaseJobStore as B,
+  DEFAULT_RETRY_STRATEGY as D,
+  custom as c,
+  exponential as e,
+  fromConfig as f,
+  linear as l,
+  noRetry as n,
+  priorityToNumber as p,
+  validateTableName as v
+};
+//# sourceMappingURL=base-store-DlNksWvQ.js.map

package/dist/chunks/base-store-DlNksWvQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-store-DlNksWvQ.js","sources":["../../src/retry.ts","../../src/base-store.ts"],"sourcesContent":["import type {\n  RetryDecision,\n  RetryStrategy,\n  RetryStrategyConfig,\n} from './types.js';\n\n/**\n * Options for exponential backoff retry strategy\n */\nexport interface ExponentialBackoffOptions {\n  /** Initial delay in milliseconds (default: 1000) */\n  initialDelay?: number;\n  /** Maximum delay in milliseconds (default: 300000 = 5 minutes) */\n  maxDelay?: number;\n  /** Multiplier for each attempt (default: 2) */\n  multiplier?: number;\n  /** Add random jitter to prevent thundering herd (default: true) */\n  jitter?: boolean;\n  /** Maximum attempts (optional, can also be set on job) */\n  maxAttempts?: number;\n}\n\n/**\n * Exponential backoff retry strategy\n *\n * Delay increases exponentially: initialDelay * multiplier^(attempt-1)\n * With optional jitter to prevent thundering herd problem.\n */\nclass ExponentialBackoffStrategy implements RetryStrategy {\n  private readonly initialDelay: number;\n  private readonly maxDelay: number;\n  private readonly multiplier: number;\n  private readonly jitter: boolean;\n  private readonly maxAttempts: number | null;\n\n  constructor(options: ExponentialBackoffOptions = {}) {\n    this.initialDelay = options.initialDelay ?? 1000;\n    this.maxDelay = options.maxDelay ?? 300000;\n    this.multiplier = options.multiplier ?? 2;\n    this.jitter = options.jitter ?? true;\n    this.maxAttempts = options.maxAttempts ?? null;\n  }\n\n  shouldRetry(attempt: number, _error: Error): RetryDecision {\n    // Check max attempts if configured\n    if (this.maxAttempts !== null && attempt >= this.maxAttempts) {\n      return { shouldRetry: false, delay: 0 };\n    }\n\n    // Calculate base delay: initialDelay * multiplier^(attempt-1)\n    let delay = this.initialDelay * this.multiplier ** (attempt - 1);\n\n    // Cap at maxDelay\n    delay = Math.min(delay, this.maxDelay);\n\n    // Add jitter (±25% randomization)\n    if (this.jitter) {\n      const jitterRange = delay * 0.25;\n      delay = delay - jitterRange + Math.random() * jitterRange * 2;\n    }\n\n    return { shouldRetry: true, delay: Math.round(delay) };\n  }\n\n  toConfig(): RetryStrategyConfig {\n    return {\n      type: 'exponential',\n      config: {\n        initialDelay: this.initialDelay,\n        maxDelay: this.maxDelay,\n        multiplier: this.multiplier,\n        jitter: this.jitter,\n        maxAttempts: this.maxAttempts,\n      },\n    };\n  }\n}\n\n/**\n * Options for linear retry strategy\n */\nexport interface LinearBackoffOptions {\n  /** Fixed delay between retries in milliseconds (default: 5000) */\n  delay?: number;\n  /** Maximum attempts (optional) */\n  maxAttempts?: number;\n}\n\n/**\n * Linear retry strategy\n *\n * Uses a fixed delay between all retry attempts.\n */\nclass LinearBackoffStrategy implements RetryStrategy {\n  private readonly delay: number;\n  private readonly maxAttempts: number | null;\n\n  constructor(options: LinearBackoffOptions = {}) {\n    this.delay = options.delay ?? 5000;\n    this.maxAttempts = options.maxAttempts ?? null;\n  }\n\n  shouldRetry(attempt: number, _error: Error): RetryDecision {\n    if (this.maxAttempts !== null && attempt >= this.maxAttempts) {\n      return { shouldRetry: false, delay: 0 };\n    }\n\n    return { shouldRetry: true, delay: this.delay };\n  }\n\n  toConfig(): RetryStrategyConfig {\n    return {\n      type: 'linear',\n      config: {\n        delay: this.delay,\n        maxAttempts: this.maxAttempts,\n      },\n    };\n  }\n}\n\n/**\n * Custom retry decision function\n */\nexport type CustomRetryFn = (attempt: number, error: Error) => RetryDecision;\n\n/**\n * Custom retry strategy\n *\n * Allows full control over retry logic via a custom function.\n */\nclass CustomRetryStrategy implements RetryStrategy {\n  private readonly fn: CustomRetryFn;\n  private readonly fnString: string;\n\n  constructor(fn: CustomRetryFn) {\n    this.fn = fn;\n    // Store string representation for serialization\n    this.fnString = fn.toString();\n  }\n\n  shouldRetry(attempt: number, error: Error): RetryDecision {\n    return this.fn(attempt, error);\n  }\n\n  toConfig(): RetryStrategyConfig {\n    return {\n      type: 'custom',\n      config: {\n        fn: this.fnString,\n      },\n    };\n  }\n}\n\n/**\n * No retry strategy - never retry\n */\nclass NoRetryStrategy implements RetryStrategy {\n  shouldRetry(_attempt: number, _error: Error): RetryDecision {\n    return { shouldRetry: false, delay: 0 };\n  }\n\n  toConfig(): RetryStrategyConfig {\n    return {\n      type: 'linear',\n      config: { maxAttempts: 1 },\n    };\n  }\n}\n\n// Factory functions\n\n/**\n * Create an exponential backoff retry strategy\n *\n * @example\n * ```typescript\n * const strategy = exponential({\n *   initialDelay: 1000,\n *   maxDelay: 300000,\n *   multiplier: 2,\n *   jitter: true,\n * });\n * ```\n */\nexport function exponential(\n  options?: ExponentialBackoffOptions,\n): RetryStrategy {\n  return new ExponentialBackoffStrategy(options);\n}\n\n/**\n * Create a linear retry strategy with fixed delay\n *\n * @example\n * ```typescript\n * const strategy = linear({ delay: 5000 });\n * ```\n */\nexport function linear(options?: LinearBackoffOptions): RetryStrategy {\n  return new LinearBackoffStrategy(options);\n}\n\n/**\n * Create a custom retry strategy\n *\n * @example\n * ```typescript\n * const strategy = custom((attempt, error) => {\n *   if (error.message.includes('RATE_LIMITED')) {\n *     return { shouldRetry: true, delay: 60000 };\n *   }\n *   return { shouldRetry: attempt < 3, delay: attempt * 1000 };\n * });\n * ```\n */\nexport function custom(fn: CustomRetryFn): RetryStrategy {\n  return new CustomRetryStrategy(fn);\n}\n\n/**\n * Create a no-retry strategy\n *\n * @example\n * ```typescript\n * const strategy = noRetry();\n * ```\n */\nexport function noRetry(): RetryStrategy {\n  return new NoRetryStrategy();\n}\n\n/**\n * Reconstruct a retry strategy from its config\n */\nexport function fromConfig(config: RetryStrategyConfig): RetryStrategy {\n  switch (config.type) {\n    case 'exponential':\n      return new ExponentialBackoffStrategy(\n        config.config as ExponentialBackoffOptions,\n      );\n    case 'linear':\n      return new LinearBackoffStrategy(config.config as LinearBackoffOptions);\n    case 'custom':\n      // For custom strategies loaded from config, we can't reconstruct the function\n      // So we fall back to exponential\n      console.warn(\n        'Custom retry strategy cannot be reconstructed from config, using exponential',\n      );\n      return new ExponentialBackoffStrategy();\n    default:\n      return new ExponentialBackoffStrategy();\n  }\n}\n\n/**\n * Default retry strategy\n */\nexport const DEFAULT_RETRY_STRATEGY = exponential({\n  initialDelay: 1000,\n  maxDelay: 300000,\n  multiplier: 2,\n  jitter: true,\n});\n","import { createId } from '@happyvertical/utils';\nimport { DEFAULT_RETRY_STRATEGY } from './retry.js';\nimport type {\n  CleanupOptions,\n  Job,\n  JobCreateOptions,\n  JobEvent,\n  JobEventListener,\n  JobEventType,\n  JobFilter,\n  JobPriority,\n  JobStore,\n  QueueStats,\n  RetryStrategyConfig,\n} from './types.js';\n\n/**\n * Valid table name pattern: alphanumeric and underscores, must start with letter or underscore\n */\nconst TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;\n\n/**\n * Validate table name to prevent SQL injection\n * @throws Error if table name contains invalid characters\n */\nexport function validateTableName(tableName: string): string {\n  if (!tableName || tableName.length === 0) {\n    throw new Error('Table name cannot be empty');\n  }\n  if (tableName.length > 128) {\n    throw new Error('Table name cannot exceed 128 characters');\n  }\n  if (!TABLE_NAME_PATTERN.test(tableName)) {\n    throw new Error(\n      `Invalid table name \"${tableName}\": must contain only alphanumeric characters and underscores, and must start with a letter or underscore`,\n    );\n  }\n  return tableName;\n}\n\n/**\n * Convert priority string to number\n */\nexport function priorityToNumber(\n  priority: JobPriority | number | undefined,\n): number {\n  if (typeof priority === 'number') return priority;\n  switch (priority) {\n    case 'critical':\n      return 100;\n    case 'high':\n      return 75;\n    case 'normal':\n      return 50;\n    case 'low':\n      return 25;\n    default:\n      return 50;\n  }\n}\n\n/**\n * Base job store with common functionality\n */\nexport abstract class BaseJobStore implements JobStore {\n  protected listeners: Set<JobEventListener> = new Set();\n  protected initialized = false;\n\n  /**\n   * Initialize the store - must be implemented by subclasses\n   */\n  abstract initialize(): Promise<void>;\n\n  /**\n   * Create a new job record\n   */\n  protected createJobRecord(options: JobCreateOptions): Job {\n    const now = new Date();\n    const retryConfig: RetryStrategyConfig =\n      options.retryStrategy && 'toConfig' in options.retryStrategy\n        ? options.retryStrategy.toConfig()\n        : ((options.retryStrategy as RetryStrategyConfig) ??\n          DEFAULT_RETRY_STRATEGY.toConfig());\n\n    return {\n      id: createId(),\n      queue: options.queue ?? 'default',\n      payload: options.payload,\n      status: 'pending',\n      priority: priorityToNumber(options.priority),\n      attempts: 0,\n      maxAttempts: options.maxAttempts ?? 3,\n      runAt: options.runAt ?? now,\n      startedAt: null,\n      completedAt: null,\n      timeout: options.timeout ?? 300000,\n      timeoutBehavior: options.timeoutBehavior ?? 'fail',\n      lastError: null,\n      resultPointer: null,\n      retryStrategy: retryConfig,\n      workerId: null,\n      workerHeartbeat: null,\n      createdAt: now,\n      updatedAt: now,\n    };\n  }\n\n  /**\n   * Emit a job event to all listeners\n   */\n  protected async emitEvent(\n    type: JobEventType,\n    job: Job,\n    extra?: { error?: string; resultPointer?: string },\n  ): Promise<void> {\n    const event: JobEvent = {\n      type,\n      job,\n      timestamp: new Date(),\n      ...extra,\n    };\n\n    const promises = Array.from(this.listeners).map((listener) =>\n      Promise.resolve(listener(event)).catch((err) => {\n        console.error('Job event listener error:', err);\n      }),\n    );\n\n    await Promise.allSettled(promises);\n  }\n\n  /**\n   * Subscribe to job events\n   */\n  subscribe(listener: JobEventListener): () => void {\n    this.listeners.add(listener);\n    return () => {\n      this.listeners.delete(listener);\n    };\n  }\n\n  /**\n   * Build WHERE clause for filters\n   */\n  protected buildFilterWhere(filter: JobFilter): {\n    where: string;\n    params: unknown[];\n  } {\n    const conditions: string[] = [];\n    const params: unknown[] = [];\n\n    if (filter.queue) {\n      conditions.push('queue = ?');\n      params.push(filter.queue);\n    }\n\n    if (filter.status) {\n      if (Array.isArray(filter.status)) {\n        const placeholders = filter.status.map(() => '?').join(', ');\n        conditions.push(`status IN (${placeholders})`);\n        params.push(...filter.status);\n      } else {\n        conditions.push('status = ?');\n        params.push(filter.status);\n      }\n    }\n\n    if (filter.objectType) {\n      conditions.push(\"json_extract(payload, '$.objectType') = ?\");\n      params.push(filter.objectType);\n    }\n\n    if (filter.method) {\n      conditions.push(\"json_extract(payload, '$.method') = ?\");\n      params.push(filter.method);\n    }\n\n    if (filter.createdAfter) {\n      conditions.push('created_at > ?');\n      params.push(filter.createdAfter.toISOString());\n    }\n\n    if (filter.createdBefore) {\n      conditions.push('created_at < ?');\n      params.push(filter.createdBefore.toISOString());\n    }\n\n    return {\n      where: conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '',\n      params,\n    };\n  }\n\n  /**\n   * Build ORDER BY clause for filters\n   */\n  protected buildOrderBy(filter: JobFilter): string {\n    const field = filter.orderBy ?? 'createdAt';\n    const dir = filter.orderDir ?? 'desc';\n\n    const fieldMap: Record<string, string> = {\n      createdAt: 'created_at',\n      runAt: 'run_at',\n      priority: 'priority',\n      attempts: 'attempts',\n    };\n\n    return `ORDER BY ${fieldMap[field] ?? 'created_at'} ${dir.toUpperCase()}`;\n  }\n\n  /**\n   * Build LIMIT/OFFSET clause\n   */\n  protected buildLimitOffset(filter: JobFilter): {\n    clause: string;\n    params: unknown[];\n  } {\n    const params: unknown[] = [];\n    let clause = '';\n\n    if (filter.limit) {\n      clause = 'LIMIT ?';\n      params.push(filter.limit);\n\n      if (filter.offset) {\n        clause += ' OFFSET ?';\n        params.push(filter.offset);\n      }\n    }\n\n    return { clause, params };\n  }\n\n  /**\n   * Parse a job row from the database\n   */\n  protected parseJobRow(row: Record<string, unknown>): Job {\n    return {\n      id: row.id as string,\n      queue: row.queue as string,\n      payload:\n        typeof row.payload === 'string' ? JSON.parse(row.payload) : row.payload,\n      status: row.status as Job['status'],\n      priority: row.priority as number,\n      attempts: row.attempts as number,\n      maxAttempts: row.max_attempts as number,\n      runAt: new Date(row.run_at as string),\n      startedAt: row.started_at ? new Date(row.started_at as string) : null,\n      completedAt: row.completed_at\n        ? new Date(row.completed_at as string)\n        : null,\n      timeout: row.timeout as number,\n      timeoutBehavior: row.timeout_behavior as Job['timeoutBehavior'],\n      lastError: row.last_error as string | null,\n      resultPointer: row.result_pointer as string | null,\n      retryStrategy:\n        typeof row.retry_strategy === 'string'\n          ? JSON.parse(row.retry_strategy)\n          : row.retry_strategy,\n      workerId: row.worker_id as string | null,\n      workerHeartbeat: row.worker_heartbeat\n        ? new Date(row.worker_heartbeat as string)\n        : null,\n      createdAt: new Date(row.created_at as string),\n      updatedAt: new Date(row.updated_at as string),\n    };\n  }\n\n  // Abstract methods that must be implemented by subclasses\n  abstract enqueue(options: JobCreateOptions): Promise<Job>;\n  abstract dequeue(\n    queues: string[],\n    limit: number,\n    workerId: string,\n  ): Promise<Job[]>;\n  abstract update(id: string, updates: Partial<Job>): Promise<Job>;\n  abstract get(id: string): Promise<Job | null>;\n  abstract list(filter: JobFilter): Promise<Job[]>;\n  abstract cancel(id: string): Promise<void>;\n  abstract cleanup(options: CleanupOptions): Promise<number>;\n  abstract heartbeat(jobId: string, workerId: string): Promise<void>;\n  abstract stats(queue?: string): Promise<QueueStats>;\n  abstract close(): Promise<void>;\n}\n"],"names":[],"mappings":"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"}

package/dist/cli/claude-context.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=claude-context.d.ts.map

package/dist/cli/claude-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-context.d.ts","sourceRoot":"","sources":["../../src/cli/claude-context.ts"],"names":[],"mappings":""}

package/dist/cli/claude-context.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, copyFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const Dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(Dirname, "../..");
+const targetDir = join(process.cwd(), ".claude");
+if (!existsSync(targetDir)) {
+  mkdirSync(targetDir, { recursive: true });
+}
+const pkgName = "jobs";
+const agentMdSrc = existsSync(join(pkgRoot, "AGENT.md")) ? join(pkgRoot, "AGENT.md") : join(pkgRoot, "CLAUDE.md");
+const metaSrc = existsSync(join(pkgRoot, "metadata.json")) ? join(pkgRoot, "metadata.json") : join(pkgRoot, ".claude-meta.json");
+if (existsSync(agentMdSrc)) {
+  copyFileSync(agentMdSrc, join(targetDir, `have-${pkgName}.md`));
+}
+if (existsSync(metaSrc)) {
+  copyFileSync(metaSrc, join(targetDir, `have-${pkgName}.meta.json`));
+}
+console.log(`✓ Installed @happyvertical/${pkgName} context to .claude/`);
+//# sourceMappingURL=claude-context.js.map

package/dist/cli/claude-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-context.js","sources":["../../src/cli/claude-context.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * CLI script to install agent context for @happyvertical/jobs\n * Run the published context installer binary for this package.\n */\nimport { copyFileSync, existsSync, mkdirSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nconst Dirname = dirname(fileURLToPath(import.meta.url));\nconst pkgRoot = join(Dirname, '../..');\nconst targetDir = join(process.cwd(), '.claude');\n\nif (!existsSync(targetDir)) {\n  mkdirSync(targetDir, { recursive: true });\n}\n\nconst pkgName = 'jobs';\nconst agentMdSrc = existsSync(join(pkgRoot, 'AGENT.md'))\n  ? join(pkgRoot, 'AGENT.md')\n  : join(pkgRoot, 'CLAUDE.md');\nconst metaSrc = existsSync(join(pkgRoot, 'metadata.json'))\n  ? join(pkgRoot, 'metadata.json')\n  : join(pkgRoot, '.claude-meta.json');\n\nif (existsSync(agentMdSrc)) {\n  copyFileSync(agentMdSrc, join(targetDir, `have-${pkgName}.md`));\n}\n\nif (existsSync(metaSrc)) {\n  copyFileSync(metaSrc, join(targetDir, `have-${pkgName}.meta.json`));\n}\n\nconsole.log(`✓ Installed @happyvertical/${pkgName} context to .claude/`);\n"],"names":[],"mappings":";;;;AASA,MAAM,UAAU,QAAQ,cAAc,YAAY,GAAG,CAAC;AACtD,MAAM,UAAU,KAAK,SAAS,OAAO;AACrC,MAAM,YAAY,KAAK,QAAQ,IAAA,GAAO,SAAS;AAE/C,IAAI,CAAC,WAAW,SAAS,GAAG;AAC1B,YAAU,WAAW,EAAE,WAAW,KAAA,CAAM;AAC1C;AAEA,MAAM,UAAU;AAChB,MAAM,aAAa,WAAW,KAAK,SAAS,UAAU,CAAC,IACnD,KAAK,SAAS,UAAU,IACxB,KAAK,SAAS,WAAW;AAC7B,MAAM,UAAU,WAAW,KAAK,SAAS,eAAe,CAAC,IACrD,KAAK,SAAS,eAAe,IAC7B,KAAK,SAAS,mBAAmB;AAErC,IAAI,WAAW,UAAU,GAAG;AAC1B,eAAa,YAAY,KAAK,WAAW,QAAQ,OAAO,KAAK,CAAC;AAChE;AAEA,IAAI,WAAW,OAAO,GAAG;AACvB,eAAa,SAAS,KAAK,WAAW,QAAQ,OAAO,YAAY,CAAC;AACpE;AAEA,QAAQ,IAAI,8BAA8B,OAAO,sBAAsB;"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @happyvertical/jobs - Job queue abstraction with multiple backend adapters
+ *
+ * @packageDocumentation
+ */
+export { BullJobStore, type BullJobStoreConfig, type RedisOptions, } from './adapters/bull.js';
+export { BullMQJobStore, type BullMQJobStoreConfig, } from './adapters/bullmq.js';
+export { CloudTasksJobStore, type CloudTasksJobStoreConfig, } from './adapters/cloud-tasks.js';
+export { PostgresJobStore, type PostgresJobStoreConfig, } from './adapters/postgres.js';
+export { SqliteJobStore, type SqliteJobStoreConfig, } from './adapters/sqlite.js';
+export { SQSJobStore, type SQSJobStoreConfig, } from './adapters/sqs.js';
+export { BaseJobStore, priorityToNumber } from './base-store.js';
+export { type CustomRetryFn, custom, DEFAULT_RETRY_STRATEGY, type ExponentialBackoffOptions, exponential, fromConfig, type LinearBackoffOptions, linear, noRetry, } from './retry.js';
+export type { CleanupOptions, Job, JobCreateOptions, JobEvent, JobEventListener, JobEventType, JobFilter, JobHandle, JobHandler, JobPayload, JobPriority, JobStatus, JobStore, QueueStats, RetryDecision, RetryStrategy, RetryStrategyConfig, TimeoutBehavior, Unsubscribe, Worker, WorkerConfig, } from './types.js';
+export { createWorker, JobWorker, type WorkerEvents } from './worker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,kBAAkB,EACvB,KAAK,YAAY,GAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,kBAAkB,EAClB,KAAK,wBAAwB,GAC9B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,gBAAgB,EAChB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,WAAW,EACX,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEjE,OAAO,EACL,KAAK,aAAa,EAClB,MAAM,EACN,sBAAsB,EACtB,KAAK,yBAAyB,EAC9B,WAAW,EACX,UAAU,EACV,KAAK,oBAAoB,EACzB,MAAM,EACN,OAAO,GACR,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,cAAc,EACd,GAAG,EACH,gBAAgB,EAChB,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACT,SAAS,EACT,UAAU,EACV,UAAU,EACV,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,eAAe,EACf,WAAW,EACX,MAAM,EACN,YAAY,GACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,252 @@
+import { BullJobStore } from "./adapters/bull.js";
+import { BullMQJobStore } from "./adapters/bullmq.js";
+import { CloudTasksJobStore } from "./adapters/cloud-tasks.js";
+import { PostgresJobStore } from "./adapters/postgres.js";
+import { SqliteJobStore } from "./adapters/sqlite.js";
+import { SQSJobStore } from "./adapters/sqs.js";
+import { f as fromConfig } from "./chunks/base-store-DlNksWvQ.js";
+import { B, D, c, e, l, n, p } from "./chunks/base-store-DlNksWvQ.js";
+import { EventEmitter } from "node:events";
+import { createId } from "@happyvertical/utils";
+const DEFAULT_CONFIG = {
+  id: "",
+  concurrency: 5,
+  queues: ["default"],
+  pollInterval: 1e3,
+  heartbeatInterval: 3e4,
+  shutdownTimeout: 3e4
+};
+class JobWorker extends EventEmitter {
+  id;
+  store;
+  handler;
+  config;
+  running = false;
+  activeJobs = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  heartbeatTimer = null;
+  shutdownPromise = null;
+  constructor(store, handler, config = {}) {
+    super();
+    this.store = store;
+    this.handler = handler;
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config,
+      id: config.id || `worker_${createId().slice(0, 8)}`
+    };
+    this.id = this.config.id;
+  }
+  /**
+   * Start processing jobs
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    this.store.subscribe(async (event) => {
+      if (event.type === "job.ready" && this.running) {
+        await this.poll();
+      }
+    });
+    this.startPolling();
+    this.startHeartbeat();
+    this.emit("worker:started");
+  }
+  /**
+   * Stop processing jobs (graceful shutdown)
+   */
+  async stop() {
+    if (!this.running) return;
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.running = false;
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.shutdownPromise = this.waitForActiveJobs();
+    try {
+      await this.shutdownPromise;
+    } finally {
+      this.shutdownPromise = null;
+      this.emit("worker:stopped");
+    }
+  }
+  /**
+   * Check if worker is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get count of active jobs
+   */
+  activeJobCount() {
+    return this.activeJobs.size;
+  }
+  /**
+   * Start the polling loop
+   */
+  startPolling() {
+    const scheduleNextPoll = () => {
+      if (!this.running) return;
+      if (!this.store.waitForUpdate) {
+        this.pollTimer = setTimeout(poll, this.config.pollInterval);
+        return;
+      }
+      this.pollTimer = setTimeout(() => {
+        void waitThenPoll();
+      }, 0);
+    };
+    const waitThenPoll = async () => {
+      try {
+        await this.store.waitForUpdate?.(this.config.pollInterval);
+      } catch (error) {
+        this.emit("worker:error", error);
+      }
+      if (this.running) {
+        await poll();
+      }
+    };
+    const poll = async () => {
+      if (!this.running) return;
+      try {
+        await this.poll();
+      } catch (error) {
+        this.emit("worker:error", error);
+      }
+      scheduleNextPoll();
+    };
+    poll();
+  }
+  /**
+   * Poll for and process jobs
+   */
+  async poll() {
+    const available = this.config.concurrency - this.activeJobs.size;
+    if (available <= 0) return;
+    const jobs = await this.store.dequeue(
+      this.config.queues,
+      available,
+      this.id
+    );
+    for (const job of jobs) {
+      this.processJob(job);
+    }
+  }
+  /**
+   * Process a single job
+   */
+  async processJob(job) {
+    this.activeJobs.set(job.id, job);
+    this.emit("job:started", job);
+    let timeoutId = null;
+    try {
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`Job timeout after ${job.timeout}ms`));
+        }, job.timeout);
+      });
+      const result = await Promise.race([this.handler(job), timeoutPromise]);
+      await this.store.update(job.id, {
+        status: "completed",
+        completedAt: /* @__PURE__ */ new Date(),
+        resultPointer: result.resultPointer ?? null
+      });
+      this.emit("job:completed", job, result.result);
+    } catch (error) {
+      await this.handleJobError(job, error);
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      this.activeJobs.delete(job.id);
+    }
+  }
+  /**
+   * Handle job execution error
+   */
+  async handleJobError(job, error) {
+    const strategy = fromConfig(job.retryStrategy);
+    const decision = strategy.shouldRetry(job.attempts, error);
+    if (decision.shouldRetry && job.attempts < job.maxAttempts) {
+      const nextRunAt = new Date(Date.now() + decision.delay);
+      await this.store.update(job.id, {
+        status: "pending",
+        lastError: error.message,
+        runAt: nextRunAt,
+        workerId: null,
+        workerHeartbeat: null
+      });
+      this.emit("job:retrying", job, error, decision.delay);
+    } else {
+      await this.store.update(job.id, {
+        status: "failed",
+        completedAt: /* @__PURE__ */ new Date(),
+        lastError: error.message
+      });
+      this.emit("job:failed", job, error);
+    }
+  }
+  /**
+   * Start heartbeat loop to keep jobs alive
+   */
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(async () => {
+      for (const [jobId] of this.activeJobs) {
+        try {
+          await this.store.heartbeat(jobId, this.id);
+        } catch (error) {
+          console.warn(`Heartbeat failed for job ${jobId}:`, error);
+        }
+      }
+    }, this.config.heartbeatInterval);
+  }
+  /**
+   * Wait for active jobs to complete with timeout
+   */
+  async waitForActiveJobs() {
+    if (this.activeJobs.size === 0) return;
+    return new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (this.activeJobs.size === 0) {
+          clearInterval(checkInterval);
+          clearTimeout(timeout);
+          resolve();
+        }
+      }, 100);
+      const timeout = setTimeout(() => {
+        clearInterval(checkInterval);
+        console.warn(
+          `Shutdown timeout: ${this.activeJobs.size} jobs still active`
+        );
+        resolve();
+      }, this.config.shutdownTimeout);
+    });
+  }
+}
+function createWorker(store, handler, config) {
+  return new JobWorker(store, handler, config);
+}
+export {
+  B as BaseJobStore,
+  BullJobStore,
+  BullMQJobStore,
+  CloudTasksJobStore,
+  D as DEFAULT_RETRY_STRATEGY,
+  JobWorker,
+  PostgresJobStore,
+  SQSJobStore,
+  SqliteJobStore,
+  createWorker,
+  c as custom,
+  e as exponential,
+  fromConfig,
+  l as linear,
+  n as noRetry,
+  p as priorityToNumber
+};
+//# sourceMappingURL=index.js.map