@workglow/postgres 0.2.36 → 0.2.37

package/dist/job-queue/node.js

@@ -1,7 +1,5 @@
 // src/job-queue/PostgresQueueStorage.ts
-import { createHash } from "node:crypto";
-import { createServiceToken, getLogger, makeFingerprint, uuid4 } from "@workglow/util";
-import { JobStatus as JobStatus2 } from "@workglow/job-queue";
+import { JobStatus as JobStatus2, validateLeaseMs } from "@workglow/job-queue";
 import {
   assertPrefixesSafe,
   buildPrefixInsertFragments,
@@ -10,6 +8,8 @@ import {
   getPrefixParamValues,
   PostgresDialect as PostgresDialect2
 } from "@workglow/storage";
+import { createServiceToken, getLogger, makeFingerprint, uuid4 } from "@workglow/util";
+import { createHash } from "node:crypto";
 
 // src/migrations/PostgresMigrationRunner.ts
 import {
@@ -149,11 +149,6 @@ var JOB_STATUS_V1 = [
 ];
 function assertJobStatusMatchesV1() {
   const current = new Set(Object.values(JobStatus));
-  for (const v of JOB_STATUS_V1) {
-    if (!current.has(v)) {
-      throw new Error(`JobStatus const is missing v1 enum value "${v}"; v1 migration values are frozen.`);
-    }
-  }
   for (const v of current) {
     if (!JOB_STATUS_V1.includes(v)) {
       throw new Error(`JobStatus contains "${v}" which is not in JOB_STATUS_V1. ` + `Add a new migration that runs "ALTER TYPE job_status ADD VALUE IF NOT EXISTS '${v}'" ` + `instead of mutating the v1 enum literal.`);
@@ -254,6 +249,56 @@ function postgresQueueMigrations(tableName, prefixes) {
           });
         }
       }
+    },
+    {
+      component,
+      version: 2,
+      description: "Add abort_requested_at and lease_expires_at columns",
+      async up(db) {
+        await db.query(`
+          ALTER TABLE ${tableName}
+            ADD COLUMN IF NOT EXISTS abort_requested_at timestamp with time zone,
+            ADD COLUMN IF NOT EXISTS lease_expires_at timestamp with time zone
+        `);
+      }
+    },
+    {
+      component,
+      version: 3,
+      description: "Rename run_after→visible_at, last_ran_at→last_attempted_at, run_attempts→attempts, max_retries→max_attempts, worker_id→lease_owner; drop run_after-keyed indexes and recreate visible_at-keyed",
+      async up(db) {
+        await db.query(`
+          DO $$
+          BEGIN
+            IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='${tableName}' AND column_name='run_after' AND table_schema=current_schema()) THEN
+              EXECUTE 'ALTER TABLE ${tableName} RENAME COLUMN run_after TO visible_at';
+            END IF;
+            IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='${tableName}' AND column_name='last_ran_at' AND table_schema=current_schema()) THEN
+              EXECUTE 'ALTER TABLE ${tableName} RENAME COLUMN last_ran_at TO last_attempted_at';
+            END IF;
+            IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='${tableName}' AND column_name='run_attempts' AND table_schema=current_schema()) THEN
+              EXECUTE 'ALTER TABLE ${tableName} RENAME COLUMN run_attempts TO attempts';
+            END IF;
+            IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='${tableName}' AND column_name='max_retries' AND table_schema=current_schema()) THEN
+              EXECUTE 'ALTER TABLE ${tableName} RENAME COLUMN max_retries TO max_attempts';
+              EXECUTE 'ALTER TABLE ${tableName} ALTER COLUMN max_attempts SET DEFAULT 10';
+            END IF;
+            IF EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='${tableName}' AND column_name='worker_id' AND table_schema=current_schema()) THEN
+              EXECUTE 'ALTER TABLE ${tableName} RENAME COLUMN worker_id TO lease_owner';
+            END IF;
+          END $$
+        `);
+        await db.query(`DROP INDEX IF EXISTS job_fetcher${indexSuffix}_idx`);
+        await db.query(`DROP INDEX IF EXISTS job_queue_fetcher${indexSuffix}_idx`);
+        await db.query(`
+          CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx
+            ON ${tableName} (${prefixIndexPrefix}id, status, visible_at)
+        `);
+        await db.query(`
+          CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx
+            ON ${tableName} (${prefixIndexPrefix}queue, status, visible_at)
+        `);
+      }
     }
   ];
 }
@@ -308,26 +353,26 @@ class PostgresQueueStorage {
     job.progress_message = "";
     job.progress_details = null;
     job.created_at = now;
-    job.run_after = now;
+    job.visible_at = now;
     const prefixColumnNames = getPrefixColumnNames(this.prefixes);
     const { columns: prefixColumnsInsert, placeholders: prefixParamPlaceholders } = buildPrefixInsertFragments(PostgresDialect2, this.prefixes, 1);
     const prefixParamValues = this.getPrefixParamValues();
     const baseParamStart = prefixColumnNames.length + 1;
     const sql = `
       INSERT INTO ${this.tableName}(
-        ${prefixColumnsInsert}queue, 
-        fingerprint, 
-        input, 
-        run_after,
+        ${prefixColumnsInsert}queue,
+        fingerprint,
+        input,
+        visible_at,
         created_at,
         deadline_at,
-        max_retries, 
-        job_run_id, 
-        progress, 
-        progress_message, 
+        max_attempts,
+        job_run_id,
+        progress,
+        progress_message,
         progress_details
       )
-      VALUES 
+      VALUES
         (${prefixParamPlaceholders}$${baseParamStart},$${baseParamStart + 1},$${baseParamStart + 2},$${baseParamStart + 3},$${baseParamStart + 4},$${baseParamStart + 5},$${baseParamStart + 6},$${baseParamStart + 7},$${baseParamStart + 8},$${baseParamStart + 9},$${baseParamStart + 10})
       RETURNING id`;
     const params = [
@@ -335,10 +380,10 @@ class PostgresQueueStorage {
       job.queue,
       job.fingerprint,
       JSON.stringify(job.input),
-      job.run_after,
+      job.visible_at,
       job.created_at,
       job.deadline_at,
-      job.max_retries,
+      job.max_attempts,
       job.job_run_id,
       job.progress,
       job.progress_message,
@@ -369,32 +414,68 @@ class PostgresQueueStorage {
         FROM ${this.tableName}
         WHERE queue = $1
         AND status = $2${prefixConditions}
-        ORDER BY run_after ASC
+        ORDER BY visible_at ASC
         LIMIT $3
         FOR UPDATE SKIP LOCKED`, [this.queueName, status, num, ...prefixParams]);
     if (!result)
       return [];
     return result.rows;
   }
-  async next(workerId) {
-    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(5);
+  async next(workerId, opts) {
+    const leaseMs = opts?.leaseMs ?? 30000;
+    validateLeaseMs(leaseMs, "leaseMs");
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(7);
     const result = await this.db.query(`
-      UPDATE ${this.tableName} 
-      SET status = $1, last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = $4
+      UPDATE ${this.tableName}
+      SET status = $1,
+          last_attempted_at = NOW() AT TIME ZONE 'UTC',
+          lease_owner = $4,
+          lease_expires_at = NOW() AT TIME ZONE 'UTC' + ($2 * INTERVAL '1 millisecond'),
+          -- A reclaimed PROCESSING row was claimed by a now-crashed worker;
+          -- that constitutes one used-up attempt against max_attempts.
+          -- PENDING claims must not be charged here — JobQueueWorker's
+          -- existing validateJobState() will FAIL the job in the next-step
+          -- branch when attempts >= max_attempts.
+          attempts = CASE WHEN status = $6 THEN attempts + 1 ELSE attempts END,
+          -- Always clear any stale abort_requested_at on (re)claim. A PROCESSING
+          -- row may have had abort_requested_at set before the worker crashed;
+          -- the new owner must start with a clean slate or the worker will see
+          -- the abort flag immediately and never run user code.
+          abort_requested_at = NULL
       WHERE id = (
-        SELECT id 
-        FROM ${this.tableName} 
-        WHERE queue = $2 
-        AND status = $3
+        SELECT id
+        FROM ${this.tableName}
+        WHERE queue = $3
+        AND (
+          (status = $5 AND visible_at <= NOW() AT TIME ZONE 'UTC')
+          OR (status = $6 AND (lease_expires_at IS NULL OR lease_expires_at < NOW() AT TIME ZONE 'UTC'))
+        )
         ${prefixConditions}
-        AND run_after <= NOW() AT TIME ZONE 'UTC'
-        ORDER BY run_after ASC 
-        FOR UPDATE SKIP LOCKED 
+        ORDER BY visible_at ASC
+        FOR UPDATE SKIP LOCKED
         LIMIT 1
       )
-      RETURNING *`, [JobStatus2.PROCESSING, this.queueName, JobStatus2.PENDING, workerId, ...prefixParams]);
+      RETURNING *`, [
+      JobStatus2.PROCESSING,
+      leaseMs,
+      this.queueName,
+      workerId,
+      JobStatus2.PENDING,
+      JobStatus2.PROCESSING,
+      ...prefixParams
+    ]);
     return result?.rows?.[0] ?? undefined;
   }
+  async extendLease(id, workerId, ms) {
+    validateLeaseMs(ms, "ms");
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(5);
+    const result = await this.db.query(`UPDATE ${this.tableName}
+         SET lease_expires_at = NOW() AT TIME ZONE 'UTC' + ($1 * INTERVAL '1 millisecond')
+         WHERE id = $2 AND queue = $3 AND lease_owner = $4 AND status = 'PROCESSING'${prefixConditions}`, [ms, id, this.queueName, workerId, ...prefixParams]);
+    if (!result || result.rowCount === 0) {
+      throw new Error(`extendLease failed: job ${String(id)} is not PROCESSING or lease is not owned by worker ${workerId}`);
+    }
+  }
   async size(status = JobStatus2.PENDING) {
     const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`
@@ -420,22 +501,23 @@ class PostgresQueueStorage {
           WHERE id = $2 AND queue = $3${prefixConditions}`, [jobDetails.status, jobDetails.id, this.queueName, ...prefixParams]);
     } else if (jobDetails.status === JobStatus2.PENDING) {
       const { conditions: prefixConditions } = this.buildPrefixWhereClause(7);
-      await this.db.query(`UPDATE ${this.tableName} 
-          SET 
-            error = $1, 
+      await this.db.query(`UPDATE ${this.tableName}
+          SET
+            error = $1,
             error_code = $2,
-            status = $3, 
-            run_after = $4, 
+            status = $3,
+            visible_at = $4,
             progress = 0,
             progress_message = '',
             progress_details = NULL,
-            run_attempts = run_attempts + 1, 
-            last_ran_at = NOW() AT TIME ZONE 'UTC'
+            attempts = attempts + 1,
+            last_attempted_at = NOW() AT TIME ZONE 'UTC',
+            abort_requested_at = NULL
           WHERE id = $5 AND queue = $6${prefixConditions}`, [
         jobDetails.error,
         jobDetails.error_code,
         jobDetails.status,
-        jobDetails.run_after,
+        jobDetails.visible_at,
         jobDetails.id,
         this.queueName,
         ...prefixParams
@@ -452,9 +534,9 @@ class PostgresQueueStorage {
               progress = 100,
               progress_message = '',
               progress_details = NULL,
-              run_attempts = run_attempts + 1, 
+              attempts = attempts + 1,
               completed_at = NOW() AT TIME ZONE 'UTC',
-              last_ran_at = NOW() AT TIME ZONE 'UTC'
+              last_attempted_at = NOW() AT TIME ZONE 'UTC'
           WHERE id = $5 AND queue = $6${prefixConditions}`, [
         jobDetails.output ? JSON.stringify(jobDetails.output) : null,
         jobDetails.error ?? null,
@@ -466,6 +548,49 @@ class PostgresQueueStorage {
       ]);
     }
   }
+  async finalize(id, fields) {
+    const sets = [];
+    const params = [];
+    let nextParam = 1;
+    const push = (col, value) => {
+      sets.push(`${col} = $${nextParam}`);
+      params.push(value);
+      nextParam += 1;
+    };
+    if ("output" in fields) {
+      push("output", fields.output != null ? JSON.stringify(fields.output) : null);
+    }
+    if ("error" in fields)
+      push("error", fields.error ?? null);
+    if ("error_code" in fields)
+      push("error_code", fields.error_code ?? null);
+    if ("status" in fields)
+      push("status", fields.status);
+    if ("completed_at" in fields)
+      push("completed_at", fields.completed_at ?? null);
+    if ("abort_requested_at" in fields) {
+      push("abort_requested_at", fields.abort_requested_at ?? null);
+    }
+    if ("lease_owner" in fields)
+      push("lease_owner", fields.lease_owner ?? null);
+    if ("progress" in fields)
+      push("progress", fields.progress ?? 0);
+    if ("progress_message" in fields)
+      push("progress_message", fields.progress_message ?? "");
+    if ("progress_details" in fields) {
+      push("progress_details", fields.progress_details != null ? JSON.stringify(fields.progress_details) : null);
+    }
+    if (sets.length === 0)
+      return;
+    const idParam = nextParam;
+    nextParam += 1;
+    const queueParam = nextParam;
+    nextParam += 1;
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(nextParam);
+    await this.db.query(`UPDATE ${this.tableName}
+         SET ${sets.join(", ")}
+         WHERE id = $${idParam} AND queue = $${queueParam}${prefixConditions}`, [...params, id, this.queueName, ...prefixParams]);
+  }
   async deleteAll() {
     const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
     await this.db.query(`
@@ -484,23 +609,37 @@ class PostgresQueueStorage {
     return result.rows[0].output;
   }
   async abort(jobId) {
-    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
-    await this.db.query(`
-      UPDATE ${this.tableName} 
-      SET status = 'ABORTING' 
-      WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
+    {
+      const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
+      await this.db.query(`UPDATE ${this.tableName}
+           SET status = 'FAILED',
+               abort_requested_at = NOW() AT TIME ZONE 'UTC',
+               completed_at = NOW() AT TIME ZONE 'UTC'
+           WHERE id = $1 AND queue = $2 AND status = $3${prefixConditions}`, [jobId, this.queueName, JobStatus2.PENDING, ...prefixParams]);
+    }
+    {
+      const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
+      await this.db.query(`UPDATE ${this.tableName}
+           SET abort_requested_at = NOW() AT TIME ZONE 'UTC'
+           WHERE id = $1 AND queue = $2 AND status = $3${prefixConditions}`, [jobId, this.queueName, JobStatus2.PROCESSING, ...prefixParams]);
+    }
   }
-  async release(jobId) {
+  async releaseClaim(jobId) {
     const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     await this.db.query(`
       UPDATE ${this.tableName}
         SET status = 'PENDING',
-            worker_id = NULL,
+            lease_owner = NULL,
             progress = 0,
             progress_message = '',
-            progress_details = NULL
+            progress_details = NULL,
+            abort_requested_at = NULL
         WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
   }
+  async saveStatus(jobId, status) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`UPDATE ${this.tableName} SET status = $1 WHERE id = $2 AND queue = $3${prefixConditions}`, [status, jobId, this.queueName, ...prefixParams]);
+  }
   async getByRunId(job_run_id) {
     const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
     const result = await this.db.query(`
@@ -663,7 +802,6 @@ class PostgresQueueStorage {
   }
 }
 // src/job-queue/PostgresRateLimiterStorage.ts
-import { createServiceToken as createServiceToken2 } from "@workglow/util";
 import {
   assertPrefixesSafe as assertPrefixesSafe2,
   buildPrefixWhereClause as buildPrefixWhereClause2,
@@ -671,6 +809,7 @@ import {
   getPrefixParamValues as getPrefixParamValues2,
   PostgresDialect as PostgresDialect4
 } from "@workglow/storage";
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
 
 // src/migrations/postgresRateLimiterMigrations.ts
 import {
@@ -895,14 +1034,223 @@ class PostgresRateLimiterStorage {
     await this.db.query(`DELETE FROM ${this.nextAvailableTableName} WHERE queue_name = $1${prefixConditions}`, [queueName, ...prefixParams]);
   }
 }
+// src/job-queue/PostgresMessageQueue.ts
+class PostgresClaim {
+  core;
+  pending;
+  id;
+  body;
+  attempts;
+  workerId;
+  constructor(core, pending, id, body, attempts, workerId) {
+    this.core = core;
+    this.pending = pending;
+    this.id = id;
+    this.body = body;
+    this.attempts = attempts;
+    this.workerId = workerId;
+  }
+  async ack(result) {
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const output = result !== undefined ? result : buf?.output !== undefined ? buf.output : current.output ?? null;
+    await this.core.finalize(this.id, {
+      output,
+      error: null,
+      error_code: null,
+      status: "COMPLETED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async retry(opts) {
+    this.pending.delete(this.id);
+    const delay = opts?.delaySeconds ?? 0;
+    const current = await this.core.get(this.id) ?? this.body;
+    await this.core.complete({
+      ...current,
+      status: "PENDING",
+      lease_owner: null,
+      lease_expires_at: null,
+      visible_at: new Date(Date.now() + delay * 1000).toISOString(),
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+  async fail(opts) {
+    opts?.permanent;
+    const buf = this.pending.get(this.id);
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id) ?? this.body;
+    const error = opts?.error !== undefined ? opts.error : buf?.error !== undefined ? buf.error : current.error ?? null;
+    const errorCode = opts?.errorCode !== undefined ? opts.errorCode : buf?.errorCode !== undefined ? buf.errorCode : current.error_code ?? null;
+    const abortRequested = opts?.abortRequested !== undefined ? opts.abortRequested : buf?.abortRequested ?? false;
+    await this.core.finalize(this.id, {
+      error,
+      error_code: errorCode,
+      abort_requested_at: abortRequested ? current.abort_requested_at ?? new Date().toISOString() : current.abort_requested_at ?? null,
+      status: "FAILED",
+      completed_at: current.completed_at ?? new Date().toISOString()
+    });
+  }
+  async extendLease(ms) {
+    await this.core.extendLease(this.id, this.workerId, ms);
+  }
+  async disable() {
+    this.pending.delete(this.id);
+    const current = await this.core.get(this.id);
+    const completedAt = current?.completed_at ?? new Date().toISOString();
+    await this.core.finalize(this.id, {
+      status: "DISABLED",
+      completed_at: completedAt,
+      lease_owner: null,
+      progress: 0,
+      progress_message: "",
+      progress_details: null
+    });
+  }
+}
+
+class PostgresMessageQueue {
+  scope;
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+    this.scope = core.scope;
+  }
+  async send(body, opts) {
+    return this.core.add(applySendOptions(body, opts));
+  }
+  async sendBatch(bodies, opts) {
+    const ids = [];
+    for (const body of bodies) {
+      ids.push(await this.send(body, opts));
+    }
+    return ids;
+  }
+  async receive(opts) {
+    const max = Math.max(1, opts.max ?? 1);
+    const claims = [];
+    while (claims.length < max) {
+      const job = await this.core.next(opts.workerId, { leaseMs: opts.leaseMs });
+      if (!job)
+        break;
+      claims.push(new PostgresClaim(this.core, this.pending, job.id, job, job.attempts ?? 0, opts.workerId));
+    }
+    return claims;
+  }
+  async releaseClaim(id) {
+    this.pending.delete(id);
+    await this.core.releaseClaim(id);
+  }
+  async migrate() {
+    await this.core.migrate();
+  }
+  getMigrations() {
+    return this.core.getMigrations();
+  }
+  subscribeToChanges(callback, options) {
+    return this.core.subscribeToChanges(callback, options);
+  }
+}
+function applySendOptions(body, opts) {
+  if (!opts)
+    return body;
+  const out = { ...body };
+  if (opts.delaySeconds != null) {
+    out.visible_at = new Date(Date.now() + opts.delaySeconds * 1000).toISOString();
+  }
+  if (opts.timeoutSeconds != null) {
+    out.deadline_at = new Date(Date.now() + opts.timeoutSeconds * 1000).toISOString();
+  }
+  if (opts.fingerprint != null)
+    out.fingerprint = opts.fingerprint;
+  if (opts.jobRunId != null)
+    out.job_run_id = opts.jobRunId;
+  if (opts.maxAttempts != null)
+    out.max_attempts = opts.maxAttempts;
+  return out;
+}
+// src/job-queue/PostgresJobStore.ts
+class PostgresJobStore {
+  core;
+  pending;
+  constructor(core, pending) {
+    this.core = core;
+    this.pending = pending;
+  }
+  get(id) {
+    return this.core.get(id);
+  }
+  async peek(status, num) {
+    return this.core.peek(status, num);
+  }
+  size(status) {
+    return this.core.size(status);
+  }
+  async getByRunId(runId) {
+    return this.core.getByRunId(runId);
+  }
+  outputForInput(input) {
+    return this.core.outputForInput(input);
+  }
+  async saveProgress(id, progress, message, details) {
+    await this.core.saveProgress(id, progress, message, details);
+  }
+  async saveResult(id, output) {
+    const buf = this.pending.get(id) ?? {};
+    buf.output = output ?? null;
+    this.pending.set(id, buf);
+  }
+  async saveError(id, error, errorCode, abortRequested) {
+    const buf = this.pending.get(id) ?? {};
+    buf.error = error;
+    buf.errorCode = errorCode;
+    buf.abortRequested = abortRequested;
+    this.pending.set(id, buf);
+  }
+  async deleteByStatusAndAge(status, olderThanMs) {
+    await this.core.deleteJobsByStatusAndAge(status, olderThanMs);
+  }
+  async delete(id) {
+    this.pending.delete(id);
+    await this.core.delete(id);
+  }
+  async deleteAll() {
+    this.pending.clear();
+    await this.core.deleteAll();
+  }
+  async abort(id) {
+    await this.core.abort(id);
+  }
+  async saveStatus(id, status) {
+    await this.core.saveStatus(id, status);
+  }
+}
+// src/job-queue/createPostgresQueue.ts
+function createPostgresQueue(queueName, pool, opts) {
+  const core = new PostgresQueueStorage(pool, queueName, opts);
+  const pending = new Map;
+  return {
+    messageQueue: new PostgresMessageQueue(core, pending),
+    jobStore: new PostgresJobStore(core, pending),
+    core
+  };
+}
 export {
   postgresRateLimiterMigrations,
   postgresQueueMigrations,
+  createPostgresQueue,
   PostgresRateLimiterStorage,
   PostgresQueueStorage,
   PostgresMigrationRunner,
+  PostgresMessageQueue,
+  PostgresJobStore,
   POSTGRES_RATE_LIMITER_STORAGE,
   POSTGRES_QUEUE_STORAGE
 };
 
-//# debugId=4374150EC82279E664756E2164756E21
+//# debugId=A893F6ECCE25069B64756E2164756E21