@ultimat3/jobs 22.14.0 → 23.0.0

package/src/driver-nats.ts

@@ -70,10 +70,10 @@ export function createNatsDriver(_options: NatsDriverOptions = {}): JobDriver {
     claim(_options: ClaimOptions): Promise<readonly ClaimedJob[]> {
       return unavailable('claim');
     },
-    ack(_jobId: string): Promise<void> {
+    ack(_jobId: string): Promise<boolean> {
       return unavailable('ack');
     },
-    nack(_jobId: string, _options: NackOptions): Promise<void> {
+    nack(_jobId: string, _options: NackOptions): Promise<boolean> {
       return unavailable('nack');
     },
     heartbeat(_jobId: string, _options: HeartbeatOptions): Promise<boolean> {

package/src/driver-pg-ddl.ts

@@ -132,6 +132,12 @@ alter table x_outbox add column if not exists claimed_at timestamptz;
 
 alter table x_outbox add column if not exists claimed_by text;
 
+-- The run the published job carries, allocated when the row is STAGED so the enqueue that staged
+-- it can answer which run it started. The row id is the published job id for the same reason.
+-- Added by alter because x_outbox shipped without it. A row staged before this column existed is
+-- given a run id by the default, which is what the driver would have minted at its publish.
+alter table x_outbox add column if not exists run_id uuid not null default gen_random_uuid();
+
 -- The scheduler watermark. Without a durable one a redeployed scheduler has no idea what the
 -- pod it replaced already fired, so runRound takes the arming branch and every occurrence
 -- between the two processes is dropped with nothing logged.
@@ -141,6 +147,13 @@ create table if not exists x_scheduler_state (
   updated_at    timestamptz not null default now()
 );
 
+-- The last occurrence that DISPATCHED, and when. Apart from the watermark, which arming a task or
+-- skipping missed occurrences also moves: an operator asking when a task last ran is asking about
+-- jobs that were queued. Added by alter because x_scheduler_state shipped without them.
+alter table x_scheduler_state add column if not exists fired_occurrence_at timestamptz;
+
+alter table x_scheduler_state add column if not exists fired_at timestamptz;
+
 -- Leader election as an EXPIRING LEASE rather than a session advisory lock: the executor this
 -- package is handed is a pool, and a session-level pg_try_advisory_lock is released the moment
 -- that connection goes back to it. A row with an expiry needs no connection affinity at all.
@@ -176,4 +189,62 @@ create table if not exists x_job_events (
 
 create index if not exists x_job_events_lookup_idx
   on x_job_events (name, published_at);
+
+-- What the body last reported through progress, as one value: done, total, note and the instant.
+-- A column and not a table, because it is read with the row and dies with it. Added by alter
+-- because x_jobs shipped without it.
+alter table x_jobs add column if not exists progress jsonb;
+
+-- The stack of the thrown value last_error describes, bounded by the driver before it is bound.
+alter table x_jobs add column if not exists last_error_stack text;
+
+-- How many times the row has been claimed, moved by the claim itself and never reset. A settle is
+-- fenced on it as well as on claimed_by: a worker that takes back its own lapsed job has the same
+-- id as the body still unwinding from the first claim, and only the ordinal tells the two apart.
+alter table x_jobs add column if not exists claims int not null default 0;
+
+-- The keyset a paged listing seeks by. Newest first, id as the tiebreak, so a page is an index
+-- range and never a sort of the whole table.
+create index if not exists x_jobs_created_idx on x_jobs (created_at desc, id desc);
+
+-- A paused queue or task, one row each. A queue pause is a fact about the QUEUE and not a column
+-- on every one of its rows: the claim reads this table with not exists, and a pause that had to
+-- rewrite a million rows would not take effect within one poll interval.
+create table if not exists x_job_pauses (
+  kind      text        not null,
+  name      text        not null,
+  paused_at timestamptz not null default now(),
+  primary key (kind, name)
+);
+
+-- The worker registry. One row per live worker, rewritten on its heartbeat and expired by time
+-- like a lease: a killed worker announces nothing and its row stops being read. Never cleaned up
+-- by anything that has to be running.
+create table if not exists x_job_workers (
+  id           text primary key,
+  host         text        not null,
+  queues       jsonb       not null,
+  concurrency  int         not null,
+  in_flight    jsonb       not null,
+  started_at   timestamptz not null,
+  heartbeat_at timestamptz not null default now(),
+  expires_at   timestamptz not null
+);
+
+-- Per-job history, in buckets. A settle adds to the one-minute bucket in the SAME statement that
+-- moves the row, and the scheduler leader folds old buckets into wider ones, so the key count per
+-- job name is fixed whatever the throughput.
+create table if not exists x_job_counters (
+  job          text        not null,
+  bucket_ms    int         not null,
+  bucket_start timestamptz not null,
+  done         bigint      not null default 0,
+  retried      bigint      not null default 0,
+  failed       bigint      not null default 0,
+  dead         bigint      not null default 0,
+  duration_ms  bigint      not null default 0,
+  primary key (job, bucket_ms, bucket_start)
+);
+
+create index if not exists x_job_counters_age_idx on x_job_counters (bucket_ms, bucket_start);
 `.trim();

package/src/driver-pg-jobs-sql.ts

@@ -3,34 +3,95 @@
 // none decodes `timestamptz` as TEXT, so `toJobRecord` read `Number('2026-01-01 00:00:00+00')`
 // and `x jobs ls` / `show` / `cancel` printed `NaN` for every timestamp.
 
+import { JOBS_WAKE_CHANNEL } from './driver-pg-wake-sql';
+
 /**
  * The `JobRow` shape as a projection. Asking Postgres for epoch ms is what makes the decoding
  * independent of the client's type map — never `select *`, whose correctness is the driver's
  * opinion about `timestamptz` rather than this statement's.
  */
 export const JOB_ROW_COLUMNS = `id, name, queue, input, idempotency_key, run_id, attempt,
-       max_attempts, state, tenant_id, last_error, claimed_by,
-       traceparent, enqueued_by,
+       max_attempts, state, tenant_id, last_error, last_error_stack, claimed_by, claims,
+       traceparent, enqueued_by, progress,
        (extract(epoch from run_at)     * 1000)::bigint as run_at,
        (extract(epoch from visible_at) * 1000)::bigint as visible_at,
        (extract(epoch from created_at) * 1000)::bigint as created_at,
        (extract(epoch from updated_at) * 1000)::bigint as updated_at`;
 
+/** `JOB_ROW_COLUMNS` by their output names — what a statement reading a derived table selects. */
+const JOB_ROW_NAMES = `id, name, queue, input, idempotency_key, run_id, attempt, max_attempts,
+       state, tenant_id, last_error, last_error_stack, claimed_by, claims, traceparent,
+       enqueued_by, progress, run_at, visible_at, created_at, updated_at`;
+
 export const SQL_JOB_GET = `
 select ${JOB_ROW_COLUMNS}
   from x_jobs where id = $1
 `.trim();
 
+/**
+ * The predicates a page shares, whichever way it reads. $1 queue, $2 name, $3 state, $5 id prefix,
+ * $6 created from (ms), $7 created to (ms), $10 tenant. The prefix is compared, never `like`d: a
+ * `_` or `%` in it is a character, as `startsWith` reads it in the memory driver.
+ */
+const LIST_MATCH = `($1::text is null or queue = $1)
+   and ($2::text is null or name  = $2)
+   and ($3::text is null or state = $3)
+   and ($5::text is null or left(id::text, length($5::text)) = $5::text)
+   and ($6::bigint is null or created_at >= to_timestamp($6::bigint / 1000.0))
+   and ($7::bigint is null or created_at <  to_timestamp($7::bigint / 1000.0))
+   and ($10::text is null or tenant_id = $10)`;
+
+/**
+ * One page, newest first, sought by KEYSET. `(created_at, id) < (cursor)` is a row comparison the
+ * `x_jobs_created_idx` range answers directly; an offset would re-read every row before it and
+ * shift under an insert.
+ *
+ * The cursor carries the last row's `createdAt` in epoch MS, and the column holds microseconds —
+ * so the seek reads the cursor row's own `created_at` by id rather than trusting a rounded value,
+ * which would skip or repeat its millisecond-mates. A cursor row deleted mid-walk falls back to
+ * the millisecond after it: rows of that one millisecond may then repeat, and none is skipped.
+ *
+ * `LIST_MATCH`'s parameters, plus $4 limit, $8 cursor createdAt (ms), $9 cursor id.
+ */
 export const SQL_JOB_LIST = `
 select ${JOB_ROW_COLUMNS}
   from x_jobs
- where ($1::text is null or queue = $1)
-   and ($2::text is null or name  = $2)
-   and ($3::text is null or state = $3)
- order by created_at desc
+ where ${LIST_MATCH}
+   and ($9::uuid is null or (created_at, id) < (
+         coalesce(
+           (select c.created_at from x_jobs c where c.id = $9::uuid),
+           to_timestamp(($8::bigint + 1) / 1000.0)
+         ),
+         $9::uuid
+       ))
+ order by created_at desc, id desc
  limit $4
 `.trim();
 
+/**
+ * The page BEFORE a cursor: the `limit` rows nearest it on the newer side — read oldest first so
+ * `limit` keeps the nearest, then turned newest first like every page. The same parameters as
+ * `SQL_JOB_LIST`, $8/$9 being the first row of the page the reader is leaving. A cursor row
+ * deleted meanwhile falls back to its millisecond: a row of it may repeat, none is skipped.
+ */
+export const SQL_JOB_LIST_BEFORE = `
+select ${JOB_ROW_NAMES} from (
+  select ${JOB_ROW_COLUMNS}
+    from x_jobs
+   where ${LIST_MATCH}
+     and (created_at, id) > (
+           coalesce(
+             (select c.created_at from x_jobs c where c.id = $9::uuid),
+             to_timestamp($8::bigint / 1000.0)
+           ),
+           $9::uuid
+         )
+   order by created_at asc, id asc
+   limit $4
+) page
+ order by created_at desc, id desc
+`.trim();
+
 export const SQL_JOB_DEAD_LETTERS = `
 select ${JOB_ROW_COLUMNS}
   from x_jobs where state = 'dead' order by updated_at desc limit $1
@@ -41,14 +102,16 @@ select ${JOB_ROW_COLUMNS}
  * to FINISHED states and releasing the claim: requeueing a running row left `claimed_by` set with
  * state `ready`, and a second worker claimed it — the job ran twice. `REQUEUEABLE_STATES`
  * (`driver.ts`) is the same set; a row this matches nothing for was refused before it was sent,
- * or raced to live in between.
+ * or raced to live in between. `woke` announces the row in the statement that made it claimable
+ * (`driver-pg-wake-sql.ts`): `x jobs retry` is a job starting now, not at an idle worker's poll.
  */
 export const SQL_JOB_REQUEUE = `
 update x_jobs
    set state = 'ready', attempt = 0, run_at = now(), updated_at = now(),
        claimed_by = null, visible_at = null
  where id = $1 and state in ('dead', 'cancelled', 'done', 'failed')
-returning ${JOB_ROW_COLUMNS}
+returning ${JOB_ROW_COLUMNS},
+          pg_notify('${JOBS_WAKE_CHANNEL}', queue)::text as woke
 `.trim();
 
 /**

package/src/driver-pg-operator-sql.ts

@@ -0,0 +1,303 @@
+// Every statement behind the operator surface (`introspection.ts`) and the scheduler's atomic
+// fire. One decision per statement throughout: a bulk call, a fold and a fire each read and write
+// in ONE round trip, so nothing here counts rows and then acts on the count.
+//
+// Text is ordered `collate "C"` wherever a list is ordered by name: the memory driver compares by
+// code unit, and a database collation would order the same names differently.
+
+import { JOB_ROW_COLUMNS } from './driver-pg-jobs-sql';
+import { JOBS_WAKE_CHANNEL } from './driver-pg-wake-sql';
+
+const LIVE = `('ready', 'delayed', 'running', 'suspended')`;
+
+/** $1 state, $2 queue, $3 name, $5 tenant — the predicates every bulk statement shares. */
+const bulkMatch = (alias = ''): string =>
+  `${alias}state = $1 and ($2::text is null or ${alias}queue = $2) and ($3::text is null or ${alias}name = $3) and ($5::text is null or ${alias}tenant_id = $5)`;
+
+/**
+ * Re-queue up to $4 finished rows. `distinct on` the idempotency namespace, because two dead rows
+ * of one key would both go `ready` and the second would break the live index — and `not exists`
+ * a live holder, the single requeue's `X_JOB_DUPLICATE`, answered here as "not this row".
+ * `matching` is counted in the same statement, before the update, so the caller's `remaining` is
+ * `matching - affected` with no second read.
+ */
+export const SQL_JOB_REQUEUE_MANY = `
+with candidates as (
+  select distinct on (j.name, coalesce(j.tenant_id, ''), j.idempotency_key) j.id
+    from x_jobs j
+   where ${bulkMatch('j.')}
+     and not exists (
+       select 1 from x_jobs l
+        where l.name = j.name
+          and coalesce(l.tenant_id, '') = coalesce(j.tenant_id, '')
+          and l.idempotency_key = j.idempotency_key
+          and l.state in ${LIVE}
+     )
+   order by j.name, coalesce(j.tenant_id, ''), j.idempotency_key, j.created_at
+   limit $4
+), moved as (
+  update x_jobs
+     set state = 'ready', attempt = 0, run_at = now(), updated_at = now(),
+         claimed_by = null, visible_at = null
+   where id in (select id from candidates) and state = $1
+  returning id
+)
+select (select count(*) from moved)::int as affected,
+       (select count(*) from x_jobs where ${bulkMatch()})::int as matching
+`.trim();
+
+/** Delete up to $4 rows and their step records. `running` is refused before this is sent. */
+export const SQL_JOB_REMOVE_MANY = `
+with doomed as (
+  select id, run_id from x_jobs
+   where ${bulkMatch()} and state <> 'running'
+   order by created_at
+   limit $4
+     for update skip locked
+), steps as (
+  delete from x_job_steps where run_id in (select run_id from doomed)
+), gone as (
+  delete from x_jobs where id in (select id from doomed) returning id
+)
+select (select count(*) from gone)::int as affected,
+       (select count(*) from x_jobs where ${bulkMatch()})::int as matching
+`.trim();
+
+/**
+ * Up to $4 rows of the filter still waiting on `run_at`, due now — `SQL_JOB_PROMOTE` over a set.
+ * `remaining` counts the rows of the filter STILL waiting afterwards: a `ready` row already due has
+ * nothing to promote, so it is neither affected nor remaining. `woke` announces the queues it made
+ * claimable, once each (`driver-pg-wake-sql.ts`).
+ */
+export const SQL_JOB_PROMOTE_MANY = `
+with due as (
+  select id from x_jobs
+   where ${bulkMatch()} and run_at > now()
+   order by created_at
+   limit $4
+     for update skip locked
+), moved as (
+  update x_jobs
+     set state = 'ready', run_at = now(), updated_at = now()
+   where id in (select id from due) and run_at > now()
+  returning id, queue
+), woke as (
+  select pg_notify('${JOBS_WAKE_CHANNEL}', queue) from (select distinct queue from moved) q
+)
+select (select count(*) from moved)::int as affected,
+       (select count(*) from woke)::int as woken,
+       (select count(*) from x_jobs where ${bulkMatch()} and run_at > now()
+          and id not in (select id from moved))::int as matching
+`.trim();
+
+/** One row and its steps. Fenced on not-running, so a claim that raced the delete wins. */
+export const SQL_JOB_REMOVE = `
+with gone as (
+  delete from x_jobs where id = $1 and state <> 'running' returning run_id
+), steps as (
+  delete from x_job_steps where run_id in (select run_id from gone)
+)
+select run_id from gone
+`.trim();
+
+/**
+ * Due now. Only a row waiting on its `run_at` — delayed at enqueue, or `ready` and backing off —
+ * and never a `suspended` one, whose wake time is its step record and not this column. `woke`
+ * announces the row in the statement that made it due (`driver-pg-wake-sql.ts`).
+ */
+export const SQL_JOB_PROMOTE = `
+update x_jobs
+   set state = 'ready', run_at = now(), updated_at = now()
+ where id = $1 and state in ('ready', 'delayed') and run_at > now()
+returning ${JOB_ROW_COLUMNS},
+          pg_notify('${JOBS_WAKE_CHANNEL}', queue)::text as woke
+`.trim();
+
+/** Fenced on the claim, as both settles are. $1 id, $2 worker, $3 the progress value, $4 claim. */
+export const SQL_JOB_PROGRESS = `
+update x_jobs set progress = $3::jsonb
+ where id = $1 and state = 'running' and claimed_by = $2 and claims = $4::int
+`.trim();
+
+/** The FIRST pause is the one recorded: pausing a paused queue does not move `paused_at`. */
+export const SQL_PAUSE = `
+insert into x_job_pauses (kind, name) values ($1, $2)
+on conflict (kind, name) do nothing
+`.trim();
+
+export const SQL_RESUME = `
+delete from x_job_pauses where kind = $1 and name = $2
+`.trim();
+
+export const SQL_PAUSED = `
+select name, (extract(epoch from paused_at) * 1000)::bigint as paused_at
+  from x_job_pauses where kind = $1 order by name collate "C"
+`.trim();
+
+/**
+ * A worker's heartbeat: the whole row rewritten, expiry pushed out. $1 id, $2 host, $3 queues,
+ * $4 slots, $5 in-flight ids, $6 started (ms), $7 ttl (ms).
+ */
+export const SQL_WORKER_ANNOUNCE = `
+insert into x_job_workers
+  (id, host, queues, concurrency, in_flight, started_at, heartbeat_at, expires_at)
+values
+  ($1, $2, $3::jsonb, $4::int, $5::jsonb, to_timestamp($6::bigint / 1000.0), now(),
+   now() + ($7::bigint * interval '1 millisecond'))
+on conflict (id) do update
+   set host = excluded.host, queues = excluded.queues, concurrency = excluded.concurrency,
+       in_flight = excluded.in_flight, heartbeat_at = excluded.heartbeat_at,
+       expires_at = excluded.expires_at
+`.trim();
+
+export const SQL_WORKER_FORGET = `
+delete from x_job_workers where id = $1
+`.trim();
+
+/**
+ * Live rows only, and the lapsed ones go in the same statement: a killed worker is never read
+ * again, and nothing else has to be running for its row to leave.
+ */
+export const SQL_WORKERS = `
+with lapsed as (
+  delete from x_job_workers where expires_at <= now()
+)
+select id, host, queues, concurrency, in_flight,
+       (extract(epoch from started_at)   * 1000)::bigint as started_at,
+       (extract(epoch from heartbeat_at) * 1000)::bigint as heartbeat_at
+  from x_job_workers
+ where expires_at > now()
+ order by started_at, id
+`.trim();
+
+const COUNTER_COLUMNS = `done, retried, failed, dead, duration_ms`;
+
+export const SQL_COUNTERS = `
+select job, bucket_ms, (extract(epoch from bucket_start) * 1000)::bigint as bucket_start,
+       ${COUNTER_COLUMNS}
+  from x_job_counters
+ where job = $1 and bucket_start >= to_timestamp($2::bigint / 1000.0)
+ order by bucket_start, bucket_ms
+`.trim();
+
+export const SQL_COUNTER_TOTALS = `
+select job, sum(done)::bigint as done, sum(retried)::bigint as retried,
+       sum(failed)::bigint as failed, sum(dead)::bigint as dead,
+       sum(duration_ms)::bigint as duration_ms
+  from x_job_counters
+ where bucket_start >= to_timestamp($1::bigint / 1000.0)
+ group by job
+ order by job collate "C"
+`.trim();
+
+/**
+ * Fold every bucket of width $1 older than $2 ms into the bucket of width $3 that contains it.
+ * Delete-and-insert in one statement, so a fold that two nodes run at once moves each bucket
+ * once: the second node's `delete` finds the rows gone.
+ */
+export const SQL_COUNTER_FOLD = `
+with old as (
+  delete from x_job_counters
+   where bucket_ms = $1::int and bucket_start < now() - ($2::bigint * interval '1 millisecond')
+  returning job, bucket_start, ${COUNTER_COLUMNS}
+), folded as (
+  insert into x_job_counters (job, bucket_ms, bucket_start, ${COUNTER_COLUMNS})
+  select job, $3::int,
+         to_timestamp(floor(extract(epoch from bucket_start) * 1000 / $3::int) * $3::int / 1000.0),
+         sum(done), sum(retried), sum(failed), sum(dead), sum(duration_ms)
+    from old
+   group by 1, 3
+  on conflict (job, bucket_ms, bucket_start) do update
+     set done        = x_job_counters.done + excluded.done,
+         retried     = x_job_counters.retried + excluded.retried,
+         failed      = x_job_counters.failed + excluded.failed,
+         dead        = x_job_counters.dead + excluded.dead,
+         duration_ms = x_job_counters.duration_ms + excluded.duration_ms
+)
+select count(*)::int as moved from old
+`.trim();
+
+/** The last tier has nowhere to fold into: past its `keepMs` a bucket is dropped. */
+export const SQL_COUNTER_DROP = `
+with old as (
+  delete from x_job_counters
+   where bucket_ms = $1::int and bucket_start < now() - ($2::bigint * interval '1 millisecond')
+  returning job
+)
+select count(*)::int as moved from old
+`.trim();
+
+/**
+ * The record of a fire that went through `driver.enqueue` — a store that could not write it in
+ * the firing statement. The watermark only ever moves forward here too. $1 task, $2 occurrence.
+ */
+export const SQL_TASK_FIRE_RECORD = `
+insert into x_scheduler_state
+  (task_name, last_fired_at, updated_at, fired_occurrence_at, fired_at)
+values ($1, to_timestamp($2::bigint / 1000.0), now(), to_timestamp($2::bigint / 1000.0), now())
+on conflict (task_name) do update
+   set last_fired_at = greatest(x_scheduler_state.last_fired_at, excluded.last_fired_at),
+       updated_at = now(),
+       fired_occurrence_at = excluded.fired_occurrence_at, fired_at = excluded.fired_at
+`.trim();
+
+/** Every task that has dispatched. A row that was only ever armed has no `fired_at`. $1 limit. */
+export const SQL_TASK_FIRES = `
+select task_name,
+       (extract(epoch from fired_occurrence_at) * 1000)::bigint as occurrence,
+       (extract(epoch from fired_at) * 1000)::bigint as fired_at
+  from x_scheduler_state
+ where fired_at is not null
+ order by task_name collate "C"
+ limit $1
+`.trim();
+
+/**
+ * One occurrence, fired ATOMICALLY: the watermark moves onto it and its jobs are queued in one
+ * statement, or neither happens.
+ *
+ * It was two round trips — enqueue each job, then mark — and anything between them (a rejected
+ * mark, a dead process, job 2 of 3 failing) left the watermark behind the jobs already queued. The
+ * next round fired the occurrence again, and the occurrence-scoped idempotency key only absorbs
+ * that while the first job is still LIVE: the unique index is partial, so once job 1 is `done` the
+ * repeat inserts a second row and the work runs twice.
+ *
+ * The watermark is the fence. `moved` is empty when it is already at or past this occurrence —
+ * another dispatcher fired it — and `queued` inserts only `where exists (select 1 from moved)`.
+ * `woken` announces each queue that received a job, once, when the statement commits — read in
+ * the final select because a plain-select CTE nothing reads is never run.
+ *
+ * $1 task, $2 occurrence (ms), $3 the jobs as a JSON array.
+ */
+export const SQL_SCHEDULER_FIRE = `
+with moved as (
+  insert into x_scheduler_state
+    (task_name, last_fired_at, updated_at, fired_occurrence_at, fired_at)
+  values ($1, to_timestamp($2::bigint / 1000.0), now(), to_timestamp($2::bigint / 1000.0), now())
+  on conflict (task_name) do update
+     set last_fired_at = excluded.last_fired_at, updated_at = now(),
+         fired_occurrence_at = excluded.fired_occurrence_at, fired_at = excluded.fired_at
+   where x_scheduler_state.last_fired_at < excluded.last_fired_at
+  returning task_name
+), queued as (
+  insert into x_jobs
+    (id, name, queue, input, idempotency_key, run_id, max_attempts, state, run_at)
+  select j.id, j.name, j.queue, coalesce(j.input, 'null'::jsonb), j.idempotency_key, j.run_id, j.max_attempts,
+         case when to_timestamp($2::bigint / 1000.0) > now() then 'delayed' else 'ready' end,
+         to_timestamp($2::bigint / 1000.0)
+    from jsonb_to_recordset($3::jsonb) as j(
+           id uuid, name text, queue text, input jsonb, idempotency_key text,
+           run_id uuid, max_attempts int)
+   where exists (select 1 from moved)
+  on conflict (name, (coalesce(tenant_id, '')), idempotency_key)
+    where state in ${LIVE}
+    do nothing
+  returning id, run_id, idempotency_key, queue
+), woken as (
+  select pg_notify('${JOBS_WAKE_CHANNEL}', w.queue) from (select distinct queue from queued) w
+)
+select (select count(*) from moved)::int as fired, q.id, q.run_id, q.idempotency_key,
+       (select count(*) from woken)::int as woken
+  from (select 1) as one
+  left join queued q on true
+`.trim();