import { type LoaderFunctionArgs, redirect } from "react-router"; import ServerError from "~/components/ui/errors/ServerError"; import { KwpConnectError, cancelKwpOAuthConnectionAttempt, completeKwpOAuthConnection, } from "~/modules/kwp/services/KwpConnectionService.server"; import { consumeKwpOAuthChallenge } from "~/modules/kwp/services/kwpOAuthChallenge.server"; import { requireKwpIntegrationModule } from "~/modules/kwp/routes/kwpAccess.server"; import { loadIntegrationsContext, requireIntegrationsPermission } from "~/utils/integrations/integrationsAccess.server"; import { integrationsAppPath, KWP_SETUP_PATH, kwpMandantSelectionPath } from "~/utils/integrations/integrationsRoutePaths"; import { ProviderOAuthCallbackAccessError, runAuthenticatedProviderOAuthCallback } from "~/utils/integrations/providerOAuthCallbackAccess.server"; import { createScopedLogger } from "~/utils/logger.server"; import { toSafeErrorLog } from "~/utils/safeErrorLog.server"; const logger = createScopedLogger("kwp.oauth.callback"); function redirectWithClearedChallenge(location: string, clearCookie: string): Response { return redirect(location, { headers: { "Set-Cookie": clearCookie } }); } function singleRequiredParameter(url: URL, name: string): string | null { const values = url.searchParams.getAll(name); return values.length === 1 && values[0] ? values[0] : null; } function singleOptionalParameter(url: URL, name: string): { readonly ok: true; readonly value?: string } | { readonly ok: false } { const values = url.searchParams.getAll(name); if (values.length === 0) return { ok: true }; if (values.length !== 1 || !values[0]) return { ok: false }; return { ok: true, value: values[0] }; } function providerResponseDiagnosticCode(url: URL, code: string | null, responseIssuerOk: boolean): string { if (url.searchParams.has("error")) { switch (singleRequiredParameter(url, "error")) { case "access_denied": return "provider_access_denied"; case "invalid_request": return "provider_invalid_request"; case "server_error": return "provider_server_error"; case "temporarily_unavailable": return "provider_temporarily_unavailable"; default: return "provider_error"; } } if (!code) return "callback_code_invalid"; if (!responseIssuerOk) return "callback_issuer_invalid"; return "callback_parameters_invalid"; } async function restoreReservationAfterProviderFailure(request: Request, payload: Parameters[0] & { readonly tenantSlug: string }) { await runAuthenticatedProviderOAuthCallback({ request, tenantId: payload.tenantId, userId: payload.userId, callback: async () => { const ctx = await loadIntegrationsContext({ request, params: { tenant: payload.tenantSlug }, requireModule: true, }); if (ctx.tenantId !== payload.tenantId || ctx.userId !== payload.userId) throw new KwpConnectError("invalid_state"); await requireKwpIntegrationModule(ctx); requireIntegrationsPermission(ctx, "integrations.connect"); return cancelKwpOAuthConnectionAttempt(payload); }, }); } export const loader = async ({ request }: LoaderFunctionArgs) => { const url = new URL(request.url); const state = singleRequiredParameter(url, "state"); const consumed = await consumeKwpOAuthChallenge(request, state); if (!consumed.ok) { logger.warn( { op: "kwp.oauth.callback.failed", failureCode: "challenge_invalid", diagnosticCode: `challenge_${consumed.reason.replaceAll("-", "_")}`, }, "KWP OAuth callback failed", ); return redirectWithClearedChallenge(`${KWP_SETUP_PATH}?kwp=error`, consumed.clearCookie); } const errorRedirect = `${integrationsAppPath(consumed.payload.tenantSlug, "kwp")}?kwp=error`; const code = singleRequiredParameter(url, "code"); const responseIssuer = singleOptionalParameter(url, "iss"); if (!code || !responseIssuer.ok || url.searchParams.has("error")) { logger.warn( { op: "kwp.oauth.callback.failed", failureCode: "provider_response_invalid", diagnosticCode: providerResponseDiagnosticCode(url, code, responseIssuer.ok), }, "KWP OAuth callback failed" ); await restoreReservationAfterProviderFailure(request, { tenantId: consumed.payload.tenantId, tenantSlug: consumed.payload.tenantSlug, userId: consumed.payload.userId, connectionId: consumed.payload.connectionId, version: consumed.payload.connectionVersion, }).catch(() => undefined); return redirectWithClearedChallenge(errorRedirect, consumed.clearCookie); } try { const completed = await runAuthenticatedProviderOAuthCallback({ request, tenantId: consumed.payload.tenantId, userId: consumed.payload.userId, callback: async () => { const ctx = await loadIntegrationsContext({ request, params: { tenant: consumed.payload.tenantSlug }, requireModule: true, }); if (ctx.tenantId !== consumed.payload.tenantId || ctx.userId !== consumed.payload.userId) { throw new KwpConnectError("invalid_state"); } await requireKwpIntegrationModule(ctx); requireIntegrationsPermission(ctx, "integrations.connect"); return completeKwpOAuthConnection({ callbackParameters: { code, state: consumed.payload.state, ...(responseIssuer.value ? { iss: responseIssuer.value } : {}), }, challenge: consumed.payload, }); }, }); return redirectWithClearedChallenge( kwpMandantSelectionPath(completed.tenantSlug, completed.connectionId), consumed.clearCookie, ); } catch (error) { logger.warn( { op: "kwp.oauth.callback.failed", ...(error instanceof KwpConnectError ? { failureCode: error.code, ...(error.diagnosticCode ? { diagnosticCode: error.diagnosticCode } : {}) } : error instanceof ProviderOAuthCallbackAccessError ? { failureCode: error.failureCode } : { failureCode: "callback_access_or_unexpected", ...toSafeErrorLog(error) }), }, "KWP OAuth callback failed" ); return redirectWithClearedChallenge(errorRedirect, consumed.clearCookie); } }; export default function KwpOAuthCallbackRoute() { return null; } export function ErrorBoundary() { return ; }