@opensas/oidc-sveltekit-adapter 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,216 @@
-# Temporary Holding Version
+# oidc-sveltekit-adapter
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Proyecto _de uso interno_ que resuelve el login por **OpenID Connect** (ADFS, Keycloak) para las
+aplicaciones SvelteKit.
+
+npm: `@opensas/oidc-sveltekit-adapter` (todavía sin publicar).
+
+## Estado
+
+Etapas 1 y 2 terminadas: la API genérica (`createOidcProvider` y helpers, en `src/lib/oidc/`, sin
+SvelteKit) y `createOidcSvelteKitHandlers`, con la app de prueba (`src/routes/`) usando las dos, con
+unitarios y e2e contra el Keycloak de Docker. Quedan para después el diagnóstico del proveedor y la
+prueba con ADFS. El diseño
+completo (API, cookies, flujo) y el plan de trabajo están en
+[`docs/todos/oidc-sveltekit-adapter.md`](docs/todos/oidc-sveltekit-adapter.md).
+
+## Uso
+
+```bash
+pnpm add @opensas/oidc-sveltekit-adapter
+```
+
+Authorization Code Flow con PKCE, sobre `openid-client`. Dos formas de usarlo.
+
+### SvelteKit: `createOidcSvelteKitHandlers`
+
+El componente arma las rutas `<basePath>/login`, `/callback` y `/logout`, las cookies del login y
+los redirects. La app arma su sesión en `onLogin` y la borra en `onLogout`.
+
+```ts
+// src/lib/server/oidc.ts
+import { createOidcSvelteKitHandlers, getUser } from '@opensas/oidc-sveltekit-adapter';
+
+import { AUTH_CLIENT_ID, AUTH_CLIENT_SECRET, AUTH_ISSUER } from '$env/static/private';
+
+export const oidc = createOidcSvelteKitHandlers({
+	issuer: AUTH_ISSUER, // el realm de Keycloak o https://<adfs>/adfs
+	clientId: AUTH_CLIENT_ID,
+	clientSecret: AUTH_CLIENT_SECRET, // sin él, client público (solo PKCE)
+	basePath: '/api/auth',
+	cookiePrefix: 'miapp',
+	sessionMaxAge: 8 * 3600,
+	onLogin: (tokens, { cookies }) => {
+		const user = getUser(tokens, { defaultDomain: 'ORGANIZACION' });
+		if (!user) return false; // sin usuario de red: 401
+		createSession(cookies, user); // la sesión es de la app
+	},
+	onLogout: ({ cookies }) => deleteSession(cookies),
+});
+```
+
+```ts
+// src/routes/api/auth/[...path]/+server.ts
+import { oidc } from '$lib/server/oidc';
+
+export const GET = oidc.handler;
+export const POST = oidc.handler;
+```
+
+```ts
+// src/hooks.server.ts: sin sesión, las navegaciones van al login (con returnTo)
+export const handle: Handle = ({ event, resolve }) => {
+	event.locals.user = getSession(event.cookies);
+	if (!event.locals.user) {
+		const login = oidc.loginRedirect(event);
+		if (login) redirect(303, login);
+	}
+	return resolve(event);
+};
+```
+
+El logout es un `POST` a `<basePath>/logout` (por ejemplo, un `<form method="POST">`).
+
+En el proveedor, el redirect URI del client es `<origin><basePath>/callback`
+(`http://localhost:5173/api/auth/callback`), y el post logout redirect URI, `<origin>/`.
+
+### Cualquier app Node: `createOidcProvider`
+
+Los tres pasos del flujo, sin cookies ni redirects: los arma la app. Ejemplo completo en la app de
+prueba (`src/routes/api/auth/`).
+
+```ts
+const oidc = createOidcProvider({
+	issuer,
+	clientId,
+	clientSecret,
+	callbackPath: '/api/auth/callback',
+});
+
+// GET /login: guardar pendingLogin (cookie HttpOnly) y redirigir a providerUrl
+const { providerUrl, pendingLogin } = await oidc.buildLoginUrl(requestUrl);
+
+// GET /callback: valida state, PKCE y el id_token; lanza OidcError si falla
+const tokens = await oidc.exchangeCode(requestUrl, pendingLogin);
+const user = getUser(tokens);
+
+// POST /logout: redirigir al logout del proveedor (undefined si no lo publica)
+const logoutUrl = await oidc.buildLogoutUrl(idToken, 'https://miapp/');
+```
+
+Helpers: `getUser`, `getDomainUser`, `getPermissions`, `isSameOrigin`, `isNavigation`, `OidcError`
+(con `code`: `PROVIDER_ERROR`, `NO_LOGIN_IN_PROGRESS`, `STATE_MISMATCH`, `TOKEN_EXCHANGE`,
+`INVALID_ID_TOKEN`, `DISCOVERY`, `LOGIN_REJECTED`).
+
+El paso a paso del flujo, con los mensajes HTTP, está en la app de prueba: `pnpm dev` y
+`/como-funciona`.
+
+## Proveedores probados
+
+El flujo se probó en la prueba de concepto (`keycloak-poc`), con la misma app y cambiando solo el
+`.env`. El componente se va a probar contra los mismos proveedores:
+
+| Proveedor | Versión                                                       | Notas                                              |
+| --------- | ------------------------------------------------------------- | -------------------------------------------------- |
+| Keycloak  | 26.8.1                                                        | En Docker (`start-dev`) y en Windows Server 2022   |
+| ADFS      | AD FS 2019 (farm behavior level 4), sobre Windows Server 2022 | Client confidencial y público (PKCE), con Kerberos |
+
+## Estructura
+
+Dos capas:
+
+- `src/lib/oidc/`: la capa genérica, para cualquier app Node. Sobre `openid-client`; no importa
+  nada de SvelteKit (lo controla ESLint).
+- La capa SvelteKit: los handlers de `/api/auth/login`, `/callback` y `/logout`, y
+  `createOidcSvelteKitHandlers` (etapa 2).
+
+`src/routes/` es la app de prueba, contra Keycloak en Docker.
+
+## Desarrollo
+
+Requisitos: las versiones de `mise.toml` (Node, pnpm), Docker y `openssl` (para Keycloak). pnpm lo
+instala corepack según `packageManager` de `package.json`.
+
+```bash
+pnpm install
+cp .env.example .env    # trae activo el bloque del Keycloak de Docker
+pnpm keycloak:start
+pnpm dev                # la app de prueba, en http://localhost:5173
+```
+
+### Tareas de pnpm
+
+Todas las de `package.json`. **Al agregar, cambiar o borrar una, actualizar esta lista.**
+
+App de prueba:
+
+```bash
+pnpm dev                # vite dev; confía en el certificado de Keycloak (NODE_EXTRA_CA_CERTS)
+pnpm build              # vite build y después prepack
+pnpm preview            # sirve el build en el 4173, el que usan los e2e; mismo certificado que dev
+```
+
+Calidad:
+
+```bash
+pnpm verify             # ESLint con --fix, Prettier y svelte-check: correrlo antes de commitear
+pnpm lint               # solo ESLint, sin --fix
+pnpm format             # solo Prettier
+pnpm check              # solo svelte-check (check:watch, en modo watch)
+pnpm lint:clean         # borra las cachés de ESLint y Prettier
+```
+
+Tests. `pnpm test` usa el Keycloak de dev ya levantado (`pnpm keycloak:start`), como una base de
+fixture; `pnpm test:ci` levanta uno propio y lo borra al terminar:
+
+```bash
+pnpm test               # test:vite y test:play
+pnpm test:unit          # Vitest, solo los unitarios
+pnpm test:vite          # Vitest, todos los proyectos
+pnpm test:e2e           # Playwright, solo los e2e
+pnpm test:play          # Playwright, todos los proyectos
+pnpm test:ci            # como en GitLab: Keycloak desechable (puerto 3112), test:vite y test:play
+```
+
+Keycloak en Docker (`docker/keycloak/`, `https://localhost:3102`, realm `oidc-test`, admin
+`admin`/`admin`):
+
+```bash
+pnpm keycloak:start     # keycloak:cert y levanta el contenedor; importa el realm si no existe
+pnpm keycloak:stop      # lo frena, sin perder los datos
+pnpm keycloak:status    # estado y puertos del contenedor
+pnpm keycloak:logs      # los logs, en vivo
+pnpm keycloak:purge     # borra el contenedor y sus datos: el próximo start reimporta el realm
+pnpm keycloak:cert      # genera el certificado autofirmado, si no existe o vence en 30 días
+pnpm keycloak:init      # espera e importa el realm por la API de admin (el de CI; KEYCLOAK_URL)
+```
+
+Paquete y dependencias:
+
+```bash
+pnpm prepack            # arma dist/ y lo valida con publint
+pnpm up:safe            # dentro de los rangos, con 24 h de antigüedad mínima
+pnpm sv:sync-deps       # compara las mayores con las que trae hoy el scaffold de SvelteKit (sv)
+```
+
+VM de ADFS (`keycloak-poc`: `docs/adfs-paso-a-paso.md`):
+
+```bash
+pnpm vm:pack            # build de adapter-node con node_modules → build-vm/oidc-app.zip (.env.vm.example)
+```
+
+Runner de GitLab local (con `sudo`):
+
+```bash
+pnpm gitlab-runner:start
+pnpm gitlab-runner:stop
+pnpm gitlab-runner:status
+pnpm gitlab-runner:logs  # los logs del servicio, en vivo
+```
+
+`prepare` (`svelte-kit sync`) no se corre a mano: lo corre `pnpm install`.
+
+## Versiones y commits
+
+SemVer. Commits y títulos de merge request en Conventional Commits, en español. `main` protegida:
+todo entra por merge request, con squash.

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './oidc/domain-user.ts';
+export * from './oidc/errors.ts';
+export { isNavigation, isSameOrigin } from './oidc/request.ts';
+export * from './oidc/permissions.ts';
+export * from './oidc/provider.ts';
+export type { Claims } from './oidc/types.ts';
+export * from './oidc/user.ts';
+export * from './sveltekit-handlers.ts';

package/dist/index.js

@@ -0,0 +1,12 @@
+// La API pública. Etapa 1, cualquier app Node: el provider (buildLoginUrl, exchangeCode,
+// buildLogoutUrl) y helpers; las cookies, la sesión y los redirects los arma la app. Etapa 2,
+// SvelteKit: createOidcSvelteKitHandlers hace eso y la app solo arma su sesión.
+// src/lib/server/ es de la app de prueba: no se publica.
+export * from "./oidc/domain-user.js";
+export * from "./oidc/errors.js";
+export { isNavigation, isSameOrigin } from "./oidc/request.js";
+export * from "./oidc/permissions.js";
+export * from "./oidc/provider.js";
+export * from "./oidc/user.js";
+// Etapa 2: la capa SvelteKit
+export * from "./sveltekit-handlers.js";

package/dist/oidc/domain-user.d.ts

@@ -0,0 +1,7 @@
+import type { Claims } from './types.ts';
+export declare const DOMAIN_USER_CLAIMS: readonly ["unique_name", "upn", "preferred_username", "email"];
+export declare const DOMAIN_CLAIM = "dominio";
+export type DomainUserOptions = {
+    defaultDomain?: string;
+};
+export declare function getDomainUser(idTokenClaims: Claims, accessTokenClaims: Claims | undefined, options?: DomainUserOptions): string | undefined;

package/dist/oidc/domain-user.js

@@ -0,0 +1,35 @@
+// Dónde manda cada proveedor el usuario de red, en orden: gana el primero con contenido. ADFS (sin
+// reglas de claims): unique_name ('ORGANIZACION\user1') y upn; Keycloak: preferred_username (con
+// LDAP, el userPrincipalName del AD). Verificado en la POC (keycloak-poc).
+export const DOMAIN_USER_CLAIMS = ['unique_name', 'upn', 'preferred_username', 'email'];
+// Mapper del client en Keycloak: el dominio de Windows del usuario. Solo en el access token.
+export const DOMAIN_CLAIM = 'dominio';
+const DOMAIN_SEPARATOR = '\\';
+const UPN_SEPARATOR = '@';
+// El usuario de red, 'DOMINIO\usuario', o undefined si ningún claim lo trae. Por cada claim de
+// DOMAIN_USER_CLAIMS mira primero el id_token (validado) y después el access token. Si el valor ya
+// trae el dominio queda tal cual; si es 'usuario@dominio.algo' (o solo 'usuario'), arma
+// '<dominio>\usuario' con el claim dominio o, si no está, con defaultDomain (sin él, undefined).
+export function getDomainUser(idTokenClaims, accessTokenClaims, options = {}) {
+    const value = DOMAIN_USER_CLAIMS.flatMap((claim) => [
+        stringClaim(idTokenClaims, claim),
+        stringClaim(accessTokenClaims, claim),
+    ]).find(Boolean);
+    if (!value)
+        return undefined;
+    if (value.includes(DOMAIN_SEPARATOR))
+        return value;
+    const [user] = value.split(UPN_SEPARATOR);
+    if (!user)
+        return undefined;
+    const domain = stringClaim(accessTokenClaims, DOMAIN_CLAIM) ??
+        stringClaim(idTokenClaims, DOMAIN_CLAIM) ??
+        options.defaultDomain;
+    if (!domain)
+        return undefined;
+    return `${domain}${DOMAIN_SEPARATOR}${user}`;
+}
+function stringClaim(claims, name) {
+    const value = claims?.[name];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}

package/dist/oidc/errors.d.ts

@@ -0,0 +1,14 @@
+export declare const OIDC_ERROR_CODES: readonly ["PROVIDER_ERROR", "NO_LOGIN_IN_PROGRESS", "STATE_MISMATCH", "TOKEN_EXCHANGE", "INVALID_ID_TOKEN", "DISCOVERY", "LOGIN_REJECTED"];
+export type OidcErrorCode = (typeof OIDC_ERROR_CODES)[number];
+export type ProviderErrorDetails = {
+    providerError?: string;
+    providerErrorDescription?: string;
+};
+export declare class OidcError extends Error {
+    readonly code: OidcErrorCode;
+    readonly providerError?: string;
+    readonly providerErrorDescription?: string;
+    constructor(code: OidcErrorCode, message: string, details?: ProviderErrorDetails & {
+        cause?: unknown;
+    });
+}

package/dist/oidc/errors.js

@@ -0,0 +1,27 @@
+export const OIDC_ERROR_CODES = [
+    // El proveedor volvió con ?error= (el usuario canceló, client mal configurado)
+    'PROVIDER_ERROR',
+    // Sin <prefix>_login: vencida, o el callback abierto a mano
+    'NO_LOGIN_IN_PROGRESS',
+    'STATE_MISMATCH',
+    // Falló el canje del code
+    'TOKEN_EXCHANGE',
+    // Firma, iss, aud, exp o nonce del id_token
+    'INVALID_ID_TOKEN',
+    // El proveedor no responde
+    'DISCOVERY',
+    // El login salió bien, pero la app no lo aceptó (por ejemplo, sin usuario de red)
+    'LOGIN_REJECTED',
+];
+export class OidcError extends Error {
+    code;
+    providerError;
+    providerErrorDescription;
+    constructor(code, message, details = {}) {
+        super(message, { cause: details.cause });
+        this.name = 'OidcError';
+        this.code = code;
+        this.providerError = details.providerError;
+        this.providerErrorDescription = details.providerErrorDescription;
+    }
+}

package/dist/oidc/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { Claims } from './types.ts';
+export type Permissions = Record<string, string[]>;
+export declare function getPermissions(accessTokenClaims: Claims | undefined, clientId: string): Permissions;

package/dist/oidc/permissions.js

@@ -0,0 +1,32 @@
+const ROLE_SEPARATOR = ':';
+// Los roles del client en Keycloak ('Recurso:accion', en resource_access.<clientId>.roles, la unión
+// de los de todos los grupos del usuario) como permisos. Solo vienen en el access token. Los roles
+// que no tienen la forma 'Recurso:accion' se ignoran. Sin roles (ADFS sin reglas), {}.
+//
+// ['Provincia:alta', 'Provincia:consulta', 'Dato:consulta']
+// → { Dato: ['consulta'], Provincia: ['alta', 'consulta'] }
+export function getPermissions(accessTokenClaims, clientId) {
+    const permissions = {};
+    for (const role of clientRoles(accessTokenClaims, clientId)) {
+        const [resource, action, ...rest] = role.split(ROLE_SEPARATOR);
+        if (!resource || !action || rest.length > 0)
+            continue;
+        (permissions[resource] ??= new Set()).add(action);
+    }
+    // El orden de los roles en el token no es estable: recursos y acciones ordenados
+    return Object.fromEntries(Object.keys(permissions)
+        .toSorted()
+        .map((resource) => [resource, [...permissions[resource]].toSorted()]));
+}
+function clientRoles(claims, clientId) {
+    const resourceAccess = claims?.resource_access;
+    if (!isRecord(resourceAccess))
+        return [];
+    const client = resourceAccess[clientId];
+    if (!isRecord(client) || !Array.isArray(client.roles))
+        return [];
+    return client.roles.filter((role) => typeof role === 'string');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/oidc/provider.d.ts

@@ -0,0 +1,33 @@
+import type { Claims } from './types.ts';
+export declare const DEFAULT_SCOPE = "openid profile email";
+export declare const RETURN_TO_PARAM = "returnTo";
+export type OidcProviderOptions = {
+    issuer: string;
+    clientId: string;
+    clientSecret?: string;
+    callbackPath: string;
+    scope?: string;
+    allowInsecureRequests?: boolean;
+};
+export type PendingLogin = {
+    codeVerifier: string;
+    state: string;
+    nonce: string;
+    returnTo: string;
+};
+export type Tokens = {
+    idToken: string;
+    accessToken: string;
+    refreshToken?: string;
+    idTokenClaims: Claims;
+    accessTokenClaims?: Claims;
+};
+export type OidcProvider = {
+    buildLoginUrl(loginUrl: URL): Promise<{
+        providerUrl: URL;
+        pendingLogin: PendingLogin;
+    }>;
+    exchangeCode(callbackUrl: URL, pendingLogin: PendingLogin | undefined): Promise<Tokens>;
+    buildLogoutUrl(idToken: string | undefined, postLogoutRedirectUri: string): Promise<URL | undefined>;
+};
+export declare function createOidcProvider(options: OidcProviderOptions): OidcProvider;

package/dist/oidc/provider.js

@@ -0,0 +1,134 @@
+import * as client from 'openid-client';
+import { OidcError } from "./errors.js";
+import { safeReturnTo } from "./request.js";
+// Keycloak rechaza los scopes que no conoce (invalid_scope): allatclaims, el de ADFS, no va por defecto
+export const DEFAULT_SCOPE = 'openid profile email';
+// /login?returnTo=/pagina: a dónde volver después del login
+export const RETURN_TO_PARAM = 'returnTo';
+const JWT_PARTS = 3;
+// Errores de openid-client (oauth4webapi) que dicen que el id_token no es válido: firma (llega
+// como respuesta inválida), iss, aud, exp, nonce, o la clave del JWKS.
+const INVALID_ID_TOKEN_ERROR_CODES = new Set([
+    'OAUTH_INVALID_RESPONSE',
+    'OAUTH_JWT_CLAIM_COMPARISON_FAILED',
+    'OAUTH_JWT_TIMESTAMP_CHECK_FAILED',
+    'OAUTH_KEY_SELECTION_FAILED',
+]);
+// Discovery la primera vez que se usa; si falla, no se cachea el error y el próximo pedido reintenta.
+// Así la app levanta aunque el proveedor esté caído.
+export function createOidcProvider(options) {
+    const scope = options.scope ?? DEFAULT_SCOPE;
+    let configuration;
+    // Una sola promesa compartida: los pedidos que llegan mientras se resuelve esperan la misma
+    function discover() {
+        configuration ??= runDiscovery();
+        return configuration;
+    }
+    async function runDiscovery() {
+        try {
+            return await client.discovery(new URL(options.issuer), options.clientId, options.clientSecret, options.clientSecret ? undefined : client.None(), options.allowInsecureRequests ? { execute: [client.allowInsecureRequests] } : undefined);
+        }
+        catch (err) {
+            configuration = undefined;
+            throw new OidcError('DISCOVERY', `no se pudo leer el discovery de ${options.issuer}`, {
+                cause: err,
+            });
+        }
+    }
+    return {
+        async buildLoginUrl(loginUrl) {
+            const config = await discover();
+            const codeVerifier = client.randomPKCECodeVerifier();
+            const state = client.randomState();
+            const nonce = client.randomNonce();
+            const providerUrl = client.buildAuthorizationUrl(config, {
+                redirect_uri: new URL(options.callbackPath, loginUrl.origin).href,
+                scope,
+                code_challenge: await client.calculatePKCECodeChallenge(codeVerifier),
+                code_challenge_method: 'S256',
+                state,
+                nonce,
+            });
+            const returnTo = safeReturnTo(loginUrl.searchParams.get(RETURN_TO_PARAM));
+            return { providerUrl, pendingLogin: { codeVerifier, state, nonce, returnTo } };
+        },
+        async exchangeCode(callbackUrl, pendingLogin) {
+            // Antes de openid-client: sus errores no distinguen estos casos de un id_token inválido
+            const providerError = callbackUrl.searchParams.get('error');
+            if (providerError)
+                throw new OidcError('PROVIDER_ERROR', 'el proveedor devolvió un error en el callback', {
+                    providerError,
+                    providerErrorDescription: callbackUrl.searchParams.get('error_description') ?? undefined,
+                });
+            if (!pendingLogin)
+                throw new OidcError('NO_LOGIN_IN_PROGRESS', 'no hay un login en curso');
+            if (callbackUrl.searchParams.get('state') !== pendingLogin.state)
+                throw new OidcError('STATE_MISMATCH', 'el state del callback no coincide');
+            const config = await discover();
+            let response;
+            try {
+                response = await client.authorizationCodeGrant(config, callbackUrl, {
+                    pkceCodeVerifier: pendingLogin.codeVerifier,
+                    expectedState: pendingLogin.state,
+                    expectedNonce: pendingLogin.nonce,
+                    idTokenExpected: true,
+                });
+            }
+            catch (err) {
+                throw toOidcError(err);
+            }
+            const idTokenClaims = response.claims();
+            if (!response.id_token || !idTokenClaims)
+                throw new OidcError('INVALID_ID_TOKEN', 'el proveedor no devolvió un id_token');
+            return {
+                idToken: response.id_token,
+                accessToken: response.access_token,
+                refreshToken: response.refresh_token,
+                idTokenClaims: { ...idTokenClaims },
+                accessTokenClaims: decodeJwtPayload(response.access_token),
+            };
+        },
+        async buildLogoutUrl(idToken, postLogoutRedirectUri) {
+            const config = await discover();
+            return config.serverMetadata().end_session_endpoint
+                ? client.buildEndSessionUrl(config, {
+                    ...(idToken && { id_token_hint: idToken }),
+                    post_logout_redirect_uri: postLogoutRedirectUri,
+                })
+                : undefined;
+        },
+    };
+}
+function toOidcError(err) {
+    if (err instanceof client.AuthorizationResponseError)
+        return new OidcError('PROVIDER_ERROR', 'el proveedor devolvió un error en el callback', {
+            providerError: err.error,
+            providerErrorDescription: err.error_description,
+            cause: err,
+        });
+    if (err instanceof client.ResponseBodyError)
+        return new OidcError('TOKEN_EXCHANGE', 'el proveedor rechazó el canje del code', {
+            providerError: err.error,
+            providerErrorDescription: err.error_description,
+            cause: err,
+        });
+    const code = err instanceof Error && 'code' in err ? err.code : undefined;
+    if (typeof code === 'string' && INVALID_ID_TOKEN_ERROR_CODES.has(code))
+        return new OidcError('INVALID_ID_TOKEN', 'el id_token no es válido', { cause: err });
+    return new OidcError('TOKEN_EXCHANGE', 'falló el canje del code', { cause: err });
+}
+// Payload de un JWT sin verificar la firma, o undefined si no es un JWT
+function decodeJwtPayload(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length !== JWT_PARTS)
+        return undefined;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+        return typeof payload === 'object' && payload !== null && !Array.isArray(payload)
+            ? payload
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/oidc/request.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_RETURN_TO = "/";
+export declare function isSameOrigin(request: Request, origin: string): boolean;
+export declare function isNavigation(request: Request): boolean;
+export declare function safeReturnTo(value: string | null | undefined): string;

package/dist/oidc/request.js

@@ -0,0 +1,23 @@
+export const DEFAULT_RETURN_TO = '/';
+const HTML_MEDIA_TYPE = 'text/html';
+// La cabecera Origin del pedido es la de la app. Sin Origin, no: el logout lo hace un form del
+// propio sitio, y los navegadores mandan Origin en todo POST.
+export function isSameOrigin(request, origin) {
+    return request.headers.get('origin') === origin;
+}
+// Una navegación del navegador (GET que acepta text/html), no un fetch de la app. Las navegaciones
+// del lado del cliente de un framework (SvelteKit: event.isDataRequest) llegan como fetch: las
+// tiene que sumar la app.
+export function isNavigation(request) {
+    return (request.method === 'GET' && Boolean(request.headers.get('accept')?.includes(HTML_MEDIA_TYPE)));
+}
+// Solo rutas propias: empieza con una sola '/'. '//otro-sitio' y '/\otro-sitio' los navegadores los
+// toman como una URL de otro origen (open redirect), igual que 'https://otro-sitio'.
+export function safeReturnTo(value) {
+    if (!value?.startsWith('/'))
+        return DEFAULT_RETURN_TO;
+    const second = value.charAt(1);
+    if (second === '/' || second === '\\')
+        return DEFAULT_RETURN_TO;
+    return value;
+}

package/dist/oidc/types.d.ts

@@ -0,0 +1 @@
+export type Claims = Record<string, unknown>;

package/dist/oidc/types.js

@@ -0,0 +1 @@
+export {};

package/dist/oidc/user.d.ts

@@ -0,0 +1,10 @@
+import { type DomainUserOptions } from './domain-user.ts';
+import { type Permissions } from './permissions.ts';
+import type { Tokens } from './provider.ts';
+export type OidcUser = {
+    domainUser: string;
+    name?: string;
+    groups: string[];
+    permissions: Permissions;
+};
+export declare function getUser(tokens: Pick<Tokens, 'idTokenClaims' | 'accessTokenClaims'>, options?: DomainUserOptions): OidcUser | undefined;

package/dist/oidc/user.js

@@ -0,0 +1,27 @@
+import { getDomainUser } from "./domain-user.js";
+import { getPermissions } from "./permissions.js";
+// El usuario a partir de los tokens de exchangeCode, o undefined si no hay usuario de red. El
+// nombre, primero del id_token (validado). Grupos y roles, del access token: Keycloak los manda
+// solo ahí. Los roles son los del client al que se le emitió el token (claim azp). Sin access
+// token JWT, sin grupos ni permisos. Guardarlo (la sesión) es cosa de la app.
+export function getUser(tokens, options) {
+    const { idTokenClaims, accessTokenClaims } = tokens;
+    const domainUser = getDomainUser(idTokenClaims, accessTokenClaims, options);
+    if (!domainUser)
+        return undefined;
+    const clientId = stringClaim(accessTokenClaims, 'azp');
+    return {
+        domainUser,
+        name: stringClaim(idTokenClaims, 'name') ?? stringClaim(accessTokenClaims, 'name'),
+        groups: stringArrayClaim(accessTokenClaims, 'groups'),
+        permissions: clientId ? getPermissions(accessTokenClaims, clientId) : {},
+    };
+}
+function stringClaim(claims, name) {
+    const value = claims?.[name];
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+function stringArrayClaim(claims, name) {
+    const value = claims?.[name];
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}

package/dist/sveltekit-handlers.d.ts

@@ -0,0 +1,18 @@
+import { type RequestEvent, type RequestHandler } from '@sveltejs/kit';
+import { OidcError } from './oidc/errors.ts';
+import { type OidcProvider, type OidcProviderOptions, type Tokens } from './oidc/provider.ts';
+export type OidcSvelteKitOptions = Omit<OidcProviderOptions, 'callbackPath'> & {
+    basePath: string;
+    cookiePrefix: string;
+    sessionMaxAge?: number;
+    postLogoutPath?: string;
+    onLogin: (tokens: Tokens, event: RequestEvent) => void | false | Promise<void | false>;
+    onLogout?: (event: RequestEvent) => void | Promise<void>;
+    onLoginError?: (error: OidcError, event: RequestEvent) => Response | Promise<Response>;
+};
+export type OidcSvelteKitHandlers = {
+    handler: RequestHandler;
+    loginRedirect: (event: RequestEvent) => string | undefined;
+    provider: OidcProvider;
+};
+export declare function createOidcSvelteKitHandlers(options: OidcSvelteKitOptions): OidcSvelteKitHandlers;

package/dist/sveltekit-handlers.js

@@ -0,0 +1,122 @@
+// La capa SvelteKit (etapa 2): hace con el provider lo que en la etapa 1 arma a mano la app (ver la
+// app de prueba, src/routes/api/auth/): las rutas, las cookies, los redirects y la página del login
+// fallido. La app solo arma su sesión (onLogin) y la borra (onLogout).
+import { error, redirect } from '@sveltejs/kit';
+import { OidcError } from "./oidc/errors.js";
+import { createOidcProvider, RETURN_TO_PARAM, } from "./oidc/provider.js";
+import { isNavigation, isSameOrigin } from "./oidc/request.js";
+const LOGIN_PATH = '/login';
+const CALLBACK_PATH = '/callback';
+const LOGOUT_PATH = '/logout';
+const DEFAULT_POST_LOGOUT_PATH = '/';
+const SECONDS_PER_MINUTE = 60;
+const LOGIN_MAX_AGE = 10 * SECONDS_PER_MINUTE;
+const SEE_OTHER = 303;
+const UNAUTHORIZED = 401;
+const FORBIDDEN = 403;
+const NOT_FOUND = 404;
+const METHOD_NOT_ALLOWED = 405;
+export function createOidcSvelteKitHandlers(options) {
+    const { basePath, cookiePrefix, sessionMaxAge, postLogoutPath = DEFAULT_POST_LOGOUT_PATH, onLogin, onLogout, onLoginError = (err) => defaultLoginError(err, basePath), ...providerOptions } = options;
+    const provider = createOidcProvider({
+        ...providerOptions,
+        callbackPath: `${basePath}${CALLBACK_PATH}`,
+    });
+    // Kit solo redirige a otro origen si está en la lista: login y logout van al proveedor
+    const external = [new URL(options.issuer).origin];
+    const loginCookie = cookie(`${cookiePrefix}_login`, `${basePath}${CALLBACK_PATH}`, LOGIN_MAX_AGE);
+    const logoutCookie = cookie(`${cookiePrefix}_logout`, `${basePath}${LOGOUT_PATH}`, sessionMaxAge);
+    const login = async ({ url, cookies }) => {
+        const { providerUrl, pendingLogin } = await provider.buildLoginUrl(url);
+        cookies.set(loginCookie.name, JSON.stringify(pendingLogin), loginCookie.options);
+        redirect(SEE_OTHER, providerUrl.href, { external });
+    };
+    const callback = async (event) => {
+        const { url, cookies } = event;
+        const pendingLogin = parsePendingLogin(cookies.get(loginCookie.name));
+        cookies.delete(loginCookie.name, loginCookie.options);
+        try {
+            const tokens = await provider.exchangeCode(url, pendingLogin);
+            if ((await onLogin(tokens, event)) === false)
+                throw new OidcError('LOGIN_REJECTED', 'la app no aceptó el login');
+            cookies.set(logoutCookie.name, tokens.idToken, logoutCookie.options);
+        }
+        catch (err) {
+            if (!(err instanceof OidcError))
+                throw err;
+            return await onLoginError(err, event);
+        }
+        // pendingLogin está: si no, exchangeCode lanzó NO_LOGIN_IN_PROGRESS
+        redirect(SEE_OTHER, pendingLogin.returnTo);
+    };
+    const logout = async (event) => {
+        const { request, url, cookies } = event;
+        // Propio aunque SvelteKit tenga su chequeo de CSRF: no corre en dev y una app lo puede desactivar
+        if (!isSameOrigin(request, url.origin))
+            error(FORBIDDEN, 'Origin distinto del de la app');
+        const idToken = cookies.get(logoutCookie.name);
+        cookies.delete(logoutCookie.name, logoutCookie.options);
+        await onLogout?.(event);
+        const home = new URL(postLogoutPath, url.origin);
+        const providerLogout = await provider.buildLogoutUrl(idToken, home.href);
+        redirect(SEE_OTHER, (providerLogout ?? home).href, { external });
+    };
+    const routes = {
+        [LOGIN_PATH]: { method: 'GET', handle: login },
+        [CALLBACK_PATH]: { method: 'GET', handle: callback },
+        [LOGOUT_PATH]: { method: 'POST', handle: logout },
+    };
+    const handler = (event) => {
+        const route = routes[event.url.pathname.slice(basePath.length)];
+        if (!route)
+            error(NOT_FOUND);
+        if (event.request.method !== route.method)
+            return new Response(undefined, {
+                status: METHOD_NOT_ALLOWED,
+                headers: { allow: route.method },
+            });
+        return route.handle(event);
+    };
+    const loginRedirect = ({ request, url, isDataRequest }) => {
+        if (!isDataRequest && !isNavigation(request))
+            return undefined;
+        if (url.pathname === basePath || url.pathname.startsWith(`${basePath}/`))
+            return undefined;
+        const params = new URLSearchParams({ [RETURN_TO_PARAM]: `${url.pathname}${url.search}` });
+        return `${basePath}${LOGIN_PATH}?${params}`;
+    };
+    return { handler, loginRedirect, provider };
+}
+// HttpOnly y SameSite=Lax; Secure lo pone SvelteKit (salvo en http://localhost). Las mismas opciones
+// para ponerla y para borrarla.
+function cookie(name, path, maxAge) {
+    return { name, options: { path, httpOnly: true, sameSite: 'lax', maxAge } };
+}
+// Sin cookie, o rota: undefined (exchangeCode da NO_LOGIN_IN_PROGRESS)
+function parsePendingLogin(value) {
+    if (!value)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+// Los errores de un +server.ts no pasan por +error.svelte: la página la arma el componente
+function defaultLoginError(err, basePath) {
+    const { code, message, providerError } = err;
+    console.warn(`[oidc] ${code}: ${message}${providerError ? ` (${providerError})` : ''}`);
+    const html = `<!doctype html>
+<html lang="es">
+<meta charset="utf-8">
+<title>No se pudo entrar</title>
+<h1>No se pudo entrar</h1>
+<p>El login falló (${code}); el detalle está en el log de la app.</p>
+<p><a href="${basePath}${LOGIN_PATH}">Reintentar</a></p>
+</html>`;
+    return new Response(html, {
+        status: UNAUTHORIZED,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    });
+}

package/package.json

@@ -1,6 +1,109 @@
 {
   "name": "@opensas/oidc-sveltekit-adapter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "description": "Login por OpenID Connect (ADFS, Keycloak) para apps SvelteKit, con una capa genérica para cualquier app Node",
+  "engines": {
+    "node": ">=24.0.0 <25"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*",
+    "!dist/**/fixtures.*",
+    "!dist/server"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "keywords": [
+    "svelte",
+    "sveltekit",
+    "oidc",
+    "openid-connect",
+    "adfs",
+    "keycloak"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/trabajo-it/comun/oidc-sveltekit-adapter.git"
+  },
+  "imports": {
+    "#lib": "./src/lib/index.js",
+    "#lib/*": "./src/lib/*",
+    "#e2e/*": "./e2e/*.ts"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": "^3.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.64.1",
+    "@sveltejs/adapter-node": "^6.0.1",
+    "@sveltejs/kit": "^3.1.0",
+    "@sveltejs/package": "^3.0.0",
+    "@sveltejs/vite-plugin-svelte": "^7.3.1",
+    "@types/node": "^24.19.2",
+    "eslint": "^10.13.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-check-file": "^3.3.2",
+    "eslint-plugin-simple-import-sort": "^14.0.0",
+    "eslint-plugin-svelte": "^3.23.1",
+    "eslint-plugin-unicorn": "^71.1.0",
+    "globals": "^17.13.0",
+    "prettier": "^3.9.10",
+    "prettier-plugin-svelte": "^4.1.0",
+    "publint": "^0.3.25",
+    "shiki": "^4.6.0",
+    "svelte": "^5.57.2",
+    "svelte-check": "^4.7.7",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.72.0",
+    "vite": "^8.3.5",
+    "vitest": "^4.1.12"
+  },
+  "dependencies": {
+    "openid-client": "^6.8.9"
+  },
+  "scripts": {
+    "dev": "NODE_EXTRA_CA_CERTS=docker/keycloak/certs/localhost.crt vite dev",
+    "build": "vite build && pnpm prepack",
+    "preview": "NODE_EXTRA_CA_CERTS=docker/keycloak/certs/localhost.crt vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "format": "prettier --write --cache --log-level warn .",
+    "lint": "eslint . --cache",
+    "lint:clean": "node -e \"for (const p of ['.eslintcache', 'node_modules/.cache/prettier']) require('node:fs').rmSync(p, { recursive: true, force: true })\"",
+    "verify": "eslint . --fix --cache && pnpm format && pnpm check",
+    "up:safe": "pnpm --config.minimumReleaseAge=1440 up -i",
+    "sv:sync-deps": "node scripts/sv-sync-deps.ts",
+    "keycloak:cert": "sh scripts/keycloak-cert.sh",
+    "keycloak:start": "pnpm keycloak:cert && docker compose -f docker/keycloak/docker-compose.yaml up -d",
+    "keycloak:stop": "docker compose -f docker/keycloak/docker-compose.yaml stop",
+    "keycloak:status": "docker ps -a --filter name=oidc-sveltekit-adapter-keycloak --format 'table {{.Names}}\\t{{.Status}}\\t{{.Ports}}'",
+    "keycloak:logs": "docker compose -f docker/keycloak/docker-compose.yaml logs -f",
+    "keycloak:purge": "docker compose -f docker/keycloak/docker-compose.yaml down -v",
+    "keycloak:init": "node scripts/keycloak-init.ts",
+    "test": "pnpm test:vite && pnpm test:play",
+    "test:unit": "vitest run --project=unit-tests",
+    "test:vite": "vitest run",
+    "test:e2e": "playwright test --project=e2e-tests --pass-with-no-tests",
+    "test:play": "playwright test --pass-with-no-tests",
+    "test:ci": "node scripts/test-ci.ts",
+    "vm:pack": "node scripts/vm-pack.ts",
+    "gitlab-runner:start": "sudo gitlab-runner start",
+    "gitlab-runner:stop": "sudo gitlab-runner stop",
+    "gitlab-runner:status": "sudo gitlab-runner status",
+    "gitlab-runner:logs": "sudo journalctl -u gitlab-runner -f"
+  }
 }