@jmlq/auth 0.0.1-alpha.1

package/dist/src/application/use-cases/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("./login-with-password.use-case"), exports);
+__exportStar(require("./logout.use-case"), exports);
+__exportStar(require("./refresh-token.use-case"), exports);
+__exportStar(require("./register-user.use-case"), exports);

package/dist/src/application/use-cases/login-with-password.use-case.d.ts

@@ -0,0 +1,9 @@
+import { IPasswordHasher, ITokenSession, IUserRepository } from "../../domain";
+import { LoginRequest, LoginResponse } from "../dtos";
+export declare class LoginWithPasswordUseCase {
+    private readonly userRepository;
+    private readonly passwordHasher;
+    private readonly tokenSessionService;
+    constructor(userRepository: IUserRepository, passwordHasher: IPasswordHasher, tokenSessionService: ITokenSession);
+    execute(request: LoginRequest): Promise<LoginResponse>;
+}

package/dist/src/application/use-cases/login-with-password.use-case.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginWithPasswordUseCase = void 0;
+const domain_1 = require("../../domain");
+class LoginWithPasswordUseCase {
+    constructor(userRepository, passwordHasher, tokenSessionService) {
+        this.userRepository = userRepository;
+        this.passwordHasher = passwordHasher;
+        this.tokenSessionService = tokenSessionService;
+    }
+    async execute(request) {
+        // Buscar usuario por email
+        const email = new domain_1.Email(request.email);
+        const user = await this.userRepository.findByEmail(email);
+        if (!user) {
+            throw new domain_1.UserNotFoundError("Invalid credentials");
+        }
+        // Verificar que el usuario esté activo
+        if (!user.canLogin()) {
+            throw new domain_1.UserDisabledError("User account is not active");
+        }
+        // Verificar contraseña
+        const isPasswordValid = await this.passwordHasher.compare(request.password, user.password.serialize());
+        if (!isPasswordValid) {
+            throw new domain_1.PasswordMismatchError("Invalid credentials");
+        }
+        // Crear sesión con tokens
+        const credential = await this.tokenSessionService.createSession(user);
+        // Retornar respuesta
+        return {
+            accessToken: credential.accessToken,
+            refreshToken: credential.refreshToken,
+        };
+    }
+}
+exports.LoginWithPasswordUseCase = LoginWithPasswordUseCase;

package/dist/src/application/use-cases/logout.use-case.d.ts

@@ -0,0 +1,7 @@
+import { ITokenSession } from "../../domain";
+import { LogoutRequest, LogoutResponse } from "../dtos";
+export declare class LogoutUseCase {
+    private readonly tokenSession;
+    constructor(tokenSession: ITokenSession);
+    execute(request: LogoutRequest): Promise<LogoutResponse>;
+}

package/dist/src/application/use-cases/logout.use-case.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogoutUseCase = void 0;
+const domain_1 = require("../../domain");
+class LogoutUseCase {
+    constructor(tokenSession) {
+        this.tokenSession = tokenSession;
+    }
+    async execute(request) {
+        try {
+            await this.tokenSession.revokeSession(request.refreshToken);
+            return {
+                success: true,
+                message: "Successfully logged out",
+            };
+        }
+        catch (error) {
+            throw new domain_1.LogoutError("Failed to logout: invalid refresh token");
+        }
+    }
+}
+exports.LogoutUseCase = LogoutUseCase;

package/dist/src/application/use-cases/refresh-token.use-case.d.ts

@@ -0,0 +1,7 @@
+import { ITokenSession } from "../../domain";
+import { RefreshTokenRequest, RefreshTokenResponse } from "../dtos";
+export declare class RefreshTokenUseCase {
+    private readonly tokenSessionService;
+    constructor(tokenSessionService: ITokenSession);
+    execute(request: RefreshTokenRequest): Promise<RefreshTokenResponse>;
+}

package/dist/src/application/use-cases/refresh-token.use-case.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshTokenUseCase = void 0;
+const domain_1 = require("../../domain");
+class RefreshTokenUseCase {
+    constructor(tokenSessionService) {
+        this.tokenSessionService = tokenSessionService;
+    }
+    async execute(request) {
+        try {
+            // Refrescar la sesión
+            const credential = await this.tokenSessionService.refreshSession(request.refreshToken);
+            return {
+                accessToken: credential.accessToken,
+                refreshToken: credential.refreshToken,
+            };
+        }
+        catch (error) {
+            throw new domain_1.InvalidOrExpiredRefreshTokenError();
+        }
+    }
+}
+exports.RefreshTokenUseCase = RefreshTokenUseCase;

package/dist/src/application/use-cases/register-user.use-case.d.ts

@@ -0,0 +1,10 @@
+import { IPasswordHasher, IPasswordPolicy } from "../../domain";
+import { IUserRepository } from "../../domain/ports/repository";
+import { RegisterUserRequest, RegisterUserResponse } from "../dtos";
+export declare class RegisterUserUseCase {
+    private readonly userRepository;
+    private readonly passwordHasher;
+    private readonly passwordPolicy;
+    constructor(userRepository: IUserRepository, passwordHasher: IPasswordHasher, passwordPolicy: IPasswordPolicy);
+    execute(request: RegisterUserRequest): Promise<RegisterUserResponse>;
+}

package/dist/src/application/use-cases/register-user.use-case.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisterUserUseCase = void 0;
+const domain_1 = require("../../domain");
+class RegisterUserUseCase {
+    constructor(userRepository, passwordHasher, passwordPolicy) {
+        this.userRepository = userRepository;
+        this.passwordHasher = passwordHasher;
+        this.passwordPolicy = passwordPolicy;
+    }
+    async execute(request) {
+        // Validar política de contraseñas
+        const passwordValidation = this.passwordPolicy.validateStrength(request.password);
+        if (!passwordValidation.isValid) {
+            throw new domain_1.PasswordPolicyViolationError(passwordValidation.errors);
+        }
+        // Verificar que el email no esté en uso
+        const email = new domain_1.Email(request.email);
+        const exists = await this.userRepository.findByEmail(email);
+        if (exists) {
+            throw new domain_1.EmailAlreadyInUseError();
+        }
+        // Hash de la contraseña
+        const hashedPassword = await this.passwordHasher.hash(request.password);
+        // Crear el usuario
+        const user = domain_1.User.create(request.email, request.roles?.map((r) => new domain_1.Role(r.role, r.permissions?.map((permission) => new domain_1.Permission(permission)))) || [], hashedPassword);
+        // Guardar en repositorio
+        await this.userRepository.save(user);
+        // Retornar respuesta
+        return {
+            id: user.id.getValue(),
+            roles: user.roles.map((role) => role.getValuePublic()),
+            isActive: user.isActive,
+        };
+    }
+}
+exports.RegisterUserUseCase = RegisterUserUseCase;

package/dist/src/domain/entities/credential.entity.d.ts

@@ -0,0 +1,78 @@
+import { Id } from "../object-values";
+import { ICredentialProps } from "../props/entities";
+/**
+ * Representa las credenciales activas de un usuario dentro del dominio
+ */
+export declare class Credential {
+    /**
+     * Identificador del usuario asociado a las credenciales
+     */
+    private readonly _userId;
+    /**
+     * Token de acceso asociado
+     */
+    private readonly _accessToken;
+    /**
+     * Token de refresco asociado
+     */
+    private readonly _refreshToken;
+    /**
+     * Fecha de expiración del token de acceso
+     */
+    private readonly _expiresAt;
+    /**
+     * Fecha de creación de las credenciales
+     */
+    private readonly _createdAt;
+    /**
+     * Constructor privado para evitar instanciación directa
+     * @param props Propiedades de las credenciales
+     */
+    constructor(props: ICredentialProps);
+    /**
+     * Obtiene el identificador del usuario asociado a las credenciales
+     */
+    get userId(): Id;
+    /**
+     * Obtiene el token de acceso
+     */
+    get accessToken(): string;
+    /**
+     * Obtiene el token de refresco
+     */
+    get refreshToken(): string;
+    /**
+     * Obtiene la fecha de expiración del token de acceso
+     */
+    get expiresAt(): Date;
+    /**
+     * Obtiene la fecha de creación de las credenciales
+     */
+    get createdAt(): Date;
+    /**
+     * Evalúa si las credenciales han expirado
+     * @returns Verdadero si las credenciales han expirado, falso en caso contrario
+     */
+    isExpired(): boolean;
+    /**
+     * Evalúa si las credenciales son válidas (no expiradas)
+     * @returns Verdadero si las credenciales son válidas (no expiradas), falso en caso contrario
+     */
+    isValid(): boolean;
+    /**
+     * Crea una nueva instancia de Credential
+     * @param userId Identificador del usuario
+     * @param accessToken Token de acceso
+     * @param refreshToken Token de refresco
+     * @param expirationDate Fecha de expiración del token de acceso
+     * @returns Nueva instancia de Credential
+     */
+    static create(userId: Id, accessToken: string, refreshToken: string, expirationDate: Date): Credential;
+    /**
+     *Reconstitution method for repository
+     *Método usado por un repositorio para reconstruir la entidad desde la base de datos
+     * @param props Propiedades de las credenciales
+     * @returns Nueva instancia de Credential
+     */
+    static reconstitute(props: ICredentialProps): Credential;
+}

package/dist/src/domain/entities/credential.entity.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credential = void 0;
+/**
+ * Representa las credenciales activas de un usuario dentro del dominio
+ */
+class Credential {
+    /**
+     * Constructor privado para evitar instanciación directa
+     * @param props Propiedades de las credenciales
+     */
+    constructor(props) {
+        this._userId = props.userId;
+        this._accessToken = props.accessToken;
+        this._refreshToken = props.refreshToken;
+        this._expiresAt = props.expiresAt;
+        this._createdAt = props.createdAt;
+    }
+    // Getters
+    /**
+     * Obtiene el identificador del usuario asociado a las credenciales
+     */
+    get userId() {
+        return this._userId;
+    }
+    /**
+     * Obtiene el token de acceso
+     */
+    get accessToken() {
+        return this._accessToken;
+    }
+    /**
+     * Obtiene el token de refresco
+     */
+    get refreshToken() {
+        return this._refreshToken;
+    }
+    /**
+     * Obtiene la fecha de expiración del token de acceso
+     */
+    get expiresAt() {
+        return new Date(this._expiresAt);
+    }
+    /**
+     * Obtiene la fecha de creación de las credenciales
+     */
+    get createdAt() {
+        return new Date(this._createdAt);
+    }
+    // Business methods
+    /**
+     * Evalúa si las credenciales han expirado
+     * @returns Verdadero si las credenciales han expirado, falso en caso contrario
+     */
+    isExpired() {
+        return new Date() > this._expiresAt;
+    }
+    /**
+     * Evalúa si las credenciales son válidas (no expiradas)
+     * @returns Verdadero si las credenciales son válidas (no expiradas), falso en caso contrario
+     */
+    isValid() {
+        return !this.isExpired();
+    }
+    /**
+     * Crea una nueva instancia de Credential
+     * @param userId Identificador del usuario
+     * @param accessToken Token de acceso
+     * @param refreshToken Token de refresco
+     * @param expirationDate Fecha de expiración del token de acceso
+     * @returns Nueva instancia de Credential
+     */
+    static create(userId, accessToken, refreshToken, expirationDate) {
+        return new Credential({
+            userId,
+            accessToken,
+            refreshToken,
+            expiresAt: expirationDate,
+            createdAt: new Date(),
+        });
+    }
+    /**
+     *Reconstitution method for repository
+     *Método usado por un repositorio para reconstruir la entidad desde la base de datos
+     * @param props Propiedades de las credenciales
+     * @returns Nueva instancia de Credential
+     */
+    static reconstitute(props) {
+        return new Credential(props);
+    }
+}
+exports.Credential = Credential;

package/dist/src/domain/entities/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./credential.entity";
+export * from "./user.entity";

package/dist/src/domain/entities/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("./credential.entity"), exports);
+__exportStar(require("./user.entity"), exports);

package/dist/src/domain/entities/user.entity.d.ts

@@ -0,0 +1,97 @@
+import { Email, HashedPassword, Id, Role } from "../object-values";
+import { IUserProps } from "../props";
+/**
+ *Representa al agregado raíz de dominio del usuario en una arquitectura limpia o DDD (Domain-Driven Design).
+ */
+export declare class User {
+    /**
+     * Identificador único del usuario
+     */
+    private readonly _id;
+    /**
+     * Correo electrónico del usuario
+     */
+    private readonly _email;
+    /**
+     * Rol del usuario dentro del sistema
+     */
+    private readonly _roles;
+    /**
+     * Contraseña hasheada del usuario
+     */
+    private readonly _password;
+    /**
+     * Indica si el usuario está activo o inactivo
+     */
+    private _isActive;
+    /**
+     * Fecha de creación del usuario
+     */
+    private readonly _createdAt;
+    /**
+     * Fecha de última actualización del usuario
+     */
+    private _updatedAt;
+    /**
+     * Constructor privado para evitar instanciación directa
+     * @param props Propiedades del usuario
+     */
+    constructor(props: IUserProps);
+    /**
+     * Obtiene el identificador único del usuario
+     */
+    get id(): Id;
+    /**
+     * Obtiene el correo electrónico del usuario
+     */
+    get email(): Email;
+    /**
+     * Obtiene el rol del usuario
+     */
+    get roles(): Role[];
+    /**
+     * Obtiene la contraseña hasheada del usuario
+     */
+    get password(): HashedPassword;
+    /**
+     * Indica si el usuario está activo o inactivo
+     */
+    get isActive(): boolean;
+    /**
+     * Obtiene la fecha de creación del usuario
+     */
+    get createdAt(): Date;
+    /**
+     * Obtiene la fecha de última actualización del usuario
+     */
+    get updatedAt(): Date;
+    /**
+     * Marca al usuario como activo
+     */
+    activate(): void;
+    /**
+     * Marca al usuario como inactivo
+     */
+    deactivate(): void;
+    /**
+     * Evalúa si el usuario puede iniciar sesión
+     * @returns Verdadero si el usuario puede iniciar sesión, falso en caso contrario
+     */
+    canLogin(): boolean;
+    /**
+     * Factory method to create a new User
+     * @param email email
+     * @param role role
+     * @param hashedPassword hashed password
+     * @returns New User instance
+     */
+    static create(email: string, roles: Role[], hashedPassword: string): User;
+    /**
+     *Reconstitution method for repository
+     *Método usado por los repositorios al reconstruir
+     *el usuario desde la base de datos o una fuente persistente
+     * @param props Propiedades del usuario
+     * @returns Nueva instancia de User
+     */
+    static reconstitute(props: IUserProps): User;
+}

package/dist/src/domain/entities/user.entity.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+const object_values_1 = require("../object-values");
+/**
+ *Representa al agregado raíz de dominio del usuario en una arquitectura limpia o DDD (Domain-Driven Design).
+ */
+class User {
+    /**
+     * Constructor privado para evitar instanciación directa
+     * @param props Propiedades del usuario
+     */
+    constructor(props) {
+        this._id = props.id;
+        this._email = props.email;
+        this._roles = props.roles;
+        this._password = props.password;
+        this._isActive = props.isActive;
+        this._createdAt = props.createdAt;
+        this._updatedAt = props.updatedAt;
+    }
+    // Getters
+    /**
+     * Obtiene el identificador único del usuario
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * Obtiene el correo electrónico del usuario
+     */
+    get email() {
+        return this._email;
+    }
+    /**
+     * Obtiene el rol del usuario
+     */
+    get roles() {
+        return this._roles;
+    }
+    /**
+     * Obtiene la contraseña hasheada del usuario
+     */
+    get password() {
+        return this._password;
+    }
+    /**
+     * Indica si el usuario está activo o inactivo
+     */
+    get isActive() {
+        return this._isActive;
+    }
+    /**
+     * Obtiene la fecha de creación del usuario
+     */
+    get createdAt() {
+        return new Date(this._createdAt);
+    }
+    /**
+     * Obtiene la fecha de última actualización del usuario
+     */
+    get updatedAt() {
+        return new Date(this._updatedAt);
+    }
+    // Business methods
+    /**
+     * Marca al usuario como activo
+     */
+    activate() {
+        this._isActive = true;
+        this._updatedAt = new Date();
+    }
+    /**
+     * Marca al usuario como inactivo
+     */
+    deactivate() {
+        this._isActive = false;
+        this._updatedAt = new Date();
+    }
+    /**
+     * Evalúa si el usuario puede iniciar sesión
+     * @returns Verdadero si el usuario puede iniciar sesión, falso en caso contrario
+     */
+    canLogin() {
+        return this._isActive;
+    }
+    /**
+     * Factory method to create a new User
+     * @param email email
+     * @param role role
+     * @param hashedPassword hashed password
+     * @returns New User instance
+     */
+    static create(email, roles, hashedPassword) {
+        return new User({
+            id: object_values_1.Id.generate(),
+            email: new object_values_1.Email(email),
+            roles: roles,
+            password: new object_values_1.HashedPassword(hashedPassword),
+            isActive: true,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        });
+    }
+    /**
+     *Reconstitution method for repository
+     *Método usado por los repositorios al reconstruir
+     *el usuario desde la base de datos o una fuente persistente
+     * @param props Propiedades del usuario
+     * @returns Nueva instancia de User
+     */
+    static reconstitute(props) {
+        return new User(props);
+    }
+}
+exports.User = User;

package/dist/src/domain/errors/auth-domain-error.d.ts

@@ -0,0 +1,82 @@
+export type AuthErrorCode = "TOKEN_EXPIRED" | "TOKEN_NOT_YET_VALID" | "TOKEN_INVALID" | "TOKEN_MALFORMED" | "SIGNATURE_INVALID" | "ALGORITHM_UNSUPPORTED" | "KEY_NOT_FOUND" | "KEY_MISMATCH" | "TOKEN_REVOKED" | "CLOCK_SKEW" | "AUTHENTICATION_FAILED" | "CLAIMS_VALIDATION_ERROR";
+export interface ClaimsIssue {
+    path: string;
+    message: string;
+}
+export declare abstract class AuthDomainError extends Error {
+    readonly code: AuthErrorCode;
+    readonly details?: unknown;
+    constructor(message: string, code: AuthErrorCode, details?: unknown);
+    toJSON(): {
+        name: string;
+        message: string;
+        code: AuthErrorCode;
+        details: unknown;
+    };
+    static isAuthError(e: unknown): e is AuthDomainError;
+}
+/** El token ya no es válido por exp (exp < now) */
+export declare class TokenExpiredError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        exp?: number;
+        now?: number;
+    });
+}
+/** El token aún no debe usarse (nbf > now) */
+export declare class TokenNotYetValidError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        nbf?: number;
+        now?: number;
+    });
+}
+/** Formato inválido (no tiene 3 partes, base64url inválido, JSON inválido) */
+export declare class InvalidTokenFormatError extends AuthDomainError {
+    constructor(message?: string, details?: unknown);
+}
+/** Firma inválida (no coincide con datos/clave) */
+export declare class InvalidSignatureError extends AuthDomainError {
+    constructor(message?: string, details?: unknown);
+}
+/** Algoritmo no soportado por la librería/política */
+export declare class UnsupportedAlgorithmError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        alg: string;
+    });
+}
+/** No se pudo resolver/obtener la clave necesaria (kid, store…) */
+export declare class KeyNotFoundError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        kid?: string;
+    });
+}
+/** La clave encontrada no corresponde (key-id/alg desalineado, par incorrecto) */
+export declare class KeyMismatchError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        alg?: string;
+        kid?: string;
+    });
+}
+/** Token revocado en listas de deny/blacklist */
+export declare class TokenRevokedError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        jti?: string;
+    });
+}
+/** Desfase de reloj detectado (leeway insuficiente) */
+export declare class ClockSkewError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        skewSeconds?: number;
+    });
+}
+/** Claims inválidas a nivel semántico (aud, iss, scope, custom…) */
+export declare class ClaimsValidationError extends AuthDomainError {
+    constructor(issues: ClaimsIssue[], message?: string);
+}
+/** Falla general de autenticación (catch-all) */
+export declare class AuthenticationError extends AuthDomainError {
+    constructor(message?: string, details?: unknown);
+}
+/** Alias histórico si lo usabas antes */
+export declare class InvalidTokenError extends AuthenticationError {
+    constructor(message?: string, details?: unknown);
+}