@jmlq/auth 0.0.1-alpha.1

package/dist/src/domain/errors/auth-domain-error.js

@@ -0,0 +1,112 @@
+"use strict";
+// src/domain/errors/auth.errors.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTokenError = exports.AuthenticationError = exports.ClaimsValidationError = exports.ClockSkewError = exports.TokenRevokedError = exports.KeyMismatchError = exports.KeyNotFoundError = exports.UnsupportedAlgorithmError = exports.InvalidSignatureError = exports.InvalidTokenFormatError = exports.TokenNotYetValidError = exports.TokenExpiredError = exports.AuthDomainError = void 0;
+class AuthDomainError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = new.target.name;
+        // Compatible con V8; ignora silenciosamente en otros engines
+        if (typeof Error.captureStackTrace === "function") {
+            Error.captureStackTrace(this, new.target);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            details: this.details,
+        };
+    }
+    static isAuthError(e) {
+        return e instanceof AuthDomainError;
+    }
+}
+exports.AuthDomainError = AuthDomainError;
+/** El token ya no es válido por exp (exp < now) */
+class TokenExpiredError extends AuthDomainError {
+    constructor(message = "Token has expired", details) {
+        super(message, "TOKEN_EXPIRED", details);
+    }
+}
+exports.TokenExpiredError = TokenExpiredError;
+/** El token aún no debe usarse (nbf > now) */
+class TokenNotYetValidError extends AuthDomainError {
+    constructor(message = "Token is not yet valid", details) {
+        super(message, "TOKEN_NOT_YET_VALID", details);
+    }
+}
+exports.TokenNotYetValidError = TokenNotYetValidError;
+/** Formato inválido (no tiene 3 partes, base64url inválido, JSON inválido) */
+class InvalidTokenFormatError extends AuthDomainError {
+    constructor(message = "Invalid token format", details) {
+        super(message, "TOKEN_MALFORMED", details);
+    }
+}
+exports.InvalidTokenFormatError = InvalidTokenFormatError;
+/** Firma inválida (no coincide con datos/clave) */
+class InvalidSignatureError extends AuthDomainError {
+    constructor(message = "Invalid token signature", details) {
+        super(message, "SIGNATURE_INVALID", details);
+    }
+}
+exports.InvalidSignatureError = InvalidSignatureError;
+/** Algoritmo no soportado por la librería/política */
+class UnsupportedAlgorithmError extends AuthDomainError {
+    constructor(message = "Unsupported algorithm", details) {
+        super(message, "ALGORITHM_UNSUPPORTED", details);
+    }
+}
+exports.UnsupportedAlgorithmError = UnsupportedAlgorithmError;
+/** No se pudo resolver/obtener la clave necesaria (kid, store…) */
+class KeyNotFoundError extends AuthDomainError {
+    constructor(message = "Signing/verification key not found", details) {
+        super(message, "KEY_NOT_FOUND", details);
+    }
+}
+exports.KeyNotFoundError = KeyNotFoundError;
+/** La clave encontrada no corresponde (key-id/alg desalineado, par incorrecto) */
+class KeyMismatchError extends AuthDomainError {
+    constructor(message = "Key does not match token/algorithm", details) {
+        super(message, "KEY_MISMATCH", details);
+    }
+}
+exports.KeyMismatchError = KeyMismatchError;
+/** Token revocado en listas de deny/blacklist */
+class TokenRevokedError extends AuthDomainError {
+    constructor(message = "Token has been revoked", details) {
+        super(message, "TOKEN_REVOKED", details);
+    }
+}
+exports.TokenRevokedError = TokenRevokedError;
+/** Desfase de reloj detectado (leeway insuficiente) */
+class ClockSkewError extends AuthDomainError {
+    constructor(message = "Clock skew detected", details) {
+        super(message, "CLOCK_SKEW", details);
+    }
+}
+exports.ClockSkewError = ClockSkewError;
+/** Claims inválidas a nivel semántico (aud, iss, scope, custom…) */
+class ClaimsValidationError extends AuthDomainError {
+    constructor(issues, message = "Invalid token claims") {
+        super(message, "CLAIMS_VALIDATION_ERROR", { issues });
+    }
+}
+exports.ClaimsValidationError = ClaimsValidationError;
+/** Falla general de autenticación (catch-all) */
+class AuthenticationError extends AuthDomainError {
+    constructor(message = "Authentication failed", details) {
+        super(message, "AUTHENTICATION_FAILED", details);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/** Alias histórico si lo usabas antes */
+class InvalidTokenError extends AuthenticationError {
+    constructor(message = "Invalid token", details) {
+        super(message, details);
+    }
+}
+exports.InvalidTokenError = InvalidTokenError;

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

@@ -0,0 +1,56 @@
+export type AuthErrorCode = "JWT_ERROR" | "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;
+    });
+}
+/** 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;
+    });
+}
+/** 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 InvalidOrExpiredRefreshTokenError extends AuthDomainError {
+    constructor(details?: {
+        exp?: number;
+        now?: number;
+    });
+}
+/** Alias histórico si lo usabas antes */
+export declare class JwtSecretError extends AuthDomainError {
+    constructor(message?: string, details?: {
+        exp?: number;
+        now?: number;
+    });
+}

package/dist/src/domain/errors/auth.errors.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtSecretError = exports.InvalidOrExpiredRefreshTokenError = exports.AuthenticationError = exports.UnsupportedAlgorithmError = exports.InvalidSignatureError = exports.InvalidTokenFormatError = exports.TokenExpiredError = exports.AuthDomainError = void 0;
+class AuthDomainError extends Error {
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = new.target.name;
+        // Compatible con V8; ignora silenciosamente en otros engines
+        if (typeof Error.captureStackTrace === "function") {
+            Error.captureStackTrace(this, new.target);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            details: this.details,
+        };
+    }
+    static isAuthError(e) {
+        return e instanceof AuthDomainError;
+    }
+}
+exports.AuthDomainError = AuthDomainError;
+/** El token ya no es válido por exp (exp < now) */
+class TokenExpiredError extends AuthDomainError {
+    constructor(message = "Token has expired", details) {
+        super(message, "TOKEN_EXPIRED", details);
+    }
+}
+exports.TokenExpiredError = TokenExpiredError;
+/** Formato inválido (no tiene 3 partes, base64url inválido, JSON inválido) */
+class InvalidTokenFormatError extends AuthDomainError {
+    constructor(message = "Invalid token format", details) {
+        super(message, "TOKEN_MALFORMED", details);
+    }
+}
+exports.InvalidTokenFormatError = InvalidTokenFormatError;
+/** Firma inválida (no coincide con datos/clave) */
+class InvalidSignatureError extends AuthDomainError {
+    constructor(message = "Invalid token signature", details) {
+        super(message, "SIGNATURE_INVALID", details);
+    }
+}
+exports.InvalidSignatureError = InvalidSignatureError;
+/** Algoritmo no soportado por la librería/política */
+class UnsupportedAlgorithmError extends AuthDomainError {
+    constructor(message = "Unsupported algorithm", details) {
+        super(message, "ALGORITHM_UNSUPPORTED", details);
+    }
+}
+exports.UnsupportedAlgorithmError = UnsupportedAlgorithmError;
+/** Falla general de autenticación (catch-all) */
+class AuthenticationError extends AuthDomainError {
+    constructor(message = "Authentication failed", details) {
+        super(message, "AUTHENTICATION_FAILED", details);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/** Alias histórico si lo usabas antes */
+class InvalidOrExpiredRefreshTokenError extends AuthDomainError {
+    constructor(details) {
+        super("Invalid or expired refresh token", "TOKEN_EXPIRED", details);
+    }
+}
+exports.InvalidOrExpiredRefreshTokenError = InvalidOrExpiredRefreshTokenError;
+/** Alias histórico si lo usabas antes */
+class JwtSecretError extends AuthDomainError {
+    constructor(message, details) {
+        super(message ? message : "Missing JWT secrets", "JWT_ERROR", details);
+    }
+}
+exports.JwtSecretError = JwtSecretError;

package/dist/src/domain/errors/identity.errors.d.ts

@@ -0,0 +1,34 @@
+export declare class InvalidEmailError extends Error {
+    constructor(value: string);
+}
+export declare class InvalidHashedPasswordError extends Error {
+    constructor(msg?: string);
+}
+export declare class PasswordPolicyViolationError extends Error {
+    readonly issues: string[];
+    constructor(issues: string[], msg?: string);
+}
+export declare class PasswordMismatchError extends Error {
+    constructor(msg?: string);
+}
+export declare class UserNotFoundError extends Error {
+    constructor(msg?: string);
+}
+export declare class UserDisabledError extends Error {
+    constructor(msg?: string);
+}
+export declare class EmailAlreadyInUseError extends Error {
+    constructor(msg?: string);
+}
+export declare class InvalidPermissionError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidRoleError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidIdError extends Error {
+    constructor(message: string);
+}
+export declare class LogoutError extends Error {
+    constructor(message: string);
+}

package/dist/src/domain/errors/identity.errors.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogoutError = exports.InvalidIdError = exports.InvalidRoleError = exports.InvalidPermissionError = exports.EmailAlreadyInUseError = exports.UserDisabledError = exports.UserNotFoundError = exports.PasswordMismatchError = exports.PasswordPolicyViolationError = exports.InvalidHashedPasswordError = exports.InvalidEmailError = void 0;
+// Object Types
+class InvalidEmailError extends Error {
+    constructor(value) {
+        super(`Invalid email format: "${value}"`);
+        this.name = "InvalidEmailError";
+    }
+}
+exports.InvalidEmailError = InvalidEmailError;
+class InvalidHashedPasswordError extends Error {
+    constructor(msg = "Invalid bcrypt hash format") {
+        super(msg);
+        this.name = "InvalidHashedPasswordError";
+    }
+}
+exports.InvalidHashedPasswordError = InvalidHashedPasswordError;
+class PasswordPolicyViolationError extends Error {
+    constructor(issues, msg = "Password policy violation") {
+        super(msg);
+        this.issues = issues;
+        this.name = "PasswordPolicyViolationError";
+    }
+}
+exports.PasswordPolicyViolationError = PasswordPolicyViolationError;
+class PasswordMismatchError extends Error {
+    constructor(msg = "Password does not match") {
+        super(msg);
+        this.name = "PasswordMismatchError";
+    }
+}
+exports.PasswordMismatchError = PasswordMismatchError;
+class UserNotFoundError extends Error {
+    constructor(msg = "User not found") {
+        super(msg);
+        this.name = "UserNotFoundError";
+    }
+}
+exports.UserNotFoundError = UserNotFoundError;
+class UserDisabledError extends Error {
+    constructor(msg = "User is disabled") {
+        super(msg);
+        this.name = "UserDisabledError";
+    }
+}
+exports.UserDisabledError = UserDisabledError;
+class EmailAlreadyInUseError extends Error {
+    constructor(msg = "Email already in use") {
+        super(msg);
+        this.name = "EmailAlreadyInUseError";
+    }
+}
+exports.EmailAlreadyInUseError = EmailAlreadyInUseError;
+class InvalidPermissionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidPermissionError";
+    }
+}
+exports.InvalidPermissionError = InvalidPermissionError;
+class InvalidRoleError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidRoleError";
+    }
+}
+exports.InvalidRoleError = InvalidRoleError;
+class InvalidIdError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidIdError";
+    }
+}
+exports.InvalidIdError = InvalidIdError;
+class LogoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LogoutError";
+    }
+}
+exports.LogoutError = LogoutError;

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

@@ -0,0 +1,2 @@
+export * from "./auth.errors";
+export * from "./identity.errors";

package/dist/src/domain/errors/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("./auth.errors"), exports);
+__exportStar(require("./identity.errors"), exports);

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

@@ -0,0 +1,6 @@
+export * from "./entities";
+export * from "./errors";
+export * from "./object-values";
+export * from "./ports";
+export * from "./props";
+export * from "./services";

package/dist/src/domain/index.js

@@ -0,0 +1,22 @@
+"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("./entities"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./object-values"), exports);
+__exportStar(require("./ports"), exports);
+__exportStar(require("./props"), exports);
+__exportStar(require("./services"), exports);

package/dist/src/domain/object-values/email.d.ts

@@ -0,0 +1,37 @@
+/**
+ *Value Object del dominio: una forma segura y
+ *validada de manejar correos electrónicos dentro del sistema.
+ */
+export declare class Email {
+    /**
+     * Guarda el correo en formato estandarizado
+     */
+    private readonly value;
+    /**
+     * Crea una nueva instancia de Email
+     * @param email
+     */
+    constructor(email: string);
+    /**
+     * Verifica que el formato sea válido
+     * @param email El correo a validar
+     * @returns true si es válido, false si no lo es
+     */
+    private isValid;
+    /**
+     * Devuelve el string del correo
+     * @return El correo electrónico
+     */
+    getValue(): string;
+    /**
+     * Compara si dos objetos Email representan el mismo correo
+     * @param other El otro objeto Email a comparar
+     * @return true si son iguales, false si no lo son
+     */
+    equals(other: Email): boolean;
+    /**
+     * Convierte el objeto Email a string
+     * @return El correo electrónico en formato string
+     */
+    toString(): string;
+}

package/dist/src/domain/object-values/email.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Email = void 0;
+const errors_1 = require("../errors");
+/**
+ *Value Object del dominio: una forma segura y
+ *validada de manejar correos electrónicos dentro del sistema.
+ */
+class Email {
+    /**
+     * Crea una nueva instancia de Email
+     * @param email
+     */
+    constructor(email) {
+        // Limpia espacios innecesarios.
+        const trimmedEmail = email.trim();
+        if (!this.isValid(trimmedEmail)) {
+            throw new errors_1.InvalidEmailError(email);
+        }
+        this.value = trimmedEmail.toLowerCase();
+    }
+    /**
+     * Verifica que el formato sea válido
+     * @param email El correo a validar
+     * @returns true si es válido, false si no lo es
+     */
+    isValid(email) {
+        // validación básica de formato de correo electrónico
+        const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+        // También limita la longitud a 254 caracteres
+        return emailRegex.test(email) && email.length <= 254;
+    }
+    /**
+     * Devuelve el string del correo
+     * @return El correo electrónico
+     */
+    getValue() {
+        return this.value;
+    }
+    /**
+     * Compara si dos objetos Email representan el mismo correo
+     * @param other El otro objeto Email a comparar
+     * @return true si son iguales, false si no lo son
+     */
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * Convierte el objeto Email a string
+     * @return El correo electrónico en formato string
+     */
+    toString() {
+        return this.value;
+    }
+}
+exports.Email = Email;

package/dist/src/domain/object-values/hashed-password.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Value object representing a hashed password.
+ */
+export declare class HashedPassword {
+    /**
+     * Guarda el valor hasheado de la contraseña
+     */
+    private readonly value;
+    /**
+     * Constructor
+     * @param hashedValue
+     */
+    constructor(hash: string);
+    /**
+     * Igualdad por valor (hash vs hash)
+     * @param other otro HashedPassword
+     * @returns boolean indicando si son iguales
+     */
+    equals(other: HashedPassword): boolean;
+    /**
+     * Solo para persistencia (repos). Evita usar en logs
+     * @returns string hasheado
+     */
+    serialize(): string;
+    /** Blindajes contra exposición accidental */
+    toString(): string;
+    toJSON(): string;
+}

package/dist/src/domain/object-values/hashed-password.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashedPassword = void 0;
+const errors_1 = require("../errors");
+/**
+ * Value object representing a hashed password.
+ */
+class HashedPassword {
+    /**
+     * Constructor
+     * @param hashedValue
+     */
+    constructor(hash) {
+        if (hash == null)
+            throw new errors_1.InvalidHashedPasswordError("Hashed password cannot be null or undefined");
+        const v = String(hash).trim();
+        if (v.length === 0)
+            throw new errors_1.InvalidHashedPasswordError("Hashed password cannot be empty");
+        if (!/^\$(2[aby])\$(\d{2})\$[./A-Za-z0-9]{53}$/.test(v)) {
+            /*
+                | Parte               | Qué busca              | Significado                              |
+                | ------------------- | ---------------------- | ---------------------------------------- |
+                | `^`                 | Inicio de la cadena    | Asegura que no haya nada antes           |
+                | `\$`                | Un símbolo `$` literal | Bcrypt separa secciones con `$`          |
+                | `(2[aby])`          | "2a", "2b" o "2y"      | Versión del algoritmo bcrypt             |
+                | `\$`                | Otro `$` literal       | Separador                                |
+                | `(\d{2})`           | Dos dígitos            | Cost factor (número de rondas, ej. `10`) |
+                | `\$`                | Otro `$`               | Separador                                |
+                | `[./A-Za-z0-9]{53}` | 53 caracteres válidos  | El *hash + salt* en codificación bcrypt  |
+                | `$`                 | Fin de la cadena       | Garantiza que no haya texto adicional    |
+      
+      
+                $2a$12$R9h/cIPz0gi.URNNX3kh2OPST9/PgBkqquzi.Ss7KIUgO2t0jWMUW
+                │││ ││ └─ Hash y salt (53 chars)
+                │││ └┴─ Cost factor (12)
+                ││└─ Separador
+                │└─ Versión (2a)
+                └─ Separador inicial
+             */
+            throw new errors_1.InvalidHashedPasswordError("Invalid bcrypt hash format");
+        }
+        // Validar el cost factor
+        const cost = Number(v.split("$")[2]);
+        // El cost factor debe estar entre 4 y 31
+        if (cost < 4 || cost > 31)
+            throw new errors_1.InvalidHashedPasswordError("Invalid bcrypt cost factor");
+        // Asignar valor si todo es correcto
+        this.value = v;
+    }
+    /**
+     * Igualdad por valor (hash vs hash)
+     * @param other otro HashedPassword
+     * @returns boolean indicando si son iguales
+     */
+    equals(other) {
+        return this.value === other.value;
+    }
+    /**
+     * Solo para persistencia (repos). Evita usar en logs
+     * @returns string hasheado
+     */
+    serialize() {
+        return this.value;
+    }
+    /** Blindajes contra exposición accidental */
+    toString() {
+        return "[PROTECTED]";
+    }
+    toJSON() {
+        return "[PROTECTED]";
+    }
+}
+exports.HashedPassword = HashedPassword;

package/dist/src/domain/object-values/id.d.ts

@@ -0,0 +1,8 @@
+export declare class Id {
+    private readonly value;
+    constructor(id: string);
+    getValue(): string;
+    equals(other: Id): boolean;
+    toString(): string;
+    static generate(): Id;
+}

package/dist/src/domain/object-values/id.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Id = void 0;
+const errors_1 = require("../errors");
+class Id {
+    constructor(id) {
+        if (!id || id.trim().length === 0) {
+            throw new errors_1.InvalidIdError("User ID cannot be empty");
+        }
+        this.value = id.trim();
+    }
+    getValue() {
+        return this.value;
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    toString() {
+        return this.value;
+    }
+    static generate() {
+        // Generar un ID único simple (en producción se podría usar uuid)
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2);
+        return new Id(`${timestamp}-${random}`);
+    }
+}
+exports.Id = Id;

package/dist/src/domain/object-values/index.d.ts

@@ -0,0 +1,5 @@
+export { Email } from "./email";
+export { HashedPassword } from "./hashed-password";
+export { Id } from "./id";
+export { Permission } from "./permission";
+export { Role } from "./role";

package/dist/src/domain/object-values/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Role = exports.Permission = exports.Id = exports.HashedPassword = exports.Email = void 0;
+var email_1 = require("./email");
+Object.defineProperty(exports, "Email", { enumerable: true, get: function () { return email_1.Email; } });
+var hashed_password_1 = require("./hashed-password");
+Object.defineProperty(exports, "HashedPassword", { enumerable: true, get: function () { return hashed_password_1.HashedPassword; } });
+var id_1 = require("./id");
+Object.defineProperty(exports, "Id", { enumerable: true, get: function () { return id_1.Id; } });
+var permission_1 = require("./permission");
+Object.defineProperty(exports, "Permission", { enumerable: true, get: function () { return permission_1.Permission; } });
+var role_1 = require("./role");
+Object.defineProperty(exports, "Role", { enumerable: true, get: function () { return role_1.Role; } });