@dacyti-gsi/auth 0.2.0 → 0.3.0

package/src/next.ts

@@ -2,14 +2,14 @@ import { cookies } from "next/headers";
 import { redirect } from "next/navigation";
 import { type NextRequest, NextResponse } from "next/server";
 
-import { defineSSO, warnIfStaleSession, type SSOClient } from "./index";
-import { bindComponents } from "./react";
+import { defineSSO, type SSOClient, warnIfStaleSession } from "./index";
 import {
   type AccessPolicy,
   type AuthorizationError,
   authorize,
   isAuthorizationError,
 } from "./policy";
+import { bindComponents } from "./react";
 import type { SSOClientOptions, SSOSession } from "./types";
 
 /** Cuándo una pantalla quiere permisos vivos en lugar de la foto de la cookie. */
@@ -52,10 +52,14 @@ export type NextSSO<Permission extends string> = SSOClient<Permission> & {
    *
    * Sin sesión redirige a autenticarse (con vuelta a la página actual cuando se
    * le pasa `returnTo`). Sin permiso o sin segundo factor, lanza
-   * `SSOForbiddenError` / `SSOMfaRequiredError` para responder 403.
+   * `SSOForbiddenError` / `SSOMfaRequiredError` para responder 403 —salvo que
+   * se pase `deniedRedirect`, que manda ahí al denegado en lugar de lanzar.
    */
   protectPage(
-    policy?: AccessPolicy<Permission> & { returnTo?: string },
+    policy?: AccessPolicy<Permission> & {
+      returnTo?: string;
+      deniedRedirect?: string;
+    },
   ): Promise<SSOSession<Permission>>;
 
   /**
@@ -242,10 +246,19 @@ export function defineNextSSO<const Permission extends string = string>(
     },
 
     async protectPage(policy = {}) {
-      const { returnTo, ...access } = policy;
+      const { returnTo, deniedRedirect, ...access } = policy;
       const session = await resolve(access.revalidate ?? false);
       if (!session) redirect(client.signInPath(returnTo));
-      return authorize(session, access);
+      try {
+        return authorize(session, access);
+      } catch (error) {
+        // Denegación de la política (no fallo del portal): con destino
+        // declarado, al aviso en lugar de al 403 seco.
+        if (deniedRedirect && isAuthorizationError(error)) {
+          redirect(deniedRedirect);
+        }
+        throw error;
+      }
     },
 
     action<Args extends unknown[], Out>(

package/src/policy.ts

@@ -1,102 +1,102 @@
-import { SSOError, SSOForbiddenError } from "./errors";
-import type { SSOSession } from "./types";
-
-/** La sesión terminó o nunca existió: hay que mandar a autenticarse. */
-export class SSOAuthRequiredError extends SSOError {
-  constructor(message = "Se requiere sesión.") {
-    super(message);
-  }
-}
-
-/** Hay sesión pero sin segundo factor, y la política lo exige. */
-export class SSOMfaRequiredError extends SSOError {
-  constructor(message = "Esta operación requiere verificación en dos pasos.") {
-    super(message);
-  }
-}
-
-/**
- * Denegación de la política: sin sesión, sin permiso o sin segundo factor.
- *
- * Son los únicos errores que `onDenied` convierte en valor. Un fallo del
- * portal (`SSOProtocolError`) o de configuración nunca se tragan: una caída
- * no es una denegación y tratarla como tal echaría a usuarios por un 502.
- */
-export type AuthorizationError =
-  | SSOAuthRequiredError
-  | SSOForbiddenError
-  | SSOMfaRequiredError;
-
-export function isAuthorizationError(
-  error: unknown,
-): error is AuthorizationError {
-  return (
-    error instanceof SSOAuthRequiredError ||
-    error instanceof SSOForbiddenError ||
-    error instanceof SSOMfaRequiredError
-  );
-}
-
-/**
- * Política de acceso declarativa. Todo deniega por defecto: solo se permite lo
- * que se declara.
- */
-export type AccessPolicy<Permission extends string = string> = {
-  /** Permiso exigido. Sin sesión o sin permiso, se deniega. */
-  permission?: Permission | readonly Permission[];
-  /** Exige que todos los permisos listados estén presentes. Por defecto basta uno. */
-  mode?: "any" | "all";
-  /**
-   * Exige tener al menos un permiso de esta aplicación, cualquiera.
-   *
-   * El portal autentica a cualquier cuenta: haber entrado no significa tener acceso a
-   * esta app. Con `access: true` quien llega sin ningún permiso queda fuera (403), sin
-   * tener que escoger un permiso «de entrada» arbitrario.
-   */
-  access?: boolean;
-  /** Exige segundo factor (`amr` incluye `mfa`). */
-  requireMfa?: boolean;
-  /** Vuelve a preguntar al portal por permisos vivos. */
-  revalidate?: boolean;
-};
-
-/**
- * Decide si una sesión cumple la política. No habla con la red: la frescura la
- * decide quien llama (`revalidate` en `protect`/`action`).
- *
- * Lanza `SSOForbiddenError`, `SSOMfaRequiredError` o `SSOAuthRequiredError`.
- * Devuelve la sesión para encadenar.
- */
-export function authorize<Permission extends string>(
-  session: SSOSession<Permission> | null,
-  policy: AccessPolicy<Permission> = {},
-): SSOSession<Permission> {
-  if (!session) throw new SSOAuthRequiredError();
-
-  if (policy.access && session.permissions.length === 0) {
-    throw new SSOForbiddenError("acceso");
-  }
-
-  const wanted = policy.permission
-    ? Array.isArray(policy.permission)
-      ? [...policy.permission]
-      : [policy.permission]
-    : [];
-
-  if (wanted.length > 0) {
-    const ok =
-      policy.mode === "all"
-        ? session.canAll(...wanted)
-        : session.canAny(...wanted);
-    if (!ok) {
-      const missing = wanted.find((p) => !session.can(p)) ?? wanted[0];
-      session.requires(missing as Permission);
-    }
-  }
-
-  if (policy.requireMfa && !session.usedSecondFactor()) {
-    throw new SSOMfaRequiredError();
-  }
-
-  return session;
-}
+import { SSOError, SSOForbiddenError } from "./errors";
+import type { SSOSession } from "./types";
+
+/** La sesión terminó o nunca existió: hay que mandar a autenticarse. */
+export class SSOAuthRequiredError extends SSOError {
+  constructor(message = "Se requiere sesión.") {
+    super(message);
+  }
+}
+
+/** Hay sesión pero sin segundo factor, y la política lo exige. */
+export class SSOMfaRequiredError extends SSOError {
+  constructor(message = "Esta operación requiere verificación en dos pasos.") {
+    super(message);
+  }
+}
+
+/**
+ * Denegación de la política: sin sesión, sin permiso o sin segundo factor.
+ *
+ * Son los únicos errores que `onDenied` convierte en valor. Un fallo del
+ * portal (`SSOProtocolError`) o de configuración nunca se tragan: una caída
+ * no es una denegación y tratarla como tal echaría a usuarios por un 502.
+ */
+export type AuthorizationError =
+  | SSOAuthRequiredError
+  | SSOForbiddenError
+  | SSOMfaRequiredError;
+
+export function isAuthorizationError(
+  error: unknown,
+): error is AuthorizationError {
+  return (
+    error instanceof SSOAuthRequiredError ||
+    error instanceof SSOForbiddenError ||
+    error instanceof SSOMfaRequiredError
+  );
+}
+
+/**
+ * Política de acceso declarativa. Todo deniega por defecto: solo se permite lo
+ * que se declara.
+ */
+export type AccessPolicy<Permission extends string = string> = {
+  /** Permiso exigido. Sin sesión o sin permiso, se deniega. */
+  permission?: Permission | readonly Permission[];
+  /** Exige que todos los permisos listados estén presentes. Por defecto basta uno. */
+  mode?: "any" | "all";
+  /**
+   * Exige tener al menos un permiso de esta aplicación, cualquiera.
+   *
+   * El portal autentica a cualquier cuenta: haber entrado no significa tener acceso a
+   * esta app. Con `access: true` quien llega sin ningún permiso queda fuera (403), sin
+   * tener que escoger un permiso «de entrada» arbitrario.
+   */
+  access?: boolean;
+  /** Exige segundo factor (`amr` incluye `mfa`). */
+  requireMfa?: boolean;
+  /** Vuelve a preguntar al portal por permisos vivos. */
+  revalidate?: boolean;
+};
+
+/**
+ * Decide si una sesión cumple la política. No habla con la red: la frescura la
+ * decide quien llama (`revalidate` en `protect`/`action`).
+ *
+ * Lanza `SSOForbiddenError`, `SSOMfaRequiredError` o `SSOAuthRequiredError`.
+ * Devuelve la sesión para encadenar.
+ */
+export function authorize<Permission extends string>(
+  session: SSOSession<Permission> | null,
+  policy: AccessPolicy<Permission> = {},
+): SSOSession<Permission> {
+  if (!session) throw new SSOAuthRequiredError();
+
+  if (policy.access && session.permissions.length === 0) {
+    throw new SSOForbiddenError("acceso");
+  }
+
+  const wanted = policy.permission
+    ? Array.isArray(policy.permission)
+      ? [...policy.permission]
+      : [policy.permission]
+    : [];
+
+  if (wanted.length > 0) {
+    const ok =
+      policy.mode === "all"
+        ? session.canAll(...wanted)
+        : session.canAny(...wanted);
+    if (!ok) {
+      const missing = wanted.find((p) => !session.can(p)) ?? wanted[0];
+      session.requires(missing as Permission);
+    }
+  }
+
+  if (policy.requireMfa && !session.usedSecondFactor()) {
+    throw new SSOMfaRequiredError();
+  }
+
+  return session;
+}

package/src/react.tsx

@@ -1,171 +1,171 @@
-import type { ComponentProps, ReactNode } from "react";
-
-import { type AccessPolicy, authorize } from "./policy";
-import type { SSOSession } from "./types";
-
-/** Lo mínimo que un componente necesita: resolver la sesión actual. */
-export type SessionResolver<Permission extends string> = {
-  session(options?: {
-    revalidate?: boolean;
-  }): Promise<SSOSession<Permission> | null>;
-};
-
-export type ProtectProps<Permission extends string> =
-  AccessPolicy<Permission> & {
-    /** El cliente Next (`sso`). Explícito a propósito: sin contexto global que heredar. */
-    sso: SessionResolver<Permission>;
-    children: ReactNode;
-    /** Qué pintar cuando se deniega. Por defecto no pinta nada (niega por defecto). */
-    fallback?: ReactNode;
-  };
-
-/**
- * Guarda declarativa para React Server Components.
- *
- * ```tsx
- * <Protect sso={sso} permission="documentos:anular" fallback={<p>Sin acceso.</p>}>
- *   <BotonAnular />
- * </Protect>
- * ```
- *
- * Nunca redirige ni lanza: denegar pinta `fallback` (o nada). Para páginas
- * completas usa `sso.protectPage()`, que sí redirige a entrar.
- */
-export async function Protect<Permission extends string>({
-  sso,
-  children,
-  fallback = null,
-  ...policy
-}: ProtectProps<Permission>): Promise<ReactNode> {
-  const session = await sso.session({ revalidate: policy.revalidate ?? false });
-
-  try {
-    authorize(session, policy);
-    return children;
-  } catch {
-    return fallback;
-  }
-}
-
-export type CanProps<Permission extends string> = AccessPolicy<Permission> & {
-  sso: SessionResolver<Permission>;
-  children: ReactNode;
-  fallback?: ReactNode;
-};
-
-/**
- * Alias de `Protect` para permisos puntuales en la interfaz. Misma negación
- * por defecto: sin permiso, `fallback` o nada.
- */
-export async function Can<Permission extends string>(
-  props: CanProps<Permission>,
-): Promise<ReactNode> {
-  return Protect(props);
-}
-
-/** Lo mínimo para pintar enlaces de entrada y salida. */
-export type LinkResolver = {
-  signInPath(returnTo?: string): string;
-  signOutPath(): string;
-};
-
-type AnchorRest = Omit<ComponentProps<"a">, "href">;
-
-export type SignInLinkProps = AnchorRest & {
-  /** El cliente Next (`sso`). */
-  sso: LinkResolver;
-  /** A dónde volver tras entrar. Por defecto, la raíz. */
-  returnTo?: string;
-};
-
-/**
- * Enlace de entrada.
- *
- * ```tsx
- * <SignInLink sso={sso} returnTo="/panel" className="boton">
- *   Entrar con el Portal SSO
- * </SignInLink>
- * ```
- */
-export function SignInLink({
-  sso,
-  returnTo,
-  children = "Entrar",
-  ...anchor
-}: SignInLinkProps): ReactNode {
-  return (
-    <a {...anchor} href={sso.signInPath(returnTo)}>
-      {children}
-    </a>
-  );
-}
-
-export type SignOutLinkProps = AnchorRest & {
-  /** El cliente Next (`sso`). */
-  sso: LinkResolver;
-};
-
-/**
- * Enlace de salida. Cierra la sesión local **y** la del portal: salir solo de
- * la local dejaría a la persona dentro del portal y el siguiente entrar la
- * devolvería sin pedir nada.
- */
-export function SignOutLink({
-  sso,
-  children = "Salir",
-  ...anchor
-}: SignOutLinkProps): ReactNode {
-  return (
-    <a {...anchor} href={sso.signOutPath()}>
-      {children}
-    </a>
-  );
-}
-
-type BoundProps<Permission extends string> = AccessPolicy<Permission> & {
-  children: ReactNode;
-  fallback?: ReactNode;
-};
-
-/**
- * Los componentes ya atados a un cliente: sin pasar `sso` en cada uso y con el catálogo de
- * permisos tipado (una errata en `permission` no compila).
- *
- * ```tsx
- * // lib/sso.ts
- * export const { Can, SignedIn, SignedOut, SignInLink, SignOutLink } = sso.components;
- *
- * <SignedOut><SignInLink returnTo="/panel" /></SignedOut>
- * <SignedIn><SignOutLink /></SignedIn>
- * <Can permission="documentos:anular"><BotonAnular /></Can>
- * ```
- */
-export function bindComponents<Permission extends string>(
-  sso: SessionResolver<Permission> & LinkResolver,
-) {
-  return {
-    /** Pinta los hijos si se cumple la política; si no, `fallback` o nada. */
-    Can: (props: BoundProps<Permission>) => Protect({ ...props, sso }),
-    /** Igual que `Can`; el nombre que lee mejor para bloques completos. */
-    Protect: (props: BoundProps<Permission>) => Protect({ ...props, sso }),
-
-    /** Solo con sesión. */
-    SignedIn: async ({
-      children,
-    }: {
-      children: ReactNode;
-    }): Promise<ReactNode> => ((await sso.session()) ? children : null),
-
-    /** Solo sin sesión. */
-    SignedOut: async ({
-      children,
-    }: {
-      children: ReactNode;
-    }): Promise<ReactNode> => ((await sso.session()) ? null : children),
-
-    SignInLink: (props: Omit<SignInLinkProps, "sso">) =>
-      SignInLink({ ...props, sso }),
-    SignOutLink: (props: Omit<SignOutLinkProps, "sso">) =>
-      SignOutLink({ ...props, sso }),
-  };
-}
+import type { ComponentProps, ReactNode } from "react";
+
+import { type AccessPolicy, authorize } from "./policy";
+import type { SSOSession } from "./types";
+
+/** Lo mínimo que un componente necesita: resolver la sesión actual. */
+export type SessionResolver<Permission extends string> = {
+  session(options?: {
+    revalidate?: boolean;
+  }): Promise<SSOSession<Permission> | null>;
+};
+
+export type ProtectProps<Permission extends string> =
+  AccessPolicy<Permission> & {
+    /** El cliente Next (`sso`). Explícito a propósito: sin contexto global que heredar. */
+    sso: SessionResolver<Permission>;
+    children: ReactNode;
+    /** Qué pintar cuando se deniega. Por defecto no pinta nada (niega por defecto). */
+    fallback?: ReactNode;
+  };
+
+/**
+ * Guarda declarativa para React Server Components.
+ *
+ * ```tsx
+ * <Protect sso={sso} permission="pedidos:anular" fallback={<p>Sin acceso.</p>}>
+ *   <BotonAnular />
+ * </Protect>
+ * ```
+ *
+ * Nunca redirige ni lanza: denegar pinta `fallback` (o nada). Para páginas
+ * completas usa `sso.protectPage()`, que sí redirige a entrar.
+ */
+export async function Protect<Permission extends string>({
+  sso,
+  children,
+  fallback = null,
+  ...policy
+}: ProtectProps<Permission>): Promise<ReactNode> {
+  const session = await sso.session({ revalidate: policy.revalidate ?? false });
+
+  try {
+    authorize(session, policy);
+    return children;
+  } catch {
+    return fallback;
+  }
+}
+
+export type CanProps<Permission extends string> = AccessPolicy<Permission> & {
+  sso: SessionResolver<Permission>;
+  children: ReactNode;
+  fallback?: ReactNode;
+};
+
+/**
+ * Alias de `Protect` para permisos puntuales en la interfaz. Misma negación
+ * por defecto: sin permiso, `fallback` o nada.
+ */
+export async function Can<Permission extends string>(
+  props: CanProps<Permission>,
+): Promise<ReactNode> {
+  return Protect(props);
+}
+
+/** Lo mínimo para pintar enlaces de entrada y salida. */
+export type LinkResolver = {
+  signInPath(returnTo?: string): string;
+  signOutPath(): string;
+};
+
+type AnchorRest = Omit<ComponentProps<"a">, "href">;
+
+export type SignInLinkProps = AnchorRest & {
+  /** El cliente Next (`sso`). */
+  sso: LinkResolver;
+  /** A dónde volver tras entrar. Por defecto, la raíz. */
+  returnTo?: string;
+};
+
+/**
+ * Enlace de entrada.
+ *
+ * ```tsx
+ * <SignInLink sso={sso} returnTo="/panel" className="boton">
+ *   Entrar con el Portal SSO
+ * </SignInLink>
+ * ```
+ */
+export function SignInLink({
+  sso,
+  returnTo,
+  children = "Entrar",
+  ...anchor
+}: SignInLinkProps): ReactNode {
+  return (
+    <a {...anchor} href={sso.signInPath(returnTo)}>
+      {children}
+    </a>
+  );
+}
+
+export type SignOutLinkProps = AnchorRest & {
+  /** El cliente Next (`sso`). */
+  sso: LinkResolver;
+};
+
+/**
+ * Enlace de salida. Cierra la sesión local **y** la del portal: salir solo de
+ * la local dejaría a la persona dentro del portal y el siguiente entrar la
+ * devolvería sin pedir nada.
+ */
+export function SignOutLink({
+  sso,
+  children = "Salir",
+  ...anchor
+}: SignOutLinkProps): ReactNode {
+  return (
+    <a {...anchor} href={sso.signOutPath()}>
+      {children}
+    </a>
+  );
+}
+
+type BoundProps<Permission extends string> = AccessPolicy<Permission> & {
+  children: ReactNode;
+  fallback?: ReactNode;
+};
+
+/**
+ * Los componentes ya atados a un cliente: sin pasar `sso` en cada uso y con el catálogo de
+ * permisos tipado (una errata en `permission` no compila).
+ *
+ * ```tsx
+ * // lib/sso.ts
+ * export const { Can, SignedIn, SignedOut, SignInLink, SignOutLink } = sso.components;
+ *
+ * <SignedOut><SignInLink returnTo="/panel" /></SignedOut>
+ * <SignedIn><SignOutLink /></SignedIn>
+ * <Can permission="pedidos:anular"><BotonAnular /></Can>
+ * ```
+ */
+export function bindComponents<Permission extends string>(
+  sso: SessionResolver<Permission> & LinkResolver,
+) {
+  return {
+    /** Pinta los hijos si se cumple la política; si no, `fallback` o nada. */
+    Can: (props: BoundProps<Permission>) => Protect({ ...props, sso }),
+    /** Igual que `Can`; el nombre que lee mejor para bloques completos. */
+    Protect: (props: BoundProps<Permission>) => Protect({ ...props, sso }),
+
+    /** Solo con sesión. */
+    SignedIn: async ({
+      children,
+    }: {
+      children: ReactNode;
+    }): Promise<ReactNode> => ((await sso.session()) ? children : null),
+
+    /** Solo sin sesión. */
+    SignedOut: async ({
+      children,
+    }: {
+      children: ReactNode;
+    }): Promise<ReactNode> => ((await sso.session()) ? null : children),
+
+    SignInLink: (props: Omit<SignInLinkProps, "sso">) =>
+      SignInLink({ ...props, sso }),
+    SignOutLink: (props: Omit<SignOutLinkProps, "sso">) =>
+      SignOutLink({ ...props, sso }),
+  };
+}

package/src/session-cookie.ts

@@ -4,13 +4,11 @@ import { EncryptJWT, jwtDecrypt } from "jose";
 
 import { SSOConfigError } from "./errors";
 
-/** Contenido que se guarda cifrado en la cookie. */
+/** Contenido que se guarda cifrado en la cookie: identidad mínima + autorización. */
 export type SessionPayload = {
   sub: string;
   email: string;
-  emailVerified: boolean;
   name: string | null;
-  image: string | null;
   roles: string[];
   permissions: string[];
   amr: string[];

package/src/types.ts

@@ -89,9 +89,7 @@ export type SSOUser = {
   /** Identificador estable. Úsalo como clave, no el correo. */
   id: string;
   email: string;
-  emailVerified: boolean;
   name: string | null;
-  image: string | null;
 };
 
 export type SSOSession<Permission extends string = string> = {