Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/privacy-gdpr.server.ts
T
2026-07-08 16:15:37 +02:00

505 lines
17 KiB
TypeScript

import { getDbClient, type DbClient } from "./client.server.js";
export const GDPR_EXPORT_URL_TTL_HOURS = 72;
export const GDPR_USER_SELF_EXPORT_LIMIT_PER_24H = 3;
export const GDPR_TENANT_DELETION_GRACE_DAYS = 30;
export type GdprExportScope = "user_self" | "tenant_full";
export type GdprExportStatus = "queued" | "processing" | "ready" | "failed" | "expired";
export type TenantDeletionRequestStatus = "pending" | "cancelled" | "executing" | "completed" | "failed";
export type TenantDeletionReason = "voluntary" | "non_payment" | "suspended_violation" | "admin_initiated";
type GdprExportJobRecord = {
id: string;
tenantId: string;
requestedByUserId: string;
targetUserId: string | null;
scope: GdprExportScope;
status: GdprExportStatus;
progressPercent: number;
resultFileId: string | null;
resultBucket: string | null;
resultKey: string | null;
resultSizeBytes: number | null;
resultExpiresAt: Date | null;
downloadCount: number;
createdAt: Date;
updatedAt: Date;
};
type TenantDeletionRequestRecord = {
id: string;
tenantId: string;
requestedByUserId: string;
reason: TenantDeletionReason;
reasonText: string | null;
slugConfirmPhrase: string;
status: TenantDeletionRequestStatus;
gracePeriodEndsAt: Date;
createdAt: Date;
updatedAt: Date;
};
type AvvAcceptanceRecord = {
id: string;
tenantId: string;
acceptedByUserId: string;
avvVersion: string;
pdfFileId: string | null;
signerName: string;
signerRole: string | null;
createdAt: Date;
};
type SubprocessorRecord = {
id: string;
name: string;
purposeText: string;
country: string;
isEuEea: boolean;
dataCategories: string[];
dpaUrl: string | null;
activeSince: Date | null;
archivedAt: Date | null;
};
type GdprExportJobCreateData = {
tenantId: string;
requestedByUserId: string;
targetUserId: string | null;
scope: GdprExportScope;
status: Extract<GdprExportStatus, "queued">;
progressPercent: number;
};
type GdprExportJobUpdateData = Partial<{
status: GdprExportStatus;
progressPercent: number;
resultFileId: string | null;
resultBucket: string | null;
resultKey: string | null;
resultSizeBytes: number | null;
resultExpiresAt: Date | null;
downloadCount: { increment: number } | number;
lastDownloadedAt: Date | null;
errorMessage: string | null;
processingStartedAt: Date | null;
processingFinishedAt: Date | null;
}>;
type TenantDeletionRequestCreateData = {
tenantId: string;
requestedByUserId: string;
reason: TenantDeletionReason;
reasonText: string | null;
slugConfirmPhrase: string;
status: Extract<TenantDeletionRequestStatus, "pending">;
gracePeriodEndsAt: Date;
};
type TenantDeletionRequestUpdateData = Partial<{
status: TenantDeletionRequestStatus;
cancelledAt: Date | null;
cancelledByUserId: string | null;
hardDeleteStartedAt: Date | null;
hardDeleteEndedAt: Date | null;
errorMessage: string | null;
}>;
type AvvAcceptanceCreateData = {
tenantId: string;
acceptedByUserId: string;
acceptedIp: string | null;
acceptedUserAgent: string | null;
avvVersion: string;
pdfFileId: string | null;
signerName: string;
signerRole: string | null;
};
export type PrivacyGdprClient = {
gdprExportJob: {
count(args: { where: Record<string, unknown> }): Promise<number>;
create(args: { data: GdprExportJobCreateData }): Promise<GdprExportJobRecord>;
findMany(args: { where: Record<string, unknown>; orderBy: Record<string, string>; take?: number; skip?: number }): Promise<GdprExportJobRecord[]>;
updateMany(args: { where: Record<string, unknown>; data: GdprExportJobUpdateData }): Promise<{ count?: number }>;
};
tenantDeletionRequest: {
count(args: { where: Record<string, unknown> }): Promise<number>;
create(args: { data: TenantDeletionRequestCreateData }): Promise<TenantDeletionRequestRecord>;
findMany(args: {
where: Record<string, unknown>;
orderBy: Record<string, string> | Array<Record<string, string>>;
take?: number;
}): Promise<TenantDeletionRequestRecord[]>;
updateMany(args: { where: Record<string, unknown>; data: TenantDeletionRequestUpdateData }): Promise<{ count?: number }>;
};
avvAcceptance: {
create(args: { data: AvvAcceptanceCreateData }): Promise<AvvAcceptanceRecord>;
findMany(args: { where: Record<string, unknown>; orderBy: Record<string, string> }): Promise<AvvAcceptanceRecord[]>;
};
subprocessor: {
findMany(args: { where: Record<string, unknown>; orderBy: Record<string, string> }): Promise<SubprocessorRecord[]>;
};
};
export type CreateGdprExportJobInput = {
tenantId: string;
requestedByUserId: string;
scope: GdprExportScope;
targetUserId?: string | null;
now?: Date;
};
export type MarkGdprExportReadyInput = {
id: string;
tenantId: string;
resultFileId?: string | null;
resultBucket: string;
resultKey: string;
resultSizeBytes?: number | null;
resultExpiresAt?: Date;
now?: Date;
};
export type MarkGdprExportProcessingInput = {
id: string;
tenantId: string;
now?: Date;
};
export type MarkGdprExportFailedInput = {
id: string;
tenantId: string;
errorMessage?: string | null;
now?: Date;
};
export type CreateTenantDeletionRequestInput = {
tenantId: string;
requestedByUserId: string;
tenantSlug: string;
slugConfirmPhrase: string;
reason: TenantDeletionReason;
reasonText?: string | null;
now?: Date;
};
export type AcceptAvvInput = {
tenantId: string;
acceptedByUserId: string;
avvVersion: string;
signerName: string;
signerRole?: string | null;
pdfFileId?: string | null;
acceptedIp?: string | null;
acceptedUserAgent?: string | null;
};
function requireText(value: string, fieldName: string): string {
const trimmed = value.trim();
if (!trimmed) {
throw new Error(`${fieldName} is required.`);
}
return trimmed;
}
function hoursBefore(date: Date, hours: number): Date {
return new Date(date.getTime() - hours * 60 * 60 * 1_000);
}
function hoursAfter(date: Date, hours: number): Date {
return new Date(date.getTime() + hours * 60 * 60 * 1_000);
}
function daysAfter(date: Date, days: number): Date {
return new Date(date.getTime() + days * 24 * 60 * 60 * 1_000);
}
function clampProgress(value: number): number {
if (!Number.isFinite(value)) {
return 0;
}
return Math.max(0, Math.min(100, Math.floor(value)));
}
function redactDiagnosticText(value: string): string {
return value
.replace(/(authorization)\s*=\s*Bearer\s+\S+/gi, "$1=Bearer [REDACTED]")
.replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]")
.replace(/(password|secret|token|api[-_]?key)=\S+/gi, "$1=[REDACTED]");
}
function clientOrDefault(client?: PrivacyGdprClient): PrivacyGdprClient {
return client ?? (getDbClient() as DbClient & PrivacyGdprClient);
}
async function updateOneTenantScoped(
operation: Promise<{ count?: number }>,
errorMessage: string,
): Promise<void> {
const result = await operation;
if (typeof result.count === "number" && result.count !== 1) {
throw new Error(errorMessage);
}
}
export async function createGdprExportJob(input: CreateGdprExportJobInput, client?: PrivacyGdprClient): Promise<GdprExportJobRecord> {
const db = clientOrDefault(client);
const tenantId = requireText(input.tenantId, "tenantId");
const requestedByUserId = requireText(input.requestedByUserId, "requestedByUserId");
const targetUserId = input.scope === "user_self" ? requireText(input.targetUserId ?? requestedByUserId, "targetUserId") : (input.targetUserId?.trim() || null);
const now = input.now ?? new Date();
if (input.scope === "user_self") {
const recentSelfExports = await db.gdprExportJob.count({
where: {
tenantId,
scope: "user_self",
targetUserId,
createdAt: { gte: hoursBefore(now, 24) },
},
});
if (recentSelfExports >= GDPR_USER_SELF_EXPORT_LIMIT_PER_24H) {
throw new Error("GDPR user self export limit reached.");
}
} else {
const activeTenantExports = await db.gdprExportJob.count({
where: {
tenantId,
scope: "tenant_full",
status: { in: ["queued", "processing"] },
},
});
if (activeTenantExports > 0) {
throw new Error("A tenant GDPR export is already active.");
}
}
return db.gdprExportJob.create({
data: {
tenantId,
requestedByUserId,
targetUserId,
scope: input.scope,
status: "queued",
progressPercent: 0,
},
});
}
export async function listGdprExportJobs(
input: { tenantId: string; requestedByUserId?: string | null; take?: number; skip?: number },
client?: PrivacyGdprClient,
): Promise<GdprExportJobRecord[]> {
const tenantId = requireText(input.tenantId, "tenantId");
return clientOrDefault(client).gdprExportJob.findMany({
where: {
tenantId,
...(input.requestedByUserId ? { requestedByUserId: input.requestedByUserId } : {}),
},
orderBy: { createdAt: "desc" },
take: input.take,
skip: input.skip,
});
}
export async function markGdprExportProcessing(input: MarkGdprExportProcessingInput, client?: PrivacyGdprClient): Promise<void> {
const now = input.now ?? new Date();
await updateOneTenantScoped(
clientOrDefault(client).gdprExportJob.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId") },
data: {
status: "processing",
progressPercent: 5,
processingStartedAt: now,
processingFinishedAt: null,
errorMessage: null,
},
}),
"GDPR export job tenant scope did not match exactly one job.",
);
}
export async function markGdprExportProgress(input: { id: string; tenantId: string; progressPercent: number }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).gdprExportJob.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId") },
data: { progressPercent: clampProgress(input.progressPercent) },
}),
"GDPR export job tenant scope did not match exactly one job.",
);
}
export async function markGdprExportReady(input: MarkGdprExportReadyInput, client?: PrivacyGdprClient): Promise<void> {
const now = input.now ?? new Date();
await updateOneTenantScoped(
clientOrDefault(client).gdprExportJob.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId") },
data: {
status: "ready",
progressPercent: 100,
resultFileId: input.resultFileId ?? null,
resultBucket: requireText(input.resultBucket, "resultBucket"),
resultKey: requireText(input.resultKey, "resultKey"),
resultSizeBytes: input.resultSizeBytes ?? null,
resultExpiresAt: input.resultExpiresAt ?? hoursAfter(now, GDPR_EXPORT_URL_TTL_HOURS),
processingFinishedAt: now,
errorMessage: null,
},
}),
"GDPR export job tenant scope did not match exactly one job.",
);
}
export async function markGdprExportFailed(input: MarkGdprExportFailedInput, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).gdprExportJob.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId") },
data: {
status: "failed",
errorMessage: redactDiagnosticText(input.errorMessage ?? "GDPR export failed.").slice(0, 2_000),
processingFinishedAt: input.now ?? new Date(),
},
}),
"GDPR export job tenant scope did not match exactly one job.",
);
}
export async function markGdprExportDownloaded(input: { id: string; tenantId: string; now?: Date }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).gdprExportJob.updateMany({
where: {
id: requireText(input.id, "id"),
tenantId: requireText(input.tenantId, "tenantId"),
status: "ready",
resultExpiresAt: { gt: input.now ?? new Date() },
},
data: {
downloadCount: { increment: 1 },
lastDownloadedAt: input.now ?? new Date(),
},
}),
"GDPR export job is not ready for download or has expired.",
);
}
export async function createTenantDeletionRequest(input: CreateTenantDeletionRequestInput, client?: PrivacyGdprClient): Promise<TenantDeletionRequestRecord> {
const tenantId = requireText(input.tenantId, "tenantId");
const requestedByUserId = requireText(input.requestedByUserId, "requestedByUserId");
const tenantSlug = requireText(input.tenantSlug, "tenantSlug");
const slugConfirmPhrase = requireText(input.slugConfirmPhrase, "slugConfirmPhrase");
if (slugConfirmPhrase !== tenantSlug) {
throw new Error("Tenant deletion confirmation phrase does not match the tenant slug.");
}
const db = clientOrDefault(client);
const activeRequests = await db.tenantDeletionRequest.count({
where: { tenantId, status: { in: ["pending", "executing"] } },
});
if (activeRequests > 0) {
throw new Error("A tenant deletion request is already active.");
}
const now = input.now ?? new Date();
return db.tenantDeletionRequest.create({
data: {
tenantId,
requestedByUserId,
reason: input.reason,
reasonText: input.reasonText?.trim() || null,
slugConfirmPhrase,
status: "pending",
gracePeriodEndsAt: daysAfter(now, GDPR_TENANT_DELETION_GRACE_DAYS),
},
});
}
export async function cancelTenantDeletionRequest(input: { id: string; tenantId: string; cancelledByUserId: string; now?: Date }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).tenantDeletionRequest.updateMany({
where: {
id: requireText(input.id, "id"),
tenantId: requireText(input.tenantId, "tenantId"),
status: "pending",
},
data: {
status: "cancelled",
cancelledAt: input.now ?? new Date(),
cancelledByUserId: requireText(input.cancelledByUserId, "cancelledByUserId"),
},
}),
"Tenant deletion request is not pending or does not belong to the tenant.",
);
}
export async function listDueTenantDeletionRequests(input: { now?: Date; take?: number }, client?: PrivacyGdprClient): Promise<TenantDeletionRequestRecord[]> {
return clientOrDefault(client).tenantDeletionRequest.findMany({
where: {
status: "pending",
gracePeriodEndsAt: { lte: input.now ?? new Date() },
},
orderBy: [{ gracePeriodEndsAt: "asc" }, { id: "asc" }],
take: Math.max(1, Math.min(input.take ?? 50, 200)),
});
}
export async function markTenantDeletionExecuting(input: { id: string; tenantId: string; now?: Date }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).tenantDeletionRequest.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId"), status: "pending" },
data: { status: "executing", hardDeleteStartedAt: input.now ?? new Date(), errorMessage: null },
}),
"Tenant deletion request tenant scope did not match exactly one pending request.",
);
}
export async function markTenantDeletionCompleted(input: { id: string; tenantId: string; now?: Date }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).tenantDeletionRequest.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId"), status: "executing" },
data: { status: "completed", hardDeleteEndedAt: input.now ?? new Date(), errorMessage: null },
}),
"Tenant deletion request tenant scope did not match exactly one executing request.",
);
}
export async function markTenantDeletionFailed(input: { id: string; tenantId: string; errorMessage?: string | null }, client?: PrivacyGdprClient): Promise<void> {
await updateOneTenantScoped(
clientOrDefault(client).tenantDeletionRequest.updateMany({
where: { id: requireText(input.id, "id"), tenantId: requireText(input.tenantId, "tenantId") },
data: { status: "failed", errorMessage: redactDiagnosticText(input.errorMessage ?? "Tenant deletion failed.").slice(0, 2_000) },
}),
"Tenant deletion request tenant scope did not match exactly one request.",
);
}
export async function acceptAvv(input: AcceptAvvInput, client?: PrivacyGdprClient): Promise<AvvAcceptanceRecord> {
return clientOrDefault(client).avvAcceptance.create({
data: {
tenantId: requireText(input.tenantId, "tenantId"),
acceptedByUserId: requireText(input.acceptedByUserId, "acceptedByUserId"),
acceptedIp: input.acceptedIp?.trim() || null,
acceptedUserAgent: input.acceptedUserAgent?.trim() || null,
avvVersion: requireText(input.avvVersion, "avvVersion"),
pdfFileId: input.pdfFileId?.trim() || null,
signerName: requireText(input.signerName, "signerName"),
signerRole: input.signerRole?.trim() || null,
},
});
}
export async function listAvvAcceptances(input: { tenantId: string }, client?: PrivacyGdprClient): Promise<AvvAcceptanceRecord[]> {
return clientOrDefault(client).avvAcceptance.findMany({
where: { tenantId: requireText(input.tenantId, "tenantId") },
orderBy: { createdAt: "desc" },
});
}
export async function listActiveSubprocessors(client?: PrivacyGdprClient): Promise<SubprocessorRecord[]> {
return clientOrDefault(client).subprocessor.findMany({
where: { archivedAt: null },
orderBy: { name: "asc" },
});
}