171 lines
6.1 KiB
TypeScript
171 lines
6.1 KiB
TypeScript
/**
|
|
* 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<number>;
|
|
pseudonymize: (entry: UserFkMapEntry, userId: string, pseudonymUserId: string) => Promise<number>;
|
|
retainTombstone: (entry: UserFkMapEntry, userId: string) => Promise<number>;
|
|
};
|
|
|
|
export type DsgvoDeletionUserClient = {
|
|
hardDeleteUser: (userId: string) => Promise<void>;
|
|
pseudonymizeUser: (userId: string, update: ReturnType<typeof buildUserPseudonymizationUpdate>) => Promise<void>;
|
|
};
|
|
|
|
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<string, unknown>;
|
|
}) => Promise<void>;
|
|
logger: { info: (fields: Record<string, unknown>, msg: string) => void; error: (fields: Record<string, unknown>, msg: string) => void };
|
|
};
|
|
|
|
export async function runDsgvoDeletion(
|
|
deps: DsgvoDeletionDependencies,
|
|
job: DsgvoDeletionJobInput,
|
|
): Promise<DsgvoDeletionResult> {
|
|
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;
|
|
}
|
|
}
|