@jmlq/auth-plugin-jose 0.0.1-alpha.7 → 0.0.1-alpha.8

package/dist/application/factories/create-jose-token-service.d.ts

@@ -1,4 +1,4 @@
-import { type ITokenServicePort } from "@jmlq/auth";
+import { JoseTokenService } from "../../infrastructure/services";
 import type { CreateAuthErrorFn } from "../../infrastructure/services/types";
 import { JoseTokenServiceOptions } from "../types";
 /**
@@ -11,4 +11,4 @@ import { JoseTokenServiceOptions } from "../types";
  */
 export declare function createJoseTokenService(options: JoseTokenServiceOptions, deps: {
     createAuthError: CreateAuthErrorFn;
-}): ITokenServicePort;
+}): JoseTokenService;

package/dist/application/factories/create-jose-token-service.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJoseTokenService = createJoseTokenService;
-const auth_1 = require("@jmlq/auth");
 const services_1 = require("../../infrastructure/services");
 const internal_1 = require("./internal");
-const types_1 = require("../types");
 /**
  * Factory para construir un `ITokenServicePort` basado en `jose`.
  *
@@ -16,21 +14,13 @@ const types_1 = require("../types");
 function createJoseTokenService(options, deps) {
     (0, internal_1.assert)(options, "JoseTokenServiceOptions is required");
     (0, internal_1.assert)(deps?.createAuthError, "createAuthError dependency is required");
-    const keyMaterial = (0, internal_1.validateKeyMaterial)(options.keyMaterial);
-    // Normalización mínima local (string trim -> undefined) OK en application
-    const issuer = (0, auth_1.readNonEmptyString)(options.issuer);
-    // IMPORTANTE:
-    // - clockSkewSeconds y defaultExpiresIn se delegan a infraestructura para
-    //   aplicar normalización estándar desde @jmlq/auth.
-    const clockSkewSeconds = options.clockSkewSeconds;
-    const defaultExpiresIn = options.defaultExpiresIn;
     return new services_1.JoseTokenService({
         options: {
-            keyMaterial,
-            issuer,
-            clockSkewSeconds,
-            defaultExpiresIn,
-            getExpirationPolicy: types_1.DEFAULT_GET_EXPIRATION_POLICY,
+            keyMaterial: options.keyMaterial,
+            issuer: options.issuer,
+            audience: options.audience,
+            clockSkewSeconds: options.clockSkewSeconds,
+            defaultExpiresIn: options.defaultExpiresIn,
         },
         createAuthError: deps.createAuthError,
     });

package/dist/application/types/index.d.ts

@@ -1,5 +1,3 @@
 export * from "./jose-token-service-options.type";
 export * from "./jose-key-material.type";
 export * from "./default-expires-in.type";
-export * from "./get-expiration-policy.type";
-export { DEFAULT_GET_EXPIRATION_POLICY } from "./get-expiration-policy.type";

package/dist/application/types/index.js

@@ -14,11 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_GET_EXPIRATION_POLICY = void 0;
 __exportStar(require("./jose-token-service-options.type"), exports);
 __exportStar(require("./jose-key-material.type"), exports);
 __exportStar(require("./default-expires-in.type"), exports);
-__exportStar(require("./get-expiration-policy.type"), exports);
-// Constantes públicas
-var get_expiration_policy_type_1 = require("./get-expiration-policy.type");
-Object.defineProperty(exports, "DEFAULT_GET_EXPIRATION_POLICY", { enumerable: true, get: function () { return get_expiration_policy_type_1.DEFAULT_GET_EXPIRATION_POLICY; } });

package/dist/application/types/jose-token-service-options.type.d.ts

@@ -1,6 +1,5 @@
 import type { JoseKeyMaterial } from "./jose-key-material.type";
 import type { DefaultExpiresIn } from "./default-expires-in.type";
-import type { GetExpirationPolicy } from "./get-expiration-policy.type";
 /**
  * Opciones públicas para construir el token service basado en jose.
  * Responsabilidad: configuración neutral, sin acoplar al consumidor a jose.
@@ -8,6 +7,14 @@ import type { GetExpirationPolicy } from "./get-expiration-policy.type";
 export interface JoseTokenServiceOptions {
     keyMaterial: JoseKeyMaterial;
     issuer?: string;
+    /**
+     * Audience opcional para firmar (claim `aud`).
+     * Puede ser string o string[].
+     *
+     * Nota: esto NO es validación de audience contra el token entrante.
+     * Es solo configuración para emisión (firmado).
+     */
+    audience?: string | string[];
     /**
      * Clock skew en segundos para validaciones temporales (iat/nbf/exp).
      */
@@ -16,9 +23,4 @@ export interface JoseTokenServiceOptions {
      * Expiraciones default si el token no define otra (por kind).
      */
     defaultExpiresIn?: DefaultExpiresIn;
-    /**
-     * Política acordada del plugin.
-     * Se fuerza a "verify-first" desde la factory.
-     */
-    getExpirationPolicy?: GetExpirationPolicy;
 }

package/dist/infrastructure/services/jose-token.service.d.ts

@@ -1,4 +1,4 @@
-import type { ITokenServicePort, IJWTPayload, IGenerateAccessTokenProps, IGenerateRefreshTokenProps } from "@jmlq/auth";
+import { type IGenerateAccessTokenProps, type IGenerateRefreshTokenProps, type IJWTPayload, type ITokenServicePort } from "@jmlq/auth";
 import type { JoseTokenServiceOptions } from "../../application/types";
 import type { CreateAuthErrorFn } from "./types";
 /**
@@ -6,20 +6,24 @@ import type { CreateAuthErrorFn } from "./types";
  *
  * Responsabilidad única:
  * - Firmar/verificar JWT
- * - Delegar validación de payload al core (normalizeJwtPayload)
+ * - Delegar validación/normalización del payload al core (normalizeJwtPayload)
  *
  * Clean Architecture (decisión del proyecto):
- * - Aquí (infra) sí consumimos utilidades estándar desde @jmlq/auth,
- *   para evitar duplicidad en cada plugin.
+ * - En infraestructura sí consumimos utilidades estándar desde @jmlq/auth
+ *   (reglas canónicas), para evitar duplicidad en cada plugin.
  */
 export declare class JoseTokenService implements ITokenServicePort {
     private readonly options;
     private readonly createAuthError;
+    private readonly keyMaterial;
     /**
      * Config normalizada (estandarizada) para uso interno.
-     * Se deriva 1 sola vez para evitar repetir lógica.
+     * Se deriva 1 sola vez para evitar repetir lógica y asegurar consistencia.
      */
     private readonly eff;
+    /**
+     * Cache lazy de llaves normalizadas (evita repetir trabajo por request).
+     */
     private keysPromise;
     constructor(cfg: {
         options: JoseTokenServiceOptions;
@@ -29,9 +33,37 @@ export declare class JoseTokenService implements ITokenServicePort {
     generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
     verifyAccessToken(token: string): Promise<IJWTPayload>;
     verifyRefreshToken(token: string): Promise<IJWTPayload>;
+    /**
+     * Obtiene la fecha de expiración del token.
+     *
+     * Estrategia:
+     * - Primero intenta verificarlo como access.
+     * - Si falla con error “retryable”, intenta verificarlo como refresh.
+     * - Si está expirado pero se puede leer exp vía decode (sin verificación),
+     *   retorna esa exp para fines informativos.
+     */
     getTokenExpiration(token: string): Promise<Date>;
+    /**
+     * Construye contexto mínimo (no sensible) para mapear errores.
+     *
+     * ¿Por qué existe?
+     * - Hace diagnósticos más fáciles (operación, tokenKind, alg, issuer).
+     * - Evita exponer token, claims completos o material criptográfico.
+     *
+     * Nota:
+     * - No incluimos audience en el contexto porque la audience en este plugin
+     *   es SOLO para emisión y no participa en verificación (por decisión de diseño).
+     */
     private ctx;
+    /**
+     * Wrapper estándar:
+     * - Ejecuta fn
+     * - En caso de error, lo traduce a AuthDomainError usando el mapper del plugin
+     */
     private withAuthError;
+    /**
+     * Normaliza/carga llaves de forma lazy y cacheada.
+     */
     private getNormalizedKeys;
     private generateToken;
     private verifyToken;

package/dist/infrastructure/services/jose-token.service.js

@@ -1,29 +1,38 @@
 "use strict";
+// src/infrastructure/services/jose-token.service.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoseTokenService = void 0;
-const auth_1 = require("@jmlq/auth");
 const jose_1 = require("jose");
+const auth_1 = require("@jmlq/auth");
+const internal_1 = require("../../application/factories/internal");
 const mappers_1 = require("../mappers");
-const internal_1 = require("./internal");
+const internal_2 = require("./internal");
 /**
  * Implementación de `ITokenServicePort` usando la librería `jose`.
  *
  * Responsabilidad única:
  * - Firmar/verificar JWT
- * - Delegar validación de payload al core (normalizeJwtPayload)
+ * - Delegar validación/normalización del payload al core (normalizeJwtPayload)
  *
  * Clean Architecture (decisión del proyecto):
- * - Aquí (infra) sí consumimos utilidades estándar desde @jmlq/auth,
- *   para evitar duplicidad en cada plugin.
+ * - En infraestructura sí consumimos utilidades estándar desde @jmlq/auth
+ *   (reglas canónicas), para evitar duplicidad en cada plugin.
  */
 class JoseTokenService {
     constructor(cfg) {
+        /**
+         * Cache lazy de llaves normalizadas (evita repetir trabajo por request).
+         */
         this.keysPromise = null;
         this.options = cfg.options;
         this.createAuthError = cfg.createAuthError;
-        // Normalización estándar (core) aplicada en infraestructura
+        // Valida estructura de keyMaterial (alg / secret / keys etc.).
+        this.keyMaterial = (0, internal_1.validateKeyMaterial)(this.options.keyMaterial);
+        // Normalización canónica (core) aplicada en infraestructura.
+        // Nota: si el usuario envía strings con espacios, se estandariza aquí.
         this.eff = {
-            issuer: cfg.options.issuer,
+            issuer: (0, auth_1.readNonEmptyString)(cfg.options.issuer), // "  a  " => "a", " " => undefined
+            audience: (0, auth_1.optionalAudience)(cfg.options.audience), // trim / dedupe+sort / errores canónicos
             clockSkewSeconds: (0, auth_1.normalizeClockSkewSeconds)(cfg.options.clockSkewSeconds),
             defaultExpiresIn: (0, auth_1.normalizeDefaultExpiresIn)(cfg.options.defaultExpiresIn),
         };
@@ -43,15 +52,16 @@ class JoseTokenService {
     async verifyRefreshToken(token) {
         return this.verifyToken("refresh", "verifyRefreshToken", token);
     }
+    /**
+     * Obtiene la fecha de expiración del token.
+     *
+     * Estrategia:
+     * - Primero intenta verificarlo como access.
+     * - Si falla con error “retryable”, intenta verificarlo como refresh.
+     * - Si está expirado pero se puede leer exp vía decode (sin verificación),
+     *   retorna esa exp para fines informativos.
+     */
     async getTokenExpiration(token) {
-        const policy = this.options.getExpirationPolicy ?? "verify-first";
-        if (policy !== "verify-first") {
-            throw this.createAuthError({
-                code: "JWT_ERROR",
-                message: "Unsupported expiration policy",
-                meta: { operation: "getTokenExpiration", tokenKind: "unknown" },
-            });
-        }
         const firstTry = await this.tryGetExpirationByVerify("access", token);
         if (firstTry.ok)
             return firstTry.value;
@@ -65,14 +75,29 @@ class JoseTokenService {
     // ---------------------------------------------------------------------------
     // Internals - ctx + error wrapper
     // ---------------------------------------------------------------------------
+    /**
+     * Construye contexto mínimo (no sensible) para mapear errores.
+     *
+     * ¿Por qué existe?
+     * - Hace diagnósticos más fáciles (operación, tokenKind, alg, issuer).
+     * - Evita exponer token, claims completos o material criptográfico.
+     *
+     * Nota:
+     * - No incluimos audience en el contexto porque la audience en este plugin
+     *   es SOLO para emisión y no participa en verificación (por decisión de diseño).
+     */
     ctx(operation, kind) {
-        const alg = (0, internal_1.getAlgFromKeyMaterial)(this.options.keyMaterial);
-        // FASE 3: sin audience en meta
-        return (0, internal_1.buildJoseCtx)(operation, kind, {
+        const alg = (0, internal_2.getAlgFromKeyMaterial)(this.keyMaterial);
+        return (0, internal_2.buildJoseCtx)(operation, kind, {
             issuer: this.eff.issuer,
             alg,
         });
     }
+    /**
+     * Wrapper estándar:
+     * - Ejecuta fn
+     * - En caso de error, lo traduce a AuthDomainError usando el mapper del plugin
+     */
     async withAuthError(operation, kind, fn) {
         try {
             return await fn();
@@ -84,9 +109,12 @@ class JoseTokenService {
     // ---------------------------------------------------------------------------
     // Internals - keys
     // ---------------------------------------------------------------------------
+    /**
+     * Normaliza/carga llaves de forma lazy y cacheada.
+     */
     getNormalizedKeys() {
         if (!this.keysPromise) {
-            this.keysPromise = (0, internal_1.normalizeKeyMaterial)(this.options.keyMaterial);
+            this.keysPromise = (0, internal_2.normalizeKeyMaterial)(this.keyMaterial);
         }
         return this.keysPromise;
     }
@@ -95,6 +123,7 @@ class JoseTokenService {
     // ---------------------------------------------------------------------------
     async generateToken(kind, operation, props) {
         return this.withAuthError(operation, kind, async () => {
+            // 1) Expiración: usar regla canónica del core (props > default).
             const expiresInFromProps = (0, auth_1.readExpiresIn)(props.expiresIn);
             const defaultExpiresIn = kind === "access"
                 ? this.eff.defaultExpiresIn?.accessToken
@@ -104,17 +133,20 @@ class JoseTokenService {
                 defaultExpiresIn,
                 operation,
             });
+            // 2) Claims estándar
             const roles = props.user.roles ?? [];
-            const customClaims = (0, auth_1.readCustomClaims)(props.customClaims) ??
-                {};
+            const customClaims = (0, auth_1.readCustomClaims)(props.customClaims) ?? {};
+            // 3) Session Id (sid) debe ser un string válido.
             const sid = (0, auth_1.readSessionId)(props.sessionId);
             if (!sid) {
+                // Nota: aquí usamos createAuthError para mantener consistencia del core.
                 throw this.createAuthError({
                     code: "JWT_PAYLOAD_INVALID",
                     message: "sessionId is required",
                     meta: { operation, tokenKind: kind, field: "sessionId" },
                 });
             }
+            // 4) Firmar
             const keys = await this.getNormalizedKeys();
             const jwt = new jose_1.SignJWT({ roles, customClaims, sid })
                 .setProtectedHeader({ alg: keys.alg })
@@ -122,8 +154,13 @@ class JoseTokenService {
                 .setJti((0, auth_1.createJwtId)())
                 .setIssuedAt()
                 .setExpirationTime(expiresIn);
+            // Issuer opcional (si viene configurado y es no-vacío)
             if (this.eff.issuer)
                 jwt.setIssuer(this.eff.issuer);
+            // Audience opcional SOLO para emisión (claim `aud`).
+            // Importante: NO se usa en verificación para no volverlo requisito.
+            if (this.eff.audience)
+                jwt.setAudience(this.eff.audience);
             return keys.alg === "HS256"
                 ? jwt.sign(keys.secret)
                 : jwt.sign(keys.privateKey);
@@ -133,11 +170,21 @@ class JoseTokenService {
         return this.withAuthError(operation, kind, async () => {
             const keys = await this.getNormalizedKeys();
             const key = keys.alg === "HS256" ? keys.secret : keys.publicKey;
-            // FASE 2/3: jwtVerify sin audience; clockSkew ya normalizado
+            /**
+             * Verificación:
+             * - issuer: se aplica si está configurado (si no, se omite)
+             * - clockTolerance: ya normalizado (clock skew seguro)
+             *
+             * Nota: NO pasamos `audience` a jwtVerify.
+             * - La audiencia en este plugin es SOLO para emisión.
+             * - Pasarla aquí convertiría audience en una restricción (“must match”)
+             *   y rompería compatibilidad con tokens válidos sin `aud`.
+             */
             const result = await (0, jose_1.jwtVerify)(token, key, {
                 issuer: this.eff.issuer,
                 clockTolerance: this.eff.clockSkewSeconds,
             });
+            // Delegar a la regla canónica del core: valida + normaliza payload.
             return (0, auth_1.normalizeJwtPayload)(result.payload);
         });
     }
@@ -147,11 +194,15 @@ class JoseTokenService {
             return { ok: true, value: (0, auth_1.toDateFromUnixSeconds)(payload.exp) };
         }
         catch (err) {
+            // Si el error ya es un AuthDomainError, aplicamos reglas de retry/fallback.
             if (auth_1.AuthDomainError.isAuthError(err)) {
+                // Caso especial: si expiró, podemos leer exp por decode (sin verificar)
+                // para devolver la fecha de expiración con fines informativos.
                 if (err.code === "TOKEN_EXPIRED") {
-                    const exp = (0, internal_1.tryReadExpByDecode)(token);
-                    if (exp !== null)
+                    const exp = (0, internal_2.tryReadExpByDecode)(token);
+                    if (exp !== null) {
                         return { ok: true, value: (0, auth_1.toDateFromUnixSeconds)(exp) };
+                    }
                 }
                 return {
                     ok: false,
@@ -159,6 +210,7 @@ class JoseTokenService {
                     error: err,
                 };
             }
+            // Si es un error no estándar, lo envolvemos para mantener consistencia.
             const wrapped = (0, mappers_1.toAuthDomainError)(this.createAuthError, err, this.ctx("getTokenExpiration", kind));
             return { ok: false, retryable: false, error: wrapped };
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jmlq/auth-plugin-jose",
   "description": "Infrastructure plugin that integrates the jose library with @jmlq/auth, providing JWT token generation and verification following Clean Architecture principles.",
-  "version": "0.0.1-alpha.7",
+  "version": "0.0.1-alpha.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -29,7 +29,7 @@
   "author": "MLahuasi",
   "license": "MIT",
   "dependencies": {
-    "@jmlq/auth": "^0.0.1-alpha.27",
+    "@jmlq/auth": "^0.0.1-alpha.28",
     "jose": "^6.1.3"
   },
   "devDependencies": {

package/dist/application/types/get-expiration-policy.type.d.ts

@@ -1,9 +0,0 @@
-/**
- * Política de expiración del plugin.
- * - "verify-first": verifica el token y si no tiene exp, aplica default.
- */
-export type GetExpirationPolicy = "verify-first";
-/**
- * Política por defecto del plugin (estándar acordado).
- */
-export declare const DEFAULT_GET_EXPIRATION_POLICY: GetExpirationPolicy;

package/dist/application/types/get-expiration-policy.type.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_GET_EXPIRATION_POLICY = void 0;
-/**
- * Política por defecto del plugin (estándar acordado).
- */
-exports.DEFAULT_GET_EXPIRATION_POLICY = "verify-first";