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

package/dist/jobs/jobs.service.js

@@ -0,0 +1,459 @@
+"use strict";
+// =============================================================================
+// Job enqueue (issue #260, epic #254)
+// =============================================================================
+//
+// The write half of the queue: the one place a `jobs` row is created, and the
+// one place the active-dedup contract is honoured. The read half — claiming a
+// row to run — is `job-claim.service.ts`, deliberately a separate service
+// because the two have different callers (every feature enqueues; only a
+// worker or the node control plane claims) and different failure modes.
+//
+// -----------------------------------------------------------------------------
+// THE DATABASE DECIDES DEDUP, NOT A PRIOR `SELECT`
+// -----------------------------------------------------------------------------
+//
+// `enqueue` inserts OPTIMISTICALLY and treats the resulting unique violation
+// as "a duplicate is already in flight". There is no pre-flight
+// "is there already an active job with this key?" query anywhere in this file,
+// and adding one would be a regression rather than an optimisation.
+//
+// REJECTED: `findFirst`-then-`create`. It is a check-then-act race, and it is
+// racy exactly when dedup matters. Two concurrent enqueues both run the
+// `findFirst`, both see no active duplicate, and both insert — which is
+// precisely the outcome a dedup key exists to prevent. Under real load (a
+// webhook redelivered while the first delivery is still being handled, two
+// replicas reacting to the same event, a user double-clicking) that window is
+// not a rare edge case, it is the normal case. Only the database can make
+// "is there already an active job with this key" atomic with the insert that
+// would violate it, and `jobs_active_dedup_uniq_idx` — the partial UNIQUE
+// index hand-written in
+// `prisma/migrations/20260906120000_add_jobs/migration.sql` — is that
+// atomicity. The `Job` model's own block comment in `schema.prisma` records
+// the same rejection from the schema side.
+//
+// So the flow is: INSERT → catch P2002 on that specific index → re-read the
+// active row and return it. The caller cannot tell whether it created the job
+// or joined an existing one, which is the point: "this work is queued" is
+// true either way.
+//
+// -----------------------------------------------------------------------------
+// `skipDedup` IS FREE, BECAUSE POSTGRES TREATS EVERY NULL AS DISTINCT
+// -----------------------------------------------------------------------------
+//
+// `skipDedup: true` does not disable a code path, take a different branch
+// through the index, or need a second insert strategy. It simply leaves
+// `dedup_key` NULL, and a NULL is never equal to another NULL for uniqueness
+// purposes — so any number of NULL-keyed rows coexist under the same unique
+// index. The index's predicate spells `dedup_key IS NOT NULL` out explicitly
+// so that this is documented as relied upon rather than incidental.
+//
+// This is why the opt-out costs nothing: there is no "dedup off" mode, only a
+// key that no other row can collide with.
+//
+// -----------------------------------------------------------------------------
+// A DEDUP KEY IS REUSABLE ONCE ITS JOB SETTLES
+// -----------------------------------------------------------------------------
+//
+// The unique index is filtered to `status IN ('pending','running')`, so a job
+// reaching `succeeded` or `failed` drops out of the index's predicate and
+// frees its key. Re-triggering the same logical work an hour later is
+// therefore allowed; only work that is *still in flight* is collapsed. That
+// filter is also what makes the re-read below able to fail — see
+// `enqueue`'s own comments.
+// =============================================================================
+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 JobsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsService = exports.ACTIVE_DEDUP_INDEX_NAME = void 0;
+exports.isActiveDedupConflict = isActiveDedupConflict;
+const common_1 = require("@nestjs/common");
+const job_reason_1 = require("./job-reason");
+const prisma_runtime_1 = require("./data/prisma-runtime");
+const index_1 = require("../core/index");
+const ports_1 = require("./ports");
+const job_keys_1 = require("./job-keys");
+const job_trace_context_1 = require("./job-trace-context");
+const ports_2 = require("./ports");
+const job_wake_1 = require("./job-wake");
+/**
+ * The name of the partial unique index that enforces active dedup. Declared
+ * in `prisma/migrations/20260906120000_add_jobs/migration.sql`; repeated here
+ * because a P2002 has to be attributed to *this* constraint and not to some
+ * other unique constraint that may exist on `jobs` in a fork.
+  *
+  * @stability experimental
+ */
+exports.ACTIVE_DEDUP_INDEX_NAME = 'jobs_active_dedup_uniq_idx';
+/** The physical column and the Prisma field the index is built over. */
+const DEDUP_COLUMN_NAME = 'dedup_key';
+const DEDUP_FIELD_NAME = 'dedupKey';
+/**
+ * How many times `enqueue` will re-attempt the insert when the conflicting
+ * job settles out from under the re-read (see `enqueue`).
+ *
+ * BOUNDED, deliberately. An unbounded `while (true)` would be correct in
+ * theory and a livelock in practice: a pathologically hot dedup key whose
+ * jobs settle within microseconds could spin a request thread indefinitely.
+ * Three attempts covers the real race — which needs a conflicting job to
+ * finish inside the few milliseconds between the failed insert and the
+ * re-read — and turns a pathological one into a visible error instead of a
+ * hang.
+ */
+const ENQUEUE_MAX_ATTEMPTS = 3;
+/**
+ * Whether `error` is a unique-constraint violation on the ACTIVE-DEDUP index
+ * specifically — as opposed to any other P2002 the `jobs` table (or a fork's
+ * additions to it) might raise.
+ *
+ * THIS DISCRIMINATION IS LOAD-BEARING. Treating every P2002 as "already
+ * queued" would make `enqueue` return some unrelated row, or `null`-ish
+ * nonsense, for a genuine constraint bug — the exact class of error that must
+ * stay loud. Anything this function does not positively recognise propagates
+ * untouched.
+ *
+ * Two metadata shapes are inspected because Prisma reports the violation
+ * differently depending on how the client is talking to Postgres:
+ *
+ *   - Driver adapter (`@prisma/adapter-pg`, which `PrismaService` uses):
+ *     `meta.driverAdapterError.cause` carries `constraint.fields`
+ *     (`['dedup_key']`) and `originalMessage`, which names the index.
+ *   - Classic query engine: `meta.target`, either the column list or the
+ *     index name.
+ *
+ * Both are checked rather than one, so switching adapters — or a Prisma
+ * upgrade moving the detail around — degrades to "the P2002 propagates",
+ * never to "an unrelated conflict is silently swallowed".
+  *
+  * @stability experimental
+ */
+function isActiveDedupConflict(error) {
+    if (!(error instanceof prisma_runtime_1.PrismaClientKnownRequestError) || error.code !== 'P2002') {
+        return false;
+    }
+    const names = new Set([exports.ACTIVE_DEDUP_INDEX_NAME, DEDUP_COLUMN_NAME, DEDUP_FIELD_NAME]);
+    const meta = (error.meta ?? {});
+    // Shape 1: driver adapter.
+    const adapterError = meta.driverAdapterError;
+    const cause = adapterError?.cause;
+    if (cause) {
+        const constraint = cause.constraint;
+        if (Array.isArray(constraint?.fields) &&
+            constraint.fields.some((field) => names.has(String(field)))) {
+            return true;
+        }
+        if (typeof constraint?.index === 'string' && constraint.index === exports.ACTIVE_DEDUP_INDEX_NAME) {
+            return true;
+        }
+        if (typeof cause.originalMessage === 'string' &&
+            cause.originalMessage.includes(exports.ACTIVE_DEDUP_INDEX_NAME)) {
+            return true;
+        }
+    }
+    // Shape 2: classic query engine.
+    const target = meta.target;
+    if (typeof target === 'string') {
+        return names.has(target);
+    }
+    if (Array.isArray(target)) {
+        return target.some((entry) => names.has(String(entry)));
+    }
+    return false;
+}
+/**
+ * The `dedup_key` an enqueue of `input` participates under, or `null`.
+ *
+ * NULL for `skipDedup`, which is what makes the opt-out free — see the file
+ * header. THE ONLY PLACE the queue decides WHETHER a job participates in
+ * dedup; `buildDedupKey` decides only what the key looks like. Factored out
+ * of `enqueue` so `enqueueWithin` cannot answer that question differently:
+ * two entry points computing "does this job dedup?" separately is precisely
+ * how one of them ends up inserting a NULL key that the index then declines
+ * to defend.
+ */
+function resolveDedupKey(input) {
+    return input.skipDedup
+        ? null
+        : (0, job_keys_1.buildDedupKey)(input.type, input.subjectType, input.subjectId);
+}
+/**
+ * The row both enqueue paths insert.
+ *
+ * ONE BUILDER, TWO CALLERS, for the same reason `buildDedupKey` is one
+ * function with two readers: `enqueue` and `enqueueWithin` differ ONLY in
+ * which client executes the insert and in what they do with a conflict. A
+ * second literal here would let the two paths drift on `priority`,
+ * `scheduledFor` or the `payload` coalesce — a divergence that shows up as
+ * "the same work behaves differently depending on which caller queued it",
+ * which is the hardest kind of queue bug to see.
+ */
+function buildJobCreateData(input, dedupKey, orgId) {
+    // The write side of the open reason vocabulary: a typo is a bug, not a new
+    // reason. Reading a stored reason is never checked (see job-reason.ts).
+    (0, job_reason_1.assertJobReason)(input.reason);
+    return {
+        orgId,
+        type: input.type,
+        reason: input.reason,
+        subjectType: input.subjectType ?? null,
+        subjectId: input.subjectId ?? null,
+        dedupKey,
+        // `undefined` means "let the column default apply" in Prisma, which is
+        // what we want for both of these: `priority` defaults to 0, and a NULL
+        // `scheduled_for` is what makes a job eligible immediately.
+        priority: input.priority ?? undefined,
+        scheduledFor: input.scheduledFor ?? undefined,
+        payload: input.payload === undefined || input.payload === null ? undefined : input.payload,
+        // #607. The span active at THIS call — the request or cron tick queuing
+        // the work — so the job's own span (server worker) or the node that
+        // claims it can continue the same trace. Captured here, in the one
+        // builder both enqueue paths share, so neither can forget it. `null` when
+        // nothing is traced; `captureJobTraceContext` never throws.
+        traceContext: (0, job_trace_context_1.captureJobTraceContext)(),
+    };
+}
+/**
+ * Enqueues jobs: one INSERT with active dedup (`jobs_active_dedup_uniq_idx`), the organization and the trace context recorded on the row.
+ *
+ * @stability experimental
+ */
+let JobsService = JobsService_1 = class JobsService {
+    prisma;
+    metrics;
+    bus;
+    orgScope;
+    logger = new common_1.Logger(JobsService_1.name);
+    constructor(prisma, metrics = ports_1.NOOP_JOBS_METRICS, bus, orgScope) {
+        this.prisma = prisma;
+        this.metrics = metrics;
+        this.bus = bus;
+        this.orgScope = orgScope;
+    }
+    /**
+     * The job's organization: the caller's explicit `orgId` (a `null` included,
+     * never replaced), else the ambient scope's, else `null`. Annotates the
+     * active span with `org.id` (never a metric label).
+     */
+    resolveOrgId(input) {
+        const orgId = input.orgId !== undefined ? input.orgId : (this.orgScope?.currentOrgId() ?? null);
+        (0, job_trace_context_1.annotateActiveSpanWithJobOrg)(orgId);
+        return orgId;
+    }
+    /**
+     * Queues a job, collapsing it into the one already in flight for the same
+     * dedup key when there is one.
+     *
+     * Returns the row the caller should consider "their" job — either the row
+     * this call inserted, or the ACTIVE row that beat it to the key. The caller
+     * is not told which, and should not branch on it: the postcondition is "a
+     * job for this work is queued", and that is true in both cases.
+     *
+     * ⚠ WHAT THE RETURNED ROW IS, WHEN DEDUP COLLAPSED THE CALL. It is the
+     * EXISTING job, so its `reason`, `priority`, `payload` and `scheduledFor`
+     * are the *first* caller's, not this one's. That is the definition of
+     * dedup, not an oversight: the work is already queued, and a second
+     * request to do the same work is not a reason to reconfigure the job that
+     * is about to do it (or, worse, to mutate a row a worker may already have
+     * claimed). A caller that genuinely needs its own row wants
+     * `skipDedup: true`.
+     */
+    async enqueue(input) {
+        const dedupKey = resolveDedupKey(input);
+        const data = buildJobCreateData(input, dedupKey, this.resolveOrgId(input));
+        let lastConflict;
+        for (let attempt = 1; attempt <= ENQUEUE_MAX_ATTEMPTS; attempt += 1) {
+            try {
+                const created = await this.prisma.job.create({ data });
+                // Counted on an actual INSERT only — a dedup collapse below returns
+                // the existing row and is not a new job.
+                this.metrics.jobEnqueued(input.type);
+                // AFTER the INSERT, which has committed (this is not a transaction):
+                // a worker woken now can see the row it was woken for.
+                this.announceEnqueued(input);
+                return created;
+            }
+            catch (error) {
+                // Any conflict that is NOT this index's is somebody else's problem
+                // and must stay loud.
+                if (!isActiveDedupConflict(error)) {
+                    throw error;
+                }
+                lastConflict = error;
+                // The index says an ACTIVE job holds this key. Go and read it.
+                const existing = await this.findActiveByDedupKey(dedupKey);
+                if (existing) {
+                    this.logger.debug(`Job of type "${input.type}" deduplicated onto existing ` +
+                        `${existing.status} job ${existing.id} (key "${dedupKey}")`);
+                    return existing;
+                }
+                // ⚠ THE RE-READ CAN LOSE ITS OWN RACE, AND THIS IS THE EXPLICIT
+                // HANDLING OF THAT.
+                //
+                // Between the INSERT failing and this SELECT running, the job that
+                // held the key can reach `succeeded` or `failed` — at which point it
+                // drops out of the partial index's predicate, the key is free again,
+                // and there is no active row left to return. Nothing is wrong; the
+                // world simply moved on between two statements.
+                //
+                // REJECTED: returning the settled row anyway (widening the re-read to
+                // any status). The caller asked for work to be QUEUED, and handing
+                // back a job that already finished would report success for work that
+                // will never run — the worst possible answer, and unrecoverable by
+                // the caller because it cannot tell that row apart from one that is
+                // about to execute.
+                //
+                // REJECTED: throwing the P2002 to the caller. The condition it
+                // describes ("a duplicate is in flight") is no longer true by the
+                // time we would report it.
+                //
+                // So: LOOP AND INSERT AGAIN. The key is free now, so the retry
+                // normally succeeds outright; if it collides again, the next
+                // iteration's re-read finds whichever job took the key. Bounded by
+                // ENQUEUE_MAX_ATTEMPTS so a pathologically hot key becomes a visible
+                // error rather than a spin.
+                this.logger.debug(`Dedup key "${dedupKey}" was released between the conflicting ` +
+                    `insert and the re-read; retrying enqueue ` +
+                    `(attempt ${attempt}/${ENQUEUE_MAX_ATTEMPTS})`);
+            }
+        }
+        this.logger.warn(`Failed to enqueue job of type "${input.type}" after ` +
+            `${ENQUEUE_MAX_ATTEMPTS} attempts: the dedup key "${dedupKey}" kept ` +
+            `being taken and released between the insert and the re-read`);
+        throw lastConflict;
+    }
+    /**
+     * Inserts a job INSIDE A TRANSACTION THE CALLER ALREADY OWNS, letting a
+     * dedup conflict PROPAGATE instead of collapsing onto the job in flight.
+     *
+     * -------------------------------------------------------------------------
+     * WHY THIS EXISTS AT ALL, GIVEN `enqueue` DIRECTLY ABOVE IT
+     * -------------------------------------------------------------------------
+     *
+     * `enqueue` is the right answer for every caller whose job row is the only
+     * row it writes. It is the WRONG answer for a caller that must create a
+     * `jobs` row AND a row in its own table as one atomic act — the shape
+     * `db.backup.run` needs (epic #345, issue #351), where a
+     * `database_backup_runs` row is written `pending` in the same commit as the
+     * job that will execute it. Two separate statements there admit two failures
+     * that this template cannot pay for, and the backup runner's own header
+     * spells out why each is unacceptable.
+     *
+     * ⚠ IT DOES NOT RETRY, AND IT DOES NOT SWALLOW THE P2002. Both are forced,
+     * not stylistic. Postgres ABORTS A TRANSACTION at the first failed
+     * statement: every subsequent statement on that connection raises
+     * `25P02 current transaction is aborted` until the transaction ends. So
+     * `enqueue`'s catch-the-conflict-and-re-read loop is not merely unnecessary
+     * here — IT CANNOT WORK, because the re-read would run on a connection that
+     * has already given up. (Prisma exposes no SAVEPOINT, which is the only
+     * thing that would make partial recovery inside a transaction possible.)
+     *
+     * The contract is therefore: the conflict rolls the CALLER'S whole
+     * transaction back — which is exactly what a caller wants, since its own
+     * row must not exist for a job that was never created — and the caller
+     * resolves the conflict AFTER the transaction has ended, with
+     * {@link isActiveDedupConflict} and a fresh read. `queueBackup` in
+     * `db-backup-runner.service.ts` is the worked example.
+     *
+     * @throws the raw Prisma `P2002` when an active job already holds the same
+     * dedup key. Callers must classify it with {@link isActiveDedupConflict}
+     * rather than assuming every failure here is a duplicate.
+     */
+    async enqueueWithin(tx, input) {
+        const created = await tx.job.create({ data: buildJobCreateData(input, resolveDedupKey(input), this.resolveOrgId(input)) });
+        // Counted when the INSERT succeeds inside the caller's transaction; a
+        // later rollback of that transaction is not un-counted (rare, and the
+        // counter is a rate, not a ledger).
+        this.metrics.jobEnqueued(input.type);
+        // ⚠ NO `jobs.enqueued` WAKE-UP HERE (PP-1.11). This runs inside the
+        // CALLER'S transaction: the row is not visible to any other session until
+        // that transaction commits, which happens after this returns and may not
+        // happen at all. A worker woken now would claim nothing, and one woken for
+        // a rolled-back insert would be told about a job that never existed. The
+        // `JOBS_POLL_MS` poll picks the job up once the caller commits.
+        return created;
+    }
+    /**
+     * Publishes `jobs.enqueued` for a job that is due NOW, so idle workers claim
+     * it without waiting out their poll. A job scheduled for the future is left
+     * to the poll — waking a worker for a row it may not claim yet is a wasted
+     * round trip on every replica. Fire and forget: `EventBus.publish` never
+     * rejects. See `job-wake.ts`.
+     */
+    announceEnqueued(input) {
+        if (!this.bus)
+            return;
+        if (input.scheduledFor && input.scheduledFor.getTime() > Date.now())
+            return;
+        const message = { type: input.type };
+        void this.bus.publish(job_wake_1.JOBS_ENQUEUED_CHANNEL, message);
+    }
+    /**
+     * The ACTIVE (`pending` or `running`) job holding `dedupKey`, or `null`.
+     *
+     * The status filter mirrors `jobs_active_dedup_uniq_idx`'s predicate
+     * exactly, and that is the whole contract: this reads back precisely the
+     * set of rows the index was defending. Widening it would return jobs the
+     * index does not consider duplicates, which is how "already queued" starts
+     * meaning "was queued once, some time ago".
+     */
+    findActiveByDedupKey(dedupKey) {
+        return this.prisma.job.findFirst({
+            where: { dedupKey, status: { in: ['pending', 'running'] } },
+            orderBy: { createdAt: 'asc' },
+        });
+    }
+    /**
+     * Records WHICH downstream provider (and which model/version of it)
+     * actually ran a job.
+     *
+     * BEST EFFORT — THIS METHOD NEVER THROWS. `providerKey` / `modelVersion`
+     * are audit columns, written once near completion and never read by the
+     * claim query or by any scheduling decision (the `Job` model's own comment
+     * says as much). A failure to write them therefore has exactly one correct
+     * consequence: a log line. Letting it propagate would let an audit write
+     * fail a job whose real work already succeeded — turning a missing
+     * annotation into a retry of work that does not need retrying, which is
+     * strictly worse than the missing annotation.
+     *
+     * The commonest failure is entirely benign and expected: the job row was
+     * purged by queue hygiene (#263) before this ran, so the update matches
+     * nothing (`P2025`).
+     */
+    async recordProvider(jobId, providerKey, modelVersion) {
+        try {
+            await this.prisma.job.update({
+                where: { id: jobId },
+                data: { providerKey, modelVersion },
+            });
+        }
+        catch (error) {
+            this.logger.warn(`Failed to record provider audit for job ${jobId} ` +
+                `(providerKey "${providerKey}", modelVersion "${modelVersion}"): ` +
+                `${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+};
+exports.JobsService = JobsService;
+exports.JobsService = JobsService = JobsService_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)),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(ports_2.JOBS_EVENT_BUS)),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, common_1.Inject)(ports_2.JOBS_ORG_SCOPE)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], JobsService);
+//# sourceMappingURL=jobs.service.js.map

package/dist/jobs/jobs.service.js.map

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

package/dist/jobs/jobs.system-settings.d.ts

@@ -0,0 +1,94 @@
+import { type JobsSettingsPatchInput, type SystemJobsValue } from '@marinoscar/platform-contract/jobs';
+/**
+ * The `jobs` PATCH merge, field by field (there is deliberately no generic
+ * deep merge for system settings): a field the patch names replaces the stored
+ * one, an absent field is kept.
+ *
+ * @param current - the stored value.
+ * @param patch - the PATCH body's `jobs` branch, when present.
+ * @returns the merged value, never a reference into `current`.
+ *
+ * @stability experimental
+ */
+export declare function mergeJobsSettings(current: SystemJobsValue, patch?: JobsSettingsPatchInput): SystemJobsValue;
+/**
+ * The `jobs` system-settings namespace (#256, epic #254): how long finished
+ * jobs are kept, whether the nightly purge runs, and when a claimed job counts
+ * as stuck. Its defaults are {@link DEFAULT_JOBS_POLICY}. `JobsModule.forRoot()`
+ * registers it unless the app already did.
+ *
+ * @stability experimental
+ */
+export declare const JOBS_SYSTEM_SETTINGS: {
+    /** The namespace key (permanent). */
+    key: "jobs";
+    /** What it holds. */
+    description: string;
+    /** The stored shape. */
+    storedSchema: import("zod").ZodObject<{
+        history: import("zod").ZodObject<{
+            retentionDays: import("zod").ZodNumber;
+            purgeEnabled: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+        stuckThresholdMinutes: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    /** The stored partial. */
+    patchSchema: import("zod").ZodObject<{
+        history: import("zod").ZodOptional<import("zod").ZodObject<{
+            retentionDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            purgeEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        stuckThresholdMinutes: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    /** The PUT body's branch. */
+    putSchema: import("zod").ZodObject<{
+        history: import("zod").ZodObject<{
+            retentionDays: import("zod").ZodNumber;
+            purgeEnabled: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+        stuckThresholdMinutes: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    /** The PATCH body's branch. */
+    wirePatchSchema: import("zod").ZodObject<{
+        history: import("zod").ZodOptional<import("zod").ZodObject<{
+            retentionDays: import("zod").ZodOptional<import("zod").ZodNumber>;
+            purgeEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        stuckThresholdMinutes: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    /** The GET response's branch. */
+    responseSchema: import("zod").ZodObject<{
+        history: import("zod").ZodObject<{
+            retentionDays: import("zod").ZodNumber;
+            purgeEnabled: import("zod").ZodBoolean;
+        }, import("zod/v4/core").$strip>;
+        stuckThresholdMinutes: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>;
+    /** `DEFAULT_JOBS_POLICY`. */
+    defaults: {
+        history: {
+            retentionDays: number;
+            purgeEnabled: boolean;
+        };
+        stuckThresholdMinutes: number;
+    };
+    /** Optional in a PUT body: omitting it keeps the stored value, never resets it. */
+    requiredOnPut: false;
+    /** The PATCH merge (`mergeJobsSettings`). */
+    merge: typeof mergeJobsSettings;
+};
+declare module '../settings/index' {
+    interface SystemSettingsNamespaces {
+        /**
+         * Job-queue policy (#256, epic #254). REQUIRED, like every system
+         * namespace: every read goes through `readKnownSettings`, which fills the
+         * block from its defaults when storage has nothing.
+         */
+        jobs: SystemJobsValue;
+    }
+    interface SystemSettingsNamespaceDeclarations {
+        /** The `jobs` declaration. */
+        jobs: typeof JOBS_SYSTEM_SETTINGS;
+    }
+}
+//# sourceMappingURL=jobs.system-settings.d.ts.map

package/dist/jobs/jobs.system-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.system-settings.d.ts","sourceRoot":"","sources":["../../src/jobs/jobs.system-settings.ts"],"names":[],"mappings":"AAYA,OAAO,EAML,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACrB,MAAM,oCAAoC,CAAC;AAa5C;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,eAAe,EAAE,KAAK,CAAC,EAAE,sBAAsB,GAAG,eAAe,CAQ3G;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB;IAC/B,qCAAqC;;IAErC,qBAAqB;;IAErB,wBAAwB;;;;;;;;IAExB,0BAA0B;;;;;;;;IAE1B,6BAA6B;;;;;;;;IAE7B,+BAA+B;;;;;;;;IAE/B,iCAAiC;;;;;;;;IAEjC,6BAA6B;;;;;;;;IAE7B,mFAAmF;;IAEnF,6CAA6C;;CAEqC,CAAC;AAErF,OAAO,QAAQ,mBAAmB,CAAC;IACjC,UAAU,wBAAwB;QAChC;;;;WAIG;QACH,IAAI,EAAE,eAAe,CAAC;KACvB;IACD,UAAU,mCAAmC;QAC3C,8BAA8B;QAC9B,IAAI,EAAE,OAAO,oBAAoB,CAAC;KACnC;CACF"}

package/dist/jobs/jobs.system-settings.js

@@ -0,0 +1,76 @@
+"use strict";
+// =============================================================================
+// System settings namespace `jobs` (issue #865; namespace #256, epic #254)
+// =============================================================================
+//
+// A declaration file: pure data, imports only leaf modules (the schemas are
+// `@marinoscar/platform-contract/jobs`'s). `JobsModule.forRoot()` registers it
+// when the app has not (`ensureSystemSettingsNamespaces`); an app that pins
+// the stored key order lists it in its own manifest instead (the reference
+// app's `settings/registry/system-settings.manifest.ts` does). Moved from the
+// reference app's `platform/jobs/jobs.system-settings.ts`.
+// =============================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOBS_SYSTEM_SETTINGS = void 0;
+exports.mergeJobsSettings = mergeJobsSettings;
+const jobs_1 = require("@marinoscar/platform-contract/jobs");
+const jobs_policy_1 = require("./jobs.policy");
+// THE ONE PLACE THESE NUMBERS LIVE: `DEFAULT_JOBS_POLICY`, so what the reaper
+// and the purge fall back on and what a fresh row is written with are one
+// definition. Inert: `history.purgeEnabled` is the only switch that is on, and
+// it only bounds a history table.
+const JOBS_SYSTEM_DEFAULTS = {
+    history: { ...jobs_policy_1.DEFAULT_JOBS_POLICY.history },
+    stuckThresholdMinutes: jobs_policy_1.DEFAULT_JOBS_POLICY.stuckThresholdMinutes,
+};
+/**
+ * The `jobs` PATCH merge, field by field (there is deliberately no generic
+ * deep merge for system settings): a field the patch names replaces the stored
+ * one, an absent field is kept.
+ *
+ * @param current - the stored value.
+ * @param patch - the PATCH body's `jobs` branch, when present.
+ * @returns the merged value, never a reference into `current`.
+ *
+ * @stability experimental
+ */
+function mergeJobsSettings(current, patch) {
+    return {
+        history: {
+            retentionDays: patch?.history?.retentionDays ?? current.history.retentionDays,
+            purgeEnabled: patch?.history?.purgeEnabled ?? current.history.purgeEnabled,
+        },
+        stuckThresholdMinutes: patch?.stuckThresholdMinutes ?? current.stuckThresholdMinutes,
+    };
+}
+/**
+ * The `jobs` system-settings namespace (#256, epic #254): how long finished
+ * jobs are kept, whether the nightly purge runs, and when a claimed job counts
+ * as stuck. Its defaults are {@link DEFAULT_JOBS_POLICY}. `JobsModule.forRoot()`
+ * registers it unless the app already did.
+ *
+ * @stability experimental
+ */
+exports.JOBS_SYSTEM_SETTINGS = {
+    /** The namespace key (permanent). */
+    key: 'jobs',
+    /** What it holds. */
+    description: 'Job-queue policy: how long finished jobs are kept, whether they are purged, and when a claimed job counts as stuck.',
+    /** The stored shape. */
+    storedSchema: jobs_1.systemJobsSchema,
+    /** The stored partial. */
+    patchSchema: jobs_1.systemJobsPatchSchema,
+    /** The PUT body's branch. */
+    putSchema: jobs_1.jobsSettingsSchema,
+    /** The PATCH body's branch. */
+    wirePatchSchema: jobs_1.jobsSettingsPatchSchema,
+    /** The GET response's branch. */
+    responseSchema: jobs_1.jobsResponseSchema,
+    /** `DEFAULT_JOBS_POLICY`. */
+    defaults: JOBS_SYSTEM_DEFAULTS,
+    /** Optional in a PUT body: omitting it keeps the stored value, never resets it. */
+    requiredOnPut: false,
+    /** The PATCH merge (`mergeJobsSettings`). */
+    merge: mergeJobsSettings,
+};
+//# sourceMappingURL=jobs.system-settings.js.map

package/dist/jobs/jobs.system-settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jobs.system-settings.js","sourceRoot":"","sources":["../../src/jobs/jobs.system-settings.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,gFAAgF;AAChF,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,4EAA4E;AAC5E,2EAA2E;AAC3E,8EAA8E;AAC9E,2DAA2D;AAC3D,gFAAgF;;;AAkChF,8CAQC;AAxCD,6DAQ4C;AAE5C,+CAAoD;AAEpD,8EAA8E;AAC9E,0EAA0E;AAC1E,+EAA+E;AAC/E,kCAAkC;AAClC,MAAM,oBAAoB,GAAoB;IAC5C,OAAO,EAAE,EAAE,GAAG,iCAAmB,CAAC,OAAO,EAAE;IAC3C,qBAAqB,EAAE,iCAAmB,CAAC,qBAAqB;CACjE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAAC,OAAwB,EAAE,KAA8B;IACxF,OAAO;QACL,OAAO,EAAE;YACP,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,IAAI,OAAO,CAAC,OAAO,CAAC,aAAa;YAC7E,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC,YAAY;SAC3E;QACD,qBAAqB,EAAE,KAAK,EAAE,qBAAqB,IAAI,OAAO,CAAC,qBAAqB;KACrF,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACU,QAAA,oBAAoB,GAAG;IAClC,qCAAqC;IACrC,GAAG,EAAE,MAAM;IACX,qBAAqB;IACrB,WAAW,EAAE,qHAAqH;IAClI,wBAAwB;IACxB,YAAY,EAAE,uBAAgB;IAC9B,0BAA0B;IAC1B,WAAW,EAAE,4BAAqB;IAClC,6BAA6B;IAC7B,SAAS,EAAE,yBAAkB;IAC7B,+BAA+B;IAC/B,eAAe,EAAE,8BAAuB;IACxC,iCAAiC;IACjC,cAAc,EAAE,yBAAkB;IAClC,6BAA6B;IAC7B,QAAQ,EAAE,oBAAoB;IAC9B,mFAAmF;IACnF,aAAa,EAAE,KAAK;IACpB,6CAA6C;IAC7C,KAAK,EAAE,iBAAiB;CAC0D,CAAC"}