@jmlq/auth 0.0.1-alpha.1

package/dist/src/infrastructure/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./token-session.service"), exports);
+__exportStar(require("./jwt-token.service"), exports);

package/dist/src/infrastructure/services/jwt-token.service.d.ts

@@ -0,0 +1,15 @@
+import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps, IJWTPayload, ITokenService } from "../../domain";
+import { JwtTokenServiceConfig } from "../../shared";
+import { JwtTokenGenerator, JwtTokenValidator, JwtTokenVerifier } from "../jwt";
+export declare class JwtTokenService implements ITokenService {
+    private readonly config;
+    private readonly jwtGenerator;
+    private readonly jwtVerifier;
+    private readonly jwtValidator;
+    constructor(config: JwtTokenServiceConfig, jwtGenerator: JwtTokenGenerator, jwtVerifier: JwtTokenVerifier, jwtValidator: JwtTokenValidator);
+    generateAccessToken(props: IGenerateAccessTokenProps): Promise<string>;
+    generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
+    verifyAccessToken(token: string): Promise<IJWTPayload>;
+    verifyRefreshToken(token: string): Promise<IJWTPayload>;
+    getTokenExpiration(token: string): Promise<Date>;
+}

package/dist/src/infrastructure/services/jwt-token.service.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtTokenService = void 0;
+// Servicio de tokens JWT que implementa ITokenService
+class JwtTokenService {
+    constructor(
+    // config → secretos, tiempos de expiración y algoritmo.
+    config, 
+    // jwtGenerator → crea y firma los tokens.
+    jwtGenerator, 
+    // jwtVerifier → comprueba firmas y expiraciones.
+    jwtVerifier, 
+    // jwtValidator → revisa formato y estructura
+    jwtValidator) {
+        this.config = config;
+        this.jwtGenerator = jwtGenerator;
+        this.jwtVerifier = jwtVerifier;
+        this.jwtValidator = jwtValidator;
+    }
+    // Genera un access token
+    async generateAccessToken(props) {
+        return this.jwtGenerator.generateAccessToken(props);
+    }
+    // Genera un refresh token
+    async generateRefreshToken(props) {
+        return this.jwtGenerator.generateRefreshToken(props);
+    }
+    // verifica si el token es válido y retorna el payload
+    async verifyAccessToken(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.verifyAccessToken(token, this.config);
+    }
+    // verifica si el refresh token es válido y retorna el payload
+    async verifyRefreshToken(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.verifyRefreshToken(token, this.config);
+    }
+    // Obtiene la fecha de expiración del token
+    async getTokenExpiration(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.getTokenExpiration(token);
+    }
+}
+exports.JwtTokenService = JwtTokenService;

package/dist/src/infrastructure/services/simple-jwt-token.service.d.ts

@@ -0,0 +1,15 @@
+import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps, IJWTPayload, ITokenService } from "../../domain";
+import { JwtTokenServiceConfig } from "../../shared";
+import { JwtTokenGenerator, JwtTokenValidator, JwtTokenVerifier } from "../jwt";
+export declare class SimpleJwtTokenService implements ITokenService {
+    private readonly config;
+    private readonly jwtGenerator;
+    private readonly jwtVerifier;
+    private readonly jwtValidator;
+    constructor(config: JwtTokenServiceConfig, jwtGenerator: JwtTokenGenerator, jwtVerifier: JwtTokenVerifier, jwtValidator: JwtTokenValidator);
+    generateAccessToken(props: IGenerateAccessTokenProps): Promise<string>;
+    generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
+    verifyAccessToken(token: string): Promise<IJWTPayload>;
+    verifyRefreshToken(token: string): Promise<IJWTPayload>;
+    getTokenExpiration(token: string): Promise<Date>;
+}

package/dist/src/infrastructure/services/simple-jwt-token.service.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleJwtTokenService = void 0;
+// Fachada principal del sistema de tokens JWT.
+// Servicio de alto nivel que orquesta las operaciones de generación, validación y verificación de tokens,
+// ocultando los detalles internos de las clases más técnicas (JwtTokenGenerator, JwtTokenVerifier, JwtTokenValidator).
+class SimpleJwtTokenService {
+    constructor(
+    // config → secretos, tiempos de expiración y algoritmo.
+    config, 
+    // jwtGenerator → crea y firma los tokens.
+    jwtGenerator, 
+    // jwtVerifier → comprueba firmas y expiraciones.
+    jwtVerifier, 
+    // jwtValidator → revisa formato y estructura
+    jwtValidator) {
+        this.config = config;
+        this.jwtGenerator = jwtGenerator;
+        this.jwtVerifier = jwtVerifier;
+        this.jwtValidator = jwtValidator;
+    }
+    // Genera un access token
+    async generateAccessToken(props) {
+        return this.jwtGenerator.generateAccessToken(props);
+    }
+    // Genera un refresh token
+    async generateRefreshToken(props) {
+        return this.jwtGenerator.generateRefreshToken(props);
+    }
+    // verifica si el token es válido y retorna el payload
+    async verifyAccessToken(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.verifyAccessToken(token, this.config);
+    }
+    // verifica si el refresh token es válido y retorna el payload
+    async verifyRefreshToken(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.verifyRefreshToken(token, this.config);
+    }
+    // Obtiene la fecha de expiración del token
+    async getTokenExpiration(token) {
+        this.jwtValidator.validateTokenInput(token);
+        return this.jwtVerifier.getTokenExpiration(token);
+    }
+}
+exports.SimpleJwtTokenService = SimpleJwtTokenService;

package/dist/src/infrastructure/services/token-session.service.d.ts

@@ -0,0 +1,24 @@
+import { Credential, ICredentialRepository, ITokenService, ITokenSession, IUserRepository, User } from "../../domain";
+import { AnyAlgorithm } from "../../shared";
+/**
+ * Servicio de gestión de sesiones de usuario mediante tokens JWT.
+ * Proporciona métodos para crear, refrescar, validar y revocar sesiones.
+ */
+export declare class TokenSessionService implements ITokenSession {
+    private readonly tokenService;
+    private readonly userRepository;
+    private readonly credentialRepository;
+    private readonly algorithm;
+    private readonly accessTokenExpiration;
+    private readonly refreshTokenExpiration;
+    private readonly accessTokenSecret?;
+    private readonly refreshTokenSecret?;
+    private readonly accessMs;
+    private readonly refreshMs;
+    constructor(tokenService: ITokenService, userRepository: IUserRepository, credentialRepository: ICredentialRepository, algorithm: AnyAlgorithm, accessTokenExpiration?: string, refreshTokenExpiration?: string, accessTokenSecret?: string | undefined, refreshTokenSecret?: string | undefined);
+    private buildJwtConfig;
+    createSession(user: User): Promise<Credential>;
+    refreshSession(refreshToken: string): Promise<Credential>;
+    validateSession(accessToken: string): Promise<User | null>;
+    revokeSession(refreshToken: string): Promise<void>;
+}

package/dist/src/infrastructure/services/token-session.service.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenSessionService = void 0;
+const domain_1 = require("../../domain");
+const shared_1 = require("../../shared");
+/**
+ * Servicio de gestión de sesiones de usuario mediante tokens JWT.
+ * Proporciona métodos para crear, refrescar, validar y revocar sesiones.
+ */
+class TokenSessionService {
+    constructor(
+    // Servicio de tokens JWT
+    tokenService, 
+    // Repositorio de usuarios
+    userRepository, 
+    // Repositorio de credenciales
+    credentialRepository, 
+    // Algoritmo JWT a usar
+    algorithm, 
+    // Configuración de expiraciones y secretos
+    accessTokenExpiration = "15m", refreshTokenExpiration = "7d", accessTokenSecret, refreshTokenSecret) {
+        this.tokenService = tokenService;
+        this.userRepository = userRepository;
+        this.credentialRepository = credentialRepository;
+        this.algorithm = algorithm;
+        this.accessTokenExpiration = accessTokenExpiration;
+        this.refreshTokenExpiration = refreshTokenExpiration;
+        this.accessTokenSecret = accessTokenSecret;
+        this.refreshTokenSecret = refreshTokenSecret;
+        // Validar que los secretos estén presentes
+        if (!accessTokenSecret || !refreshTokenSecret)
+            throw new domain_1.JwtSecretError("Missing JWT secrets");
+        // Parsear las expiraciones a milisegundos
+        try {
+            this.accessMs = shared_1.TimeParser.parseToMilliseconds(accessTokenExpiration);
+            this.refreshMs = shared_1.TimeParser.parseToMilliseconds(refreshTokenExpiration);
+        }
+        catch (error) {
+            throw new Error(`Invalid token expiration configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    // Construir configuración JWT para generación de tokens
+    buildJwtConfig() {
+        return {
+            accessTokenExpirationMs: this.accessMs,
+            refreshTokenExpirationMs: this.refreshMs,
+            accessTokenSecret: this.accessTokenSecret,
+            refreshTokenSecret: this.refreshTokenSecret,
+            algorithm: this.algorithm,
+        };
+    }
+    // Crear una nueva sesión de usuario
+    async createSession(user) {
+        const config = this.buildJwtConfig();
+        // Generar tokens
+        const accessToken = await this.tokenService.generateAccessToken({
+            user: {
+                id: user.id.toString(),
+                email: user.email.toString(),
+                roles: user.roles.map((role) => role.getValuePublic()),
+            },
+            expiresIn: this.accessTokenExpiration,
+            config,
+        });
+        // Generar refresh token
+        const refreshToken = await this.tokenService.generateRefreshToken({
+            user: {
+                id: user.id.toString(),
+                email: user.email.toString(),
+                roles: user.roles.map((role) => role.getValuePublic()),
+            },
+            expiresIn: this.refreshTokenExpiration,
+            config,
+        });
+        // Crear y guardar la credencial
+        const credential = domain_1.Credential.create(user.id, accessToken, refreshToken, new Date(Date.now() + this.accessMs));
+        // Guardar la credencial en el repositorio
+        await this.credentialRepository.save(credential);
+        // Retornar la credencial creada
+        return credential;
+    }
+    // Refrescar una sesión existente usando el refresh token
+    async refreshSession(refreshToken) {
+        // Verificar si la credencial con el refresh token existe
+        const existing = await this.credentialRepository.findByRefreshToken(refreshToken);
+        // Si no existe, lanzar error
+        if (!existing) {
+            throw new domain_1.InvalidOrExpiredRefreshTokenError();
+        }
+        // Verificar y obtener el payload del refresh token
+        const payload = await this.tokenService
+            .verifyRefreshToken(refreshToken)
+            .catch(() => {
+            throw new domain_1.InvalidOrExpiredRefreshTokenError();
+        });
+        // Obtener el usuario asociado al payload
+        const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
+        // Validar que el usuario exista y pueda iniciar sesión
+        if (!user)
+            throw new domain_1.UserNotFoundError();
+        // Validar que el usuario no esté deshabilitado
+        if (!user.canLogin())
+            throw new domain_1.UserDisabledError();
+        // Crear una nueva sesión para el usuario
+        const newCredential = await this.createSession(user);
+        // Eliminar la credencial antigua asociada al refresh token
+        await this.credentialRepository.deleteByRefreshToken(refreshToken); // rotación
+        // Retornar la nueva credencial
+        return newCredential;
+    }
+    // Validar una sesión usando el access token
+    async validateSession(accessToken) {
+        try {
+            // Verificar y obtener el payload del access token
+            const payload = await this.tokenService.verifyAccessToken(accessToken);
+            // Obtener el usuario asociado al payload
+            const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
+            // Retornar el usuario si existe y puede iniciar sesión, sino retornar null
+            return user && user.canLogin() ? user : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Revocar una sesión usando el refresh token
+    async revokeSession(refreshToken) {
+        // Eliminar la credencial asociada al refresh token
+        await this.credentialRepository.deleteByRefreshToken(refreshToken);
+    }
+}
+exports.TokenSessionService = TokenSessionService;

package/dist/src/infrastructure/types/auth-service-container.d.ts

@@ -0,0 +1,14 @@
+import { LoginWithPasswordUseCase, LogoutUseCase, RefreshTokenUseCase, RegisterUserUseCase } from "../../application";
+import { ICredentialRepository, IPasswordHasher, IPasswordPolicy, ITokenService, ITokenSession, IUserRepository } from "../../domain";
+export interface IAuthServiceContainer {
+    userRepository: IUserRepository;
+    credentialRepository: ICredentialRepository;
+    passwordHasher: IPasswordHasher;
+    tokenService: ITokenService;
+    passwordPolicy: IPasswordPolicy;
+    tokenSession: ITokenSession;
+    registerUserUseCase: RegisterUserUseCase;
+    loginWithPasswordUseCase: LoginWithPasswordUseCase;
+    refreshTokenUseCase: RefreshTokenUseCase;
+    logoutUseCase: LogoutUseCase;
+}

package/dist/src/infrastructure/types/auth-service-container.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/infrastructure/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./auth-service-container";

package/dist/src/infrastructure/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./auth-service-container"), exports);

package/dist/src/shared/constants/index.d.ts

@@ -0,0 +1 @@
+export * from "./jwt-algorithms";

package/dist/src/shared/constants/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./jwt-algorithms"), exports);

package/dist/src/shared/constants/jwt-algorithms.d.ts

@@ -0,0 +1,17 @@
+export declare const algorithms: {
+    readonly hmac: {
+        readonly HS256: "HS256";
+        readonly HS384: "HS384";
+        readonly HS512: "HS512";
+    };
+    readonly rsa: {
+        readonly RS256: "RS256";
+        readonly RS384: "RS384";
+        readonly RS512: "RS512";
+    };
+    readonly ecdsa: {
+        readonly ES256: "ES256";
+        readonly ES384: "ES384";
+        readonly ES512: "ES512";
+    };
+};

package/dist/src/shared/constants/jwt-algorithms.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.algorithms = void 0;
+exports.algorithms = {
+    // simétrica (una sola clave)
+    hmac: {
+        HS256: "HS256",
+        HS384: "HS384",
+        HS512: "HS512",
+    },
+    // asimétrica (clave pública/privada)
+    rsa: {
+        RS256: "RS256",
+        RS384: "RS384",
+        RS512: "RS512",
+    },
+    // curvas elípticas
+    ecdsa: {
+        ES256: "ES256",
+        ES384: "ES384",
+        ES512: "ES512",
+    },
+};

package/dist/src/shared/encoders/base64-url-encoder.d.ts

@@ -0,0 +1,29 @@
+/**
+ *Esta clase implementa la codificación y decodificación Base64 URL-safe,
+ *que es una variante del estándar Base64 diseñada para ser segura en URLs.
+ */
+export declare class Base64UrlEncoder {
+    /**
+     * Convierte una cadena de texto a formato Base64 URL-safe
+     * @param str La cadena a codificar
+     * @returns La cadena codificada en Base64 URL-safe
+     */
+    encode(str: string): string;
+    /**
+     * Convierte de Base64 URL-safe de vuelta a texto original
+     * @param str La cadena codificada en Base64 URL-safe
+     * @returns La cadena decodificada
+     */
+    decode(str: string): string;
+}
+/**
+ * El Base64 estándar usa caracteres (+, /, =) que tienen significado especial en URLs.
+ * Base64 URL-safe los reemplaza para evitar problemas cuando se usan en:
+ *
+ * - Parámetros de URL
+ * - Tokens JWT (muy común)
+ * - Headers HTTP
+ * - Rutas de API
+ *
+ * Esta implementación es típicamente usada para codificar/decodificar las partes de un JWT (header y payload) de forma segura para transmisión web.
+ */

package/dist/src/shared/encoders/base64-url-encoder.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base64UrlEncoder = void 0;
+/**
+ *Esta clase implementa la codificación y decodificación Base64 URL-safe,
+ *que es una variante del estándar Base64 diseñada para ser segura en URLs.
+ */
+class Base64UrlEncoder {
+    /**
+     * Convierte una cadena de texto a formato Base64 URL-safe
+     * @param str La cadena a codificar
+     * @returns La cadena codificada en Base64 URL-safe
+     */
+    encode(str) {
+        return Buffer.from(str)
+            .toString("base64")
+            .replace(/\+/g, "-")
+            .replace(/\//g, "_")
+            .replace(/=/g, "");
+    }
+    /**
+     * Convierte de Base64 URL-safe de vuelta a texto original
+     * @param str La cadena codificada en Base64 URL-safe
+     * @returns La cadena decodificada
+     */
+    decode(str) {
+        const padding = 4 - (str.length % 4);
+        if (padding !== 4) {
+            str += "=".repeat(padding);
+        }
+        return Buffer.from(str.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString();
+    }
+}
+exports.Base64UrlEncoder = Base64UrlEncoder;
+/**
+ * El Base64 estándar usa caracteres (+, /, =) que tienen significado especial en URLs.
+ * Base64 URL-safe los reemplaza para evitar problemas cuando se usan en:
+ *
+ * - Parámetros de URL
+ * - Tokens JWT (muy común)
+ * - Headers HTTP
+ * - Rutas de API
+ *
+ * Esta implementación es típicamente usada para codificar/decodificar las partes de un JWT (header y payload) de forma segura para transmisión web.
+ */

package/dist/src/shared/encoders/index.d.ts

@@ -0,0 +1 @@
+export * from "./base64-url-encoder";

package/dist/src/shared/encoders/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./base64-url-encoder"), exports);

package/dist/src/shared/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./utils";
+export * from "./encoders";
+export * from "./constants";
+export * from "./types";

package/dist/src/shared/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./encoders"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/shared/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./jwt.types";

package/dist/src/shared/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./jwt.types"), exports);

package/dist/src/shared/types/jwt.d.ts

@@ -0,0 +1,25 @@
+import { algorithms } from "../constants";
+/**
+ * Tipos de algoritmos JWT soportados.
+ */
+export type AlgorithmCategory = keyof typeof algorithms;
+/**
+ * Nombres de todos los algoritmos soportados.
+ */
+export type AlgorithmName = (typeof algorithms.hmac)[keyof typeof algorithms.hmac] | (typeof algorithms.rsa)[keyof typeof algorithms.rsa] | (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type HmacAlgorithm = (typeof algorithms.hmac)[keyof typeof algorithms.hmac];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type RsaAlgorithm = (typeof algorithms.rsa)[keyof typeof algorithms.rsa];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type EcdsaAlgorithm = (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
+/**
+ * Tipo que agrupa todos los algoritmos posibles.
+ */
+export type AnyAlgorithm = HmacAlgorithm | RsaAlgorithm | EcdsaAlgorithm;

package/dist/src/shared/types/jwt.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/shared/types/jwt.types.d.ts

@@ -0,0 +1,39 @@
+import { IAuthConfig } from "../../domain/ports";
+import { algorithms } from "../constants";
+/**
+ * Tipos de algoritmos JWT soportados.
+ */
+export type AlgorithmCategory = keyof typeof algorithms;
+/**
+ * Nombres de todos los algoritmos soportados.
+ */
+export type AlgorithmName = (typeof algorithms.hmac)[keyof typeof algorithms.hmac] | (typeof algorithms.rsa)[keyof typeof algorithms.rsa] | (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type HmacAlgorithm = (typeof algorithms.hmac)[keyof typeof algorithms.hmac];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type RsaAlgorithm = (typeof algorithms.rsa)[keyof typeof algorithms.rsa];
+/**
+ * Tipos específicos de algoritmos por categoría.
+ */
+export type EcdsaAlgorithm = (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
+/**
+ * Tipo que agrupa todos los algoritmos posibles.
+ */
+export type AnyAlgorithm = HmacAlgorithm | RsaAlgorithm | EcdsaAlgorithm;
+/**
+ * Configuración necesaria para los servicios de tokens JWT.
+ * Esto lo usan clases como JwtTokenGenerator o JwtTokenVerifier paara saber cómo firmar y con qué tipo de clave.
+ * Incluye opciones de JWT e información adicional.
+ * @param algorithm Algoritmo de firma (opcional).
+ * @param privateKey Clave privada para algoritmos RSA/ECDSA (opcional).
+ * @param publicKey Clave pública para algoritmos RSA/ECDSA (opcional).
+ */
+export type JwtTokenServiceConfig = IAuthConfig["jwt"] & IAuthConfig["info"] & {
+    algorithm: AnyAlgorithm;
+    privateKey?: string;
+    publicKey?: string;
+};

package/dist/src/shared/types/jwt.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/shared/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./time-parser";

package/dist/src/shared/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./time-parser"), exports);