import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto"; import { getDbClient } from "./client.server.js"; import type { InboxLead, Prisma, PublicIncomingWebhookEndpoint, PublicWebhookAuthMode, PublicWebhookDeliveryLog, PublicWebhookDeliveryStatus, PublicWebhookIngestionLog, PublicWebhookSubscription, } from "./prisma-browser.js"; export const PUBLIC_API_SECRET_HASH_VERSION = 1; export const DEFAULT_PUBLIC_API_SECRET_HASH_SECRET = "public-api-secret-v1"; export const PUBLIC_WEBHOOK_MAX_DELIVERY_ATTEMPTS = 5; export const PUBLIC_WEBHOOK_AUTO_DISABLE_FAILURES = 10; export type PublicApiSecretMetadata = { hash: string; prefix: string; lastFour: string; }; export type PublicWebhookEndpointWithSecret = PublicIncomingWebhookEndpoint & { plaintextSecret: string | null; }; export type PublicWebhookSubscriptionWithSecret = PublicWebhookSubscription & { plaintextSecret: string; }; export type CreatePublicIncomingWebhookEndpointInput = { tenantId: string; slug: string; name: string; authMode: PublicWebhookAuthMode; apiKeyId?: string | null; payloadMapping?: Prisma.InputJsonValue; autoMatchRules?: Prisma.InputJsonValue; isDemoData?: boolean; }; export type CreatePublicWebhookSubscriptionInput = { tenantId: string; name: string; targetUrl: string; eventTypes: readonly string[]; createdByUserId?: string | null; isDemoData?: boolean; }; export type PublicWebhookPayload = Prisma.InputJsonValue; export type IngestPublicLeadWebhookInput = { tenantId: string; endpoint: Pick; payload: PublicWebhookPayload; requestId?: string | null; sourceIp?: string | null; }; export type IngestPublicLeadWebhookResult = { lead: InboxLead; log: PublicWebhookIngestionLog; matchedKontaktId: string | null; automationExecutionIds: string[]; }; export type EnqueuePublicWebhookEventInput = { tenantId: string; eventType: string; payload: PublicWebhookPayload; sourceEventId?: string | null; }; export type EnqueuePublicWebhookEventResult = { deliveries: PublicWebhookDeliveryLog[]; }; export type DeliverPublicWebhookInput = { deliveryId: string; tenantId: string; payload: PublicWebhookPayload; fetcher?: typeof fetch; hashSecret?: string | null; }; export type PublicWebhookDeliveryHeaders = { "Content-Type": "application/json"; "X-HiveGrid-Event": string; "X-HiveGrid-Delivery": string; "X-HiveGrid-Idempotency-Key": string; "X-HiveGrid-Timestamp": string; "X-HiveGrid-Signature": string; }; type PublicApiClient = ReturnType; export function generatePublicApiSecret(): string { return `hgwh_${randomBytes(32).toString("base64url")}`; } export function derivePublicWebhookSigningSecret(input: { tenantId: string; subscriptionId: string }, hashSecret?: string | null): string { const secret = normalizePublicApiSecretHashSecret(hashSecret); const digest = createHmac("sha256", secret).update(`${input.tenantId}:${input.subscriptionId}`).digest("base64url"); return `hgwh_${digest}`; } export function derivePublicApiSecretMetadata(secret: string, hashSecret?: string | null): PublicApiSecretMetadata { const normalizedSecret = normalizePublicApiSecretHashSecret(hashSecret); return { hash: createHmac("sha256", normalizedSecret).update(secret).digest("hex"), prefix: secret.slice(0, 10), lastFour: secret.slice(-4), }; } export function verifyPublicApiSecret(secret: string, expectedHash: string | null | undefined, hashSecret?: string | null): boolean { if (!expectedHash) { return false; } const actual = derivePublicApiSecretMetadata(secret, hashSecret).hash; return safeEqual(actual, expectedHash); } export async function createPublicIncomingWebhookEndpoint( input: CreatePublicIncomingWebhookEndpointInput, client: PublicApiClient = getDbClient(), hashSecret?: string | null, ): Promise { const plaintextSecret = input.authMode === "api_key" ? null : generatePublicApiSecret(); const metadata = plaintextSecret ? derivePublicApiSecretMetadata(plaintextSecret, hashSecret) : null; const endpoint = await client.publicIncomingWebhookEndpoint.create({ data: { tenantId: input.tenantId, slug: input.slug, name: input.name, authMode: input.authMode, apiKeyId: input.apiKeyId ?? null, tokenHash: input.authMode === "url_token" ? metadata?.hash : null, tokenPrefix: input.authMode === "url_token" ? metadata?.prefix : null, tokenLastFour: input.authMode === "url_token" ? metadata?.lastFour : null, hmacSecretHash: input.authMode === "hmac" ? metadata?.hash : null, hmacSecretPrefix: input.authMode === "hmac" ? metadata?.prefix : null, hmacSecretLastFour: input.authMode === "hmac" ? metadata?.lastFour : null, payloadMapping: input.payloadMapping ?? {}, autoMatchRules: input.autoMatchRules ?? {}, isDemoData: input.isDemoData ?? false, }, }); return { ...endpoint, plaintextSecret }; } export async function findPublicIncomingWebhookEndpoint( input: { tenantId: string; slug: string }, client: PublicApiClient = getDbClient(), ): Promise { return client.publicIncomingWebhookEndpoint.findFirst({ where: { tenantId: input.tenantId, slug: input.slug, archivedAt: null, }, }); } export async function createPublicWebhookIngestionLog( data: Prisma.PublicWebhookIngestionLogUncheckedCreateInput, client: PublicApiClient = getDbClient(), ): Promise { return client.publicWebhookIngestionLog.create({ data }); } export async function ingestPublicLeadWebhook( input: IngestPublicLeadWebhookInput, client: PublicApiClient = getDbClient(), ): Promise { const payloadHash = hashJsonValue(input.payload); const extracted = extractLeadFields(input.payload, input.endpoint.payloadMapping); return client.$transaction(async (tx) => { await tx.$executeRaw`SELECT set_config('app.tenant_id', ${input.tenantId}, true)`; const matchedKontaktId = await findMatchingKontaktId(tx, input.tenantId, extracted.email, extracted.telefon); const lead = await tx.inboxLead.create({ data: { tenantId: input.tenantId, quelle: "custom", quelleDetail: { source: "public_api_webhook", endpointId: input.endpoint.id, endpointSlug: input.endpoint.slug, requestId: input.requestId ?? null, }, sourceOrigin: `public_api:${input.endpoint.slug}`, status: "new", vorname: extracted.vorname, nachname: extracted.nachname, email: extracted.email, telefon: extracted.telefon, message: extracted.message, rohdaten: input.payload, verknuepfterKontaktId: matchedKontaktId, }, }); const automationExecutionIds = await createWebhookAutomationExecutions(tx, { tenantId: input.tenantId, endpointId: input.endpoint.id, endpointSlug: input.endpoint.slug, leadId: lead.id, payload: input.payload, payloadHash, sourceEventId: input.requestId, }); const log = await tx.publicWebhookIngestionLog.create({ data: { tenantId: input.tenantId, endpointId: input.endpoint.id, endpointSlug: input.endpoint.slug, authMode: input.endpoint.authMode, requestId: input.requestId ?? null, sourceIp: input.sourceIp ?? null, status: 201, result: "lead_created", payloadHash, payloadPreview: createPayloadPreview(input.payload), leadId: lead.id, matchedKontaktId, automationRunId: automationExecutionIds[0] ?? null, }, }); return { lead, log, matchedKontaktId, automationExecutionIds }; }); } export async function createPublicWebhookSubscription( input: CreatePublicWebhookSubscriptionInput, client: PublicApiClient = getDbClient(), hashSecret?: string | null, ): Promise { const id = randomUUID(); const plaintextSecret = derivePublicWebhookSigningSecret({ tenantId: input.tenantId, subscriptionId: id }, hashSecret); const metadata = derivePublicApiSecretMetadata(plaintextSecret, hashSecret); const subscription = await client.publicWebhookSubscription.create({ data: { id, tenantId: input.tenantId, name: input.name, targetUrl: input.targetUrl, eventTypes: [...new Set(input.eventTypes.filter(Boolean))], signingSecretHash: metadata.hash, signingSecretPrefix: metadata.prefix, signingSecretLastFour: metadata.lastFour, createdByUserId: input.createdByUserId ?? null, isDemoData: input.isDemoData ?? false, }, }); return { ...subscription, plaintextSecret }; } export async function enqueuePublicWebhookEvent( input: EnqueuePublicWebhookEventInput, client: PublicApiClient = getDbClient(), ): Promise { const payloadHash = hashJsonValue(input.payload); const subscriptions = await client.publicWebhookSubscription.findMany({ where: { tenantId: input.tenantId, status: "active", archivedAt: null, }, }); const matching = subscriptions.filter((subscription) => subscriptionMatchesEvent(subscription.eventTypes, input.eventType)); const deliveries = await Promise.all( matching.map((subscription) => client.publicWebhookDeliveryLog.create({ data: { tenantId: input.tenantId, subscriptionId: subscription.id, eventType: input.eventType, targetUrl: subscription.targetUrl, status: "queued", idempotencyKey: buildPublicWebhookIdempotencyKey({ subscriptionId: subscription.id, eventType: input.eventType, sourceEventId: input.sourceEventId, payloadHash, }), payloadHash, }, }), ), ); return { deliveries }; } export async function markPublicWebhookDeliveryResult( input: { deliveryId: string; tenantId: string; ok: boolean; httpStatus?: number | null; error?: string | null; responsePreview?: Prisma.InputJsonValue; now?: Date; }, client: PublicApiClient = getDbClient(), ): Promise { const now = input.now ?? new Date(); return client.$transaction(async (tx) => { const delivery = await tx.publicWebhookDeliveryLog.findFirst({ where: { id: input.deliveryId, tenantId: input.tenantId }, include: { subscription: true }, }); if (!delivery) { throw new Error("Public webhook delivery not found"); } if (input.ok) { await tx.publicWebhookSubscription.update({ where: { id: delivery.subscriptionId }, data: { failureCount: 0, lastDeliveredAt: now, lastErrorAt: null }, }); return tx.publicWebhookDeliveryLog.update({ where: { id: delivery.id }, data: { status: "success", httpStatus: input.httpStatus ?? null, error: null, responsePreview: input.responsePreview ?? undefined, sentAt: now, nextAttemptAt: null }, }); } const nextAttempt = delivery.attempt + 1; const nextFailureCount = delivery.subscription.failureCount + 1; const exhaustedDelivery = nextAttempt > delivery.maxAttempts; const shouldDisable = nextFailureCount >= PUBLIC_WEBHOOK_AUTO_DISABLE_FAILURES; const nextStatus: PublicWebhookDeliveryStatus = shouldDisable ? "disabled" : exhaustedDelivery ? "failed" : "retrying"; const nextAttemptAt = nextStatus === "retrying" ? planPublicWebhookRetry({ attempt: delivery.attempt, now }) : null; await tx.publicWebhookSubscription.update({ where: { id: delivery.subscriptionId }, data: { failureCount: nextFailureCount, lastErrorAt: now, ...(shouldDisable ? { status: "paused", autoDisabledAt: now, pausedAt: now } : {}), }, }); return tx.publicWebhookDeliveryLog.update({ where: { id: delivery.id }, data: { status: nextStatus, httpStatus: input.httpStatus ?? null, error: input.error ?? null, responsePreview: input.responsePreview ?? undefined, nextAttemptAt, attempt: exhaustedDelivery || shouldDisable ? delivery.attempt : nextAttempt, }, }); }); } export async function deliverPublicWebhook( input: DeliverPublicWebhookInput, client: PublicApiClient = getDbClient(), ): Promise { const delivery = await client.publicWebhookDeliveryLog.findFirst({ where: { id: input.deliveryId, tenantId: input.tenantId }, include: { subscription: true }, }); if (!delivery) { throw new Error("Public webhook delivery not found"); } if (delivery.subscription.status !== "active" || delivery.status === "success" || delivery.status === "disabled") { return delivery; } await client.publicWebhookDeliveryLog.update({ where: { id: delivery.id }, data: { status: "delivering" }, }); const headers = createPublicWebhookDeliveryHeadersForSubscription({ subscription: delivery.subscription, eventType: delivery.eventType, deliveryId: delivery.id, idempotencyKey: delivery.idempotencyKey, payload: input.payload, hashSecret: input.hashSecret, }); try { const response = await (input.fetcher ?? fetch)(delivery.targetUrl, { method: "POST", headers, body: stableStringify(input.payload), }); const responsePreview = await readWebhookResponsePreview(response); return markPublicWebhookDeliveryResult( { deliveryId: delivery.id, tenantId: delivery.tenantId, ok: response.ok, httpStatus: response.status, error: response.ok ? null : `Webhook target returned HTTP ${response.status}.`, responsePreview, }, client, ); } catch (error) { return markPublicWebhookDeliveryResult( { deliveryId: delivery.id, tenantId: delivery.tenantId, ok: false, error: error instanceof Error ? error.name : "WebhookDeliveryError", }, client, ); } } export function createPublicWebhookDeliveryHeaders(input: { eventType: string; deliveryId: string; idempotencyKey: string; payload: PublicWebhookPayload; signingSecret: string; timestamp?: Date; }): PublicWebhookDeliveryHeaders { const timestamp = Math.floor((input.timestamp ?? new Date()).getTime() / 1000).toString(); const body = stableStringify(input.payload); const signature = createHmac("sha256", input.signingSecret).update(`${timestamp}.${body}`).digest("hex"); return { "Content-Type": "application/json", "X-HiveGrid-Event": input.eventType, "X-HiveGrid-Delivery": input.deliveryId, "X-HiveGrid-Idempotency-Key": input.idempotencyKey, "X-HiveGrid-Timestamp": timestamp, "X-HiveGrid-Signature": `sha256=${signature}`, }; } export function createPublicWebhookDeliveryHeadersForSubscription(input: { subscription: Pick; eventType: string; deliveryId: string; idempotencyKey: string; payload: PublicWebhookPayload; hashSecret?: string | null; timestamp?: Date; }): PublicWebhookDeliveryHeaders { return createPublicWebhookDeliveryHeaders({ eventType: input.eventType, deliveryId: input.deliveryId, idempotencyKey: input.idempotencyKey, payload: input.payload, signingSecret: derivePublicWebhookSigningSecret( { tenantId: input.subscription.tenantId, subscriptionId: input.subscription.id }, input.hashSecret, ), timestamp: input.timestamp, }); } export function verifyPublicWebhookHmacWithPresentedSecret(input: { body: string; timestamp: string | null; signature: string | null; presentedSecret: string | null; secretHash: string | null; hashSecret?: string | null; }): boolean { if (!input.timestamp || !input.signature || !input.presentedSecret || !verifyPublicApiSecret(input.presentedSecret, input.secretHash, input.hashSecret)) { return false; } const expected = `sha256=${createHmac("sha256", input.presentedSecret).update(`${input.timestamp}.${input.body}`).digest("hex")}`; return safeEqual(expected, input.signature); } export function buildPublicWebhookIdempotencyKey(input: { subscriptionId: string; eventType: string; sourceEventId?: string | null; payloadHash: string; }): string { return [input.subscriptionId, input.eventType, input.sourceEventId || input.payloadHash].join(":"); } export function planPublicWebhookRetry(input: { attempt: number; now?: Date; baseDelayMs?: number }): Date { const baseDelayMs = input.baseDelayMs ?? 60_000; const delayMs = baseDelayMs * 2 ** Math.max(input.attempt - 1, 0); return new Date((input.now ?? new Date()).getTime() + delayMs); } export function hashJsonValue(value: PublicWebhookPayload): string { return createHash("sha256").update(stableStringify(value)).digest("hex"); } function normalizePublicApiSecretHashSecret(secret: string | undefined | null): string { const normalized = secret?.trim(); return normalized || DEFAULT_PUBLIC_API_SECRET_HASH_SECRET; } function safeEqual(actual: string, expected: string): boolean { const actualBuffer = Buffer.from(actual); const expectedBuffer = Buffer.from(expected); return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer); } function extractLeadFields(payload: PublicWebhookPayload, mapping: Prisma.JsonValue): { vorname: string | null; nachname: string | null; email: string | null; telefon: string | null; message: string | null } { const object = isRecord(payload) ? payload : {}; const map = isRecord(mapping) ? mapping : {}; return { vorname: readMappedString(object, map, "vorname", ["vorname", "firstName", "first_name", "contact.firstName"]), nachname: readMappedString(object, map, "nachname", ["nachname", "lastName", "last_name", "contact.lastName"]), email: normalizeEmail(readMappedString(object, map, "email", ["email", "contact.email", "from.email"])), telefon: readMappedString(object, map, "telefon", ["telefon", "phone", "telephone", "contact.phone"]), message: readMappedString(object, map, "message", ["message", "nachricht", "text", "body"]), }; } function readMappedString(object: Record, mapping: Record, key: string, fallbacks: readonly string[]): string | null { const mapped = typeof mapping[key] === "string" ? getPath(object, mapping[key]) : undefined; const value = mapped ?? fallbacks.map((path) => getPath(object, path)).find((item) => typeof item === "string" && item.trim()); return typeof value === "string" && value.trim() ? value.trim().slice(0, 2_000) : null; } function getPath(object: Record, path: string): unknown { let current: unknown = object; for (const part of path.split(".")) { if (!isRecord(current)) { return undefined; } current = current[part]; } return current; } async function findMatchingKontaktId( tx: Prisma.TransactionClient, tenantId: string, email: string | null, telefon: string | null, ): Promise { if (email) { const match = await tx.kontaktEmail.findFirst({ where: { tenantId, email }, select: { kontaktId: true }, }); if (match) return match.kontaktId; } if (telefon) { const match = await tx.kontaktTelefon.findFirst({ where: { tenantId, telefon }, select: { kontaktId: true }, }); if (match) return match.kontaktId; } return null; } async function createWebhookAutomationExecutions( tx: Prisma.TransactionClient, input: { tenantId: string; endpointId: string; endpointSlug: string; leadId: string; payload: PublicWebhookPayload; payloadHash: string; sourceEventId?: string | null }, ): Promise { const rules = await tx.automationRule.findMany({ where: { tenantId: input.tenantId, triggerKey: "webhook.received", enabled: true, status: "active", archivedAt: null }, select: { id: true, name: true }, }); const executions = await Promise.all( rules.map((rule) => tx.automationExecution.create({ data: { tenantId: input.tenantId, ruleId: rule.id, triggerKey: "webhook.received", triggerPayload: { source: "external_event", endpointId: input.endpointId, endpointSlug: input.endpointSlug, leadId: input.leadId, payload: input.payload, }, status: "queued", idempotencyKey: [input.tenantId, rule.id, "webhook.received", input.sourceEventId || input.payloadHash].join(":"), summaryText: `Webhook ${input.endpointSlug} queued automation ${rule.name}`, }, }), ), ); return executions.map((execution) => execution.id); } function subscriptionMatchesEvent(eventTypes: Prisma.JsonValue, eventType: string): boolean { if (!Array.isArray(eventTypes)) { return false; } return eventTypes.includes("*") || eventTypes.includes(eventType); } function createPayloadPreview(payload: PublicWebhookPayload): Prisma.InputJsonValue { if (!isRecord(payload)) { return payload; } const entries = Object.entries(payload).slice(0, 20).map(([key, value]) => [key, previewValue(value)]); return Object.fromEntries(entries); } function previewValue(value: unknown): Prisma.InputJsonValue { if (typeof value === "string") return value.slice(0, 500); if (typeof value === "number" || typeof value === "boolean") return value; if (value === null) return "null"; if (Array.isArray(value)) return value.slice(0, 10).map(previewValue); if (isRecord(value)) return Object.fromEntries(Object.entries(value).slice(0, 10).map(([key, item]) => [key, previewValue(item)])); return String(value); } async function readWebhookResponsePreview(response: Response): Promise { const text = await response.text().catch(() => ""); return { status: response.status, body: text.slice(0, 1_000), }; } function normalizeEmail(value: string | null): string | null { return value ? value.trim().toLowerCase() : null; } function stableStringify(value: unknown): string { if (value === null || typeof value !== "object") { return JSON.stringify(value); } if (Array.isArray(value)) { return `[${value.map(stableStringify).join(",")}]`; } const entries = Object.entries(value as Record).sort(([a], [b]) => a.localeCompare(b)); return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`; } function isRecord(value: unknown): value is Record { return typeof value === "object" && value !== null && !Array.isArray(value); }