/** * Phase 10 Task #68 — DSGVO deletion-cascade worker. * * Walks every entry in `USER_FK_MAP` and applies its declared strategy * to the rows that reference the deletion target: * * • hard-delete → `model.deleteMany({ where: { column: userId } })`. * • pseudonymize → `model.updateMany(..., { column: pseudonym.id })` * with a deterministic pseudonym (see * packages/db/src/dsgvo/pseudonymize.ts). When the * model also stores an email or other PII column, * caller-supplied `pseudonymizeRow` may rewrite it. * • retain-tombstone → `model.updateMany(..., { column: null })` — * the column is nullable per schema; the row * outlives the user but loses the reference. * * Once every entry is processed the canonical `User` row itself is * deleted (hard delete) unless `mode === 'pseudonymize'` in which case * the row is kept and the deterministic-pseudonym field set is written * via `buildUserPseudonymizationUpdate`. * * The worker is host-agnostic — the bootstrap supplies the table * client + audit writer so this file is fully unit-testable. */ import { USER_FK_MAP, type UserFkMapEntry } from "@toolctrl/db/dsgvo/user-fk-map"; import { buildUserPseudonymizationUpdate, pseudonymize } from "@toolctrl/db/dsgvo/pseudonymize"; export type DsgvoDeletionMode = "delete" | "pseudonymize"; export type DsgvoDeletionJobInput = { userId: string; tenantId: string | null; requestId: string; actorType: "user" | "admin" | "system"; actorId: string; mode: DsgvoDeletionMode; reason?: string | null; }; export type DsgvoDeletionTableResult = { model: string; column: string; strategy: UserFkMapEntry["strategy"]; affectedRows: number; }; export type DsgvoDeletionResult = { userId: string; requestId: string; mode: DsgvoDeletionMode; tables: DsgvoDeletionTableResult[]; userOutcome: "deleted" | "pseudonymized"; }; export type DsgvoDeletionTableClient = { hardDelete: (entry: UserFkMapEntry, userId: string) => Promise; pseudonymize: (entry: UserFkMapEntry, userId: string, pseudonymUserId: string) => Promise; retainTombstone: (entry: UserFkMapEntry, userId: string) => Promise; }; export type DsgvoDeletionUserClient = { hardDeleteUser: (userId: string) => Promise; pseudonymizeUser: (userId: string, update: ReturnType) => Promise; }; export type DsgvoDeletionDependencies = { tableClient: DsgvoDeletionTableClient; userClient: DsgvoDeletionUserClient; writeAuditEvent: (input: { tenantId: string | null; actorId: string; actorType: string; action: string; targetType: string; targetId: string; regulatoryScope: string[]; dataSensitivity: "pii"; outcome: "success" | "failure"; metadata: Record; }) => Promise; logger: { info: (fields: Record, msg: string) => void; error: (fields: Record, msg: string) => void }; }; export async function runDsgvoDeletion( deps: DsgvoDeletionDependencies, job: DsgvoDeletionJobInput, ): Promise { const pseudo = pseudonymize(job.userId); const tables: DsgvoDeletionTableResult[] = []; try { for (const entry of USER_FK_MAP) { let affectedRows = 0; switch (entry.strategy) { case "hard-delete": // In `mode=pseudonymize` we *still* hard-delete from join/RBAC // tables (TenantUser, UserRole, GroupUser): keeping these rows // would let the pseudonymized identity stay attached to active // workspaces, which contradicts the user's deletion intent. The // pseudonymization mode only protects retention-bound rows. affectedRows = await deps.tableClient.hardDelete(entry, job.userId); break; case "pseudonymize": affectedRows = await deps.tableClient.pseudonymize(entry, job.userId, pseudo.pseudoId); break; case "retain-tombstone": affectedRows = await deps.tableClient.retainTombstone(entry, job.userId); break; } tables.push({ model: entry.model, column: entry.column, strategy: entry.strategy, affectedRows }); } let userOutcome: "deleted" | "pseudonymized"; if (job.mode === "pseudonymize") { await deps.userClient.pseudonymizeUser(job.userId, buildUserPseudonymizationUpdate(job.userId)); userOutcome = "pseudonymized"; } else { await deps.userClient.hardDeleteUser(job.userId); userOutcome = "deleted"; } await deps.writeAuditEvent({ tenantId: job.tenantId, actorId: job.actorId, actorType: job.actorType, action: job.mode === "pseudonymize" ? "PSEUDONYMIZE_USER" : "DELETE_USER", targetType: "User", targetId: job.userId, regulatoryScope: ["gdpr"], dataSensitivity: "pii", outcome: "success", metadata: { requestId: job.requestId, mode: job.mode, tablesProcessed: tables.length, rowsAffected: tables.reduce((sum, t) => sum + t.affectedRows, 0), reason: job.reason ?? null, }, }); deps.logger.info( { userId: job.userId, requestId: job.requestId, mode: job.mode, tables: tables.length }, "dsgvo-deletion.complete", ); return { userId: job.userId, requestId: job.requestId, mode: job.mode, tables, userOutcome }; } catch (error) { deps.logger.error({ userId: job.userId, requestId: job.requestId, err: String(error) }, "dsgvo-deletion.failed"); await deps.writeAuditEvent({ tenantId: job.tenantId, actorId: job.actorId, actorType: job.actorType, action: job.mode === "pseudonymize" ? "PSEUDONYMIZE_USER" : "DELETE_USER", targetType: "User", targetId: job.userId, regulatoryScope: ["gdpr"], dataSensitivity: "pii", outcome: "failure", metadata: { requestId: job.requestId, mode: job.mode, tablesProcessed: tables.length, error: String(error), reason: job.reason ?? null, }, }); throw error; } }