Files
HiveGrid-Wireframes/hivegrid-cloud/apps/worker/src/jobs/dsgvo-deletion.ts
T

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;
}
}