Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/integrations.kwp.oauth.callback.tsx
T

166 lines
6.4 KiB
TypeScript

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<typeof cancelKwpOAuthConnectionAttempt>[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 <ServerError />;
}