@ultimat3/jobs 1.0.0

package/src/driver-memory.ts

@@ -0,0 +1,216 @@
+// In-process driver for `x dev` and tests: same semantics as pg (visibility timeout,
+// idempotency dedupe, dead-letter) with zero infrastructure, so a test suite exercises the
+// real claim/ack/nack paths rather than a mock that always succeeds.
+
+import type { Clock } from '@ultimat3/core';
+import { assert, systemClock, uuid } from '@ultimat3/core';
+import { nowMs } from './clock';
+import type {
+  ClaimedJob,
+  ClaimOptions,
+  EnqueueRequest,
+  EnqueueResult,
+  JobDriver,
+  JobFilter,
+  JobIntrospection,
+  JobRecord,
+  NackOptions,
+  QueueStats,
+} from './driver';
+import { DEFAULT_QUEUE } from './driver';
+import { JobDuplicateError } from './errors';
+import type { StepStore } from './steps';
+import { createMemoryStepStore } from './steps';
+
+export interface MemoryDriverOptions {
+  readonly clock?: Clock;
+  readonly steps?: StepStore;
+}
+
+const LIVE_STATES = new Set(['ready', 'delayed', 'running', 'suspended']);
+
+export function createMemoryDriver(options: MemoryDriverOptions = {}): JobDriver {
+  const clock = options.clock ?? systemClock;
+  const steps = options.steps ?? createMemoryStepStore();
+  const jobs = new Map<string, JobRecord>();
+
+  const liveByKey = (key: string): JobRecord | undefined => {
+    for (const record of jobs.values()) {
+      if (record.idempotencyKey === key && LIVE_STATES.has(record.state)) return record;
+    }
+    return undefined;
+  };
+
+  const update = (id: string, patch: Partial<JobRecord>): void => {
+    const existing = jobs.get(id);
+    if (existing === undefined) return;
+    jobs.set(id, { ...existing, ...patch, updatedAt: nowMs(clock) });
+  };
+
+  const introspect: JobIntrospection = {
+    job(jobId) {
+      return Promise.resolve(jobs.get(jobId));
+    },
+    list(filter: JobFilter = {}) {
+      const rows = [...jobs.values()]
+        .filter((record) => filter.queue === undefined || record.queue === filter.queue)
+        .filter((record) => filter.name === undefined || record.name === filter.name)
+        .filter((record) => filter.state === undefined || record.state === filter.state)
+        .sort((a, b) => a.createdAt - b.createdAt)
+        .slice(0, filter.limit ?? 100);
+      return Promise.resolve(rows);
+    },
+    deadLetters(limit = 100) {
+      const rows = [...jobs.values()]
+        .filter((record) => record.state === 'dead')
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, limit);
+      return Promise.resolve(rows);
+    },
+    async requeue(jobId, requeueOptions) {
+      const existing = jobs.get(jobId);
+      assert(
+        existing !== undefined,
+        `no job ${jobId} in the memory driver`,
+        'requeue a job id returned by enqueue() or stats() — the memory driver holds no state across processes, so an id from another run will not resolve',
+      );
+      const record = existing;
+      if (requeueOptions?.fromStep !== undefined) {
+        // Drop the target step so it re-executes; earlier steps stay memoized.
+        await steps.del(record.runId, requeueOptions.fromStep);
+      }
+      update(jobId, { state: 'ready', attempt: 0, runAt: nowMs(clock) });
+      const next = jobs.get(jobId);
+      return next ?? record;
+    },
+  };
+
+  return {
+    name: 'memory',
+    steps,
+    introspect,
+
+    enqueue(request: EnqueueRequest): Promise<EnqueueResult> {
+      const existing = liveByKey(request.idempotencyKey);
+      if (existing !== undefined) {
+        if (request.onConflict === 'error') {
+          throw new JobDuplicateError({
+            job: request.name,
+            idempotencyKey: request.idempotencyKey,
+            existingId: existing.id,
+          });
+        }
+        return Promise.resolve({ id: existing.id, runId: existing.runId, deduped: true });
+      }
+
+      const at = nowMs(clock);
+      const runAt = request.runAt ?? at;
+      const record: JobRecord = {
+        id: uuid(),
+        name: request.name,
+        queue: request.queue || DEFAULT_QUEUE,
+        input: request.input,
+        idempotencyKey: request.idempotencyKey,
+        runId: request.runId ?? uuid(),
+        attempt: 0,
+        maxAttempts: request.maxAttempts,
+        state: runAt > at ? 'delayed' : 'ready',
+        runAt,
+        createdAt: at,
+        updatedAt: at,
+        ...(request.tenantId === undefined ? {} : { tenantId: request.tenantId }),
+      };
+      jobs.set(record.id, record);
+      return Promise.resolve({ id: record.id, runId: record.runId, deduped: false });
+    },
+
+    claim(claimOptions: ClaimOptions): Promise<readonly ClaimedJob[]> {
+      const at = nowMs(clock);
+      const wanted = new Set(claimOptions.queues);
+      const claimable = [...jobs.values()]
+        .filter((record) => wanted.size === 0 || wanted.has(record.queue))
+        .filter((record) => {
+          if (record.runAt > at) return false;
+          if (record.state === 'ready' || record.state === 'delayed') return true;
+          if (record.state === 'suspended') return true;
+          // Lease expiry: a worker that died without ack releases its job here.
+          return record.state === 'running' && (record.visibleAt ?? 0) <= at;
+        })
+        .sort((a, b) => a.runAt - b.runAt)
+        .slice(0, claimOptions.limit);
+
+      const out: ClaimedJob[] = [];
+      for (const record of claimable) {
+        const claimed: ClaimedJob = {
+          ...record,
+          state: 'running',
+          attempt: record.attempt + 1,
+          claimedBy: claimOptions.workerId,
+          claimedAt: at,
+          visibleAt: at + claimOptions.visibilityTimeoutMs,
+          updatedAt: at,
+        };
+        jobs.set(record.id, claimed);
+        out.push(claimed);
+      }
+      return Promise.resolve(out);
+    },
+
+    ack(jobId: string): Promise<void> {
+      update(jobId, { state: 'done' });
+      return Promise.resolve();
+    },
+
+    nack(jobId: string, nackOptions: NackOptions): Promise<void> {
+      const record = jobs.get(jobId);
+      if (record === undefined) return Promise.resolve();
+      const at = nowMs(clock);
+      const counts = nackOptions.countsAsAttempt !== false;
+      const patch: Partial<JobRecord> = {
+        state: nackOptions.deadLetter === true ? 'dead' : counts ? 'ready' : 'suspended',
+        runAt: at + nackOptions.delayMs,
+        // A suspension must not burn an attempt, or a 3-day sleep dead-letters the run.
+        attempt: counts ? record.attempt : record.attempt - 1,
+        ...(nackOptions.error === undefined ? {} : { lastError: nackOptions.error }),
+      };
+      update(jobId, patch);
+      return Promise.resolve();
+    },
+
+    heartbeat(jobId: string, heartbeatOptions): Promise<void> {
+      update(jobId, { visibleAt: nowMs(clock) + heartbeatOptions.visibilityTimeoutMs });
+      return Promise.resolve();
+    },
+
+    stats(): Promise<readonly QueueStats[]> {
+      const at = nowMs(clock);
+      const byQueue = new Map<string, QueueStats>();
+      for (const record of jobs.values()) {
+        const current = byQueue.get(record.queue) ?? {
+          queue: record.queue,
+          ready: 0,
+          delayed: 0,
+          running: 0,
+          suspended: 0,
+          dead: 0,
+          oldestReadyMs: 0,
+        };
+        const next = { ...current };
+        if (record.state === 'ready' && record.runAt <= at) {
+          next.ready += 1;
+          next.oldestReadyMs = Math.max(next.oldestReadyMs, at - record.runAt);
+        } else if (record.state === 'ready' || record.state === 'delayed') next.delayed += 1;
+        else if (record.state === 'running') next.running += 1;
+        else if (record.state === 'suspended') next.suspended += 1;
+        else if (record.state === 'dead') next.dead += 1;
+        byQueue.set(record.queue, next);
+      }
+      return Promise.resolve([...byQueue.values()].sort((a, b) => a.queue.localeCompare(b.queue)));
+    },
+
+    close(): Promise<void> {
+      jobs.clear();
+      return Promise.resolve();
+    },
+  };
+}

package/src/driver-nats.d.ts

@@ -0,0 +1,7 @@
+import type { JobDriver } from './driver';
+export interface NatsDriverOptions {
+    readonly servers?: readonly string[];
+    readonly streamPrefix?: string;
+}
+export declare function createNatsDriver(_options?: NatsDriverOptions): JobDriver;
+//# sourceMappingURL=driver-nats.d.ts.map

package/src/driver-nats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-nats.d.ts","sourceRoot":"","sources":["driver-nats.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAKV,SAAS,EAGV,MAAM,UAAU,CAAC;AA4BlB,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,GAAE,iBAAsB,GAAG,SAAS,CAuB5E"}

package/src/driver-nats.js

@@ -0,0 +1,51 @@
+// NATS driver — interface-complete, not implemented. The intended mapping, so the eventual
+// implementation has no design decisions left: a JetStream work-queue stream per job queue,
+// a durable pull consumer per worker pool (`fetch` == claim, `ack`/`nak` map 1:1),
+// `ack_wait` as the visibility timeout, and a KV bucket for step records.
+import { JobsNotImplementedError } from './errors';
+const FIX = 'use driver: "pg" (default) or "memory" — see docs/jobs/drivers.md#nats';
+const unavailable = (method) => {
+    throw new JobsNotImplementedError({ feature: `nats jobs driver (${method})`, fix: FIX });
+};
+const natsStepStore = () => ({
+    get(_runId, _name) {
+        return unavailable('steps.get');
+    },
+    put(_record) {
+        return unavailable('steps.put');
+    },
+    list(_runId) {
+        return unavailable('steps.list');
+    },
+    del(_runId, _name) {
+        return unavailable('steps.del');
+    },
+    clear(_runId) {
+        return unavailable('steps.clear');
+    },
+});
+export function createNatsDriver(_options = {}) {
+    return {
+        name: 'nats',
+        steps: natsStepStore(),
+        enqueue(_request) {
+            return unavailable('enqueue');
+        },
+        claim(_options) {
+            return unavailable('claim');
+        },
+        ack(_jobId) {
+            return unavailable('ack');
+        },
+        nack(_jobId, _options) {
+            return unavailable('nack');
+        },
+        heartbeat(_jobId, _options) {
+            return unavailable('heartbeat');
+        },
+        stats() {
+            return unavailable('stats');
+        },
+    };
+}
+//# sourceMappingURL=driver-nats.js.map

package/src/driver-nats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-nats.js","sourceRoot":"","sources":["driver-nats.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,4FAA4F;AAC5F,mFAAmF;AACnF,0EAA0E;AAW1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD,MAAM,GAAG,GAAG,wEAAwE,CAAC;AAErF,MAAM,WAAW,GAAG,CAAC,MAAc,EAAS,EAAE;IAC5C,MAAM,IAAI,uBAAuB,CAAC,EAAE,OAAO,EAAE,qBAAqB,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;AAC3F,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,GAAc,EAAE,CAAC,CAAC;IACtC,GAAG,CAAC,MAAc,EAAE,KAAa;QAC/B,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IACD,GAAG,CAAC,OAAmB;QACrB,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,CAAC,MAAc;QACjB,OAAO,WAAW,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC;IACD,GAAG,CAAC,MAAc,EAAE,KAAa;QAC/B,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC;IAClC,CAAC;IACD,KAAK,CAAC,MAAc;QAClB,OAAO,WAAW,CAAC,aAAa,CAAC,CAAC;IACpC,CAAC;CACF,CAAC,CAAC;AAOH,MAAM,UAAU,gBAAgB,CAAC,QAAQ,GAAsB,EAAE;IAC/D,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,aAAa,EAAE;QACtB,OAAO,CAAC,QAAwB;YAC9B,OAAO,WAAW,CAAC,SAAS,CAAC,CAAC;QAChC,CAAC;QACD,KAAK,CAAC,QAAsB;YAC1B,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;QACD,GAAG,CAAC,MAAc;YAChB,OAAO,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,MAAc,EAAE,QAAqB;YACxC,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;QACD,SAAS,CAAC,MAAc,EAAE,QAAkD;YAC1E,OAAO,WAAW,CAAC,WAAW,CAAC,CAAC;QAClC,CAAC;QACD,KAAK;YACH,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/src/driver-nats.ts

@@ -0,0 +1,73 @@
+// NATS driver — interface-complete, not implemented. The intended mapping, so the eventual
+// implementation has no design decisions left: a JetStream work-queue stream per job queue,
+// a durable pull consumer per worker pool (`fetch` == claim, `ack`/`nak` map 1:1),
+// `ack_wait` as the visibility timeout, and a KV bucket for step records.
+
+import type {
+  ClaimedJob,
+  ClaimOptions,
+  EnqueueRequest,
+  EnqueueResult,
+  JobDriver,
+  NackOptions,
+  QueueStats,
+} from './driver';
+import { JobsNotImplementedError } from './errors';
+import type { StepRecord, StepStore } from './steps';
+
+// Names the config edit that actually removes the stub, plus the runnable command for whatever
+// is already queued. The nats driver lands in v2; there is no flag that turns this one on.
+const FIX =
+  "set jobs: { driver: 'postgres' } in app.config.ts, then: x jobs drain --to memory --json";
+
+const unavailable = (method: string): never => {
+  throw new JobsNotImplementedError({ feature: `nats jobs driver (${method})`, fix: FIX });
+};
+
+const natsStepStore = (): StepStore => ({
+  get(_runId: string, _name: string): Promise<StepRecord | undefined> {
+    return unavailable('steps.get');
+  },
+  put(_record: StepRecord): Promise<void> {
+    return unavailable('steps.put');
+  },
+  list(_runId: string): Promise<readonly StepRecord[]> {
+    return unavailable('steps.list');
+  },
+  del(_runId: string, _name: string): Promise<void> {
+    return unavailable('steps.del');
+  },
+  clear(_runId: string): Promise<void> {
+    return unavailable('steps.clear');
+  },
+});
+
+export interface NatsDriverOptions {
+  readonly servers?: readonly string[];
+  readonly streamPrefix?: string;
+}
+
+export function createNatsDriver(_options: NatsDriverOptions = {}): JobDriver {
+  return {
+    name: 'nats',
+    steps: natsStepStore(),
+    enqueue(_request: EnqueueRequest): Promise<EnqueueResult> {
+      return unavailable('enqueue');
+    },
+    claim(_options: ClaimOptions): Promise<readonly ClaimedJob[]> {
+      return unavailable('claim');
+    },
+    ack(_jobId: string): Promise<void> {
+      return unavailable('ack');
+    },
+    nack(_jobId: string, _options: NackOptions): Promise<void> {
+      return unavailable('nack');
+    },
+    heartbeat(_jobId: string, _options: { readonly visibilityTimeoutMs: number }): Promise<void> {
+      return unavailable('heartbeat');
+    },
+    stats(): Promise<readonly QueueStats[]> {
+      return unavailable('stats');
+    },
+  };
+}

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

@@ -0,0 +1,19 @@
+export declare const SQL_JOBS_TABLE: string;
+export declare const SQL_ENQUEUE: string;
+export declare const SQL_FIND_LIVE_BY_KEY: string;
+/**
+ * The claim. SKIP LOCKED is the whole design: without it, worker 2 blocks on worker 1's row
+ * lock and throughput collapses to one worker. `visible_at` in the predicate reclaims leases
+ * abandoned by a crashed worker.
+ */
+export declare const SQL_CLAIM: string;
+export declare const SQL_ACK: string;
+export declare const SQL_NACK: string;
+export declare const SQL_HEARTBEAT: string;
+export declare const SQL_STATS: string;
+/** Scheduler leader election. Session-scoped, so a crashed node's lock releases itself. */
+export declare const SQL_TRY_ADVISORY_LOCK = "select pg_try_advisory_lock($1) as locked";
+export declare const SQL_ADVISORY_UNLOCK = "select pg_advisory_unlock($1) as unlocked";
+export declare const SQL_STEP_GET: string;
+export declare const SQL_STEP_PUT: string;
+//# sourceMappingURL=driver-pg-sql.d.ts.map

package/src/driver-pg-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-pg-sql.d.ts","sourceRoot":"","sources":["driver-pg-sql.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,cAAc,QA4CnB,CAAC;AAET,eAAO,MAAM,WAAW,QAWhB,CAAC;AAET,eAAO,MAAM,oBAAoB,QAKzB,CAAC;AAET;;;;GAIG;AACH,eAAO,MAAM,SAAS,QA4Bd,CAAC;AAET,eAAO,MAAM,OAAO,QAIZ,CAAC;AAET,eAAO,MAAM,QAAQ,QAUb,CAAC;AAET,eAAO,MAAM,aAAa,QAIlB,CAAC;AAET,eAAO,MAAM,SAAS,QAYd,CAAC;AAET,2FAA2F;AAC3F,eAAO,MAAM,qBAAqB,8CAA8C,CAAC;AACjF,eAAO,MAAM,mBAAmB,8CAA8C,CAAC;AAE/E,eAAO,MAAM,YAAY,QAOjB,CAAC;AAET,eAAO,MAAM,YAAY,QAYjB,CAAC"}

package/src/driver-pg-sql.js

@@ -0,0 +1,160 @@
+// Every statement the Postgres driver runs, spelled out as template strings on purpose: an
+// agent debugging a stuck queue should be able to read, run and correct the exact statement
+// it saw in a log, without reassembling it from a builder. Kept beside the driver rather than
+// inside it so the driver file stays the control flow and this one stays the wire format.
+export const SQL_JOBS_TABLE = `
+create table if not exists x_jobs (
+  id              uuid primary key,
+  name            text        not null,
+  queue           text        not null default 'default',
+  input           jsonb       not null,
+  idempotency_key text        not null,
+  run_id          uuid        not null,
+  attempt         int         not null default 0,
+  max_attempts    int         not null default 3,
+  state           text        not null default 'ready',
+  run_at          timestamptz not null default now(),
+  visible_at      timestamptz,
+  claimed_by      text,
+  last_error      text,
+  tenant_id       text,
+  created_at      timestamptz not null default now(),
+  updated_at      timestamptz not null default now()
+);
+
+-- Partial unique index: one LIVE job per idempotency key. Completed rows stay for history,
+-- so re-running the same work tomorrow is allowed and re-delivering it today is not.
+create unique index if not exists x_jobs_idempotency_live_idx
+  on x_jobs (idempotency_key)
+  where state in ('ready', 'delayed', 'running', 'suspended');
+
+create index if not exists x_jobs_claim_idx
+  on x_jobs (queue, run_at)
+  where state in ('ready', 'delayed', 'suspended');
+
+create table if not exists x_job_steps (
+  run_id       uuid        not null,
+  name         text        not null,
+  status       text        not null,
+  output       jsonb,
+  started_at   timestamptz not null default now(),
+  completed_at timestamptz,
+  wake_at      timestamptz,
+  event        text,
+  correlation_key text,
+  attempts     int         not null default 1,
+  error        text,
+  primary key (run_id, name)
+);
+`.trim();
+export const SQL_ENQUEUE = `
+insert into x_jobs
+  (id, name, queue, input, idempotency_key, run_id, max_attempts, state, run_at, tenant_id)
+values
+  ($1, $2, $3, $4::jsonb, $5, $6, $7,
+   case when to_timestamp($8 / 1000.0) > now() then 'delayed' else 'ready' end,
+   to_timestamp($8 / 1000.0), $9)
+on conflict (idempotency_key)
+  where state in ('ready', 'delayed', 'running', 'suspended')
+  do nothing
+returning id, run_id
+`.trim();
+export const SQL_FIND_LIVE_BY_KEY = `
+select id, run_id from x_jobs
+ where idempotency_key = $1
+   and state in ('ready', 'delayed', 'running', 'suspended')
+ limit 1
+`.trim();
+/**
+ * The claim. SKIP LOCKED is the whole design: without it, worker 2 blocks on worker 1's row
+ * lock and throughput collapses to one worker. `visible_at` in the predicate reclaims leases
+ * abandoned by a crashed worker.
+ */
+export const SQL_CLAIM = `
+with claimed as (
+  select id
+    from x_jobs
+   where queue = any($1::text[])
+     and run_at <= now()
+     and (
+       state in ('ready', 'delayed', 'suspended')
+       or (state = 'running' and visible_at <= now())
+     )
+   order by run_at
+   limit $2
+     for update skip locked
+)
+update x_jobs j
+   set state      = 'running',
+       attempt    = j.attempt + 1,
+       claimed_by = $3,
+       visible_at = now() + ($4::bigint * interval '1 millisecond'),
+       updated_at = now()
+  from claimed c
+ where j.id = c.id
+returning j.id, j.name, j.queue, j.input, j.idempotency_key, j.run_id, j.attempt,
+          j.max_attempts, j.state, j.tenant_id, j.last_error, j.claimed_by,
+          (extract(epoch from j.run_at)     * 1000)::bigint as run_at,
+          (extract(epoch from j.visible_at) * 1000)::bigint as visible_at,
+          (extract(epoch from j.created_at) * 1000)::bigint as created_at,
+          (extract(epoch from j.updated_at) * 1000)::bigint as updated_at
+`.trim();
+export const SQL_ACK = `
+update x_jobs
+   set state = 'done', visible_at = null, claimed_by = null, updated_at = now()
+ where id = $1
+`.trim();
+export const SQL_NACK = `
+update x_jobs
+   set state      = $2,
+       attempt    = case when $3::boolean then attempt else greatest(attempt - 1, 0) end,
+       run_at     = now() + ($4::bigint * interval '1 millisecond'),
+       visible_at = null,
+       claimed_by = null,
+       last_error = coalesce($5, last_error),
+       updated_at = now()
+ where id = $1
+`.trim();
+export const SQL_HEARTBEAT = `
+update x_jobs
+   set visible_at = now() + ($2::bigint * interval '1 millisecond'), updated_at = now()
+ where id = $1 and state = 'running'
+`.trim();
+export const SQL_STATS = `
+select queue,
+       count(*) filter (where state = 'ready' and run_at <= now())              as ready,
+       count(*) filter (where state = 'delayed' or run_at > now())              as delayed,
+       count(*) filter (where state = 'running')                                as running,
+       count(*) filter (where state = 'suspended')                              as suspended,
+       count(*) filter (where state = 'dead')                                   as dead,
+       coalesce(max(extract(epoch from now() - run_at)) filter
+         (where state = 'ready' and run_at <= now()), 0) * 1000                 as oldest_ready_ms
+  from x_jobs
+ group by queue
+ order by queue
+`.trim();
+/** Scheduler leader election. Session-scoped, so a crashed node's lock releases itself. */
+export const SQL_TRY_ADVISORY_LOCK = 'select pg_try_advisory_lock($1) as locked';
+export const SQL_ADVISORY_UNLOCK = 'select pg_advisory_unlock($1) as unlocked';
+export const SQL_STEP_GET = `
+select run_id, name, status, output, attempts, error,
+       (extract(epoch from started_at)   * 1000)::bigint as started_at,
+       (extract(epoch from completed_at) * 1000)::bigint as completed_at,
+       (extract(epoch from wake_at)      * 1000)::bigint as wake_at,
+       event, correlation_key
+  from x_job_steps where run_id = $1 and name = $2
+`.trim();
+export const SQL_STEP_PUT = `
+insert into x_job_steps
+  (run_id, name, status, output, started_at, completed_at, wake_at, event,
+   correlation_key, attempts, error)
+values ($1, $2, $3, $4::jsonb, to_timestamp($5 / 1000.0),
+        case when $6::bigint is null then null else to_timestamp($6 / 1000.0) end,
+        case when $7::bigint is null then null else to_timestamp($7 / 1000.0) end,
+        $8, $9, $10, $11)
+on conflict (run_id, name) do update
+   set status = excluded.status, output = excluded.output,
+       completed_at = excluded.completed_at, wake_at = excluded.wake_at,
+       attempts = excluded.attempts, error = excluded.error
+`.trim();
+//# sourceMappingURL=driver-pg-sql.js.map

package/src/driver-pg-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver-pg-sql.js","sourceRoot":"","sources":["driver-pg-sql.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,4FAA4F;AAC5F,8FAA8F;AAC9F,0FAA0F;AAE1F,MAAM,CAAC,MAAM,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C7B,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;CAW1B,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;CAKnC,CAAC,IAAI,EAAE,CAAC;AAET;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,OAAO,GAAG;;;;CAItB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,QAAQ,GAAG;;;;;;;;;;CAUvB,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,aAAa,GAAG;;;;CAI5B,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;CAYxB,CAAC,IAAI,EAAE,CAAC;AAET,2FAA2F;AAC3F,MAAM,CAAC,MAAM,qBAAqB,GAAG,2CAA2C,CAAC;AACjF,MAAM,CAAC,MAAM,mBAAmB,GAAG,2CAA2C,CAAC;AAE/E,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;CAO3B,CAAC,IAAI,EAAE,CAAC;AAET,MAAM,CAAC,MAAM,YAAY,GAAG;;;;;;;;;;;;CAY3B,CAAC,IAAI,EAAE,CAAC"}