@nodii/dsar 0.20.0 → 0.23.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/bind-pattern-a.d.ts +127 -13
- package/dist/bind-pattern-a.d.ts.map +1 -1
- package/dist/bind-pattern-a.js +553 -32
- package/dist/bind-pattern-a.js.map +1 -1
- package/dist/bind-pattern-b.d.ts.map +1 -1
- package/dist/bind-pattern-b.js +58 -3
- package/dist/bind-pattern-b.js.map +1 -1
- package/dist/grpc/dsar-service.d.ts +29 -0
- package/dist/grpc/dsar-service.d.ts.map +1 -1
- package/dist/grpc/dsar-service.js +34 -0
- package/dist/grpc/dsar-service.js.map +1 -1
- package/dist/grpc/proto-path.d.ts +33 -0
- package/dist/grpc/proto-path.d.ts.map +1 -0
- package/dist/grpc/proto-path.js +87 -0
- package/dist/grpc/proto-path.js.map +1 -0
- package/dist/hold-failure-mode.d.ts +24 -0
- package/dist/hold-failure-mode.d.ts.map +1 -1
- package/dist/hold-failure-mode.js +24 -0
- package/dist/hold-failure-mode.js.map +1 -1
- package/dist/hold-gate-probe.d.ts +61 -0
- package/dist/hold-gate-probe.d.ts.map +1 -0
- package/dist/hold-gate-probe.js +146 -0
- package/dist/hold-gate-probe.js.map +1 -0
- package/dist/holds.d.ts +60 -1
- package/dist/holds.d.ts.map +1 -1
- package/dist/holds.js +60 -3
- package/dist/holds.js.map +1 -1
- package/dist/index.d.ts +16 -6
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +28 -5
- package/dist/index.js.map +1 -1
- package/dist/migrations/index.d.ts.map +1 -1
- package/dist/migrations/index.js +10 -0
- package/dist/migrations/index.js.map +1 -1
- package/dist/orchestrator.d.ts +48 -0
- package/dist/orchestrator.d.ts.map +1 -1
- package/dist/orchestrator.js +297 -20
- package/dist/orchestrator.js.map +1 -1
- package/dist/register.d.ts +35 -1
- package/dist/register.d.ts.map +1 -1
- package/dist/register.js +26 -0
- package/dist/register.js.map +1 -1
- package/dist/retention-sweeper.d.ts +252 -0
- package/dist/retention-sweeper.d.ts.map +1 -0
- package/dist/retention-sweeper.js +356 -0
- package/dist/retention-sweeper.js.map +1 -0
- package/dist/retention.d.ts +109 -1
- package/dist/retention.d.ts.map +1 -1
- package/dist/retention.js +216 -3
- package/dist/retention.js.map +1 -1
- package/dist/subject-kinds.d.ts +74 -0
- package/dist/subject-kinds.d.ts.map +1 -0
- package/dist/subject-kinds.js +141 -0
- package/dist/subject-kinds.js.map +1 -0
- package/dist/types.d.ts +423 -7
- package/dist/types.d.ts.map +1 -1
- package/dist/types.js +164 -0
- package/dist/types.js.map +1 -1
- package/package.json +7 -4
- package/proto/nodii/dsar/v1/dsar.proto +202 -0
- package/src/migrations/001-lifecycle-requests.sql +422 -0
package/dist/bind-pattern-a.js
CHANGED
|
@@ -12,35 +12,49 @@
|
|
|
12
12
|
// enforce it.
|
|
13
13
|
import { actionName } from "./audit-actions.js";
|
|
14
14
|
import { holdKindFromProto, subjectKindFromProto, } from "./grpc/dsar-service.js";
|
|
15
|
-
import {
|
|
15
|
+
import { UNKNOWN_SUBJECT_KIND_REASON, isSubjectKind, unknownSubjectKindRefusal, } from "./subject-kinds.js";
|
|
16
|
+
import { brandHoldGateRefusal, carryHoldGateRefusalBrand, HOLD_CONSULT_FAILED_REASON, HOLD_GATE_NO_SQL_CLIENT_DETAIL, holdGateRefusalAuditPayload, resolveFailClosedHolds, } from "./hold-failure-mode.js";
|
|
17
|
+
import { HOLD_GATE_PROBE_TIMEOUT_MS, HoldGateUnreachableError, probeHoldGate, } from "./hold-gate-probe.js";
|
|
16
18
|
import { isHeld, listActiveHolds } from "./holds.js";
|
|
17
19
|
import { PostgresLifecycleRequestsStore, withLifecycleIdempotency, } from "./state-store/postgres-lifecycle.js";
|
|
18
|
-
import { DEFAULT_ERASE_BLOCKING_HOLD_KINDS, MissingOutboxEmitterError, RPC_TO_COMPLIANCE_VERB, } from "./types.js";
|
|
20
|
+
import { DEFAULT_ERASE_BLOCKING_HOLD_KINDS, DEFAULT_PII_BUCKET, MissingOutboxEmitterError, MissingSqlClientForHoldGateError, RPC_TO_COMPLIANCE_VERB, RestrictedMarkerNotWritten, STATUTORY_ALREADY_TENANT_SHREDDED_REASON, STATUTORY_NOT_RETENTION_KEYED_REASON, STATUTORY_RETENTION_PARTIAL_REASON, StatutoryBucketNotRetentionKeyed, isPiiBucket, } from "./types.js";
|
|
19
21
|
/**
|
|
20
22
|
* Map a `LifecycleResponse.status` to the D239 compliance status.
|
|
21
|
-
* COMPLETED / PARTIAL → 'completed'
|
|
22
|
-
* HELD
|
|
23
|
-
* everything else (FAILED / ACCEPTED /
|
|
23
|
+
* COMPLETED / PARTIAL / NO_DATA → 'completed'
|
|
24
|
+
* HELD → 'held'
|
|
25
|
+
* everything else (FAILED / ACCEPTED / UNSPECIFIED / …) → 'failed'
|
|
24
26
|
*
|
|
25
27
|
* Hoisted to module scope (it was a `bindPatternA` closure) so the mapping is a
|
|
26
28
|
* DIRECTLY TESTABLE pure function. Before the hoist the only way to observe it
|
|
27
29
|
* was to boot a Pattern A service against a real Postgres and read the emitted
|
|
28
30
|
* outbox row back, which meant 3 of the 7 `LifecycleResponse["status"]` members
|
|
29
31
|
* (COMPLETED / FAILED / HELD) were pinned and the other 4 were unobservable in
|
|
30
|
-
* any CI job without the stack.
|
|
32
|
+
* any CI job without the stack.
|
|
31
33
|
*
|
|
32
|
-
*
|
|
33
|
-
*
|
|
34
|
-
*
|
|
35
|
-
*
|
|
36
|
-
*
|
|
37
|
-
*
|
|
38
|
-
*
|
|
39
|
-
*
|
|
34
|
+
* `NO_DATA` IS A SUCCESS (issue #713, fixed). "I hold nothing for this subject"
|
|
35
|
+
* discharges the obligation exactly as a completed erase/export does — the
|
|
36
|
+
* participant was asked, it answered truthfully, and there was nothing to act
|
|
37
|
+
* on. It used to land in the `else` arm, which recorded it as a compliance
|
|
38
|
+
* FAILURE carrying a fabricated `failureReason` ("unspecified_failure", since a
|
|
39
|
+
* NO_DATA response has no `reason`) AND wrote a `<svc>.dsar.<verb>_failed` row
|
|
40
|
+
* to the tamper-evident audit chain — a regulator-facing chain asserting a
|
|
41
|
+
* failure that never happened. The three-value compliance vocabulary
|
|
42
|
+
* (`completed` | `failed` | `held`) has no `no_data` member, so `completed` is
|
|
43
|
+
* the only truthful arm.
|
|
44
|
+
*
|
|
45
|
+
* This does NOT contradict D399. D399 governs the ORCHESTRATOR's aggregate
|
|
46
|
+
* (`toAggregatorStatus` / § 6.2), where an all-NO_DATA fan-out must not be
|
|
47
|
+
* coerced to COMPLETED and the wire `LifecycleResponse.status` stays NO_DATA
|
|
48
|
+
* verbatim. Neither is changed here; this is the participant-side collapse into
|
|
49
|
+
* the narrower D239 event vocabulary, which cannot represent NO_DATA at all.
|
|
50
|
+
*
|
|
51
|
+
* Twins: python `nodii_dsar.bind_patterns.compliance_status_for`, go
|
|
52
|
+
* `dsar.ComplianceStatusFor`. All three moved in the same commit.
|
|
40
53
|
*/
|
|
41
54
|
export function complianceStatusFor(status) {
|
|
42
|
-
if (status === "COMPLETED" || status === "PARTIAL")
|
|
55
|
+
if (status === "COMPLETED" || status === "PARTIAL" || status === "NO_DATA") {
|
|
43
56
|
return "completed";
|
|
57
|
+
}
|
|
44
58
|
if (status === "HELD")
|
|
45
59
|
return "held";
|
|
46
60
|
return "failed";
|
|
@@ -65,6 +79,63 @@ export function bindPatternA(opts) {
|
|
|
65
79
|
throw new MissingOutboxEmitterError(serviceName);
|
|
66
80
|
}
|
|
67
81
|
const outboxEmitter = opts.outboxEmitter;
|
|
82
|
+
// THE HOLD GATE MUST BE ABLE TO RUN (libs#612 → bind time).
|
|
83
|
+
//
|
|
84
|
+
// `handlers.erase` + `handlers.restrict` are REQUIRED members of
|
|
85
|
+
// PatternAHandlers, so binding Pattern A always binds the two hold-gated RPCs.
|
|
86
|
+
// With no `sqlClient` there is no holds table to consult; the gate is
|
|
87
|
+
// unconditionally fail-closed (operator ruling 2026-07-30), so both RPCs would
|
|
88
|
+
// refuse every request for the life of the process. That is a boot
|
|
89
|
+
// misconfiguration, and it now fails at BOOT — loudly, once — instead of
|
|
90
|
+
// surfacing as a `hold_consult_failed_fail_closed` on the first production
|
|
91
|
+
// erase. Same position + shape as the D239 outbox check directly above; the
|
|
92
|
+
// outbox check stays FIRST so a boot missing both still names the outbox gap.
|
|
93
|
+
if (opts.sqlClient == null || typeof opts.sqlClient.unsafe !== "function") {
|
|
94
|
+
throw new MissingSqlClientForHoldGateError(serviceName);
|
|
95
|
+
}
|
|
96
|
+
const sqlClient = opts.sqlClient;
|
|
97
|
+
// …AND IT MUST BE ABLE TO REACH THE HOLDS TABLE.
|
|
98
|
+
//
|
|
99
|
+
// The check above is STRUCTURAL — it proves an object with an `unsafe` method
|
|
100
|
+
// was passed. A pool aimed at a down host, at the WRONG database, or at one
|
|
101
|
+
// that never had `applyDsarMigrations` run satisfies it completely. The probe
|
|
102
|
+
// is the behavioural half: one bounded round-trip asserting the connection
|
|
103
|
+
// works AND `data_residency_holds` exists.
|
|
104
|
+
//
|
|
105
|
+
// `bindPatternA` is synchronous, so this CANNOT throw from here (see
|
|
106
|
+
// `hold-gate-probe.ts`). The promise is exposed as `impl.holdGateReady`, and
|
|
107
|
+
// `bindPatternAAndVerify` awaits it for callers who want the gate in one call.
|
|
108
|
+
//
|
|
109
|
+
// THE PROBE IS A DEPLOY GATE, NOT A RUNTIME LATCH — deliberately. An earlier
|
|
110
|
+
// draft had `checkHold` await it and convert a failure into a refusal, which
|
|
111
|
+
// is wrong twice over: a service that booted during a five-second DB blip
|
|
112
|
+
// would refuse every erase FOREVER (until redeployed), and the operator ruling
|
|
113
|
+
// the whole fail-closed posture rests on says the opposite —
|
|
114
|
+
// "it's just a matter of a retry when holds is accessible". A latched boot
|
|
115
|
+
// verdict is precisely the un-retryable refusal that D650's non-memoization
|
|
116
|
+
// rule exists to prevent, moved from the row cache into process memory.
|
|
117
|
+
//
|
|
118
|
+
// Nothing is lost by not latching: every condition the probe detects
|
|
119
|
+
// (unreachable pool, wrong database, unmigrated schema) ALSO makes the
|
|
120
|
+
// per-request `isHeld` consult raise, and that already produces the branded,
|
|
121
|
+
// audited, non-memoizable refusal. The runtime floor was never the probe's
|
|
122
|
+
// job. Its unique contribution is telling a DEPLOY, once, instead of telling
|
|
123
|
+
// the first production erase.
|
|
124
|
+
const holdGateProbe = probeHoldGate({
|
|
125
|
+
sql: sqlClient,
|
|
126
|
+
holdsTableName: opts.holdsTableName ?? "data_residency_holds",
|
|
127
|
+
timeoutMs: opts.holdGateProbeTimeoutMs ?? HOLD_GATE_PROBE_TIMEOUT_MS,
|
|
128
|
+
}).then((result) => {
|
|
129
|
+
if (!result.ok) {
|
|
130
|
+
throw new HoldGateUnreachableError(serviceName, result.detail, result.cause);
|
|
131
|
+
}
|
|
132
|
+
});
|
|
133
|
+
// An unawaited rejected promise is an unhandled rejection, which on modern
|
|
134
|
+
// Node CRASHES the process — turning a diagnostic into an outage for services
|
|
135
|
+
// that never opted into (1) or (2). Attach a terminal no-op handler NOW; the
|
|
136
|
+
// rejection is still delivered to everyone who awaits `holdGateProbe` itself,
|
|
137
|
+
// because attaching a handler to a promise does not consume it.
|
|
138
|
+
void holdGateProbe.catch(() => { });
|
|
68
139
|
// Hold gate is UNCONDITIONALLY fail-closed (operator ruling 2026-07-30 —
|
|
69
140
|
// fail CLOSED, all twins). This call survives only to reject the deprecated
|
|
70
141
|
// `failClosedHolds: false` loudly here (boot), where it is visible, rather
|
|
@@ -105,6 +176,15 @@ export function bindPatternA(opts) {
|
|
|
105
176
|
if (status === "held") {
|
|
106
177
|
event.statuteHoldCitation = response.statute_citation ?? "";
|
|
107
178
|
}
|
|
179
|
+
// D720 — the retained statutory classes ride the compliance event, because
|
|
180
|
+
// the wire `LifecycleResponse` has no field for them yet (adding a 7th
|
|
181
|
+
// proto field is a separate cross-repo change). Without this the orchestrator
|
|
182
|
+
// aggregating a fan-out would record "erase completed" with no trace that
|
|
183
|
+
// anything was lawfully kept.
|
|
184
|
+
if (response.retained_classes !== undefined &&
|
|
185
|
+
response.retained_classes.length > 0) {
|
|
186
|
+
event.retainedClasses = response.retained_classes;
|
|
187
|
+
}
|
|
108
188
|
return event;
|
|
109
189
|
};
|
|
110
190
|
/**
|
|
@@ -127,6 +207,15 @@ export function bindPatternA(opts) {
|
|
|
127
207
|
* treat the `tx`-carrying call as the durable terminal row.
|
|
128
208
|
*/
|
|
129
209
|
const makeInTxHook = (rpcMethod, env, dataClasses) => async (tx, response) => {
|
|
210
|
+
// D720 — the RESTRICTED marker joins the SAME tx as the lifecycle row,
|
|
211
|
+
// the compliance event and the terminal audit. A retained-statutory erase
|
|
212
|
+
// whose marker was lost to a partial commit reads, on the next audit, as
|
|
213
|
+
// a subject that was never erased at all.
|
|
214
|
+
if (rpcMethod === "EraseData" &&
|
|
215
|
+
response.retained_classes !== undefined &&
|
|
216
|
+
response.retained_classes.length > 0) {
|
|
217
|
+
await markRestricted(tx, env);
|
|
218
|
+
}
|
|
130
219
|
const event = buildComplianceEvent(rpcMethod, env, response, dataClasses);
|
|
131
220
|
await outboxEmitter(tx, event);
|
|
132
221
|
await emitTerminalAudit(tx, rpcMethod, env, response);
|
|
@@ -147,9 +236,10 @@ export function bindPatternA(opts) {
|
|
|
147
236
|
/**
|
|
148
237
|
* D239 — the TERMINAL audit row, emitted INSIDE the lifecycle tx alongside
|
|
149
238
|
* the compliance event so it commits/rolls-back atomically with both.
|
|
150
|
-
*
|
|
151
|
-
*
|
|
152
|
-
*
|
|
239
|
+
* The phase is derived from {@link complianceStatusFor}: COMPLETED / PARTIAL
|
|
240
|
+
* / NO_DATA → `completed`; HELD / FAILED / everything else → `failed`. The
|
|
241
|
+
* `tx` is passed to `auditEmitter.emit` as the second arg (additive,
|
|
242
|
+
* optional) so a tx-aware emitter writes in-tx.
|
|
153
243
|
*/
|
|
154
244
|
const emitTerminalAudit = async (tx, rpcMethod, env, response) => {
|
|
155
245
|
if (!opts.auditEmitter)
|
|
@@ -184,14 +274,213 @@ export function bindPatternA(opts) {
|
|
|
184
274
|
}, handler, inTx);
|
|
185
275
|
};
|
|
186
276
|
const eraseBlockingKinds = opts.eraseBlockingHoldKinds ?? DEFAULT_ERASE_BLOCKING_HOLD_KINDS;
|
|
277
|
+
// -------------------------------------------------------------------------
|
|
278
|
+
// D720 — the three-bucket erase declaration.
|
|
279
|
+
// -------------------------------------------------------------------------
|
|
280
|
+
/** data_class → bucket, boot-validated. Absent ⇒ operational (pre-D720). */
|
|
281
|
+
const bucketOfClass = new Map();
|
|
282
|
+
/** data_class → the statute the service registered for it. */
|
|
283
|
+
const citationOfClass = new Map();
|
|
284
|
+
for (const dc of opts.retention?.dataClasses ?? []) {
|
|
285
|
+
const bucket = dc.bucket ?? DEFAULT_PII_BUCKET;
|
|
286
|
+
if (!isPiiBucket(bucket)) {
|
|
287
|
+
// Boot-loud, same position + reason as the D719 kind check: this
|
|
288
|
+
// declaration decides whether an erase destroys a class or keeps it, and
|
|
289
|
+
// a silently-defaulted typo picks "destroy".
|
|
290
|
+
throw new Error(`bindPatternA({ serviceName: ${JSON.stringify(serviceName)} }): data class ${JSON.stringify(dc.dataClass)} declares unknown retention bucket ${JSON.stringify(bucket)} — expected statutory | operational | free_text (D720).`);
|
|
291
|
+
}
|
|
292
|
+
bucketOfClass.set(dc.dataClass, bucket);
|
|
293
|
+
if (dc.statuteCitation)
|
|
294
|
+
citationOfClass.set(dc.dataClass, dc.statuteCitation);
|
|
295
|
+
}
|
|
296
|
+
const declaredStatutoryClasses = [...bucketOfClass.entries()]
|
|
297
|
+
.filter(([, b]) => b === "statutory")
|
|
298
|
+
.map(([c]) => c);
|
|
299
|
+
// A statutory class with nowhere to stamp `restricted_at` is a half-built
|
|
300
|
+
// declaration: the erase would retain the data and leave no durable record
|
|
301
|
+
// that it did, which on the next audit is indistinguishable from an erase
|
|
302
|
+
// that silently failed. Boot-loud, not request-loud.
|
|
303
|
+
if (declaredStatutoryClasses.length > 0 &&
|
|
304
|
+
!opts.retention?.dataSubjectsTableName) {
|
|
305
|
+
throw new Error(`bindPatternA({ serviceName: ${JSON.stringify(serviceName)} }): retention.dataClasses declares statutory class(es) [${declaredStatutoryClasses.join(", ")}] but no \`retention.dataSubjectsTableName\`. D720 requires the RESTRICTED marker (\`restricted_at\`) to be stamped on <svc>_data_subjects in the same tx as the erase — a statutory retention with no marker leaves no durable record that the subject was erased as far as the law allows.`);
|
|
306
|
+
}
|
|
307
|
+
const dataSubjectsTableName = opts.retention?.dataSubjectsTableName;
|
|
308
|
+
if (dataSubjectsTableName !== undefined &&
|
|
309
|
+
!/^[a-z_][a-z0-9_]*$/.test(dataSubjectsTableName)) {
|
|
310
|
+
throw new Error(`bindPatternA({ serviceName: ${JSON.stringify(serviceName)} }): retention.dataSubjectsTableName ${JSON.stringify(dataSubjectsTableName)} is not a bare SQL identifier (/^[a-z_][a-z0-9_]*$/).`);
|
|
311
|
+
}
|
|
312
|
+
/**
|
|
313
|
+
* D720 — partition the erase scope into (destroyed, retained).
|
|
314
|
+
*
|
|
315
|
+
* `requested` is the request's `data_classes[]`. Empty means "everything the
|
|
316
|
+
* service holds", so the partition falls back to the full declared set —
|
|
317
|
+
* otherwise a class-agnostic erase would silently skip the statutory check
|
|
318
|
+
* and shred through it, which is the exact hole this closes.
|
|
319
|
+
*/
|
|
320
|
+
const partitionByBucket = (requested) => {
|
|
321
|
+
const scope = requested.length > 0 ? requested : [...bucketOfClass.keys()];
|
|
322
|
+
const destroyed = [];
|
|
323
|
+
const retained = [];
|
|
324
|
+
for (const dc of scope) {
|
|
325
|
+
// Undeclared classes default to operational — the pre-D720 behaviour.
|
|
326
|
+
if ((bucketOfClass.get(dc) ?? DEFAULT_PII_BUCKET) === "statutory") {
|
|
327
|
+
retained.push(dc);
|
|
328
|
+
}
|
|
329
|
+
else {
|
|
330
|
+
destroyed.push(dc);
|
|
331
|
+
}
|
|
332
|
+
}
|
|
333
|
+
return { destroyed, retained };
|
|
334
|
+
};
|
|
335
|
+
/**
|
|
336
|
+
* D720 — build `retained_classes[]` for the statutory classes an erase kept.
|
|
337
|
+
* The schedule lookup is best-effort per class: a class with no resolvable
|
|
338
|
+
* schedule is STILL reported (omitting it would understate what survived),
|
|
339
|
+
* carrying whatever citation the registration declared.
|
|
340
|
+
*/
|
|
341
|
+
const buildRetainedClasses = async (env, classes) => {
|
|
342
|
+
const out = [];
|
|
343
|
+
for (const dataClass of classes) {
|
|
344
|
+
let resolved = null;
|
|
345
|
+
if (opts.retention?.schedule) {
|
|
346
|
+
try {
|
|
347
|
+
resolved = await opts.retention.schedule({
|
|
348
|
+
tenantId: env.tenant_id,
|
|
349
|
+
subjectId: env.subject_id,
|
|
350
|
+
subjectKind: String(env.subject_kind),
|
|
351
|
+
dataClass,
|
|
352
|
+
});
|
|
353
|
+
}
|
|
354
|
+
catch {
|
|
355
|
+
// A schedule lookup failure must not turn a lawful retention into a
|
|
356
|
+
// failed erase. Report the class with the registered citation.
|
|
357
|
+
resolved = null;
|
|
358
|
+
}
|
|
359
|
+
}
|
|
360
|
+
const citation = resolved?.statute_citation ?? citationOfClass.get(dataClass);
|
|
361
|
+
out.push({
|
|
362
|
+
data_class: dataClass,
|
|
363
|
+
...(citation ? { statute_citation: citation } : {}),
|
|
364
|
+
...(resolved?.retained_until
|
|
365
|
+
? { retained_until: resolved.retained_until }
|
|
366
|
+
: {}),
|
|
367
|
+
});
|
|
368
|
+
}
|
|
369
|
+
return out;
|
|
370
|
+
};
|
|
371
|
+
/**
|
|
372
|
+
* D720 — the anti-silent-shred probe. Before an erase whose scope includes a
|
|
373
|
+
* statutory class, PROVE that class is keyed to the tenant retention DEK.
|
|
374
|
+
*
|
|
375
|
+
* A `false` (or a missing probe) means the statutory data is under the
|
|
376
|
+
* per-subject DEK that `erasePerSubject` is about to NULL — so proceeding
|
|
377
|
+
* would destroy a record the law requires the tenant to keep, and would
|
|
378
|
+
* report COMPLETED while doing it. Returns a FAILED refusal instead.
|
|
379
|
+
*/
|
|
380
|
+
const checkStatutoryKeying = async (env, retained) => {
|
|
381
|
+
if (retained.length === 0)
|
|
382
|
+
return { kind: "retain" };
|
|
383
|
+
const refuse = (detail) => ({
|
|
384
|
+
kind: "refuse",
|
|
385
|
+
response: {
|
|
386
|
+
request_id: env.request_id,
|
|
387
|
+
status: "FAILED",
|
|
388
|
+
reason: STATUTORY_NOT_RETENTION_KEYED_REASON,
|
|
389
|
+
retention_gate_error: detail,
|
|
390
|
+
},
|
|
391
|
+
});
|
|
392
|
+
const probe = opts.pii?.retentionDekState;
|
|
393
|
+
if (typeof probe !== "function") {
|
|
394
|
+
return refuse(new StatutoryBucketNotRetentionKeyed(serviceName, env.tenant_id, retained, "adapter_missing_probe").message);
|
|
395
|
+
}
|
|
396
|
+
let state;
|
|
397
|
+
try {
|
|
398
|
+
state = await probe.call(opts.pii, env.tenant_id);
|
|
399
|
+
}
|
|
400
|
+
catch (err) {
|
|
401
|
+
// Fail-CLOSED, for the same reason the hold gate does: we cannot show the
|
|
402
|
+
// statutory data is safe, and the operation is irreversible.
|
|
403
|
+
return refuse(err instanceof Error ? err.message : String(err));
|
|
404
|
+
}
|
|
405
|
+
if (state === "present")
|
|
406
|
+
return { kind: "retain" };
|
|
407
|
+
if (state === "erased") {
|
|
408
|
+
// The D105 tenant shred already destroyed the statutory ciphertext. There
|
|
409
|
+
// is nothing left to protect, so the erase PROCEEDS. Refusing here would
|
|
410
|
+
// permanently block every Art. 17 request for a closed tenant AND blame a
|
|
411
|
+
// misconfiguration that does not exist.
|
|
412
|
+
return { kind: "already_erased" };
|
|
413
|
+
}
|
|
414
|
+
// state === "absent" — the real misconfiguration.
|
|
415
|
+
return refuse(new StatutoryBucketNotRetentionKeyed(serviceName, env.tenant_id, retained, "no_retention_dek").message);
|
|
416
|
+
};
|
|
417
|
+
/**
|
|
418
|
+
* D720 — stamp the RESTRICTED marker on `<svc>_data_subjects`.
|
|
419
|
+
*
|
|
420
|
+
* Runs on `tx` (the lifecycle transaction) so the marker, the lifecycle row,
|
|
421
|
+
* the compliance event and the terminal audit all commit or all roll back:
|
|
422
|
+
* a subject whose statutory data was retained but whose marker was lost is a
|
|
423
|
+
* subject the next audit reads as never-erased.
|
|
424
|
+
*
|
|
425
|
+
* Idempotent (`restricted_at = COALESCE(restricted_at, now())`) — a replayed
|
|
426
|
+
* request must not move the timestamp.
|
|
427
|
+
*/
|
|
428
|
+
const markRestricted = async (tx, env) => {
|
|
429
|
+
if (!dataSubjectsTableName)
|
|
430
|
+
return;
|
|
431
|
+
// UPSERT, not UPDATE. A STATUTORY-ONLY subject has no `data_subjects` row
|
|
432
|
+
// at all — `encryptStatutory` keys to the tenant retention DEK and never
|
|
433
|
+
// mints a per-subject DEK, so nothing ever inserted one. A plain UPDATE
|
|
434
|
+
// silently matched zero rows there, and the response went out claiming a
|
|
435
|
+
// marker that did not exist. The INSERT arm records exactly what is true:
|
|
436
|
+
// this subject exists in this service, holds NO subject DEK, and is
|
|
437
|
+
// RESTRICTED.
|
|
438
|
+
//
|
|
439
|
+
// `dek_kms_key_id` / `dek_kms_key_version` are NOT NULL in the canonical
|
|
440
|
+
// § 8 schema but describe a key this subject never had; the empty string is
|
|
441
|
+
// the sentinel for "no per-subject key was ever minted", paired with
|
|
442
|
+
// `dek_ciphertext IS NULL` which is what every reader actually checks.
|
|
443
|
+
//
|
|
444
|
+
// `erased_at` is deliberately NOT set here. It is `@nodii/pii`'s column,
|
|
445
|
+
// stamped by `executeErasePerSubject` when a crypto-shred really happens;
|
|
446
|
+
// a statutory-only subject has nothing to shred, and a second writer with
|
|
447
|
+
// different semantics would make the column unreadable. `erased_at IS NULL`
|
|
448
|
+
// + `restricted_at IS NOT NULL` is the honest record of that case.
|
|
449
|
+
//
|
|
450
|
+
// COALESCE on the update arm keeps a replayed request from moving the
|
|
451
|
+
// timestamp.
|
|
452
|
+
const rows = (await tx.unsafe(`INSERT INTO ${dataSubjectsTableName}
|
|
453
|
+
(tenant_id, subject_id, subject_kind,
|
|
454
|
+
dek_ciphertext, dek_kms_key_id, dek_kms_key_version, restricted_at)
|
|
455
|
+
VALUES ($1, $2, $3, NULL, '', '', now())
|
|
456
|
+
ON CONFLICT (tenant_id, subject_id, subject_kind)
|
|
457
|
+
DO UPDATE SET restricted_at =
|
|
458
|
+
COALESCE(${dataSubjectsTableName}.restricted_at, now())
|
|
459
|
+
RETURNING 1 AS marked`, [env.tenant_id, env.subject_id, String(env.subject_kind).toUpperCase()]));
|
|
460
|
+
// Rows-affected is checked, not assumed. Without it the whole marker is
|
|
461
|
+
// advisory: a missing table, a missing `restricted_at` column, or a missing
|
|
462
|
+
// UNIQUE constraint all fail SILENTLY and the response still promises
|
|
463
|
+
// retention.
|
|
464
|
+
if (!Array.isArray(rows) || rows.length !== 1) {
|
|
465
|
+
throw new RestrictedMarkerNotWritten(serviceName, dataSubjectsTableName, Array.isArray(rows) ? rows.length : 0);
|
|
466
|
+
}
|
|
467
|
+
};
|
|
187
468
|
/**
|
|
188
469
|
* Consult the hold table before an erase/restrict path. Returns a non-null
|
|
189
470
|
* `LifecycleResponse` when the operation must NOT proceed:
|
|
190
471
|
* - `HELD` — an active hold matched.
|
|
191
|
-
* - `FAILED` — the consult threw
|
|
192
|
-
*
|
|
472
|
+
* - `FAILED` — the consult threw, OR no `sqlClient` is configured at all
|
|
473
|
+
* (libs#612). UNCONDITIONAL: there is no mode to select, no flag to
|
|
474
|
+
* unset, and no configuration that skips the gate — operator ruling
|
|
475
|
+
* 2026-07-30; gap 3; D650.
|
|
193
476
|
* Returns `null` when the operation may proceed.
|
|
194
477
|
*
|
|
478
|
+
* The no-`sqlClient` leg is now UNREACHABLE from a successful `bindPatternA`
|
|
479
|
+
* (the bind throws {@link MissingSqlClientForHoldGateError} first) and is KEPT
|
|
480
|
+
* as defence in depth: it is the last line that turns a missing pool into a
|
|
481
|
+
* refusal rather than a skipped gate, and removing it would restore the
|
|
482
|
+
* original defect the moment anyone relaxes the bind-time check.
|
|
483
|
+
*
|
|
195
484
|
* For erase, consults the SET of blocking kinds (gap 1) + optional
|
|
196
485
|
* data_class (gap 2). For restrict, consults the legacy `restrict` gate.
|
|
197
486
|
*
|
|
@@ -201,10 +490,18 @@ export function bindPatternA(opts) {
|
|
|
201
490
|
* a matter of a retry when holds is accessible".
|
|
202
491
|
*/
|
|
203
492
|
const checkHold = async (tenantId, subjectId, gate, dataClass) => {
|
|
204
|
-
if (!opts.sqlClient)
|
|
205
|
-
return null;
|
|
206
493
|
const holdKind = gate === "erase" ? eraseBlockingKinds : "restrict";
|
|
207
494
|
try {
|
|
495
|
+
// libs#612 — NO SQL CLIENT is a hold-consult failure, not a reason to skip
|
|
496
|
+
// the gate. This used to `return null` (proceed), which made the
|
|
497
|
+
// "UNCONDITIONALLY fail-closed" docstring above literally false whenever
|
|
498
|
+
// the pool was absent: the fail-open opt-out D650 removed at FLAG level
|
|
499
|
+
// survived at CONFIG level. Raising here routes it through the exact same
|
|
500
|
+
// branded, audited, non-memoizable refusal path as an unreadable holds
|
|
501
|
+
// table — which is what "if holds is inaccessible - we deny the write"
|
|
502
|
+
// means when the inaccessibility is that we never had a connection.
|
|
503
|
+
if (!opts.sqlClient)
|
|
504
|
+
throw new Error(HOLD_GATE_NO_SQL_CLIENT_DETAIL);
|
|
208
505
|
const result = await isHeld({
|
|
209
506
|
sql: opts.sqlClient,
|
|
210
507
|
tenantId,
|
|
@@ -362,18 +659,108 @@ export function bindPatternA(opts) {
|
|
|
362
659
|
request_id: env.request_id,
|
|
363
660
|
});
|
|
364
661
|
}
|
|
662
|
+
// D720 — partition the erase scope by retention bucket BEFORE anything
|
|
663
|
+
// irreversible runs. `retained` is the statutory set: it must survive
|
|
664
|
+
// this erase, and if it cannot be shown to be keyed to the tenant
|
|
665
|
+
// retention DEK, nothing is shredded at all.
|
|
666
|
+
const { destroyed, retained } = partitionByBucket(dataClasses);
|
|
667
|
+
// Scope matters. A per-SUBJECT erase must not destroy statutory data,
|
|
668
|
+
// so it is gated. A TENANT-scope erase is the D105 whole-tenant close —
|
|
669
|
+
// there statutory destruction is the intended outcome (the CMK shred
|
|
670
|
+
// takes the retention DEK with everything else), so gating it would
|
|
671
|
+
// block the one erase that is supposed to reach the statutory bucket.
|
|
672
|
+
const verdict = scope === "subject"
|
|
673
|
+
? await checkStatutoryKeying(env, retained)
|
|
674
|
+
: { kind: "retain" };
|
|
675
|
+
if (verdict.kind === "refuse") {
|
|
676
|
+
await emitAudit("EraseData", "failed", env.tenant_id, env.subject_id, {
|
|
677
|
+
error: verdict.response.retention_gate_error,
|
|
678
|
+
statutory_classes: retained,
|
|
679
|
+
});
|
|
680
|
+
return verdict.response;
|
|
681
|
+
}
|
|
682
|
+
// The tenant key is already shredded (D105): the statutory ciphertext
|
|
683
|
+
// is dead, so nothing is RETAINED — but the rows are still not this
|
|
684
|
+
// erase's to row-delete.
|
|
685
|
+
const alreadyErased = verdict.kind === "already_erased";
|
|
365
686
|
await emitAudit("EraseData", "started", env.tenant_id, env.subject_id);
|
|
366
687
|
try {
|
|
367
688
|
if (opts.pii) {
|
|
368
689
|
if (scope === "tenant") {
|
|
690
|
+
// The tenant-wide erase IS the D105 shred — it reaches the
|
|
691
|
+
// retention DEK too, by design (the tenant is closing).
|
|
369
692
|
await opts.pii.erasePerTenant(env.tenant_id);
|
|
370
693
|
}
|
|
371
694
|
else {
|
|
695
|
+
// Per-subject crypto-shred. This destroys the operational +
|
|
696
|
+
// free_text buckets ONLY: statutory columns are under the tenant
|
|
697
|
+
// retention DEK, which no per-subject path touches (D720).
|
|
372
698
|
await opts.pii.erasePerSubject(env.tenant_id, env.subject_id, env.subject_kind);
|
|
373
699
|
}
|
|
374
700
|
}
|
|
375
|
-
|
|
376
|
-
|
|
701
|
+
// D720 — CARRY THE PARTITION INTO THE HANDLER. The crypto-shred kills
|
|
702
|
+
// the operational + free_text buckets, but it cannot stop a handler
|
|
703
|
+
// from row-deleting a statutory record, and a handler told to erase
|
|
704
|
+
// "everything for this subject" destroys exactly the rows the
|
|
705
|
+
// response is about to report as retained. So the handler is told
|
|
706
|
+
// what to destroy AND what to spare.
|
|
707
|
+
//
|
|
708
|
+
// A tenant close spares nothing: the D105 shred is meant to reach the
|
|
709
|
+
// statutory bucket, so the full scope goes to `data_classes`.
|
|
710
|
+
const handlerRetained = scope === "subject" && retained.length > 0
|
|
711
|
+
? await buildRetainedClasses(env, retained)
|
|
712
|
+
: [];
|
|
713
|
+
const handlerDestroy = scope === "tenant" ? [...destroyed, ...retained] : destroyed;
|
|
714
|
+
const classSelection = dataClasses.length > 0 ? "explicit" : "all";
|
|
715
|
+
const result = await handlers.erase({
|
|
716
|
+
...env,
|
|
717
|
+
scope,
|
|
718
|
+
data_classes: handlerDestroy,
|
|
719
|
+
retained_classes: handlerRetained,
|
|
720
|
+
class_selection: classSelection,
|
|
721
|
+
});
|
|
722
|
+
// What the SUBJECT is told. Diverges from what the HANDLER is told in
|
|
723
|
+
// the already-shredded case: the handler must still not delete those
|
|
724
|
+
// rows, but promising the subject they "survive under statute" when
|
|
725
|
+
// their key is gone would be false.
|
|
726
|
+
const retainedClasses = alreadyErased ? [] : handlerRetained;
|
|
727
|
+
const alreadyErasedClasses = alreadyErased && scope === "subject" ? [...retained] : [];
|
|
728
|
+
await emitAudit("EraseData", "completed", env.tenant_id, env.subject_id, {
|
|
729
|
+
scope,
|
|
730
|
+
artifactId: result.artifactId,
|
|
731
|
+
destroyed_classes: handlerDestroy,
|
|
732
|
+
...(retainedClasses.length > 0
|
|
733
|
+
? { retained_classes: retainedClasses }
|
|
734
|
+
: {}),
|
|
735
|
+
...(alreadyErasedClasses.length > 0
|
|
736
|
+
? { statutory_already_erased: alreadyErasedClasses }
|
|
737
|
+
: {}),
|
|
738
|
+
});
|
|
739
|
+
if (retainedClasses.length > 0) {
|
|
740
|
+
// A reasoned PARTIAL refusal: the operational + free_text buckets
|
|
741
|
+
// are gone, the statutory ones survive under statute. PARTIAL still
|
|
742
|
+
// classifies as `completed` in the D239 compliance vocabulary
|
|
743
|
+
// (complianceStatusFor) — the participant discharged the obligation
|
|
744
|
+
// as far as the law permits, which is what it is obliged to do.
|
|
745
|
+
return {
|
|
746
|
+
request_id: env.request_id,
|
|
747
|
+
status: "PARTIAL",
|
|
748
|
+
reason: STATUTORY_RETENTION_PARTIAL_REASON,
|
|
749
|
+
retained_classes: retainedClasses,
|
|
750
|
+
};
|
|
751
|
+
}
|
|
752
|
+
if (alreadyErasedClasses.length > 0) {
|
|
753
|
+
// Nothing survived, so nothing is retained and the erase is TOTAL.
|
|
754
|
+
// The note says what was already gone when the request arrived —
|
|
755
|
+
// neither a retention promise nor a misconfiguration report, both
|
|
756
|
+
// of which would be false here.
|
|
757
|
+
return {
|
|
758
|
+
request_id: env.request_id,
|
|
759
|
+
status: "COMPLETED",
|
|
760
|
+
reason: STATUTORY_ALREADY_TENANT_SHREDDED_REASON,
|
|
761
|
+
statutory_already_erased: alreadyErasedClasses,
|
|
762
|
+
};
|
|
763
|
+
}
|
|
377
764
|
return {
|
|
378
765
|
request_id: env.request_id,
|
|
379
766
|
status: "COMPLETED",
|
|
@@ -608,6 +995,18 @@ export function bindPatternA(opts) {
|
|
|
608
995
|
};
|
|
609
996
|
}
|
|
610
997
|
const retentionHoldHandlers = opts.retentionHoldHandlers;
|
|
998
|
+
// SCOPE PASSTHROUGH (drift `f65c3930`). The lift handler used to receive
|
|
999
|
+
// only `{request_id, tenant_id, subject_kind, subject_id, justification,
|
|
1000
|
+
// requested_by}` — every narrowing dimension the REQUEST carried
|
|
1001
|
+
// (`hold_kind`, `data_class`, `hold_request_id`) was DROPPED on the floor,
|
|
1002
|
+
// and `subject_id` arrived pre-flattened to `""` for a tenant-level lift by
|
|
1003
|
+
// the scalar bind rule (`String(x ?? "")`). So a handler could not tell
|
|
1004
|
+
// "lift the tenant's legal hold" from "lift subject ''"'s holds", and could
|
|
1005
|
+
// not narrow to the kind/class/dedupe-key the caller asked for — it had to
|
|
1006
|
+
// lift with whatever defaults it invented, which is precisely the
|
|
1007
|
+
// over-broad `liftHold` call drift 4a72cce1 is about. `place` (directly
|
|
1008
|
+
// above) has passed all three through since v0.4.0; `lift` never did.
|
|
1009
|
+
const subjectScoped = request.subject_id != null && String(request.subject_id) !== "";
|
|
611
1010
|
// D239 — same-tx lifecycle row +
|
|
612
1011
|
// <svc>.compliance.retention_hold_lifted.completed.v1 outbox event.
|
|
613
1012
|
return runWithIdempotency("LiftRetentionHold", request, async () => {
|
|
@@ -619,6 +1018,22 @@ export function bindPatternA(opts) {
|
|
|
619
1018
|
subject_id: env.subject_id,
|
|
620
1019
|
justification: String(request.justification ?? ""),
|
|
621
1020
|
requested_by: env.requested_by,
|
|
1021
|
+
// ALWAYS present (a derived boolean, never nullish) so the handler
|
|
1022
|
+
// branches without a nullish dance — this is the bit `subject_id:
|
|
1023
|
+
// ""` could not carry.
|
|
1024
|
+
tenant_level: !subjectScoped,
|
|
1025
|
+
// Nullish OMITS the key, exactly as `place` does (see the nullish
|
|
1026
|
+
// rule on placeHoldHandler): an explicit `null` must not reach the
|
|
1027
|
+
// handler as the literal 4-char string "null".
|
|
1028
|
+
...(request.hold_kind != null
|
|
1029
|
+
? { hold_kind: holdKindFromProto(request.hold_kind) }
|
|
1030
|
+
: {}),
|
|
1031
|
+
...(request.data_class != null
|
|
1032
|
+
? { data_class: String(request.data_class) }
|
|
1033
|
+
: {}),
|
|
1034
|
+
...(request.hold_request_id != null
|
|
1035
|
+
? { hold_request_id: String(request.hold_request_id) }
|
|
1036
|
+
: {}),
|
|
622
1037
|
});
|
|
623
1038
|
await emitAudit("LiftRetentionHold", "completed", env.tenant_id, env.subject_id);
|
|
624
1039
|
return {
|
|
@@ -726,16 +1141,122 @@ export function bindPatternA(opts) {
|
|
|
726
1141
|
};
|
|
727
1142
|
}
|
|
728
1143
|
};
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
|
|
1144
|
+
/**
|
|
1145
|
+
* D719 — the DECODE BOUNDARY guard, applied to every RPC in one place.
|
|
1146
|
+
*
|
|
1147
|
+
* `subjectKindFromProto` is a lenient decoder: it hands back whatever string
|
|
1148
|
+
* the wire carried when it does not recognise the shape. Every call site then
|
|
1149
|
+
* unchecked-cast that result into `SubjectKindStr` and carried on, so a
|
|
1150
|
+
* retired kind (`platform_admin`), a typo, or an internal DEK key SCOPE flowed
|
|
1151
|
+
* straight into `lifecycle_requests.subject_kind`, into the envelope handed to
|
|
1152
|
+
* consumer handlers, and into the hold rows — none of which any fan-out can
|
|
1153
|
+
* ever reach again (routing is subject_kind-ONLY, D486).
|
|
1154
|
+
*
|
|
1155
|
+
* Wrapping the returned impl map is deliberate: a per-handler check is a
|
|
1156
|
+
* checklist that a tenth RPC will silently skip. This runs before ANY handler
|
|
1157
|
+
* body, before `envelope()`, and before `withLifecycleIdempotency` touches the
|
|
1158
|
+
* store — so a refused request persists nothing and dispatches nothing.
|
|
1159
|
+
*/
|
|
1160
|
+
const guardSubjectKind = (rpcMethod, handler) => {
|
|
1161
|
+
return async (request) => {
|
|
1162
|
+
const decoded = subjectKindFromProto(request.subject_kind);
|
|
1163
|
+
if (isSubjectKind(decoded))
|
|
1164
|
+
return handler(request);
|
|
1165
|
+
const requestId = String(request.request_id ?? "");
|
|
1166
|
+
await emitRefusalAudit(rpcMethod, request, decoded);
|
|
1167
|
+
return unknownSubjectKindRefusal(requestId);
|
|
1168
|
+
};
|
|
1169
|
+
};
|
|
1170
|
+
/**
|
|
1171
|
+
* Best-effort audit of a decode-boundary refusal. This is the ONLY place the
|
|
1172
|
+
* offending value is recorded in full, since the wire response carries just
|
|
1173
|
+
* the stable token — without it, an operator reading the orchestrator's
|
|
1174
|
+
* `per_sibling_state` would know a sibling refused but not what it refused.
|
|
1175
|
+
*
|
|
1176
|
+
* Never allowed to convert a refusal into a crash: if the consumer's audit
|
|
1177
|
+
* emitter is broken, the refusal still returns. Refusing loudly is the
|
|
1178
|
+
* guarantee; auditing the refusal is the diagnostic on top of it.
|
|
1179
|
+
*/
|
|
1180
|
+
const emitRefusalAudit = async (rpcMethod, request, decoded) => {
|
|
1181
|
+
if (!opts.auditEmitter)
|
|
1182
|
+
return;
|
|
1183
|
+
try {
|
|
1184
|
+
await opts.auditEmitter.emit({
|
|
1185
|
+
action: actionName(opts.serviceName, rpcMethod, "failed"),
|
|
1186
|
+
target_kind: "data_subject",
|
|
1187
|
+
target_id: String(request.subject_id ?? ""),
|
|
1188
|
+
tenant_id: String(request.tenant_id ?? ""),
|
|
1189
|
+
payload: {
|
|
1190
|
+
refusal_reason: UNKNOWN_SUBJECT_KIND_REASON,
|
|
1191
|
+
rejected_subject_kind: decoded,
|
|
1192
|
+
},
|
|
1193
|
+
});
|
|
1194
|
+
}
|
|
1195
|
+
catch {
|
|
1196
|
+
// Swallowed by design — see the doc comment above.
|
|
1197
|
+
}
|
|
1198
|
+
};
|
|
1199
|
+
const impl = {
|
|
1200
|
+
AccessData: guardSubjectKind("AccessData", accessHandler),
|
|
1201
|
+
EraseData: guardSubjectKind("EraseData", eraseHandler),
|
|
1202
|
+
RectifyData: guardSubjectKind("RectifyData", rectifyHandler),
|
|
1203
|
+
ExportPortableData: guardSubjectKind("ExportPortableData", portabilityHandler),
|
|
1204
|
+
RestrictProcessing: guardSubjectKind("RestrictProcessing", restrictHandler),
|
|
1205
|
+
PlaceRetentionHold: guardSubjectKind("PlaceRetentionHold", placeHoldHandler),
|
|
1206
|
+
LiftRetentionHold: guardSubjectKind("LiftRetentionHold", liftHoldHandler),
|
|
1207
|
+
// GetLifecycleRequestStatus + ListActiveHolds are READ paths keyed on
|
|
1208
|
+
// request_id / tenant_id; `subject_kind` is an optional narrowing filter
|
|
1209
|
+
// there, not a routing or persistence key, so they are intentionally not
|
|
1210
|
+
// guarded — refusing a read because a filter is unrecognised would hide
|
|
1211
|
+
// exactly the rows an operator is trying to find while cleaning up.
|
|
737
1212
|
GetLifecycleRequestStatus: statusHandler,
|
|
738
1213
|
ListActiveHolds: listActiveHoldsHandler,
|
|
739
1214
|
};
|
|
1215
|
+
// NON-ENUMERABLE so the impl still presents EXACTLY the 9 RPC keys to
|
|
1216
|
+
// `Object.keys` / spread / `server.addService` — a 10th enumerable key would
|
|
1217
|
+
// reach every consumer that iterates the descriptor to mount handlers, and
|
|
1218
|
+
// would be registered as an RPC that does not exist on the wire.
|
|
1219
|
+
Object.defineProperty(impl, "holdGateReady", {
|
|
1220
|
+
value: holdGateProbe,
|
|
1221
|
+
enumerable: false,
|
|
1222
|
+
writable: false,
|
|
1223
|
+
configurable: false,
|
|
1224
|
+
});
|
|
1225
|
+
return impl;
|
|
1226
|
+
}
|
|
1227
|
+
/**
|
|
1228
|
+
* {@link bindPatternA} with the hold-gate probe AWAITED — the hard boot gate.
|
|
1229
|
+
*
|
|
1230
|
+
* Identical to `bindPatternA` except that it does not resolve until the probe
|
|
1231
|
+
* has succeeded, and REJECTS with {@link HoldGateUnreachableError} when it has
|
|
1232
|
+
* not. Use it at boot when a participant that cannot consult holds should fail
|
|
1233
|
+
* the deploy rather than serve refusals:
|
|
1234
|
+
*
|
|
1235
|
+
* ```ts
|
|
1236
|
+
* const dsar = await bindPatternAAndVerify({ … }); // throws if holds unreachable
|
|
1237
|
+
* ```
|
|
1238
|
+
*
|
|
1239
|
+
* The synchronous `bindPatternA` remains for callers whose boot path cannot
|
|
1240
|
+
* await; they get the same guarantee one step later by awaiting
|
|
1241
|
+
* `impl.holdGateReady`, and the same refusal at request time if they do neither.
|
|
1242
|
+
*/
|
|
1243
|
+
export async function bindPatternAAndVerify(opts) {
|
|
1244
|
+
const impl = bindPatternA(opts);
|
|
1245
|
+
await holdGateReadyOf(impl);
|
|
1246
|
+
return impl;
|
|
1247
|
+
}
|
|
1248
|
+
/**
|
|
1249
|
+
* The hold-gate probe promise attached to a `bindPatternA` impl.
|
|
1250
|
+
*
|
|
1251
|
+
* Exposed as a function rather than a typed field because `DsarServiceImpl` is
|
|
1252
|
+
* the WIRE descriptor — the 9 RPCs and nothing else — and widening it would
|
|
1253
|
+
* declare a 10th method on a shape consumers hand to `server.addService`.
|
|
1254
|
+
* Returns an already-resolved promise for impls that carry no probe (Pattern B /
|
|
1255
|
+
* Pattern C, which have no hold gate to verify), so a caller can await it
|
|
1256
|
+
* unconditionally.
|
|
1257
|
+
*/
|
|
1258
|
+
export function holdGateReadyOf(impl) {
|
|
1259
|
+
const ready = impl.holdGateReady;
|
|
1260
|
+
return ready ?? Promise.resolve();
|
|
740
1261
|
}
|
|
741
1262
|
//# sourceMappingURL=bind-pattern-a.js.map
|