dpdp-kit 0.1.2 → 0.2.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/README.md +104 -10
- package/dist/audit.d.ts +1 -1
- package/dist/{chunk-MX5FRZQT.js → chunk-KVTUMHXO.js} +36 -0
- package/dist/cli.js +21 -3
- package/dist/config.d.ts +10 -0
- package/dist/data-access.d.ts +19 -0
- package/dist/dpdp.d.ts +60 -3
- package/dist/drizzle.d.ts +494 -4
- package/dist/drizzle.js +254 -3
- package/dist/erasure.d.ts +2 -1
- package/dist/errors.d.ts +1 -1
- package/dist/index.d.ts +6 -2
- package/dist/index.js +367 -22
- package/dist/records.d.ts +124 -0
- package/dist/retention.d.ts +47 -0
- package/dist/rights.d.ts +49 -0
- package/dist/run-audit.d.ts +9 -0
- package/dist/store.d.ts +9 -2
- package/package.json +1 -1
package/dist/index.js
CHANGED
|
@@ -6,15 +6,17 @@ import {
|
|
|
6
6
|
CONSENT_REQUIRED_BODY
|
|
7
7
|
} from "./chunk-FGZAH2NF.js";
|
|
8
8
|
import {
|
|
9
|
+
REQUEST_TYPES,
|
|
9
10
|
audit,
|
|
10
11
|
checkSchema,
|
|
11
12
|
durationMs,
|
|
12
13
|
guessPersonal,
|
|
13
14
|
hasErrors,
|
|
14
15
|
isDuration,
|
|
16
|
+
isRunnable,
|
|
15
17
|
maxDuration,
|
|
16
18
|
tokenize
|
|
17
|
-
} from "./chunk-
|
|
19
|
+
} from "./chunk-KVTUMHXO.js";
|
|
18
20
|
|
|
19
21
|
// src/config.ts
|
|
20
22
|
function defineConfig(config) {
|
|
@@ -24,6 +26,9 @@ function purposeNames(config) {
|
|
|
24
26
|
return Object.keys(config.purposes);
|
|
25
27
|
}
|
|
26
28
|
|
|
29
|
+
// src/dpdp.ts
|
|
30
|
+
import { randomUUID as randomUUID2 } from "crypto";
|
|
31
|
+
|
|
27
32
|
// src/erasure.ts
|
|
28
33
|
function erasureDelay(config, ended) {
|
|
29
34
|
let delay = "0d";
|
|
@@ -55,7 +60,7 @@ function planErasure(config, input) {
|
|
|
55
60
|
const allFieldsGo = fields.length === Object.keys(table.fields).length && fields.every((f) => f.action !== "keep");
|
|
56
61
|
let action;
|
|
57
62
|
if (fields.some((f) => f.action === "hold")) action = "hold";
|
|
58
|
-
else if (input.reason
|
|
63
|
+
else if (input.reason !== "withdrawal" && allFieldsGo) action = "delete-rows";
|
|
59
64
|
else if (fields.some((f) => f.action === "erase")) action = "erase-fields";
|
|
60
65
|
else action = "keep";
|
|
61
66
|
tables.push({
|
|
@@ -127,6 +132,204 @@ function isNoticeLanguage(value) {
|
|
|
127
132
|
return typeof value === "string" && Object.hasOwn(NOTICE_LANGUAGES, value);
|
|
128
133
|
}
|
|
129
134
|
|
|
135
|
+
// src/retention.ts
|
|
136
|
+
import { randomUUID } from "crypto";
|
|
137
|
+
var MAX_ATTEMPTS = 5;
|
|
138
|
+
var STALE_AFTER_MS = 15 * 60 * 1e3;
|
|
139
|
+
var addMs = (iso, ms) => new Date(Date.parse(iso) + ms).toISOString();
|
|
140
|
+
function tasksFromPlan(config, plan, now) {
|
|
141
|
+
const minimum = config.minimumRetention ?? "0d";
|
|
142
|
+
const base = { subjectId: plan.subjectId, reason: plan.reason, createdAt: now, status: "pending", attempts: 0 };
|
|
143
|
+
const due = (wait) => addMs(now, durationMs(maxDuration(wait, minimum)));
|
|
144
|
+
const tasks = [];
|
|
145
|
+
for (const table of plan.tables) {
|
|
146
|
+
if (table.action === "keep") continue;
|
|
147
|
+
if (table.action === "hold" && table.hold) {
|
|
148
|
+
const fields = table.fields.filter((f) => f.action === "hold").map((f) => f.field);
|
|
149
|
+
tasks.push({
|
|
150
|
+
...base,
|
|
151
|
+
id: randomUUID(),
|
|
152
|
+
kind: table.hold.then === "delete" ? "delete-rows" : "erase-fields",
|
|
153
|
+
table: table.key,
|
|
154
|
+
...table.hold.then === "delete" ? {} : { fields },
|
|
155
|
+
dueAt: due(table.hold.keep)
|
|
156
|
+
});
|
|
157
|
+
continue;
|
|
158
|
+
}
|
|
159
|
+
const erasable = table.fields.filter((f) => f.action === "erase");
|
|
160
|
+
const wait = erasable.reduce((d, f) => f.after ? maxDuration(d, f.after) : d, "0d");
|
|
161
|
+
tasks.push({
|
|
162
|
+
...base,
|
|
163
|
+
id: randomUUID(),
|
|
164
|
+
kind: table.action === "delete-rows" ? "delete-rows" : "erase-fields",
|
|
165
|
+
table: table.key,
|
|
166
|
+
...table.action === "delete-rows" ? {} : { fields: erasable.map((f) => f.field) },
|
|
167
|
+
dueAt: due(wait)
|
|
168
|
+
});
|
|
169
|
+
}
|
|
170
|
+
for (const processor of plan.processors) {
|
|
171
|
+
tasks.push({ ...base, id: randomUUID(), kind: "processor-stop", processor: processor.name, purposes: processor.ended, dueAt: now });
|
|
172
|
+
if (processor.action === "erase") {
|
|
173
|
+
tasks.push({
|
|
174
|
+
...base,
|
|
175
|
+
id: randomUUID(),
|
|
176
|
+
kind: "processor-erase",
|
|
177
|
+
processor: processor.name,
|
|
178
|
+
purposes: processor.ended,
|
|
179
|
+
dueAt: due("0d")
|
|
180
|
+
});
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
return tasks;
|
|
184
|
+
}
|
|
185
|
+
var errorText = (err) => err instanceof Error ? err.message : String(err);
|
|
186
|
+
async function carryOut(task, input) {
|
|
187
|
+
if (task.kind === "processor-stop" || task.kind === "processor-erase") {
|
|
188
|
+
const hook = input.processors[task.processor ?? ""]?.[task.kind === "processor-stop" ? "stop" : "erase"];
|
|
189
|
+
if (!hook) return { manual: true };
|
|
190
|
+
await hook({ subjectId: task.subjectId, purposes: task.purposes ?? [], reason: task.reason });
|
|
191
|
+
return {};
|
|
192
|
+
}
|
|
193
|
+
const def = input.config.data[task.table ?? ""];
|
|
194
|
+
if (!def) throw new Error(`Table "${task.table}" is no longer in the data map`);
|
|
195
|
+
if (!input.data) throw new Error("No data access configured: pass `data` to createDpdp to erase from your tables");
|
|
196
|
+
if (task.kind === "delete-rows") {
|
|
197
|
+
return { affected: await input.data.deleteRows(def.table, def.subject, task.subjectId) };
|
|
198
|
+
}
|
|
199
|
+
return { affected: await input.data.eraseFields(def.table, def.subject, task.subjectId, task.fields ?? []) };
|
|
200
|
+
}
|
|
201
|
+
async function runDueTasks(input) {
|
|
202
|
+
const when = { now: input.now, staleBefore: addMs(input.now, -STALE_AFTER_MS), maxAttempts: MAX_ATTEMPTS };
|
|
203
|
+
const report = { done: [], failed: [], manual: [] };
|
|
204
|
+
for (const task of await input.store.dueTasks({ ...when, limit: input.limit })) {
|
|
205
|
+
if (!await input.store.claimTask({ id: task.id, ...when })) continue;
|
|
206
|
+
const attempts = task.attempts + 1;
|
|
207
|
+
try {
|
|
208
|
+
const result = await carryOut(task, input);
|
|
209
|
+
const { lastError: _, claimedAt: __, ...rest } = task;
|
|
210
|
+
const finished = result.manual ? { ...rest, status: "manual", attempts } : {
|
|
211
|
+
...rest,
|
|
212
|
+
status: "done",
|
|
213
|
+
attempts,
|
|
214
|
+
doneAt: input.now,
|
|
215
|
+
...result.affected !== void 0 ? { affected: result.affected } : {}
|
|
216
|
+
};
|
|
217
|
+
await input.store.updateTask(finished);
|
|
218
|
+
(result.manual ? report.manual : report.done).push(finished);
|
|
219
|
+
} catch (err) {
|
|
220
|
+
const { claimedAt: _, ...rest } = task;
|
|
221
|
+
const failed = { ...rest, status: "failed", attempts, lastError: errorText(err) };
|
|
222
|
+
await input.store.updateTask(failed);
|
|
223
|
+
report.failed.push(failed);
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
return report;
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
// src/rights.ts
|
|
230
|
+
var DEFAULT_RESPONSE_WITHIN = "90d";
|
|
231
|
+
function responseWithin(config, type) {
|
|
232
|
+
const setting = config.rights?.responseWithin;
|
|
233
|
+
if (setting === void 0) return DEFAULT_RESPONSE_WITHIN;
|
|
234
|
+
if (typeof setting === "string") return setting;
|
|
235
|
+
return setting[type] ?? DEFAULT_RESPONSE_WITHIN;
|
|
236
|
+
}
|
|
237
|
+
function dueAt(config, type, openedAt) {
|
|
238
|
+
return new Date(Date.parse(openedAt) + durationMs(responseWithin(config, type))).toISOString();
|
|
239
|
+
}
|
|
240
|
+
async function buildAccessSummary(input) {
|
|
241
|
+
const { config, data, subjectId, consents, now } = input;
|
|
242
|
+
const legitimateUses = Object.entries(config.purposes).filter(([, def]) => def.basis === "legitimate-use").map(([name]) => name);
|
|
243
|
+
const applies = /* @__PURE__ */ new Set([...consents, ...legitimateUses]);
|
|
244
|
+
const tables = [];
|
|
245
|
+
for (const [key, def] of Object.entries(config.data)) {
|
|
246
|
+
const fields = Object.entries(def.fields).map(([field, f]) => ({
|
|
247
|
+
field,
|
|
248
|
+
category: f.category,
|
|
249
|
+
purposes: [...f.purposes]
|
|
250
|
+
}));
|
|
251
|
+
const rows = await data.read(
|
|
252
|
+
def.table,
|
|
253
|
+
def.subject,
|
|
254
|
+
subjectId,
|
|
255
|
+
fields.map((f) => f.field)
|
|
256
|
+
);
|
|
257
|
+
if (rows.length > 0) tables.push({ key, table: def.table, fields, rows });
|
|
258
|
+
}
|
|
259
|
+
const sharedWith = Object.entries(config.processors ?? {}).map(([name, p]) => ({
|
|
260
|
+
name,
|
|
261
|
+
...p.description !== void 0 ? { description: p.description } : {},
|
|
262
|
+
purposes: p.purposes.filter((purpose) => applies.has(purpose))
|
|
263
|
+
})).filter((p) => p.purposes.length > 0);
|
|
264
|
+
return { subjectId, generatedAt: now, data: tables, consents, legitimateUses, sharedWith };
|
|
265
|
+
}
|
|
266
|
+
|
|
267
|
+
// src/store.ts
|
|
268
|
+
function isDpdpStore(store) {
|
|
269
|
+
const s = store;
|
|
270
|
+
return typeof s.insertRequest === "function" && typeof s.insertTasks === "function";
|
|
271
|
+
}
|
|
272
|
+
function memoryStore() {
|
|
273
|
+
const all = /* @__PURE__ */ new Map();
|
|
274
|
+
const requests = /* @__PURE__ */ new Map();
|
|
275
|
+
const tasks = /* @__PURE__ */ new Map();
|
|
276
|
+
const byDue = (a, b) => a.dueAt < b.dueAt ? -1 : a.dueAt > b.dueAt ? 1 : 0;
|
|
277
|
+
return {
|
|
278
|
+
all,
|
|
279
|
+
requests,
|
|
280
|
+
tasks,
|
|
281
|
+
async insertRequest(request) {
|
|
282
|
+
requests.set(request.id, structuredClone(request));
|
|
283
|
+
},
|
|
284
|
+
async getRequest(id) {
|
|
285
|
+
const r = requests.get(id);
|
|
286
|
+
return r && structuredClone(r);
|
|
287
|
+
},
|
|
288
|
+
async updateRequest(request) {
|
|
289
|
+
requests.set(request.id, structuredClone(request));
|
|
290
|
+
},
|
|
291
|
+
async listRequests(filter) {
|
|
292
|
+
return [...requests.values()].filter((r) => (!filter.subjectId || r.subjectId === filter.subjectId) && (!filter.status || r.status === filter.status)).sort((a, b) => a.openedAt < b.openedAt ? -1 : 1).map((r) => structuredClone(r));
|
|
293
|
+
},
|
|
294
|
+
async insertTasks(list) {
|
|
295
|
+
for (const t of list) tasks.set(t.id, structuredClone(t));
|
|
296
|
+
},
|
|
297
|
+
async dueTasks({ limit, ...when }) {
|
|
298
|
+
return [...tasks.values()].filter((t) => isRunnable(t, when)).sort(byDue).slice(0, limit).map((t) => structuredClone(t));
|
|
299
|
+
},
|
|
300
|
+
async claimTask({ id, ...when }) {
|
|
301
|
+
const t = tasks.get(id);
|
|
302
|
+
if (!t || !isRunnable(t, when)) return false;
|
|
303
|
+
tasks.set(id, { ...t, status: "running", claimedAt: when.now });
|
|
304
|
+
return true;
|
|
305
|
+
},
|
|
306
|
+
async updateTask(task) {
|
|
307
|
+
tasks.set(task.id, structuredClone(task));
|
|
308
|
+
},
|
|
309
|
+
async getTask(id) {
|
|
310
|
+
const t = tasks.get(id);
|
|
311
|
+
return t && structuredClone(t);
|
|
312
|
+
},
|
|
313
|
+
async listTasks(filter) {
|
|
314
|
+
return [...tasks.values()].filter((t) => (!filter.subjectId || t.subjectId === filter.subjectId) && (!filter.status || t.status === filter.status)).sort(byDue).map((t) => structuredClone(t));
|
|
315
|
+
},
|
|
316
|
+
async lastEvent(subjectId) {
|
|
317
|
+
const list = all.get(subjectId);
|
|
318
|
+
return list?.[list.length - 1];
|
|
319
|
+
},
|
|
320
|
+
async insert(event) {
|
|
321
|
+
const list = all.get(event.subjectId) ?? [];
|
|
322
|
+
if (list.some((e) => e.seq === event.seq)) throw new SeqConflictError(event.subjectId, event.seq);
|
|
323
|
+
list.push(structuredClone(event));
|
|
324
|
+
list.sort((a, b) => a.seq - b.seq);
|
|
325
|
+
all.set(event.subjectId, list);
|
|
326
|
+
},
|
|
327
|
+
async events(subjectId) {
|
|
328
|
+
return structuredClone(all.get(subjectId) ?? []);
|
|
329
|
+
}
|
|
330
|
+
};
|
|
331
|
+
}
|
|
332
|
+
|
|
130
333
|
// src/dpdp.ts
|
|
131
334
|
function hashEvent(event) {
|
|
132
335
|
return sha256(
|
|
@@ -222,6 +425,59 @@ ${lines.join("\n")}`, issues);
|
|
|
222
425
|
checkSubject(subjectId);
|
|
223
426
|
return [...grantedFrom(await store.events(subjectId))];
|
|
224
427
|
}
|
|
428
|
+
const nowIso = () => now().toISOString();
|
|
429
|
+
const processorHooks = options.processors ?? {};
|
|
430
|
+
function fullStore(feature) {
|
|
431
|
+
if (!isDpdpStore(store)) {
|
|
432
|
+
throw new DpdpError(
|
|
433
|
+
"store-unsupported",
|
|
434
|
+
`${feature} needs a store that keeps requests and tasks: memoryStore(), drizzleStore(db), or a full DpdpStore`
|
|
435
|
+
);
|
|
436
|
+
}
|
|
437
|
+
return store;
|
|
438
|
+
}
|
|
439
|
+
function dataAccess() {
|
|
440
|
+
if (!options.data) {
|
|
441
|
+
throw new DpdpError("no-data-access", "Pass `data` to createDpdp (e.g. drizzleData(db)) to read or erase personal data");
|
|
442
|
+
}
|
|
443
|
+
return options.data;
|
|
444
|
+
}
|
|
445
|
+
async function schedule(plan) {
|
|
446
|
+
const tasks = tasksFromPlan(config, plan, nowIso());
|
|
447
|
+
if (tasks.length > 0) await fullStore("Scheduling erasure").insertTasks(tasks);
|
|
448
|
+
return tasks;
|
|
449
|
+
}
|
|
450
|
+
async function requireRequest(id) {
|
|
451
|
+
const request = await fullStore("Rights requests").getRequest(id);
|
|
452
|
+
if (!request) throw new DpdpError("request-not-found", `No rights request with id ${JSON.stringify(id)}`);
|
|
453
|
+
return request;
|
|
454
|
+
}
|
|
455
|
+
async function close(id, status, note) {
|
|
456
|
+
const request = await requireRequest(id);
|
|
457
|
+
if (request.status !== "open") {
|
|
458
|
+
throw new DpdpError("request-closed", `Request ${id} is already ${request.status}`);
|
|
459
|
+
}
|
|
460
|
+
const at = nowIso();
|
|
461
|
+
const closed = {
|
|
462
|
+
...request,
|
|
463
|
+
status,
|
|
464
|
+
closedAt: at,
|
|
465
|
+
history: [...request.history, { at, status, ...note !== void 0 ? { note } : {} }]
|
|
466
|
+
};
|
|
467
|
+
await fullStore("Rights requests").updateRequest(closed);
|
|
468
|
+
return closed;
|
|
469
|
+
}
|
|
470
|
+
function accountPlan(subjectId, reason, keepFor) {
|
|
471
|
+
for (const p of keepFor) {
|
|
472
|
+
if (!purposes[p]) throw new DpdpError("unknown-purpose", `Unknown purpose ${JSON.stringify(p)}`);
|
|
473
|
+
}
|
|
474
|
+
return planErasure(config, {
|
|
475
|
+
subjectId,
|
|
476
|
+
reason,
|
|
477
|
+
ended: Object.keys(purposes).filter((p) => !keepFor.includes(p)),
|
|
478
|
+
remaining: [...keepFor]
|
|
479
|
+
});
|
|
480
|
+
}
|
|
225
481
|
return {
|
|
226
482
|
config,
|
|
227
483
|
consent: {
|
|
@@ -235,7 +491,8 @@ ${lines.join("\n")}`, issues);
|
|
|
235
491
|
ended: event.purposes,
|
|
236
492
|
remaining: [...legitimate, ...stillGranted]
|
|
237
493
|
});
|
|
238
|
-
|
|
494
|
+
const tasks = isDpdpStore(store) ? await schedule(erasure) : [];
|
|
495
|
+
return { event, erasure, tasks };
|
|
239
496
|
},
|
|
240
497
|
async has(subjectId, purpose) {
|
|
241
498
|
checkSubject(subjectId);
|
|
@@ -272,42 +529,127 @@ ${lines.join("\n")}`, issues);
|
|
|
272
529
|
erasure: {
|
|
273
530
|
async plan(subjectId, input) {
|
|
274
531
|
checkSubject(subjectId);
|
|
275
|
-
return
|
|
532
|
+
return accountPlan(subjectId, input.reason, []);
|
|
533
|
+
},
|
|
534
|
+
schedule,
|
|
535
|
+
async deleteAccount(subjectId) {
|
|
536
|
+
checkSubject(subjectId);
|
|
537
|
+
const plan = accountPlan(subjectId, "account-deletion", []);
|
|
538
|
+
return { plan, tasks: await schedule(plan) };
|
|
539
|
+
}
|
|
540
|
+
},
|
|
541
|
+
retention: {
|
|
542
|
+
async run(input = {}) {
|
|
543
|
+
return runDueTasks({
|
|
544
|
+
config,
|
|
545
|
+
store: fullStore("The retention runner"),
|
|
546
|
+
data: options.data,
|
|
547
|
+
processors: processorHooks,
|
|
548
|
+
now: nowIso(),
|
|
549
|
+
limit: input.limit ?? 500
|
|
550
|
+
});
|
|
551
|
+
},
|
|
552
|
+
async tasks(filter = {}) {
|
|
553
|
+
return fullStore("Erasure tasks").listTasks(filter);
|
|
554
|
+
},
|
|
555
|
+
async markDone(taskId, note) {
|
|
556
|
+
const tasks = fullStore("Erasure tasks");
|
|
557
|
+
const task = await tasks.getTask(taskId);
|
|
558
|
+
if (!task) throw new DpdpError("task-not-found", `No erasure task with id ${JSON.stringify(taskId)}`);
|
|
559
|
+
if (task.status !== "manual" && task.status !== "failed") {
|
|
560
|
+
throw new DpdpError("task-not-manual", `Task ${taskId} is ${task.status}; only manual or failed tasks can be marked done`);
|
|
561
|
+
}
|
|
562
|
+
const done = { ...task, status: "done", doneAt: nowIso(), note };
|
|
563
|
+
await tasks.updateTask(done);
|
|
564
|
+
return done;
|
|
565
|
+
}
|
|
566
|
+
},
|
|
567
|
+
rights: {
|
|
568
|
+
async open(subjectId, type, details) {
|
|
569
|
+
checkSubject(subjectId);
|
|
570
|
+
if (!REQUEST_TYPES.includes(type)) {
|
|
571
|
+
throw new DpdpError("invalid-request-type", `Unknown request type ${JSON.stringify(type)}`);
|
|
572
|
+
}
|
|
573
|
+
const openedAt = nowIso();
|
|
574
|
+
const request = {
|
|
575
|
+
id: randomUUID2(),
|
|
276
576
|
subjectId,
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
577
|
+
type,
|
|
578
|
+
status: "open",
|
|
579
|
+
openedAt,
|
|
580
|
+
dueAt: dueAt(config, type, openedAt),
|
|
581
|
+
...details !== void 0 ? { details: structuredClone(details) } : {},
|
|
582
|
+
history: [{ at: openedAt, status: "open" }]
|
|
583
|
+
};
|
|
584
|
+
await fullStore("Rights requests").insertRequest(request);
|
|
585
|
+
return request;
|
|
586
|
+
},
|
|
587
|
+
get: (id) => fullStore("Rights requests").getRequest(id),
|
|
588
|
+
async list(filter = {}) {
|
|
589
|
+
const { overdue, ...rest } = filter;
|
|
590
|
+
const list = await fullStore("Rights requests").listRequests(overdue ? { ...rest, status: "open" } : rest);
|
|
591
|
+
if (!overdue) return list;
|
|
592
|
+
const at = nowIso();
|
|
593
|
+
return list.filter((r) => r.dueAt < at);
|
|
594
|
+
},
|
|
595
|
+
resolve: (id, note) => close(id, "resolved", note),
|
|
596
|
+
reject: (id, reason) => close(id, "rejected", reason),
|
|
597
|
+
async summary(subjectId) {
|
|
598
|
+
checkSubject(subjectId);
|
|
599
|
+
return buildAccessSummary({
|
|
600
|
+
config,
|
|
601
|
+
data: dataAccess(),
|
|
602
|
+
subjectId,
|
|
603
|
+
consents: await activeFor(subjectId),
|
|
604
|
+
now: nowIso()
|
|
280
605
|
});
|
|
606
|
+
},
|
|
607
|
+
async erase(subjectId, input = {}) {
|
|
608
|
+
checkSubject(subjectId);
|
|
609
|
+
if (input.requestId) {
|
|
610
|
+
const request = await requireRequest(input.requestId);
|
|
611
|
+
if (request.subjectId !== subjectId) {
|
|
612
|
+
throw new DpdpError("request-not-found", `Request ${input.requestId} belongs to a different person`);
|
|
613
|
+
}
|
|
614
|
+
}
|
|
615
|
+
const plan = accountPlan(subjectId, "erasure-request", input.keepFor ?? []);
|
|
616
|
+
const tasks = await schedule(plan);
|
|
617
|
+
if (input.requestId) {
|
|
618
|
+
await close(input.requestId, "resolved", `Erasure scheduled: ${tasks.length} task(s)`);
|
|
619
|
+
}
|
|
620
|
+
return { plan, tasks };
|
|
281
621
|
}
|
|
282
622
|
}
|
|
283
623
|
};
|
|
284
624
|
}
|
|
285
625
|
|
|
286
|
-
// src/
|
|
287
|
-
function
|
|
288
|
-
const
|
|
626
|
+
// src/data-access.ts
|
|
627
|
+
function memoryData(tables) {
|
|
628
|
+
const rowsOf = (table) => tables[table] ??= [];
|
|
629
|
+
const mine = (subjectColumn, subjectId) => (row) => String(row[subjectColumn]) === subjectId;
|
|
289
630
|
return {
|
|
290
|
-
|
|
291
|
-
async
|
|
292
|
-
|
|
293
|
-
return list?.[list.length - 1];
|
|
631
|
+
tables,
|
|
632
|
+
async read(table, subjectColumn, subjectId, columns) {
|
|
633
|
+
return rowsOf(table).filter(mine(subjectColumn, subjectId)).map((row) => Object.fromEntries(columns.map((c) => [c, row[c] ?? null])));
|
|
294
634
|
},
|
|
295
|
-
async
|
|
296
|
-
const
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
list.sort((a, b) => a.seq - b.seq);
|
|
300
|
-
all.set(event.subjectId, list);
|
|
635
|
+
async eraseFields(table, subjectColumn, subjectId, columns) {
|
|
636
|
+
const rows = rowsOf(table).filter(mine(subjectColumn, subjectId));
|
|
637
|
+
for (const row of rows) for (const c of columns) row[c] = null;
|
|
638
|
+
return rows.length;
|
|
301
639
|
},
|
|
302
|
-
async
|
|
303
|
-
|
|
640
|
+
async deleteRows(table, subjectColumn, subjectId) {
|
|
641
|
+
const before = rowsOf(table).length;
|
|
642
|
+
tables[table] = rowsOf(table).filter((row) => !mine(subjectColumn, subjectId)(row));
|
|
643
|
+
return before - tables[table].length;
|
|
304
644
|
}
|
|
305
645
|
};
|
|
306
646
|
}
|
|
307
647
|
export {
|
|
308
648
|
CONSENT_REQUIRED_BODY,
|
|
649
|
+
DEFAULT_RESPONSE_WITHIN,
|
|
309
650
|
DpdpError,
|
|
310
651
|
NOTICE_LANGUAGES,
|
|
652
|
+
REQUEST_TYPES,
|
|
311
653
|
SeqConflictError,
|
|
312
654
|
audit,
|
|
313
655
|
checkSchema,
|
|
@@ -317,10 +659,13 @@ export {
|
|
|
317
659
|
guessPersonal,
|
|
318
660
|
hasErrors,
|
|
319
661
|
hashEvent,
|
|
662
|
+
isDpdpStore,
|
|
320
663
|
isDuration,
|
|
321
664
|
isNoticeLanguage,
|
|
665
|
+
memoryData,
|
|
322
666
|
memoryStore,
|
|
323
667
|
planErasure,
|
|
324
668
|
purposeNames,
|
|
669
|
+
tasksFromPlan,
|
|
325
670
|
tokenize
|
|
326
671
|
};
|
|
@@ -0,0 +1,124 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Records kept alongside consent events: rights requests (Sections 11–14) and erasure tasks
|
|
3
|
+
* (Section 8(7), Rule 8(3)).
|
|
4
|
+
*/
|
|
5
|
+
/** The rights a person can exercise under Sections 11–14 of the Act. */
|
|
6
|
+
export type RequestType = "access" | "correction" | "erasure" | "grievance" | "nomination";
|
|
7
|
+
export declare const REQUEST_TYPES: readonly RequestType[];
|
|
8
|
+
export type RequestStatus = "open" | "resolved" | "rejected";
|
|
9
|
+
export interface RequestHistoryEntry {
|
|
10
|
+
at: string;
|
|
11
|
+
status: RequestStatus;
|
|
12
|
+
note?: string;
|
|
13
|
+
}
|
|
14
|
+
/** A rights request or grievance, from the moment it's raised until it's answered. */
|
|
15
|
+
export interface RightsRequest {
|
|
16
|
+
id: string;
|
|
17
|
+
subjectId: string;
|
|
18
|
+
type: RequestType;
|
|
19
|
+
status: RequestStatus;
|
|
20
|
+
openedAt: string;
|
|
21
|
+
/** When the answer is due. */
|
|
22
|
+
dueAt: string;
|
|
23
|
+
closedAt?: string;
|
|
24
|
+
/** What the person asked for: the correction, the nominee, the grievance text… */
|
|
25
|
+
details?: Record<string, unknown>;
|
|
26
|
+
/** Every status change, oldest first, so the response can be shown later. */
|
|
27
|
+
history: RequestHistoryEntry[];
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* One step of erasing a person's data.
|
|
31
|
+
* - `erase-fields`: set the listed fields to null in that table's rows for the person.
|
|
32
|
+
* - `delete-rows`: delete the person's rows in that table.
|
|
33
|
+
* - `processor-stop`: tell a processor to stop using the data for the ended purposes (Section 6(6)).
|
|
34
|
+
* - `processor-erase`: tell a processor to erase the data (Section 8(7)(b)).
|
|
35
|
+
*/
|
|
36
|
+
export type TaskKind = "erase-fields" | "delete-rows" | "processor-stop" | "processor-erase";
|
|
37
|
+
/**
|
|
38
|
+
* - `pending`: waiting for its due date.
|
|
39
|
+
* - `running`: claimed by a runner.
|
|
40
|
+
* - `done`: carried out.
|
|
41
|
+
* - `failed`: the last attempt threw; retried on the next run (up to 5 attempts).
|
|
42
|
+
* - `manual`: needs a person, e.g. a processor with no `erase` hook. Mark it done when handled.
|
|
43
|
+
*/
|
|
44
|
+
export type TaskStatus = "pending" | "running" | "done" | "failed" | "manual";
|
|
45
|
+
export interface ErasureTask {
|
|
46
|
+
id: string;
|
|
47
|
+
subjectId: string;
|
|
48
|
+
/** Why it exists: `"withdrawal"`, `"account-deletion"` or `"erasure-request"`. */
|
|
49
|
+
reason: string;
|
|
50
|
+
kind: TaskKind;
|
|
51
|
+
/** Key in `config.data`, for table tasks. */
|
|
52
|
+
table?: string;
|
|
53
|
+
/** Field names (as in the data map), for `erase-fields`. */
|
|
54
|
+
fields?: string[];
|
|
55
|
+
/** Key in `config.processors`, for processor tasks. */
|
|
56
|
+
processor?: string;
|
|
57
|
+
/** Purposes that ended, for processor tasks. */
|
|
58
|
+
purposes?: string[];
|
|
59
|
+
createdAt: string;
|
|
60
|
+
/** Not run before this time. */
|
|
61
|
+
dueAt: string;
|
|
62
|
+
status: TaskStatus;
|
|
63
|
+
attempts: number;
|
|
64
|
+
claimedAt?: string;
|
|
65
|
+
doneAt?: string;
|
|
66
|
+
/** Rows changed, for table tasks. */
|
|
67
|
+
affected?: number;
|
|
68
|
+
/** Message from the last failure, for developers. */
|
|
69
|
+
lastError?: string;
|
|
70
|
+
/** Who or what completed a manual task. */
|
|
71
|
+
note?: string;
|
|
72
|
+
}
|
|
73
|
+
export interface RequestFilter {
|
|
74
|
+
subjectId?: string;
|
|
75
|
+
status?: RequestStatus;
|
|
76
|
+
}
|
|
77
|
+
export interface TaskFilter {
|
|
78
|
+
subjectId?: string;
|
|
79
|
+
status?: TaskStatus;
|
|
80
|
+
}
|
|
81
|
+
/** Storage for rights requests. */
|
|
82
|
+
export interface RequestStore {
|
|
83
|
+
insertRequest(request: RightsRequest): Promise<void>;
|
|
84
|
+
getRequest(id: string): Promise<RightsRequest | undefined>;
|
|
85
|
+
/** Replace a stored request. */
|
|
86
|
+
updateRequest(request: RightsRequest): Promise<void>;
|
|
87
|
+
/** Oldest first. */
|
|
88
|
+
listRequests(filter: RequestFilter): Promise<RightsRequest[]>;
|
|
89
|
+
}
|
|
90
|
+
/** Storage for erasure tasks. */
|
|
91
|
+
export interface TaskStore {
|
|
92
|
+
insertTasks(tasks: readonly ErasureTask[]): Promise<void>;
|
|
93
|
+
/**
|
|
94
|
+
* Tasks to run now: `pending` or `failed` (fewer than `maxAttempts`) with `dueAt <= now`, plus
|
|
95
|
+
* `running` tasks claimed before `staleBefore` (their runner died). Oldest due first.
|
|
96
|
+
*/
|
|
97
|
+
dueTasks(input: {
|
|
98
|
+
now: string;
|
|
99
|
+
staleBefore: string;
|
|
100
|
+
maxAttempts: number;
|
|
101
|
+
limit: number;
|
|
102
|
+
}): Promise<ErasureTask[]>;
|
|
103
|
+
/**
|
|
104
|
+
* Atomically mark a due task as `running`. Returns false if another runner got it first, so the
|
|
105
|
+
* same task is never carried out twice at once.
|
|
106
|
+
*/
|
|
107
|
+
claimTask(input: {
|
|
108
|
+
id: string;
|
|
109
|
+
now: string;
|
|
110
|
+
staleBefore: string;
|
|
111
|
+
maxAttempts: number;
|
|
112
|
+
}): Promise<boolean>;
|
|
113
|
+
/** Replace a stored task. */
|
|
114
|
+
updateTask(task: ErasureTask): Promise<void>;
|
|
115
|
+
getTask(id: string): Promise<ErasureTask | undefined>;
|
|
116
|
+
/** Oldest due first. */
|
|
117
|
+
listTasks(filter: TaskFilter): Promise<ErasureTask[]>;
|
|
118
|
+
}
|
|
119
|
+
/** Whether a task can be picked up by a runner right now. */
|
|
120
|
+
export declare function isRunnable(task: ErasureTask, { now, staleBefore, maxAttempts }: {
|
|
121
|
+
now: string;
|
|
122
|
+
staleBefore: string;
|
|
123
|
+
maxAttempts: number;
|
|
124
|
+
}): boolean;
|
|
@@ -0,0 +1,47 @@
|
|
|
1
|
+
import type { DpdpConfig } from "./config.js";
|
|
2
|
+
import type { DataAccess } from "./data-access.js";
|
|
3
|
+
import type { ErasurePlan } from "./erasure.js";
|
|
4
|
+
import type { ErasureTask, TaskStore } from "./records.js";
|
|
5
|
+
/** What a processor hook is told. */
|
|
6
|
+
export interface ProcessorHookInput {
|
|
7
|
+
subjectId: string;
|
|
8
|
+
/** Purposes that ended. */
|
|
9
|
+
purposes: string[];
|
|
10
|
+
/** `"withdrawal"`, `"account-deletion"` or `"erasure-request"`. */
|
|
11
|
+
reason: string;
|
|
12
|
+
}
|
|
13
|
+
/**
|
|
14
|
+
* How to reach a third party you shared data with. A hook should call their API (or open a ticket).
|
|
15
|
+
* Without a hook the task becomes `manual`, for a person to handle and mark done.
|
|
16
|
+
*/
|
|
17
|
+
export interface ProcessorHooks {
|
|
18
|
+
/** Stop using the person's data for the ended purposes (Section 6(6)). */
|
|
19
|
+
stop?: (input: ProcessorHookInput) => Promise<void> | void;
|
|
20
|
+
/** Erase the person's data (Section 8(7)(b)). */
|
|
21
|
+
erase?: (input: ProcessorHookInput) => Promise<void> | void;
|
|
22
|
+
}
|
|
23
|
+
export interface RunReport {
|
|
24
|
+
done: ErasureTask[];
|
|
25
|
+
failed: ErasureTask[];
|
|
26
|
+
manual: ErasureTask[];
|
|
27
|
+
}
|
|
28
|
+
export declare const MAX_ATTEMPTS = 5;
|
|
29
|
+
/** A `running` task claimed longer ago than this is assumed abandoned and picked up again. */
|
|
30
|
+
export declare const STALE_AFTER_MS: number;
|
|
31
|
+
/**
|
|
32
|
+
* Turn an erasure plan into dated tasks. Nothing is erased before the person's data has been kept
|
|
33
|
+
* for `config.minimumRetention` (Rule 8(3)), and legal holds wait for their own period. Those
|
|
34
|
+
* periods count from now, the time the plan is scheduled, which is never earlier than the last
|
|
35
|
+
* processing, so data is kept at least as long as the law requires.
|
|
36
|
+
*/
|
|
37
|
+
export declare function tasksFromPlan(config: DpdpConfig<string>, plan: ErasurePlan, now: string): ErasureTask[];
|
|
38
|
+
export interface RunInput {
|
|
39
|
+
config: DpdpConfig<string>;
|
|
40
|
+
store: TaskStore;
|
|
41
|
+
data: DataAccess | undefined;
|
|
42
|
+
processors: Record<string, ProcessorHooks>;
|
|
43
|
+
now: string;
|
|
44
|
+
limit: number;
|
|
45
|
+
}
|
|
46
|
+
/** Carry out every due task once. Safe to run from several processes at the same time. */
|
|
47
|
+
export declare function runDueTasks(input: RunInput): Promise<RunReport>;
|
package/dist/rights.d.ts
ADDED
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
import type { Category, DpdpConfig } from "./config.js";
|
|
2
|
+
import type { DataAccess } from "./data-access.js";
|
|
3
|
+
import { type Duration } from "./duration.js";
|
|
4
|
+
import type { RequestType } from "./records.js";
|
|
5
|
+
/** Default answer time: Rule 14(3) caps grievance responses at ninety days. */
|
|
6
|
+
export declare const DEFAULT_RESPONSE_WITHIN: Duration;
|
|
7
|
+
export declare function responseWithin(config: DpdpConfig<string>, type: RequestType): Duration;
|
|
8
|
+
export declare function dueAt(config: DpdpConfig<string>, type: RequestType, openedAt: string): string;
|
|
9
|
+
/**
|
|
10
|
+
* What a person gets back from an access request (Section 11(1)): (a) the personal data you
|
|
11
|
+
* process and why, and (b) who else it was shared with.
|
|
12
|
+
*/
|
|
13
|
+
export interface AccessSummary {
|
|
14
|
+
subjectId: string;
|
|
15
|
+
generatedAt: string;
|
|
16
|
+
data: Array<{
|
|
17
|
+
/** Key in `config.data`. */
|
|
18
|
+
key: string;
|
|
19
|
+
table: string;
|
|
20
|
+
fields: Array<{
|
|
21
|
+
field: string;
|
|
22
|
+
category: Category;
|
|
23
|
+
purposes: string[];
|
|
24
|
+
}>;
|
|
25
|
+
/** The person's rows, personal fields only. */
|
|
26
|
+
rows: Record<string, unknown>[];
|
|
27
|
+
}>;
|
|
28
|
+
/** Consent purposes currently granted. */
|
|
29
|
+
consents: string[];
|
|
30
|
+
/** Legitimate-use purposes that apply without consent (Section 7). */
|
|
31
|
+
legitimateUses: string[];
|
|
32
|
+
/**
|
|
33
|
+
* Processors that receive data for a purpose that applies to this person (Section 11(1)(b)).
|
|
34
|
+
* Section 11(2) exempts sharing with authorities for preventing or investigating offences;
|
|
35
|
+
* leave those out of `config.processors`.
|
|
36
|
+
*/
|
|
37
|
+
sharedWith: Array<{
|
|
38
|
+
name: string;
|
|
39
|
+
description?: string;
|
|
40
|
+
purposes: string[];
|
|
41
|
+
}>;
|
|
42
|
+
}
|
|
43
|
+
export declare function buildAccessSummary(input: {
|
|
44
|
+
config: DpdpConfig<string>;
|
|
45
|
+
data: DataAccess;
|
|
46
|
+
subjectId: string;
|
|
47
|
+
consents: string[];
|
|
48
|
+
now: string;
|
|
49
|
+
}): Promise<AccessSummary>;
|