import { CatalogError, foundationErrors, type JsonValue } from "./errors.js"; export type IdempotencyResponse = { status: number; body?: JsonValue; headers?: Record; }; export type IdempotencyClient = { idempotencyKey: { findUnique(args: { where: { idempotency_key_scope_key: { scope: string; key: string } } }): Promise<{ requestHash: string; responseStatus: number; responseBody: JsonValue | null; responseHeaders: Record | null; expiresAt?: Date | null; } | null>; create(args: { data: { scope: string; key: string; requestHash: string; responseStatus: number; responseBody?: JsonValue | null; responseHeaders?: Record | null; expiresAt?: Date | null; }; }): Promise; update(args: { where: { idempotency_key_scope_key: { scope: string; key: string } }; data: { responseStatus: number; responseBody?: JsonValue | null; responseHeaders?: Record | null; expiresAt?: Date | null; }; }): Promise; deleteMany?(args?: { where?: { scope?: string; key?: string; expiresAt?: { lte?: Date } } }): Promise; }; }; const idempotencyLockTails = new Map>(); export async function withIdempotency( input: { scope?: string; key?: string | null; fingerprint: JsonValue; expiresAt?: Date | null }, client: IdempotencyClient, operation: () => Promise, ): Promise { const key = input.key?.trim(); if (!key) return { ...(await operation()), replayed: false }; const scope = input.scope ?? "default"; return runWithIdempotencyLock(`${scope}:${key}`, async () => runIdempotencyOperation({ ...input, scope, key }, client, operation)); } async function runIdempotencyOperation( input: { scope: string; key: string; fingerprint: JsonValue; expiresAt?: Date | null }, client: IdempotencyClient, operation: () => Promise, ): Promise { const { scope, key } = input; const requestHash = stableStringify(input.fingerprint); const existing = await client.idempotencyKey.findUnique({ where: { idempotency_key_scope_key: { scope, key } } }); if (existing) { return replayExistingIdempotencyResponse(existing, requestHash); } try { await client.idempotencyKey.create({ data: { scope, key, requestHash, responseStatus: 0, responseBody: null, responseHeaders: null, expiresAt: input.expiresAt ?? null, }, }); } catch (error) { if (!isUniqueConstraintError(error)) { throw error; } const reserved = await client.idempotencyKey.findUnique({ where: { idempotency_key_scope_key: { scope, key } } }); if (reserved) { return replayExistingIdempotencyResponse(reserved, requestHash); } throw error; } try { const response = await operation(); await client.idempotencyKey.update({ where: { idempotency_key_scope_key: { scope, key } }, data: { responseStatus: response.status, responseBody: response.body ?? null, responseHeaders: response.headers ?? null, expiresAt: input.expiresAt ?? null, }, }); return { ...response, replayed: false }; } catch (error) { await client.idempotencyKey.deleteMany?.({ where: { scope, key } }); throw error; } } function replayExistingIdempotencyResponse( existing: { requestHash: string; responseStatus: number; responseBody: JsonValue | null; responseHeaders: Record | null; }, requestHash: string, ): IdempotencyResponse & { replayed: true } { if (existing.requestHash !== requestHash) { throw new CatalogError(foundationErrors.idempotencyConflict); } if (existing.responseStatus <= 0) { throw new CatalogError(foundationErrors.idempotencyInProgress); } return { status: existing.responseStatus, body: existing.responseBody ?? undefined, headers: existing.responseHeaders ?? undefined, replayed: true, }; } function isUniqueConstraintError(error: unknown): boolean { return Boolean( error && typeof error === "object" && ("code" in error ? (error as { code?: unknown }).code === "P2002" : false), ); } async function runWithIdempotencyLock(lockKey: string, task: () => Promise): Promise { const previousTail = idempotencyLockTails.get(lockKey) ?? Promise.resolve(); let release!: () => void; const gate = new Promise((resolve) => { release = resolve; }); const nextTail = previousTail.catch(() => undefined).then(() => gate); idempotencyLockTails.set(lockKey, nextTail); await previousTail.catch(() => undefined); try { return await task(); } finally { release(); if (idempotencyLockTails.get(lockKey) === nextTail) { idempotencyLockTails.delete(lockKey); } } } function stableStringify(value: JsonValue): string { if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`; if (value && typeof value === "object") { return `{${Object.entries(value) .sort(([left], [right]) => left.localeCompare(right)) .map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`) .join(",")}}`; } return JSON.stringify(value); }