@marinoscar/platform-api 0.0.0-stage → 0.1.0-next.10

package/dist/jobs/job-admin.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-admin.service.js","sourceRoot":"","sources":["../../src/jobs/job-admin.service.ts"],"names":[],"mappings":"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"}

package/dist/jobs/job-claim.service.d.ts

@@ -0,0 +1,103 @@
+import { type Job, type JobsPrisma } from './data/jobs-db';
+import { type JobsMetrics } from './ports';
+import type { ClaimLease } from './job-execution-profile';
+/**
+ * Which side of the system is executing a claimed job. Written to
+ * `jobs.executor` so history records where the work actually ran.
+  *
+  * @stability experimental
+ */
+export type JobExecutor = 'server' | 'node';
+/**
+ * One claim request: who claims, which types, how many, and each type's lease.
+ *
+ * @stability experimental
+ */
+export interface ClaimOptions {
+    /**
+     * The worker node taking the rows, or `null` for the API server's own
+     * in-process worker.
+     *
+     * Typed `string | null` and cast to `uuid` in the statement: the column is
+     * `@db.Uuid`, and there is no FK to a node table yet (the `Job` model's
+     * comment explains why, and what arrives with the node plane).
+     */
+    nodeId: string | null;
+    /** What to write to `jobs.executor`. */
+    executor: JobExecutor;
+    /**
+     * The job types this claimer is allowed to run.
+     *
+     * ALWAYS an explicit list, never "everything". The in-process worker passes
+     * the registry's `types()` in `all` mode and `serverOnlyTypes()` in
+     * `system` mode (#262); the node plane passes what a node can run (#268).
+     * A claimer must never take a job it has no handler for — that would turn
+     * a perfectly good job into an "unknown job type" permanent failure.
+     */
+    eligibleTypes: string[];
+    /** Maximum rows to claim in this call. */
+    limit: number;
+    /**
+     * How long the claim is good for, PER TYPE, in milliseconds. Written as
+     * `lease_expires_at = now() + <this type's lease>`, and it is what the lease
+     * reaper (#263) reads to find jobs whose claimer died holding them.
+     *
+     * A LIST RATHER THAN ONE NUMBER, because a claim is not homogeneous (#346).
+     * Per-type execution profiles give a type its own runtime ceiling, and the
+     * lease is derived from that ceiling — so the rows a single claim takes no
+     * longer share one. A worker node claiming up to its concurrency across
+     * several types in one statement is the case that makes this unavoidable: a
+     * single batch-wide number would have to be either the shortest lease (which
+     * reaps the long job mid-run and duplicates it) or the longest (which leaves
+     * a dead executor's short job held for hours). Neither is a lease.
+     *
+     * Build it with `buildClaimLeases` (`job-execution-profile.ts`) rather than
+     * by hand: both claimers must derive the same lease for the same type, and
+     * that function is the one place that derivation happens.
+     *
+     * ⚠ IT MUST COVER `eligibleTypes`. See `claim()` for why the join can never
+     * drop a row, and why that is a structural invariant rather than a
+     * convention a caller is asked to honour.
+     */
+    leases: ClaimLease[];
+}
+/**
+ * Every `Job` field mapped to the physical column it is stored in.
+ *
+ * TYPED `Record<keyof Job, string>` ON PURPOSE — see the file header. This is
+ * the compile-time half of "the claim's `RETURNING` clause cannot drift from
+ * the schema"; `job-model-fields.spec.ts` is the runtime half.
+  *
+  * @stability experimental
+ */
+export declare const JOB_CLAIM_COLUMNS: Readonly<Record<keyof Job, string>>;
+/**
+ * The atomic claim: one `FOR UPDATE SKIP LOCKED` statement shared by the server worker and the node control plane.
+ *
+ * @stability experimental
+ */
+export declare class JobClaimService {
+    private readonly prisma;
+    private readonly metrics;
+    private readonly logger;
+    constructor(prisma: JobsPrisma, metrics?: JobsMetrics);
+    /**
+     * Atomically takes up to `limit` runnable jobs and marks them `running`.
+     *
+     * Returns the claimed rows as generated `Job` values, already carrying
+     * `attempts` incremented, `startedAt` set, and the lease applied. An empty
+     * array means "nothing to do right now", which is the overwhelmingly common
+     * answer and is not an error.
+     *
+     * ⚠ THE RETURNED ARRAY IS UNORDERED.
+     * `ORDER BY priority ASC, created_at ASC` decides *which* rows are taken; `RETURNING` promises nothing about
+     * the order they arrive in. Sort at the call site if it matters.
+     *
+     * MULTI-PROCESS SAFE. Two claimers running concurrently — two replicas, a
+     * replica and a node, two threads of the same pool — never receive the same
+     * row. See the file header for the mechanism and for the three alternatives
+     * that are not safe.
+     */
+    claim(options: ClaimOptions): Promise<Job[]>;
+}
+//# sourceMappingURL=job-claim.service.d.ts.map

package/dist/jobs/job-claim.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-claim.service.d.ts","sourceRoot":"","sources":["../../src/jobs/job-claim.service.ts"],"names":[],"mappings":"AAwOA,OAAO,EAAE,KAAK,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAI3D,OAAO,EAAmC,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5C;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtB,wCAAwC;IACxC,QAAQ,EAAE,WAAW,CAAC;IAEtB;;;;;;;;OAQG;IACH,aAAa,EAAE,MAAM,EAAE,CAAC;IAExB,0CAA0C;IAC1C,KAAK,EAAE,MAAM,CAAC;IAEd;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,GAAG,EAAE,MAAM,CAAC,CA+BjE,CAAC;AA6CF;;;;GAIG;AACH,qBACa,eAAe;IAIC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEd,OAAO,CAAC,QAAQ,CAAC,OAAO;IAL5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoC;gBAGf,MAAM,EAAE,UAAU,EAET,OAAO,GAAE,WAA+B;IAG7F;;;;;;;;;;;;;;;;OAgBG;IACG,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAkGnD"}

package/dist/jobs/job-claim.service.js

@@ -0,0 +1,457 @@
+"use strict";
+// =============================================================================
+// The atomic claim (issue #260, epic #254)
+// =============================================================================
+//
+// ONE STATEMENT. That is the entire design, and everything else in this file
+// exists to keep it one statement.
+//
+// `claim()` issues a single `UPDATE … WHERE id IN (SELECT … FOR UPDATE SKIP
+// LOCKED …) RETURNING …`. The inner `SELECT` picks eligible rows and locks
+// them, skipping any row another transaction already holds; the outer
+// `UPDATE` marks exactly those rows `running` and hands them back. There is
+// no window between "I chose this row" and "I own this row" in which a second
+// claimer can choose it too, because there is no gap between the two — they
+// are the same statement, in the same implicit transaction.
+//
+// This method is SHARED VERBATIM by both claimers in this epic: the
+// in-process worker (#262) and, later, the node control plane (#268). That
+// is why `ClaimOptions` carries `nodeId` and `executor` rather than the
+// service knowing which side it is running on — a second copy of this query,
+// specialised per caller, is exactly how the two would drift apart on the one
+// statement that must not drift.
+//
+// -----------------------------------------------------------------------------
+// WHY `FOR UPDATE SKIP LOCKED`, AND WHAT WAS REJECTED
+// -----------------------------------------------------------------------------
+//
+// REJECTED: `SELECT … FOR UPDATE` followed by a separate `UPDATE`. Two
+// statements, two round trips, a wider window in which the claiming process
+// can die between them (leaving rows locked until the transaction unwinds),
+// and no gain whatsoever — the second statement re-finds rows the first
+// already identified. `SKIP LOCKED` plus `RETURNING` collapses both into one.
+//
+// REJECTED: an advisory lock (`pg_advisory_xact_lock`) around the claim. It
+// works, and it serialises every claimer in the fleet through a single lock:
+// with N workers, N-1 of them wait to do a query that takes microseconds. The
+// whole point of `SKIP LOCKED` is that it is the primitive for "give me a row
+// nobody else is working on" — it never blocks, it just steps over contended
+// rows.
+//
+// REJECTED: an in-process mutex around claiming (which is what the source
+// application this design was extracted from actually started with). It
+// serialises claims WITHIN one process and is completely blind outside it,
+// so it works perfectly on a laptop, works perfectly with one replica, and
+// double-claims the moment a second replica is scheduled or a remote node
+// joins. THIS IS THE BUG THIS DESIGN EXISTS TO AVOID: a correctness property
+// that holds right up until the first time the system is scaled.
+//
+// -----------------------------------------------------------------------------
+// ⚠ `attempts` IS CHARGED AT CLAIM TIME. IT MEANS "ATTEMPTS STARTED".
+// -----------------------------------------------------------------------------
+//
+// `attempts = attempts + 1` is in the claim statement, not in any failure
+// path, and this is a correctness decision rather than a convenience.
+//
+// A job can take the whole process down with it: an OOM kill, a hard crash, a
+// container the orchestrator terminates mid-run. NONE of those reach a
+// failure handler — there is no handler left to reach. So if `attempts` were
+// charged when a job FAILS, such a job would be requeued with its budget
+// untouched, claimed again, kill the process again, and crash-loop the
+// container for as long as anyone lets it. The retry budget would be
+// unreachable by exactly the failures it most needs to bound.
+//
+// Charging at claim makes the counter mean "attempts STARTED", which is the
+// only thing observable from outside a process that may not survive. It is
+// what lets the lease reaper (#263) find a job whose lease expired with its
+// budget spent and mark it permanently `failed` — bounding a poison pill to
+// N crashes instead of infinity.
+//
+// The cost is honest and small: a job whose worker was killed for reasons of
+// its own (a deploy, a node drain) is charged an attempt it did not deserve.
+// A retry budget losing one of N on a redeploy is a far better failure than
+// an unbounded crash loop.
+//
+// TWO CONSEQUENCES THAT LIVE ELSEWHERE, recorded here so neither gets
+// rediscovered as a bug:
+//
+//   - The rate-limit deferral path (#261) explicitly UN-CHARGES this
+//     increment. A provider throttling us is not an attempt at the work, and
+//     a job merely waiting its turn must not exhaust a budget meant for a job
+//     that keeps failing. That is also why `rateLimitHits` is a separate
+//     counter — see the `Job` model's block comment in `schema.prisma`.
+//   - `attempts` is already 1 by the time a handler's `process()` runs. Any
+//     code reading it inside a handler is reading the count INCLUDING the
+//     current attempt, never excluding it.
+//
+// -----------------------------------------------------------------------------
+// THE LEASE IS PER ROW, AND IT IS STILL ONE STATEMENT (#346)
+// -----------------------------------------------------------------------------
+//
+// Per-type execution profiles gave each job type its own runtime ceiling, and
+// the claim lease is derived from that ceiling — so the rows one claim takes
+// no longer share a lease. The in-process worker takes `limit: 1` and would
+// not have noticed, but A NODE CLAIMS UP TO ITS CONCURRENCY ACROSS SEVERAL
+// TYPES IN ONE STATEMENT, and a single batch-wide number there has to be
+// either the shortest lease in the batch (which reaps a long job while it is
+// still running, and duplicates it) or the longest (which leaves a dead
+// executor's short job held for an hour). Neither is a lease; both are a
+// compromise forced by the shape of the parameter rather than by anything
+// real.
+//
+// `unnest(types, lease_ms)` turns the `{ type, leaseMs }` pairs into a
+// two-column relation the same `UPDATE` joins against, so each row gets ITS
+// OWN lease and the statement count stays at one. That last part is the
+// requirement: a per-type lease implemented as "claim, then a second UPDATE to
+// set leases" would reopen exactly the window `FOR UPDATE SKIP LOCKED` closes.
+//
+// REJECTED: a `CASE WHEN type = … THEN … END` ladder built by interpolating
+// the types into the SQL text. It is one statement too, and it works, and it
+// is the only construct in this file that would put caller-supplied strings
+// into SQL structure rather than into a placeholder — for no gain over a
+// parameterised array.
+//
+// -----------------------------------------------------------------------------
+// ⚠⚠ THE ROW PICK IS A `MATERIALIZED` CTE, NOT A SUBQUERY — AND THE `LIMIT`
+// ⚠⚠ DEPENDS ON THAT. THIS IS NOT A STYLE CHOICE.
+// -----------------------------------------------------------------------------
+//
+// THIS IS THE SUBTLEST THING IN THE FILE, it was a real bug caught only by a
+// database test, and it is invisible to every unit test that will ever be
+// written against a mocked driver. Read this before touching the shape of the
+// statement below.
+//
+// Until #346 the row selection was an uncorrelated subquery in the `WHERE`:
+//
+//     UPDATE jobs SET … WHERE id IN (SELECT … FOR UPDATE SKIP LOCKED LIMIT n)
+//
+// With no `FROM` clause, Postgres can only plan that as an InitPlan: the
+// subquery is evaluated ONCE, before the update, and its result is a fixed set
+// of ids. `LIMIT n` therefore meant n rows, always.
+//
+// Adding `FROM unnest(…)` for the per-type leases removes that guarantee. The
+// planner is now free to turn the same subquery into a SubPlan RE-EVALUATED
+// PER OUTER ROW — and each re-evaluation takes FRESH ROW LOCKS. `SKIP LOCKED`
+// then does exactly what it is for: it steps over the rows the earlier
+// evaluations already locked, so every evaluation returns a DIFFERENT set, and
+// the union of those sets is far larger than `n`. Measured on PostgreSQL 16:
+// five pending rows of one type, `LIMIT 2`, `UPDATE 5`. A worker asking for
+// one job is handed five, each one charged an attempt, four of them held by a
+// slot that will never run them.
+//
+// ⚠ AND IT IS PLAN-DEPENDENT, WHICH IS WHY IT MUST BE PINNED RATHER THAN
+// TESTED FOR. The same statement over nine rows across three types returned
+// exactly two. The bug appears or does not appear according to the row counts,
+// the statistics and the plan the planner happens to choose — so a green test
+// on one data shape proves nothing whatsoever about another, and a claim that
+// is *usually* correct is worse than one that is reliably wrong.
+//
+// `WITH picked AS MATERIALIZED (…)` removes the planner's freedom. Two things
+// are doing work there, and it is worth being precise about which is which,
+// because a future reader will otherwise delete the half that looks redundant:
+//
+//   - THE CTE, joined as `FROM picked p … WHERE jobs.id = p.id`, is what
+//     retires the `id IN (SELECT …)` shape entirely. That shape is the one
+//     measured above returning five rows for `LIMIT 2`; a join against a
+//     computed relation has no per-outer-row subquery to re-evaluate.
+//
+//   - `MATERIALIZED` pins the single evaluation EXPLICITLY rather than leaving
+//     it to the planner's inlining rules (PostgreSQL 12+ folds a plain `WITH`
+//     into the parent query under conditions that are not this file's business
+//     to track, and that can change between major versions). It is cheap, it
+//     is exact, and what it buys is that this statement's correctness stops
+//     depending on a default. Measured: with the keyword, five rows of one
+//     type at `LIMIT 2` claims exactly two, and nine rows across three types
+//     at `LIMIT 2` claims exactly two, each row carrying its own type's lease.
+//
+// So: do not fold the CTE back into the `WHERE` — that is the demonstrated
+// bug. And do not drop `MATERIALIZED` — that is the guarantee that the demo
+// stays true on a planner nobody here has run.
+//
+// The regression tests live in `test/jobs/job-claim.db.spec.ts` ("the limit is
+// honoured whatever the planner does") and they must stay DATABASE tests. A
+// mocked `$queryRaw` returns whatever the test tells it to; only a real server
+// can execute a plan. They were confirmed to FAIL against the pre-fix shape.
+//
+// -----------------------------------------------------------------------------
+// ⚠ `claim_token` IS MINTED BY THE STATEMENT, PER ROW — NOT BOUND AS A
+// ⚠ PARAMETER. DO NOT "CLEAN THIS UP" INTO A `${uuid}` PLACEHOLDER (#361)
+// -----------------------------------------------------------------------------
+//
+// Every other value in this statement is a bound parameter, on purpose, so
+// `gen_random_uuid()` sitting in the SQL text looks like an oversight. It is
+// not, and the difference is the whole point of the column.
+//
+// A token identifies THIS CLAIM OF THIS ROW. A single value bound once and
+// sent with the statement would give every row in one batch the SAME token —
+// which identifies the claiming PROCESS, not the claim. That is precisely the
+// defect `claimedByNodeId` already has one level up, re-created one level
+// down: a worker that claims job J, stalls, loses J to the reaper, and then
+// claims J again would carry the same token across both runs and be unable to
+// tell itself apart from itself. A per-process token closes nothing.
+//
+// `gen_random_uuid()` is VOLATILE, so PostgreSQL evaluates it once per updated
+// row rather than folding it to a constant — which is exactly the semantics
+// wanted here, and is not something a placeholder can express. It has been
+// built in since PostgreSQL 13 (no `pgcrypto` extension needed) and this repo
+// targets 16.
+//
+// Nothing caller-supplied goes anywhere near it: the function name is a fixed
+// literal in the template, so this is not an interpolation of any kind.
+//
+// -----------------------------------------------------------------------------
+// EVERY `RETURNING` COLUMN IS ALIASED TO ITS camelCase PRISMA FIELD
+// -----------------------------------------------------------------------------
+//
+// The table is snake_case; the generated `Job` type is camelCase. Aliasing
+// every column in `RETURNING` means the rows Postgres hands back ARE `Job`
+// values — no mapping function between the query and its callers, and
+// therefore no mapping function to forget a field in.
+//
+// ⚠ `ORDER BY` SELECTS *WHICH* ROWS, NOT THE ORDER THEY COME BACK IN. The
+// `ORDER BY priority ASC, created_at ASC` lives in the inner `SELECT`, where
+// it decides which rows the claim takes — the most urgent, oldest-first. SQL
+// gives `UPDATE … RETURNING` no ordering guarantee at all, so the returned
+// array is a SET, not a sequence, and Postgres is free to hand it back in any
+// order. A caller that needs the rows sorted must sort them; nothing in this
+// epic does, because a worker dispatches each claimed job independently. Do
+// not "fix" this by adding an outer `ORDER BY` — `UPDATE` has no such clause,
+// and wrapping the statement to get one would trade the single-statement
+// atomicity this whole file exists for against an ordering nobody needs.
+//
+// The alias list is derived from `JOB_CLAIM_COLUMNS` below rather than typed
+// out inline, which is what turns a schema change into a COMPILE error: that
+// map is typed `Record<keyof Job, string>`, so adding a column to `Job`
+// fails to compile until the map covers it, and renaming one fails to compile
+// on the stale key. Written out by hand instead, the same rename would
+// produce a row missing a field, silently `undefined` at every call site —
+// the failure would surface as a null-ish value somewhere downstream rather
+// than at the line that caused it. `job-model-fields.spec.ts` locks the same
+// pairing down from the test side.
+// =============================================================================
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var JobClaimService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobClaimService = exports.JOB_CLAIM_COLUMNS = void 0;
+const common_1 = require("@nestjs/common");
+const prisma_runtime_1 = require("./data/prisma-runtime");
+const index_1 = require("../core/index");
+const ports_1 = require("./ports");
+/**
+ * Every `Job` field mapped to the physical column it is stored in.
+ *
+ * TYPED `Record<keyof Job, string>` ON PURPOSE — see the file header. This is
+ * the compile-time half of "the claim's `RETURNING` clause cannot drift from
+ * the schema"; `job-model-fields.spec.ts` is the runtime half.
+  *
+  * @stability experimental
+ */
+exports.JOB_CLAIM_COLUMNS = {
+    id: 'id',
+    type: 'type',
+    subjectType: 'subject_type',
+    subjectId: 'subject_id',
+    dedupKey: 'dedup_key',
+    status: 'status',
+    reason: 'reason',
+    priority: 'priority',
+    providerKey: 'provider_key',
+    modelVersion: 'model_version',
+    payload: 'payload',
+    attempts: 'attempts',
+    lastError: 'last_error',
+    createdAt: 'created_at',
+    startedAt: 'started_at',
+    finishedAt: 'finished_at',
+    scheduledFor: 'scheduled_for',
+    rateLimitedAt: 'rate_limited_at',
+    rateLimitHits: 'rate_limit_hits',
+    claimedByNodeId: 'claimed_by_node_id',
+    claimToken: 'claim_token',
+    leaseExpiresAt: 'lease_expires_at',
+    executor: 'executor',
+    // #607. Returned so the node claim can hand the enqueuing trace to the node
+    // and the server worker can parent the job's span on it.
+    traceContext: 'trace_context',
+    // #734. Returned, never filtered on: the claim stays ONE cross-organization
+    // statement (no per-org fairness yet); the worker reads it for the job
+    // span's `org.id` and `JobScope.run`.
+    orgId: 'org_id',
+};
+/**
+ * The `RETURNING` list: `jobs.created_at AS "createdAt", …` for every field
+ * above.
+ *
+ * `raw` is used because a column list is SQL structure, not a value,
+ * and structure cannot be parameterised. It is safe here for a reason that
+ * has nothing to do with trust in the caller: the ONLY input is the
+ * module-level constant above, evaluated once at import time, with no path
+ * from any request, argument or environment variable to this string. Every
+ * genuine value in `claim()` below goes through a real placeholder.
+ *
+ * ⚠ EVERY COLUMN IS QUALIFIED `jobs.`, and it has to be (#346). The statement
+ * gained a `FROM unnest(…) AS l(type, lease_ms)` to carry per-type leases, and
+ * `l` has a column called `type` — so an unqualified `type AS "type"` in
+ * `RETURNING` is ambiguous and Postgres rejects the whole statement. Qualifying
+ * all of them rather than just that one keeps the rule "every entry in this
+ * list looks the same", so a column added to `Job` later cannot be the one
+ * that quietly reintroduces the ambiguity.
+ */
+const CLAIM_RETURNING = (0, prisma_runtime_1.raw)(Object.entries(exports.JOB_CLAIM_COLUMNS)
+    .map(([field, column]) => `jobs.${column} AS "${field}"`)
+    .join(', '));
+/**
+ * The lease applied to an eligible type that `ClaimOptions.leases` somehow did
+ * not carry an entry for.
+ *
+ * UNREACHABLE THROUGH `buildClaimLeases`, which produces exactly one entry per
+ * eligible type from the same list this statement filters on. It exists
+ * because the alternative to a value here is `undefined` inside a bound
+ * `double precision[]` parameter, which fails the statement and stalls every
+ * claim in the process over one caller's mistake.
+ *
+ * An hour, matching `UNBOUNDED_LEASE_MS`, because the safe direction is LONG:
+ * a lease that is too long delays the recovery of one abandoned job by an
+ * hour, while a lease that is too short has the reaper hand still-running work
+ * to a second executor. Deferred recovery is a delay; duplicate execution is a
+ * correctness failure.
+ */
+const FALLBACK_LEASE_MS = 3_600_000;
+/**
+ * The atomic claim: one `FOR UPDATE SKIP LOCKED` statement shared by the server worker and the node control plane.
+ *
+ * @stability experimental
+ */
+let JobClaimService = JobClaimService_1 = class JobClaimService {
+    prisma;
+    metrics;
+    logger = new common_1.Logger(JobClaimService_1.name);
+    constructor(prisma, metrics = ports_1.NOOP_JOBS_METRICS) {
+        this.prisma = prisma;
+        this.metrics = metrics;
+    }
+    /**
+     * Atomically takes up to `limit` runnable jobs and marks them `running`.
+     *
+     * Returns the claimed rows as generated `Job` values, already carrying
+     * `attempts` incremented, `startedAt` set, and the lease applied. An empty
+     * array means "nothing to do right now", which is the overwhelmingly common
+     * answer and is not an error.
+     *
+     * ⚠ THE RETURNED ARRAY IS UNORDERED.
+     * `ORDER BY priority ASC, created_at ASC` decides *which* rows are taken; `RETURNING` promises nothing about
+     * the order they arrive in. Sort at the call site if it matters.
+     *
+     * MULTI-PROCESS SAFE. Two claimers running concurrently — two replicas, a
+     * replica and a node, two threads of the same pool — never receive the same
+     * row. See the file header for the mechanism and for the three alternatives
+     * that are not safe.
+     */
+    async claim(options) {
+        const { nodeId, executor, eligibleTypes, limit, leases } = options;
+        // SHORT-CIRCUIT, NOT A ROUND TRIP. Both of these are ordinary states, not
+        // misconfigurations: a worker in `system` mode with no server-only
+        // handlers registered has an empty `eligibleTypes`, and a pool with every
+        // slot busy asks for a `limit` of 0. The query would correctly return no
+        // rows in both cases — `type = ANY('{}')` matches nothing, `LIMIT 0`
+        // returns nothing — so this is purely about not paying for a database
+        // round trip on every poll tick to be told what is already known here.
+        if (eligibleTypes.length === 0 || limit <= 0) {
+            return [];
+        }
+        // THE TWO PARALLEL ARRAYS THE `unnest` JOIN IS BUILT FROM, produced by ONE
+        // WALK over ONE list (#346). That is what makes the join total rather than
+        // a convention the caller is trusted to honour: `types` is the array the
+        // inner `SELECT` filters on, `leaseValues` is filled index-by-index from
+        // the same iteration, so `l` is guaranteed to have a row for every type a
+        // claimed job can possibly have. There is no arrangement of the inputs
+        // that produces a claimed row with no lease to join against — the failure
+        // mode this shape exists to remove is a `WHERE jobs.type = l.type` that
+        // silently matches nothing and claims nothing while looking correct.
+        //
+        // DEDUPLICATED, because a duplicate type would give `l` two rows for it
+        // and leave which lease wins up to Postgres. `registry.types()` cannot
+        // repeat, but a node's stored `eligibleTypes` array is a database value a
+        // caller could have written twice, and nondeterminism is not worth
+        // inheriting from it.
+        const leaseByType = new Map(leases.map(({ type, leaseMs }) => [type, leaseMs]));
+        const types = [...new Set(eligibleTypes)];
+        const leaseValues = types.map((type) => leaseByType.get(type) ?? FALLBACK_LEASE_MS);
+        // ONE STATEMENT. Do not split this into a SELECT and an UPDATE; the file
+        // header explains why the atomicity lives in the fact that it is one. The
+        // `WITH` below does NOT make it two — a CTE is part of the same statement,
+        // in the same implicit transaction, so the pick and the claim are still
+        // indivisible and there is still no window between "I chose this row" and
+        // "I own this row".
+        //
+        // ⚠ DO NOT FOLD THE CTE BACK INTO AN `id IN (SELECT …)` IN THE `WHERE`,
+        // and do not drop `MATERIALIZED`. With the `FROM` clause present, that
+        // subquery can be re-evaluated PER OUTER ROW, and `FOR UPDATE SKIP LOCKED`
+        // makes each re-evaluation return rows the previous one did not — so the
+        // claim silently exceeds its `LIMIT`. It is plan-dependent, so it will
+        // look fine on whatever data you happen to try it on. The file header has
+        // the measurements and points at the regression tests.
+        //
+        // Every value below is a real bound parameter (`sql`'s tagged
+        // template turns each `${}` into a placeholder) — nothing is interpolated
+        // into the SQL text. The explicit casts are there because a placeholder
+        // carries no type of its own: `::"JobStatus"` for the enum comparisons,
+        // `::uuid` for the nullable node id, `::text[]` for the type list, and
+        // `::double precision[]` for the leases so the multiplication against
+        // `interval '1 millisecond'` resolves regardless of how the driver sends
+        // the numbers.
+        const rows = await this.prisma.$queryRaw((0, prisma_runtime_1.sql) `
+      WITH picked AS MATERIALIZED (
+        SELECT id FROM jobs
+        WHERE status = 'pending'::"JobStatus"
+          AND (scheduled_for IS NULL OR scheduled_for <= now())
+          AND type = ANY(${types}::text[])
+        ORDER BY priority ASC, created_at ASC
+        FOR UPDATE SKIP LOCKED
+        LIMIT ${limit}
+      )
+      UPDATE jobs SET
+        status = 'running'::"JobStatus",
+        started_at = now(),
+        scheduled_for = NULL,
+        attempts = attempts + 1,
+        claimed_by_node_id = ${nodeId}::uuid,
+        -- Minted here, by the server, once per updated row. See the file
+        -- header: a bound parameter would give the whole batch one token and
+        -- would identify the process rather than the claim.
+        claim_token = gen_random_uuid(),
+        executor = ${executor},
+        lease_expires_at = now() + (l.lease_ms::double precision * interval '1 millisecond')
+      FROM picked p, unnest(${types}::text[], ${leaseValues}::double precision[]) AS l(type, lease_ms)
+      WHERE jobs.id = p.id AND jobs.type = l.type
+      RETURNING ${CLAIM_RETURNING}
+    `);
+        if (rows.length > 0) {
+            this.metrics.jobsClaimedBy(executor, rows.map((row) => row.type));
+            this.logger.debug(`Claimed ${rows.length} job(s) as ${executor}` +
+                `${nodeId ? ` (node ${nodeId})` : ''}: ` +
+                rows.map((row) => `${row.id} (${row.type})`).join(', '));
+        }
+        return rows;
+    }
+};
+exports.JobClaimService = JobClaimService;
+exports.JobClaimService = JobClaimService = JobClaimService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(index_1.PLATFORM_PRISMA)),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(ports_1.JOBS_METRICS)),
+    __metadata("design:paramtypes", [Object, Object])
+], JobClaimService);
+//# sourceMappingURL=job-claim.service.js.map

package/dist/jobs/job-claim.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-claim.service.js","sourceRoot":"","sources":["../../src/jobs/job-claim.service.ts"],"names":[],"mappings":"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"}