@workglow/postgres 0.2.28

package/dist/job-queue/node.js

@@ -0,0 +1,732 @@
+// src/job-queue/PostgresQueueStorage.ts
+import { createHash } from "node:crypto";
+import { createServiceToken, getLogger, makeFingerprint, uuid4 } from "@workglow/util";
+import { JobStatus } from "@workglow/job-queue";
+var POSTGRES_QUEUE_STORAGE = createServiceToken("jobqueue.storage.postgres");
+var SAFE_IDENTIFIER = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+
+class PostgresQueueStorage {
+  db;
+  queueName;
+  scope = "cluster";
+  prefixes;
+  prefixValues;
+  tableName;
+  constructor(db, queueName, options) {
+    this.db = db;
+    this.queueName = queueName;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    for (const prefix of this.prefixes) {
+      if (!SAFE_IDENTIFIER.test(prefix.name)) {
+        throw new Error(`Prefix column name must start with a letter and contain only letters, digits, and underscores, got: ${prefix.name}`);
+      }
+    }
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.tableName = `job_queue_${prefixNames}`;
+    } else {
+      this.tableName = "job_queue";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+      `) + `,
+      `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause(startParam) {
+    if (this.prefixes.length === 0) {
+      return { conditions: "", params: [] };
+    }
+    const conditions = this.prefixes.map((p, i) => `${p.name} = $${startParam + i}`).join(" AND ");
+    const params = this.prefixes.map((p) => this.prefixValues[p.name]);
+    return { conditions: " AND " + conditions, params };
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async setupDatabase() {
+    let sql;
+    try {
+      const enumValues = Object.values(JobStatus);
+      for (const v of enumValues) {
+        if (!SAFE_IDENTIFIER.test(v)) {
+          throw new Error(`Invalid JobStatus enum value: ${v}`);
+        }
+      }
+      sql = `CREATE TYPE job_status AS ENUM (${enumValues.map((v) => `'${v}'`).join(",")})`;
+      await this.db.query(sql);
+    } catch (e) {
+      if (e.code !== "42710")
+        throw e;
+    }
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    sql = `
+    CREATE TABLE IF NOT EXISTS ${this.tableName} (
+      id SERIAL NOT NULL,
+      ${prefixColumnsSql}fingerprint text NOT NULL,
+      queue text NOT NULL,
+      job_run_id text NOT NULL,
+      status job_status NOT NULL default 'PENDING',
+      input jsonb NOT NULL,
+      output jsonb,
+      run_attempts integer default 0,
+      max_retries integer default 20,
+      run_after timestamp with time zone DEFAULT now(),
+      last_ran_at timestamp with time zone,
+      created_at timestamp with time zone DEFAULT now(),
+      deadline_at timestamp with time zone,
+      completed_at timestamp with time zone,
+      error text,
+      error_code text,
+      progress real DEFAULT 0,
+      progress_message text DEFAULT '',
+      progress_details jsonb,
+      worker_id text
+    )`;
+    await this.db.query(sql);
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    sql = `
+      CREATE INDEX IF NOT EXISTS job_fetcher${indexSuffix}_idx 
+        ON ${this.tableName} (${prefixIndexPrefix}id, status, run_after)`;
+    await this.db.query(sql);
+    sql = `
+      CREATE INDEX IF NOT EXISTS job_queue_fetcher${indexSuffix}_idx 
+        ON ${this.tableName} (${prefixIndexPrefix}queue, status, run_after)`;
+    await this.db.query(sql);
+    sql = `
+      CREATE INDEX IF NOT EXISTS jobs_fingerprint${indexSuffix}_unique_idx
+        ON ${this.tableName} (${prefixIndexPrefix}queue, fingerprint, status)`;
+    await this.db.query(sql);
+    const fnName = `${this.tableName}_notify`;
+    const trgName = `${this.tableName}_notify_trg`;
+    try {
+      await this.db.query(`
+        CREATE OR REPLACE FUNCTION ${fnName}() RETURNS trigger AS $fn$
+        DECLARE
+          channel TEXT := 'wglw_q_' || md5('${this.tableName}' || COALESCE(NEW.queue, OLD.queue));
+          payload TEXT;
+        BEGIN
+          payload := json_build_object(
+            'op', TG_OP,
+            'id', COALESCE(NEW.id, OLD.id),
+            'queue', COALESCE(NEW.queue, OLD.queue),
+            'status', COALESCE(NEW.status::text, OLD.status::text)
+          )::text;
+          PERFORM pg_notify(channel, payload);
+          RETURN NULL;
+        END;
+        $fn$ LANGUAGE plpgsql;
+      `);
+      await this.db.query(`DROP TRIGGER IF EXISTS ${trgName} ON ${this.tableName}`);
+      await this.db.query(`
+        CREATE TRIGGER ${trgName}
+          AFTER INSERT OR UPDATE ON ${this.tableName}
+          FOR EACH ROW EXECUTE FUNCTION ${fnName}();
+      `);
+    } catch {}
+  }
+  notifyChannelName() {
+    const tableAndQueue = `${this.tableName}${this.queueName}`;
+    const hash = createHash("md5").update(tableAndQueue).digest("hex");
+    return `wglw_q_${hash}`;
+  }
+  async add(job) {
+    const now = new Date().toISOString();
+    job.queue = this.queueName;
+    job.job_run_id = job.job_run_id ?? uuid4();
+    job.fingerprint = await makeFingerprint(job.input);
+    job.status = JobStatus.PENDING;
+    job.progress = 0;
+    job.progress_message = "";
+    job.progress_details = null;
+    job.created_at = now;
+    job.run_after = now;
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(",") + "," : "";
+    const baseParamStart = prefixColumnNames.length + 1;
+    const sql = `
+      INSERT INTO ${this.tableName}(
+        ${prefixColumnsInsert}queue, 
+        fingerprint, 
+        input, 
+        run_after,
+        created_at,
+        deadline_at,
+        max_retries, 
+        job_run_id, 
+        progress, 
+        progress_message, 
+        progress_details
+      )
+      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 = [
+      ...prefixParamValues,
+      job.queue,
+      job.fingerprint,
+      JSON.stringify(job.input),
+      job.run_after,
+      job.created_at,
+      job.deadline_at,
+      job.max_retries,
+      job.job_run_id,
+      job.progress,
+      job.progress_message,
+      job.progress_details ? JSON.stringify(job.progress_details) : null
+    ];
+    const result = await this.db.query(sql, params);
+    if (!result)
+      throw new Error("Failed to add to queue");
+    job.id = result.rows[0].id;
+    return job.id;
+  }
+  async get(id) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`SELECT *
+        FROM ${this.tableName}
+        WHERE id = $1 AND queue = $2${prefixConditions}
+        FOR UPDATE SKIP LOCKED
+        LIMIT 1`, [id, this.queueName, ...prefixParams]);
+    if (!result || result.rows.length === 0)
+      return;
+    return result.rows[0];
+  }
+  async peek(status = JobStatus.PENDING, num = 100) {
+    num = Number(num) || 100;
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
+    const result = await this.db.query(`
+      SELECT *
+        FROM ${this.tableName}
+        WHERE queue = $1
+        AND status = $2${prefixConditions}
+        ORDER BY run_after 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);
+    const result = await this.db.query(`
+      UPDATE ${this.tableName} 
+      SET status = $1, last_ran_at = NOW() AT TIME ZONE 'UTC', worker_id = $4
+      WHERE id = (
+        SELECT id 
+        FROM ${this.tableName} 
+        WHERE queue = $2 
+        AND status = $3
+        ${prefixConditions}
+        AND run_after <= NOW() AT TIME ZONE 'UTC'
+        ORDER BY run_after ASC 
+        FOR UPDATE SKIP LOCKED 
+        LIMIT 1
+      )
+      RETURNING *`, [JobStatus.PROCESSING, this.queueName, JobStatus.PENDING, workerId, ...prefixParams]);
+    return result?.rows?.[0] ?? undefined;
+  }
+  async size(status = JobStatus.PENDING) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT COUNT(*) as count
+        FROM ${this.tableName}
+        WHERE queue = $1
+        AND status = $2${prefixConditions}`, [this.queueName, status, ...prefixParams]);
+    if (!result)
+      return 0;
+    return parseInt(result.rows[0].count, 10);
+  }
+  async complete(jobDetails) {
+    const prefixParams = this.getPrefixParamValues();
+    if (jobDetails.status === JobStatus.DISABLED) {
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(4);
+      await this.db.query(`UPDATE ${this.tableName} 
+          SET 
+            status = $1, 
+            progress = 100,
+            progress_message = '',
+            progress_details = NULL,
+            completed_at = NOW() AT TIME ZONE 'UTC'
+          WHERE id = $2 AND queue = $3${prefixConditions}`, [jobDetails.status, jobDetails.id, this.queueName, ...prefixParams]);
+    } else if (jobDetails.status === JobStatus.PENDING) {
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(7);
+      await this.db.query(`UPDATE ${this.tableName} 
+          SET 
+            error = $1, 
+            error_code = $2,
+            status = $3, 
+            run_after = $4, 
+            progress = 0,
+            progress_message = '',
+            progress_details = NULL,
+            run_attempts = run_attempts + 1, 
+            last_ran_at = NOW() AT TIME ZONE 'UTC'
+          WHERE id = $5 AND queue = $6${prefixConditions}`, [
+        jobDetails.error,
+        jobDetails.error_code,
+        jobDetails.status,
+        jobDetails.run_after,
+        jobDetails.id,
+        this.queueName,
+        ...prefixParams
+      ]);
+    } else {
+      const { conditions: prefixConditions } = this.buildPrefixWhereClause(7);
+      await this.db.query(`
+          UPDATE ${this.tableName} 
+            SET 
+              output = $1, 
+              error = $2, 
+              error_code = $3,
+              status = $4, 
+              progress = 100,
+              progress_message = '',
+              progress_details = NULL,
+              run_attempts = run_attempts + 1, 
+              completed_at = NOW() AT TIME ZONE 'UTC',
+              last_ran_at = NOW() AT TIME ZONE 'UTC'
+          WHERE id = $5 AND queue = $6${prefixConditions}`, [
+        jobDetails.output ? JSON.stringify(jobDetails.output) : null,
+        jobDetails.error ?? null,
+        jobDetails.error_code ?? null,
+        jobDetails.status,
+        jobDetails.id,
+        this.queueName,
+        ...prefixParams
+      ]);
+    }
+  }
+  async deleteAll() {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    await this.db.query(`
+      DELETE FROM ${this.tableName}
+        WHERE queue = $1${prefixConditions}`, [this.queueName, ...prefixParams]);
+  }
+  async outputForInput(input) {
+    const fingerprint = await makeFingerprint(input);
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT output
+        FROM ${this.tableName}
+        WHERE fingerprint = $1 AND queue = $2 AND status = 'COMPLETED'${prefixConditions}`, [fingerprint, this.queueName, ...prefixParams]);
+    if (!result || result.rows.length === 0)
+      return null;
+    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]);
+  }
+  async release(jobId) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`
+      UPDATE ${this.tableName}
+        SET status = 'PENDING',
+            worker_id = NULL,
+            progress = 0,
+            progress_message = '',
+            progress_details = NULL
+        WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
+  }
+  async getByRunId(job_run_id) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT * FROM ${this.tableName} WHERE job_run_id = $1 AND queue = $2${prefixConditions}`, [job_run_id, this.queueName, ...prefixParams]);
+    if (!result)
+      return [];
+    return result.rows;
+  }
+  async saveProgress(jobId, progress, message, details) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(6);
+    await this.db.query(`
+      UPDATE ${this.tableName} 
+      SET progress = $1,
+          progress_message = $2,
+          progress_details = $3
+      WHERE id = $4 AND queue = $5${prefixConditions}`, [
+      progress,
+      message,
+      details ? JSON.stringify(details) : null,
+      jobId,
+      this.queueName,
+      ...prefixParams
+    ]);
+  }
+  async delete(jobId) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`DELETE FROM ${this.tableName} WHERE id = $1 AND queue = $2${prefixConditions}`, [jobId, this.queueName, ...prefixParams]);
+  }
+  async deleteJobsByStatusAndAge(status, olderThanMs) {
+    const cutoffDate = new Date(Date.now() - olderThanMs).toISOString();
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(4);
+    await this.db.query(`DELETE FROM ${this.tableName} 
+       WHERE queue = $1 
+       AND status = $2 
+       AND completed_at IS NOT NULL 
+       AND completed_at <= $3${prefixConditions}`, [this.queueName, status, cutoffDate, ...prefixParams]);
+  }
+  subscribeToChanges(callback, options) {
+    const poolMaybe = this.db;
+    if (typeof poolMaybe.connect !== "function") {
+      throw new Error("PostgresQueueStorage.subscribeToChanges requires a pg.Pool (got a single-connection wrapper)");
+    }
+    const pool = poolMaybe;
+    const channel = this.notifyChannelName();
+    const effectivePrefixFilter = options?.prefixFilter === undefined ? this.prefixes.length > 0 ? this.prefixValues : null : Object.keys(options.prefixFilter).length === 0 ? null : options.prefixFilter;
+    let unsubscribed = false;
+    let activeClient = null;
+    let reconnectTimer = null;
+    let backoffMs = 250;
+    const dispatch = (change) => {
+      try {
+        callback(change);
+      } catch (err) {
+        getLogger().debug("PostgresQueueStorage subscribe callback threw", {
+          channel,
+          changeType: change.type,
+          error: err
+        });
+      }
+    };
+    const matchesPrefix = (change, filter) => {
+      const row = change.new ?? change.old;
+      if (!row)
+        return false;
+      for (const [k, v] of Object.entries(filter)) {
+        if (row[k] !== v)
+          return false;
+      }
+      return true;
+    };
+    const hydrate = async (id) => {
+      try {
+        return await this.get(id);
+      } catch {
+        return;
+      }
+    };
+    const handleNotification = (msg) => {
+      if (msg.channel !== channel || !msg.payload)
+        return;
+      let parsed;
+      try {
+        parsed = JSON.parse(msg.payload);
+      } catch {
+        return;
+      }
+      (async () => {
+        const op = parsed.op;
+        const fallback = {
+          id: parsed.id,
+          queue: parsed.queue,
+          status: parsed.status
+        };
+        const fullRow = op === "DELETE" ? undefined : await hydrate(parsed.id);
+        const change = {
+          type: op === "INSERT" ? "INSERT" : op === "DELETE" ? "DELETE" : "UPDATE",
+          new: op === "DELETE" ? undefined : fullRow ?? fallback,
+          old: op === "DELETE" ? fallback : undefined
+        };
+        if (effectivePrefixFilter && !matchesPrefix(change, effectivePrefixFilter))
+          return;
+        dispatch(change);
+      })();
+    };
+    const connect = async () => {
+      if (unsubscribed)
+        return;
+      try {
+        const client = await pool.connect();
+        if (unsubscribed) {
+          client.release();
+          return;
+        }
+        activeClient = client;
+        client.on("notification", handleNotification);
+        client.on("error", () => scheduleReconnect());
+        await client.query(`LISTEN ${channel}`);
+        backoffMs = 250;
+        dispatch({ type: "RESYNC" });
+      } catch {
+        scheduleReconnect();
+      }
+    };
+    const scheduleReconnect = () => {
+      if (unsubscribed || reconnectTimer)
+        return;
+      const c = activeClient;
+      activeClient = null;
+      try {
+        c?.removeAllListeners?.("notification");
+        c?.removeAllListeners?.("error");
+        c?.release();
+      } catch {}
+      const delay = Math.min(backoffMs, 30000);
+      backoffMs = Math.min(backoffMs * 2, 30000);
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        connect();
+      }, delay);
+    };
+    connect();
+    return () => {
+      unsubscribed = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      const c = activeClient;
+      activeClient = null;
+      if (c) {
+        c.query(`UNLISTEN ${channel}`).catch(() => {}).finally(() => {
+          try {
+            c.removeAllListeners?.("notification");
+            c.removeAllListeners?.("error");
+            c.release();
+          } catch {}
+        });
+      }
+    };
+  }
+}
+// src/job-queue/PostgresRateLimiterStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var POSTGRES_RATE_LIMITER_STORAGE = createServiceToken2("ratelimiter.storage.postgres");
+
+class PostgresRateLimiterStorage {
+  db;
+  scope = "cluster";
+  prefixes;
+  prefixValues;
+  executionTableName;
+  nextAvailableTableName;
+  constructor(db, options) {
+    this.db = db;
+    this.prefixes = options?.prefixes ?? [];
+    this.prefixValues = options?.prefixValues ?? {};
+    if (this.prefixes.length > 0) {
+      const prefixNames = this.prefixes.map((p) => p.name).join("_");
+      this.executionTableName = `rate_limit_executions_${prefixNames}`;
+      this.nextAvailableTableName = `rate_limit_next_available_${prefixNames}`;
+    } else {
+      this.executionTableName = "rate_limit_executions";
+      this.nextAvailableTableName = "rate_limit_next_available";
+    }
+  }
+  getPrefixColumnType(type) {
+    return type === "uuid" ? "UUID" : "INTEGER";
+  }
+  buildPrefixColumnsSql() {
+    if (this.prefixes.length === 0)
+      return "";
+    return this.prefixes.map((p) => `${p.name} ${this.getPrefixColumnType(p.type)} NOT NULL`).join(`,
+        `) + `,
+        `;
+  }
+  getPrefixColumnNames() {
+    return this.prefixes.map((p) => p.name);
+  }
+  buildPrefixWhereClause(startParam) {
+    if (this.prefixes.length === 0) {
+      return { conditions: "", params: [] };
+    }
+    const conditions = this.prefixes.map((p, i) => `${p.name} = $${startParam + i}`).join(" AND ");
+    const params = this.prefixes.map((p) => this.prefixValues[p.name]);
+    return { conditions: " AND " + conditions, params };
+  }
+  getPrefixParamValues() {
+    return this.prefixes.map((p) => this.prefixValues[p.name]);
+  }
+  async setupDatabase() {
+    const prefixColumnsSql = this.buildPrefixColumnsSql();
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixIndexPrefix = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const indexSuffix = prefixColumnNames.length > 0 ? "_" + prefixColumnNames.join("_") : "";
+    await this.db.query(`
+      CREATE TABLE IF NOT EXISTS ${this.executionTableName} (
+        id SERIAL PRIMARY KEY,
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        executed_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+      )
+    `);
+    await this.db.query(`
+      CREATE INDEX IF NOT EXISTS rate_limit_exec_queue${indexSuffix}_idx 
+        ON ${this.executionTableName} (${prefixIndexPrefix}queue_name, executed_at)
+    `);
+    const primaryKeyColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    await this.db.query(`
+      CREATE TABLE IF NOT EXISTS ${this.nextAvailableTableName} (
+        ${prefixColumnsSql}queue_name TEXT NOT NULL,
+        next_available_at TIMESTAMP WITH TIME ZONE,
+        PRIMARY KEY (${primaryKeyColumns})
+      )
+    `);
+  }
+  async tryReserveExecution(queueName, maxExecutions, windowMs) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixCount = prefixColumnNames.length;
+    const queueParam = `$${prefixCount + 1}`;
+    const windowStartParam = `$${prefixCount + 2}`;
+    const lockKeyParts = [`'${this.executionTableName}'`];
+    for (let i = 0;i < prefixCount; i++) {
+      lockKeyParts.push(`$${i + 1}::text`);
+    }
+    lockKeyParts.push(`${queueParam}::text`);
+    const lockKeyExpr = `hashtextextended(${lockKeyParts.join(" || '|' || ")}, 0)`;
+    const prefixWhere = prefixCount > 0 ? " AND " + prefixColumnNames.map((p, i) => `${p} = $${i + 1}`).join(" AND ") : "";
+    const prefixInsertCols = prefixCount > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixInsertPlaceholders = prefixCount > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const windowStart = new Date(Date.now() - windowMs).toISOString();
+    const supportsConnect = typeof this.db.connect === "function";
+    if (!supportsConnect) {
+      const dbAny = this.db;
+      const ctorName = dbAny.constructor?.name;
+      const looksLikePGlite = typeof dbAny.exec === "function" && dbAny.waitReady !== undefined;
+      const looksLikePGLitePool = ctorName === "PGLitePool";
+      if (!looksLikePGlite && !looksLikePGLitePool) {
+        throw new Error(`PostgresRateLimiterStorage.tryReserveExecution requires a pg.Pool with connect() or a known single-connection wrapper (PGLitePool, PGlite); got ${ctorName ?? typeof this.db}. A multi-connection pool without connect() would dispatch the advisory lock and the INSERT to different sessions, breaking atomicity.`);
+      }
+    }
+    const conn = supportsConnect ? await this.db.connect() : { query: this.db.query.bind(this.db), release: () => {} };
+    try {
+      await conn.query("BEGIN");
+      try {
+        await conn.query(`SELECT pg_advisory_xact_lock(${lockKeyExpr})`, [
+          ...prefixParamValues,
+          queueName
+        ]);
+        const countResult = await conn.query(`
+          SELECT COUNT(*)::int AS n
+          FROM ${this.executionTableName}
+          WHERE queue_name = ${queueParam} AND executed_at > ${windowStartParam}${prefixWhere}
+          `, [...prefixParamValues, queueName, windowStart]);
+        const n = countResult.rows[0]?.n ?? 0;
+        if (n >= maxExecutions) {
+          await conn.query("COMMIT");
+          return null;
+        }
+        const naResult = await conn.query(`
+          SELECT next_available_at
+          FROM ${this.nextAvailableTableName}
+          WHERE queue_name = ${queueParam}${prefixWhere}
+          `, [...prefixParamValues, queueName]);
+        const nextAvailableAt = naResult.rows[0]?.next_available_at ?? null;
+        if (nextAvailableAt && new Date(nextAvailableAt).getTime() > Date.now()) {
+          await conn.query("COMMIT");
+          return null;
+        }
+        const insertResult = await conn.query(`
+          INSERT INTO ${this.executionTableName} (${prefixInsertCols}queue_name)
+          VALUES (${prefixInsertPlaceholders}${queueParam})
+          RETURNING id
+          `, [...prefixParamValues, queueName]);
+        await conn.query("COMMIT");
+        return insertResult.rows[0]?.id ?? null;
+      } catch (err) {
+        try {
+          await conn.query("ROLLBACK");
+        } catch {}
+        throw err;
+      }
+    } finally {
+      conn.release();
+    }
+  }
+  async releaseExecution(queueName, token) {
+    if (token === null || token === undefined)
+      return;
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    await this.db.query(`DELETE FROM ${this.executionTableName} WHERE id = $1 AND queue_name = $2${prefixConditions}`, [token, queueName, ...prefixParams]);
+  }
+  async recordExecution(queueName) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const queueParamNum = prefixColumnNames.length + 1;
+    await this.db.query(`
+      INSERT INTO ${this.executionTableName} (${prefixColumnsInsert}queue_name)
+      VALUES (${prefixParamPlaceholders}$${queueParamNum})
+    `, [...prefixParamValues, queueName]);
+  }
+  async getExecutionCount(queueName, windowStartTime) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT COUNT(*) AS count
+      FROM ${this.executionTableName}
+      WHERE queue_name = $1 AND executed_at > $2${prefixConditions}
+    `, [queueName, windowStartTime, ...prefixParams]);
+    return parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async getOldestExecutionAtOffset(queueName, offset) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(3);
+    const result = await this.db.query(`
+      SELECT executed_at
+      FROM ${this.executionTableName}
+      WHERE queue_name = $1${prefixConditions}
+      ORDER BY executed_at ASC
+      LIMIT 1 OFFSET $2
+    `, [queueName, offset, ...prefixParams]);
+    const executedAt = result.rows[0]?.executed_at;
+    if (!executedAt)
+      return;
+    return new Date(executedAt).toISOString();
+  }
+  async getNextAvailableTime(queueName) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    const result = await this.db.query(`
+      SELECT next_available_at
+      FROM ${this.nextAvailableTableName}
+      WHERE queue_name = $1${prefixConditions}
+    `, [queueName, ...prefixParams]);
+    const nextAvailableAt = result.rows[0]?.next_available_at;
+    if (!nextAvailableAt)
+      return;
+    return new Date(nextAvailableAt).toISOString();
+  }
+  async setNextAvailableTime(queueName, nextAvailableAt) {
+    const prefixColumnNames = this.getPrefixColumnNames();
+    const prefixColumnsInsert = prefixColumnNames.length > 0 ? prefixColumnNames.join(", ") + ", " : "";
+    const prefixParamValues = this.getPrefixParamValues();
+    const prefixParamPlaceholders = prefixColumnNames.length > 0 ? prefixColumnNames.map((_, i) => `$${i + 1}`).join(", ") + ", " : "";
+    const baseParamStart = prefixColumnNames.length + 1;
+    const conflictColumns = prefixColumnNames.length > 0 ? `${prefixColumnNames.join(", ")}, queue_name` : "queue_name";
+    await this.db.query(`
+      INSERT INTO ${this.nextAvailableTableName} (${prefixColumnsInsert}queue_name, next_available_at)
+      VALUES (${prefixParamPlaceholders}$${baseParamStart}, $${baseParamStart + 1})
+      ON CONFLICT (${conflictColumns})
+      DO UPDATE SET next_available_at = EXCLUDED.next_available_at
+    `, [...prefixParamValues, queueName, nextAvailableAt]);
+  }
+  async clear(queueName) {
+    const { conditions: prefixConditions, params: prefixParams } = this.buildPrefixWhereClause(2);
+    await this.db.query(`DELETE FROM ${this.executionTableName} WHERE queue_name = $1${prefixConditions}`, [queueName, ...prefixParams]);
+    await this.db.query(`DELETE FROM ${this.nextAvailableTableName} WHERE queue_name = $1${prefixConditions}`, [queueName, ...prefixParams]);
+  }
+}
+export {
+  PostgresRateLimiterStorage,
+  PostgresQueueStorage,
+  POSTGRES_RATE_LIMITER_STORAGE,
+  POSTGRES_QUEUE_STORAGE
+};
+
+//# debugId=561DECA09B89A19664756E2164756E21