bullmq 6.3.11 → 6.3.13

package/dist/cjs/postgres/migrations/0003_dedup_stale_key.sql

@@ -1,147 +0,0 @@
--- BullMQ PostgreSQL backend — deduplication stale-key recovery.
---
--- Replaces `deduplicate_job` (created in 0002_functions.sql) to fix two ways a
--- deduplication key could outlive the job it points at:
---
---   1. Stale key: a key with no expiry is meant to disappear when its winner
---      finishes, but `clean`, `drain`, `obliterate` (and outages) delete the
---      job row without clearing the `dedup` row. Every later add then matched
---      that dead winner and was silently dropped, forever. Mirrors the Redis
---      `recoverStaleDeduplicationKey` include.
---   2. Orphaned proto-next: replacing a *delayed* winner left behind any
---      `dedup_next` payload stashed while that winner was previously active,
---      so it got resurrected when the replacement finished.
---
--- Only the function body changes — no schema/DDL change — so the signature is
--- identical and older clients keep working against the updated schema.
-
-CREATE OR REPLACE FUNCTION deduplicate_job(
-  p_queue text, p_dedup jsonb, p_job_id text, p_now bigint,
-  p_name text, p_data jsonb, p_opts jsonb
-) RETURNS text
-LANGUAGE plpgsql
-SET search_path FROM CURRENT
-AS $$
-DECLARE
-  v_id       text    := p_dedup->>'id';
-  v_ttl      bigint  := NULLIF(p_dedup->>'ttl', '')::bigint;
-  v_extend   boolean := COALESCE((p_dedup->>'extend')::boolean, false);
-  v_replace  boolean := COALESCE((p_dedup->>'replace')::boolean, false);
-  v_keeplast boolean := COALESCE((p_dedup->>'keepLastIfActive')::boolean, false);
-  v_cur      text;
-  v_exp      bigint;
-  v_state    job_state;
-BEGIN
-  IF v_id IS NULL OR v_id = '' THEN
-    RETURN NULL;
-  END IF;
-
-  -- The current winner (only if the key is still live).
-  SELECT job_id, expire_at_ms INTO v_cur, v_exp
-    FROM dedup WHERE queue = p_queue AND dedup_id = v_id;
-  IF v_cur IS NULL OR (v_exp IS NOT NULL AND v_exp <= p_now) THEN
-    v_cur := NULL;
-  ELSIF v_exp IS NULL AND NOT EXISTS (
-    SELECT 1 FROM job WHERE queue = p_queue AND id = v_cur
-  ) THEN
-    -- Stale key recovery (mirrors recoverStaleDeduplicationKey): a key with no
-    -- expiry is meant to disappear when its winner finishes. If the job row is
-    -- gone (clean, drain, obliterate, an outage…) the key is stale, so discard
-    -- it together with any pending proto-next (which would otherwise be
-    -- resurrected) and start a new window with the incoming job.
-    DELETE FROM dedup WHERE queue = p_queue AND dedup_id = v_id;
-    DELETE FROM dedup_next WHERE queue = p_queue AND dedup_id = v_id;
-    v_cur := NULL;
-  END IF;
-
-  IF v_replace THEN
-    IF v_cur IS NOT NULL THEN
-      SELECT state INTO v_state
-        FROM job WHERE queue = p_queue AND id = v_cur;
-      IF v_state = 'delayed' THEN
-        -- Drop the previous delayed job and take its place.
-        DELETE FROM job WHERE queue = p_queue AND id = v_cur;
-        PERFORM publish_event(p_queue, 'removed',
-          jsonb_build_object('jobId', v_cur, 'prev', 'delayed'));
-        PERFORM publish_event(p_queue, 'deduplicated',
-          jsonb_build_object('jobId', p_job_id, 'deduplicationId', v_id,
-            'deduplicatedJobId', v_cur));
-        -- Discard any pending proto-next stashed while the replaced job was
-        -- active, otherwise it would be resurrected when p_job_id finalizes.
-        DELETE FROM dedup_next WHERE queue = p_queue AND dedup_id = v_id;
-        IF v_keeplast THEN
-          UPDATE dedup SET job_id = p_job_id, expire_at_ms = NULL
-           WHERE queue = p_queue AND dedup_id = v_id;
-        ELSIF NOT v_extend AND COALESCE(v_ttl, 0) > 0 THEN
-          -- KEEPTTL: keep the existing window, just swap the winner.
-          UPDATE dedup SET job_id = p_job_id
-           WHERE queue = p_queue AND dedup_id = v_id;
-        ELSE
-          UPDATE dedup
-             SET job_id = p_job_id,
-                 expire_at_ms = CASE WHEN COALESCE(v_ttl, 0) > 0
-                                     THEN p_now + v_ttl ELSE NULL END
-           WHERE queue = p_queue AND dedup_id = v_id;
-        END IF;
-        RETURN NULL;
-      ELSE
-        -- Winner is not a removable delayed job: stash proto-next if it is
-        -- active + keepLastIfActive, then deduplicate.
-        PERFORM dedup_store_next(p_queue, v_id, v_cur, p_job_id,
-          v_keeplast, p_name, p_data, p_opts);
-        RETURN v_cur;
-      END IF;
-    ELSE
-      INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
-        VALUES (p_queue, v_id, p_job_id,
-          CASE WHEN NOT v_keeplast AND COALESCE(v_ttl, 0) > 0
-               THEN p_now + v_ttl ELSE NULL END)
-      ON CONFLICT (queue, dedup_id) DO UPDATE
-        SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
-      RETURN NULL;
-    END IF;
-  END IF;
-
-  -- Without replace.
-  IF COALESCE(v_ttl, 0) > 0 AND v_extend THEN
-    IF v_cur IS NOT NULL THEN
-      -- Stash proto-next if active+keepLast; else extend the window (or
-      -- persist when keepLastIfActive). Either way keep the current winner.
-      IF NOT dedup_store_next(p_queue, v_id, v_cur, p_job_id,
-               v_keeplast, p_name, p_data, p_opts) THEN
-        UPDATE dedup
-           SET expire_at_ms = CASE WHEN v_keeplast THEN NULL ELSE p_now + v_ttl END
-         WHERE queue = p_queue AND dedup_id = v_id;
-      END IF;
-      PERFORM publish_event(p_queue, 'deduplicated',
-        jsonb_build_object('jobId', v_cur, 'deduplicationId', v_id,
-          'deduplicatedJobId', p_job_id));
-      RETURN v_cur;
-    END IF;
-    INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
-      VALUES (p_queue, v_id, p_job_id,
-        CASE WHEN v_keeplast THEN NULL ELSE p_now + v_ttl END)
-    ON CONFLICT (queue, dedup_id) DO UPDATE
-      SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
-    RETURN NULL;
-  END IF;
-
-  -- SET NX semantics (ttl>0 non-extend, or no ttl at all).
-  IF v_cur IS NOT NULL THEN
-    PERFORM dedup_store_next(p_queue, v_id, v_cur, p_job_id,
-      v_keeplast, p_name, p_data, p_opts);
-    PERFORM publish_event(p_queue, 'deduplicated',
-      jsonb_build_object('jobId', v_cur, 'deduplicationId', v_id,
-        'deduplicatedJobId', p_job_id));
-    RETURN v_cur;
-  END IF;
-
-  INSERT INTO dedup (queue, dedup_id, job_id, expire_at_ms)
-    VALUES (p_queue, v_id, p_job_id,
-      CASE WHEN NOT v_keeplast AND COALESCE(v_ttl, 0) > 0
-           THEN p_now + v_ttl ELSE NULL END)
-  ON CONFLICT (queue, dedup_id) DO UPDATE
-    SET job_id = EXCLUDED.job_id, expire_at_ms = EXCLUDED.expire_at_ms;
-  RETURN NULL;
-END;
-$$;

package/dist/esm/postgres/commands/add_flow.sql

@@ -1,3 +0,0 @@
--- Insert a flow (tree) of jobs atomically. Param: $1 entries (jsonb array,
--- ordered roots-first). Returns the job ids in input order.
-SELECT id FROM add_flow($1::jsonb) AS t(id);

package/dist/esm/postgres/commands/add_job.sql

@@ -1,5 +0,0 @@
--- Insert a single job, routing it to waiting or delayed; returns its id.
-SELECT add_job(
-  $1, $2, $3, $4::jsonb, $5::jsonb, $6, $7, $8, $9,
-  $10, $11, $12, $13, $14, $15
-) AS id;

package/dist/esm/postgres/commands/add_job_scheduler.sql

@@ -1,6 +0,0 @@
--- Register/update a scheduler and enqueue its next iteration; returns the
--- delayed job id and its delay. Params: $1 queue, $2 scheduler_id,
--- $3 next_millis, $4 template_data (jsonb), $5 template_opts (jsonb),
--- $6 opts (jsonb), $7 delayed_opts (jsonb), $8 now, $9 producer_id.
-SELECT job_id, delay
-  FROM add_job_scheduler($1, $2, $3, $4, $5, $6, $7, $8, $9);

package/dist/esm/postgres/commands/add_jobs_bulk.sql

@@ -1,3 +0,0 @@
--- Fast set-based bulk insert of INDEPENDENT jobs (no parents, no dedup).
--- Param: $1 queue, $2 entries (jsonb array). Returns the job ids in input order.
-SELECT id FROM add_jobs_bulk($1, $2::jsonb) AS t(id);

package/dist/esm/postgres/commands/add_log.sql

@@ -1,14 +0,0 @@
--- Append a log line at the next per-job ordinal; returns its index.
--- Params: $1 queue, $2 job_id, $3 row.
--- The unqualified table name resolves in the configured BullMQ schema via
--- search_path (default schema: bullmq).
-INSERT INTO job_log (queue, job_id, idx, row)
-VALUES (
-  $1, $2,
-  COALESCE(
-    (SELECT MAX(idx) + 1 FROM job_log WHERE queue = $1 AND job_id = $2),
-    0
-  ),
-  $3
-)
-RETURNING idx;

package/dist/esm/postgres/commands/change_delay.sql

@@ -1,3 +0,0 @@
--- Reschedule a delayed job. Params: $1 queue, $2 id, $3 delay, $4 now.
--- Returns 0 ok, -1 missing, -3 not delayed.
-SELECT change_delay($1, $2, $3, $4) AS code;

package/dist/esm/postgres/commands/change_priority.sql

@@ -1,3 +0,0 @@
--- Change a job's priority (and reposition via lifo). Params: $1 queue, $2 id,
--- $3 priority, $4 lifo. Returns 0 ok, -1 missing.
-SELECT change_priority($1, $2, $3, $4) AS code;

package/dist/esm/postgres/commands/clean.sql

@@ -1,3 +0,0 @@
--- Remove jobs of a state older than a timestamp, up to a limit (0 = all);
--- returns removed ids. Params: $1 queue, $2 type, $3 timestamp, $4 limit.
-SELECT id FROM clean($1, $2, $3, $4) AS t(id);

package/dist/esm/postgres/commands/clear_logs.sql

@@ -1,9 +0,0 @@
--- Clear a job's logs, keeping the latest $3 entries (NULL/0 → remove all).
--- Params: $1 queue, $2 job_id, $3 keepLogs.
-DELETE FROM job_log
- WHERE queue = $1 AND job_id = $2
-   AND idx < COALESCE(
-     (SELECT MAX(idx) FROM job_log WHERE queue = $1 AND job_id = $2)
-       - $3 + 1,
-     idx + 1
-   );

package/dist/esm/postgres/commands/collect_metrics.sql

@@ -1,4 +0,0 @@
--- Record one finished job into the queue/kind metrics (per-minute deltas).
--- Params: $1 queue, $2 kind ('completed' | 'failed'), $3 maxDataPoints,
--- $4 finish timestamp (epoch ms).
-SELECT collect_metrics($1, $2, $3, $4);

package/dist/esm/postgres/commands/delete_deduplication_key.sql

@@ -1,6 +0,0 @@
--- Unconditionally remove a deduplication key (Queue.removeDeduplicationKey /
--- the deprecated removeDebounceKey). Params: $1 queue, $2 dedup_id. Returns the
--- removed key (0 or 1 row).
-DELETE FROM dedup
-WHERE queue = $1 AND dedup_id = $2
-RETURNING dedup_id;

package/dist/esm/postgres/commands/drain.sql

@@ -1,2 +0,0 @@
--- Remove waiting (and optionally delayed) jobs. Params: $1 queue, $2 delayed.
-SELECT drain($1, $2);

package/dist/esm/postgres/commands/extend_lock.sql

@@ -1,3 +0,0 @@
--- Refresh an active job's lock; returns 1 on success, 0 if the lock was lost.
--- Params: $1 queue, $2 id, $3 token, $4 lock_ms, $5 now_ms.
-SELECT extend_lock($1, $2, $3, $4, $5) AS n;

package/dist/esm/postgres/commands/extend_locks.sql

@@ -1,25 +0,0 @@
--- Refresh multiple active-job locks in one round-trip; returns the ids whose
--- locks could not be renewed. Params: $1 queue, $2 ids (text[]), $3 tokens
--- (text[]), $4 lock_ms, $5 now_ms.
-WITH input AS (
-  SELECT ids.job_id, toks.token, ids.ord
-    FROM unnest($2::text[]) WITH ORDINALITY AS ids(job_id, ord)
-    JOIN unnest($3::text[]) WITH ORDINALITY AS toks(token, ord)
-      USING (ord)
-),
-updated AS (
-  UPDATE job
-     SET locked_until_ms = $5::bigint + $4::bigint
-    FROM input
-   WHERE queue = $1
-     AND id = input.job_id
-     AND state = 'active'
-     AND lock_token = input.token
-  RETURNING id
-)
-SELECT input.job_id AS id
-  FROM input
-  LEFT JOIN updated
-    ON updated.id = input.job_id
- WHERE updated.id IS NULL
- ORDER BY input.ord;

package/dist/esm/postgres/commands/get_client_list.sql

@@ -1,11 +0,0 @@
--- Connected BullMQ clients, mirroring Redis `CLIENT LIST` for worker/queue
--- discovery. Each long-lived worker / QueueEvents listener names its dedicated
--- connection via `application_name` (the PostgreSQL analogue of
--- `CLIENT SETNAME`), so listing the named sessions on this database reproduces
--- the same discovery surface. Pooled query connections leave `application_name`
--- empty and are excluded. One row per connection; the backend formats them into
--- `name=<application_name>` lines for the shared client-list parser.
-SELECT application_name
-FROM pg_stat_activity
-WHERE datname = current_database()
-  AND application_name <> '';

package/dist/esm/postgres/commands/get_counts.sql

@@ -1,13 +0,0 @@
--- Job counts by state for a queue. Param: $1 queue.
--- "prioritized" = waiting with priority > 0; "waiting" = waiting with priority 0.
-SELECT
-  COUNT(*) FILTER (WHERE state = 'active')                   AS active,
-  COUNT(*) FILTER (WHERE state = 'completed')                AS completed,
-  COUNT(*) FILTER (WHERE state = 'failed')                   AS failed,
-  COUNT(*) FILTER (WHERE state = 'delayed')                  AS delayed,
-  COUNT(*) FILTER (WHERE state = 'waiting' AND priority = 0) AS waiting,
-  COUNT(*) FILTER (WHERE state = 'waiting' AND priority > 0) AS prioritized,
-  COUNT(*) FILTER (WHERE state = 'waiting-children')         AS "waiting-children",
-  (SELECT value FROM meta WHERE queue = $1 AND field = 'paused') AS paused
-FROM job
-WHERE queue = $1;

package/dist/esm/postgres/commands/get_counts_per_priority.sql

@@ -1,14 +0,0 @@
--- Waiting-job counts per priority. Params: $1 queue, $2 priorities (bigint[]).
--- Returns one row per requested priority, in the input array order, with the
--- number of waiting jobs at that priority. Pausing is an O(1) meta flag that
--- leaves jobs in the 'waiting' state, so the counts are identical whether or
--- not the queue is paused (mirrors Redis, where pausing does not touch the
--- wait/prioritized sets).
-SELECT COUNT(j.id) AS cnt
-FROM unnest($2::bigint[]) WITH ORDINALITY AS pr(priority, ord)
-LEFT JOIN job j
-  ON j.queue = $1
- AND j.state = 'waiting'
- AND j.priority = pr.priority
-GROUP BY pr.ord
-ORDER BY pr.ord;

package/dist/esm/postgres/commands/get_deduplication_job_id.sql

@@ -1,7 +0,0 @@
--- The current "winner" job id for a deduplication key, or none when absent or
--- expired. Params: $1 queue, $2 dedup_id, $3 now (ms).
-SELECT job_id
-FROM dedup
-WHERE queue = $1
-  AND dedup_id = $2
-  AND (expire_at_ms IS NULL OR expire_at_ms > $3);

package/dist/esm/postgres/commands/get_dependencies.sql

@@ -1,8 +0,0 @@
--- All of a parent job's child dependencies with their status and stored value.
--- Params: $1 parent_queue, $2 parent_id. Status maps to the public categories:
--- processed → processed (value = return value), pending → unprocessed,
--- ignored → ignored (value = reason), failed → failed.
-SELECT status::text AS status, child_key, value
-FROM job_dependency
-WHERE parent_queue = $1 AND parent_id = $2
-ORDER BY child_id;

package/dist/esm/postgres/commands/get_dependencies_page.sql

@@ -1,7 +0,0 @@
--- One page of a parent's child dependencies in a single status category.
--- Params: $1 parent_queue, $2 parent_id, $3 status, $4 offset, $5 count.
-SELECT child_key, value
-FROM job_dependency
-WHERE parent_queue = $1 AND parent_id = $2 AND status = $3::dep_status
-ORDER BY child_id
-OFFSET $4 LIMIT $5;

package/dist/esm/postgres/commands/get_dependency_counts.sql

@@ -1,9 +0,0 @@
--- Child-dependency counts per status for a parent job.
--- Params: $1 parent_queue, $2 parent_id. ("unprocessed" = pending children.)
-SELECT
-  COUNT(*) FILTER (WHERE status = 'processed') AS processed,
-  COUNT(*) FILTER (WHERE status = 'pending')   AS unprocessed,
-  COUNT(*) FILTER (WHERE status = 'ignored')   AS ignored,
-  COUNT(*) FILTER (WHERE status = 'failed')    AS failed
-FROM job_dependency
-WHERE parent_queue = $1 AND parent_id = $2;

package/dist/esm/postgres/commands/get_ignored_children_failures.sql

@@ -1,7 +0,0 @@
--- Ignored children of a parent as (child_key → failure reason) pairs. The reason
--- is stored as a JSON scalar string, so `#>> '{}'` extracts the raw text
--- (mirrors the Redis `<jobId>:failed` hash). Params: $1 parent_queue, $2 parent_id.
-SELECT child_key, COALESCE(value #>> '{}', value::text) AS reason
-FROM job_dependency
-WHERE parent_queue = $1 AND parent_id = $2 AND status = 'ignored'
-ORDER BY child_id;

package/dist/esm/postgres/commands/get_job_data.sql

@@ -1,2 +0,0 @@
--- A job's full row. Params: $1 queue, $2 id.
-SELECT * FROM job WHERE queue = $1 AND id = $2;

package/dist/esm/postgres/commands/get_job_logs_asc.sql

@@ -1,6 +0,0 @@
--- A page of a job's logs, oldest first.
--- Params: $1 queue, $2 job_id, $3 offset, $4 limit.
-SELECT row FROM job_log
- WHERE queue = $1 AND job_id = $2
- ORDER BY idx ASC
- OFFSET $3 LIMIT $4;

package/dist/esm/postgres/commands/get_job_logs_count.sql

@@ -1,2 +0,0 @@
--- Total number of log lines for a job. Params: $1 queue, $2 job_id.
-SELECT COUNT(*) AS count FROM job_log WHERE queue = $1 AND job_id = $2;

package/dist/esm/postgres/commands/get_job_logs_desc.sql

@@ -1,6 +0,0 @@
--- A page of a job's logs, newest first.
--- Params: $1 queue, $2 job_id, $3 offset, $4 limit.
-SELECT row FROM job_log
- WHERE queue = $1 AND job_id = $2
- ORDER BY idx DESC
- OFFSET $3 LIMIT $4;

package/dist/esm/postgres/commands/get_job_scheduler.sql

@@ -1,6 +0,0 @@
--- Fetch a single scheduler's stored metadata and next-run score.
--- Params: $1 queue, $2 scheduler_id.
-SELECT name, iteration_count, limit_count, start_date_ms, end_date_ms, tz,
-       pattern, every_ms, offset_ms, template_data, template_opts, next_run_ms
-  FROM scheduler
- WHERE queue = $1 AND scheduler_id = $2;

package/dist/esm/postgres/commands/get_job_schedulers_count.sql

@@ -1,2 +0,0 @@
--- Number of registered schedulers in a queue. Param: $1 queue.
-SELECT count(*)::int AS count FROM scheduler WHERE queue = $1;

package/dist/esm/postgres/commands/get_job_schedulers_range.sql

@@ -1,10 +0,0 @@
--- Fetch a page of schedulers ordered by next-run time. Params: $1 queue,
--- $2 asc (boolean), $3 offset, $4 count (NULL = all remaining).
-SELECT scheduler_id, next_run_ms
-  FROM scheduler
- WHERE queue = $1
- ORDER BY CASE WHEN $2 THEN next_run_ms END ASC,
-          CASE WHEN NOT $2 THEN next_run_ms END DESC,
-          scheduler_id
- OFFSET $3
- LIMIT $4;

package/dist/esm/postgres/commands/get_metrics.sql

@@ -1,14 +0,0 @@
--- Metrics for a queue/kind: the cumulative meta `count` and the per-minute data
--- points (newest first), sliced to [start, end] with Redis LRANGE semantics
--- (index 0 is the newest point; a negative end means "to the oldest").
--- Params: $1 queue, $2 kind ('completed' | 'failed'), $3 start, $4 end.
-SELECT
-  COALESCE((SELECT count FROM metrics
-             WHERE queue = $1 AND kind = $2), 0)::bigint AS total,
-  COALESCE((
-    SELECT CASE
-             WHEN $4 < 0 THEN data[($3 + 1) : ]
-             ELSE data[($3 + 1) : ($4 + 1)]
-           END
-      FROM metrics WHERE queue = $1 AND kind = $2
-  ), ARRAY[]::bigint[]) AS data;

package/dist/esm/postgres/commands/get_processed_children_values.sql

@@ -1,8 +0,0 @@
--- Processed children of a parent as (child_key → serialized value) pairs. The
--- value is returned as JSON text so the caller can JSON.parse it (mirrors the
--- Redis `<jobId>:processed` hash of stringified values). Params: $1 parent_queue,
--- $2 parent_id.
-SELECT child_key, value::text AS value
-FROM job_dependency
-WHERE parent_queue = $1 AND parent_id = $2 AND status = 'processed'
-ORDER BY child_id;

package/dist/esm/postgres/commands/get_queue_meta.sql

@@ -1,2 +0,0 @@
--- The full queue metadata hash. Param: $1 queue.
-SELECT field, value FROM meta WHERE queue = $1;

package/dist/esm/postgres/commands/get_queue_meta_field.sql

@@ -1,2 +0,0 @@
--- A single queue metadata field's value. Params: $1 queue, $2 field.
-SELECT value FROM meta WHERE queue = $1 AND field = $2;

package/dist/esm/postgres/commands/get_queue_meta_fields.sql

@@ -1,3 +0,0 @@
--- Several queue metadata fields. Params: $1 queue, $2 fields (text[]).
-SELECT field, value FROM meta
- WHERE queue = $1 AND field = ANY($2::text[]);

package/dist/esm/postgres/commands/get_range.sql

@@ -1,3 +0,0 @@
--- Job ids in a state, sliced by [start, end]. Params: $1 queue, $2 type,
--- $3 start, $4 end, $5 asc.
-SELECT id FROM get_range($1, $2, $3, $4, $5) AS t(id);

package/dist/esm/postgres/commands/get_rate_limit_ttl.sql

@@ -1,3 +0,0 @@
--- Current rate-limit ttl in ms (Redis getRateLimitTtl semantics). Params:
--- $1 queue, $2 maxJobs (0 = unspecified → meta `max` / raw window), $3 now_ms.
-SELECT rate_limit_ttl($1, $2, $3) AS ttl;

package/dist/esm/postgres/commands/get_state.sql

@@ -1,2 +0,0 @@
--- A job's state and priority. Params: $1 queue, $2 id.
-SELECT state, priority FROM job WHERE queue = $1 AND id = $2;

package/dist/esm/postgres/commands/has_queue_meta_field.sql

@@ -1,4 +0,0 @@
--- Whether a queue metadata field exists. Params: $1 queue, $2 field.
-SELECT EXISTS(
-  SELECT 1 FROM meta WHERE queue = $1 AND field = $2
-) AS exists;

package/dist/esm/postgres/commands/has_waiting_job.sql

@@ -1,11 +0,0 @@
--- Whether the queue has a claimable (waiting, non-paused) job right now. Used
--- by waitForJob to close the race where a NOTIFY fires before the listener is
--- established (mirrors the atomicity of Redis's blocking pop). Param: $1 queue.
-SELECT
-  EXISTS(
-    SELECT 1 FROM job WHERE queue = $1 AND state = 'waiting'
-  )
-  AND NOT EXISTS(
-    SELECT 1 FROM meta
-     WHERE queue = $1 AND field = 'paused' AND value = '1'
-  ) AS present;

package/dist/esm/postgres/commands/is_finished.sql

@@ -1,4 +0,0 @@
--- A job's finished state and result/reason (for waitUntilFinished / isFinished).
--- Params: $1 queue, $2 id.
-SELECT state, return_value, failed_reason
-  FROM job WHERE queue = $1 AND id = $2;

package/dist/esm/postgres/commands/is_job_in_state.sql

@@ -1,6 +0,0 @@
--- Whether a job is currently in the given state. Params: $1 queue, $2 id,
--- $3 state.
-SELECT EXISTS(
-  SELECT 1 FROM job
-   WHERE queue = $1 AND id = $2 AND state = $3::job_state
-) AS present;

package/dist/esm/postgres/commands/is_job_in_wait.sql

@@ -1,15 +0,0 @@
--- Whether a (non-prioritized) waiting job is in the wait or paused list. The
--- queue has no separate paused list: a waiting job belongs to the paused list
--- when the queue is paused, and to the wait list otherwise. $3 selects which
--- list to test (true = paused, false = wait). Params: $1 queue, $2 id, $3 paused.
-SELECT EXISTS(
-  SELECT 1 FROM job j
-   WHERE j.queue = $1 AND j.id = $2
-     AND j.state = 'waiting' AND j.priority = 0
-     AND (
-       EXISTS(
-         SELECT 1 FROM meta m
-          WHERE m.queue = $1 AND m.field = 'paused' AND m.value = '1'
-       )
-     ) = $3
-) AS present;

package/dist/esm/postgres/commands/is_job_prioritized.sql

@@ -1,6 +0,0 @@
--- Whether a job is prioritized (waiting with a non-zero priority).
--- Params: $1 queue, $2 id.
-SELECT EXISTS(
-  SELECT 1 FROM job
-   WHERE queue = $1 AND id = $2 AND state = 'waiting' AND priority > 0
-) AS present;

package/dist/esm/postgres/commands/is_job_scheduler.sql

@@ -1,4 +0,0 @@
--- Whether an id corresponds to a registered scheduler. Params: $1 queue, $2 id.
-SELECT EXISTS (
-  SELECT 1 FROM scheduler WHERE queue = $1 AND scheduler_id = $2
-) AS exists;

package/dist/esm/postgres/commands/is_maxed.sql

@@ -1,10 +0,0 @@
--- Whether the queue is "maxed": it has a global concurrency limit and the
--- number of active jobs has reached it (mirrors isQueueMaxed). Returns false
--- when no concurrency limit is configured.
--- Params: $1 queue.
-SELECT COALESCE(
-  (SELECT count(*) FROM job WHERE queue = $1 AND state = 'active')
-    >= (SELECT value::integer FROM meta
-         WHERE queue = $1 AND field = 'concurrency'),
-  false
-) AS maxed;

package/dist/esm/postgres/commands/listen_events.sql

@@ -1,3 +0,0 @@
--- Subscribe to the shared event-stream channel. Producers
--- `pg_notify('bullmq_events', <queue>)`; a consumer filters for its own queue.
-LISTEN bullmq_events;

package/dist/esm/postgres/commands/listen_jobs.sql

@@ -1,4 +0,0 @@
--- Subscribe to the shared job-notification channel (fixed name keeps this
--- portable). Producers `pg_notify('bullmq_jobs', <queue>)`; a worker filters
--- notifications for its own queue.
-LISTEN bullmq_jobs;

package/dist/esm/postgres/commands/move_active_to_wait.sql

@@ -1,4 +0,0 @@
--- Move an active job back to wait (Job.moveToWait / dynamic rate limit).
--- Params: $1 queue, $2 id, $3 token ('0' bypasses the lock check), $4 now_ms.
--- Returns the limiter window ms (>=0), or -1 when the job no longer exists.
-SELECT move_active_to_wait($1, $2, $3, $4) AS n;

package/dist/esm/postgres/commands/move_stalled_jobs_to_wait.sql

@@ -1,4 +0,0 @@
--- Two-phase stalled-job recovery (mark on one pass, reclaim on the next);
--- returns the reclaimed ids. Params: $1 queue, $2 max_stalled_count,
--- $3 now_ms, $4 max_check_time_ms (stalledInterval).
-SELECT id FROM move_stalled_jobs_to_wait($1, $2, $3, $4) AS t(id);

package/dist/esm/postgres/commands/move_to_active.sql

@@ -1,4 +0,0 @@
--- Claim the next ready job for a worker (0 or 1 rows), honouring the limiter.
--- Params: $1 queue, $2 token, $3 lock_ms, $4 now_ms, $5 worker name,
--- $6 limiter max (worker option, NULL if none), $7 limiter duration ms.
-SELECT * FROM move_to_active($1, $2, $3, $4, $5, $6, $7);

package/dist/esm/postgres/commands/move_to_completed.sql

@@ -1,4 +0,0 @@
--- Finish an active job successfully; returns the finished-at timestamp.
--- Params: $1 queue, $2 id, $3 token, $4 return_value (jsonb), $5 finished_on,
---         $6 remove_all, $7 keep_age (s), $8 keep_count.
-SELECT move_to_completed($1, $2, $3, $4::jsonb, $5, $6, $7, $8) AS finished_on;

package/dist/esm/postgres/commands/move_to_completed_fetch.sql

@@ -1,9 +0,0 @@
--- Finish an active job successfully AND claim the next ready job in one
--- transaction (one commit) — the fused equivalent of move_to_completed followed
--- by move_to_active, mirroring Redis's moveToFinished. Returns 0 or 1 job rows.
--- Params: $1 queue, $2 id, $3 token, $4 return_value (jsonb), $5 finished_on,
---         $6 remove_all, $7 keep_age (s), $8 keep_count,
---         $9 lock_ms, $10 now_ms, $11 worker name,
---         $12 limiter max (worker option, NULL if none), $13 limiter duration ms.
-SELECT * FROM move_to_completed_fetch(
-  $1, $2, $3, $4::jsonb, $5, $6, $7, $8, $9, $10, $11, $12, $13);

package/dist/esm/postgres/commands/move_to_delayed.sql

@@ -1,4 +0,0 @@
--- Re-queue an active job to the delayed state (retry-with-delay / manual delay).
--- Params: $1 queue, $2 id, $3 token, $4 process_at, $5 delay,
---         $6 skip_attempt, $7 failed_reason, $8 stacktrace (jsonb).
-SELECT move_to_delayed($1, $2, $3, $4, $5, $6, $7, $8::jsonb) AS n;

package/dist/esm/postgres/commands/move_to_failed.sql

@@ -1,4 +0,0 @@
--- Mark an active job failed; returns the finished-at timestamp.
--- Params: $1 queue, $2 id, $3 token, $4 failed_reason, $5 stacktrace (jsonb),
---         $6 finished_on, $7 remove_all, $8 keep_age (s), $9 keep_count.
-SELECT move_to_failed($1, $2, $3, $4, $5::jsonb, $6, $7, $8, $9) AS finished_on;

package/dist/esm/postgres/commands/move_to_failed_fetch.sql

@@ -1,9 +0,0 @@
--- Fail (or retry) an active job AND claim the next ready job in one transaction
--- (one commit) — the fused equivalent of move_to_failed followed by
--- move_to_active, mirroring Redis's moveToFinished. Returns 0 or 1 job rows.
--- Params: $1 queue, $2 id, $3 token, $4 failed_reason, $5 stacktrace (jsonb),
---         $6 finished_on, $7 remove_all, $8 keep_age (s), $9 keep_count,
---         $10 lock_ms, $11 now_ms, $12 worker name,
---         $13 limiter max (worker option, NULL if none), $14 limiter duration ms.
-SELECT * FROM move_to_failed_fetch(
-  $1, $2, $3, $4, $5::jsonb, $6, $7, $8, $9, $10, $11, $12, $13, $14);

package/dist/esm/postgres/commands/move_to_waiting_children.sql

@@ -1,3 +0,0 @@
--- Move an active parent to waiting-children if it has pending children.
--- Params: $1 queue, $2 id, $3 token. Returns 1 (should wait), 0 (proceed).
-SELECT move_to_waiting_children($1, $2, $3) AS code;

package/dist/esm/postgres/commands/next_delay.sql

@@ -1,2 +0,0 @@
--- The timestamp of the next delayed job, or NULL if there are none.
-SELECT next_delay($1) AS next_delay;

package/dist/esm/postgres/commands/next_signal.sql

@@ -1,3 +0,0 @@
--- The worker "no job" signal: effective rate-limit ttl + next delayed-job time.
--- Params: $1 queue, $2 limiter max (worker option, NULL if none), $3 now_ms.
-SELECT rate_limit_ttl, next_delay FROM next_signal($1, $2, $3);

package/dist/esm/postgres/commands/obliterate.sql

@@ -1,4 +0,0 @@
--- Obliterate a queue: delete up to $2 jobs; returns -1 (not paused), -2 (active
--- jobs without force), 1 (more to delete), or 0 (done). Params: $1 queue,
--- $2 count, $3 force.
-SELECT obliterate($1, $2, $3) AS cursor;