@jmlq/logger 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/tests/domain/services/to-pii-regex.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const services_1 = require("../../../src/domain/services");
+describe("toPiiRegex()", () => {
+    // ---------------------------------------------------------------------------
+    // 1️⃣ Patrón válido con flags por defecto (g)
+    // ---------------------------------------------------------------------------
+    it("debe crear un RegExp válido con flags 'g' por defecto", () => {
+        const props = {
+            pattern: "\\d+",
+            replaceWith: "[NUM]",
+        };
+        const regex = (0, services_1.toPiiRegex)(props);
+        expect(regex).toBeInstanceOf(RegExp);
+        expect(regex.source).toBe("\\d+");
+        expect(regex.flags).toBe("g");
+        const result = "abc123def456".replace(regex, props.replaceWith);
+        expect(result).toBe("abc[NUM]def[NUM]");
+    });
+    // ---------------------------------------------------------------------------
+    // 2️⃣ Patrón válido con flags personalizados
+    // ---------------------------------------------------------------------------
+    it("debe respetar los flags personalizados si son válidos", () => {
+        const props = {
+            pattern: "test",
+            flags: "gi",
+            replaceWith: "X",
+        };
+        const regex = (0, services_1.toPiiRegex)(props);
+        expect(regex.source).toBe("test");
+        expect(regex.flags).toBe("gi");
+        expect("TeSt 1, test 2".replace(regex, props.replaceWith)).toBe("X 1, X 2");
+    });
+    // ---------------------------------------------------------------------------
+    // 3️⃣ Patrón inválido → debe retornar el RegExp fallback /$a/
+    // ---------------------------------------------------------------------------
+    it("debe retornar un RegExp imposible (/\\$a/) si el patrón es inválido", () => {
+        const props = {
+            pattern: "[unclosed",
+            flags: "g",
+            replaceWith: "X",
+        };
+        const regex = (0, services_1.toPiiRegex)(props);
+        // El fallback esperado es /$a/
+        expect(regex).toBeInstanceOf(RegExp);
+        expect(regex.source).toBe("$a");
+        expect(regex.test("cualquier texto")).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // 4️⃣ Flags inválidos → también debe usar el fallback
+    // ---------------------------------------------------------------------------
+    it("debe usar el fallback si los flags son inválidos", () => {
+        const props = {
+            pattern: "\\d+",
+            flags: "z", // flag inválido
+            replaceWith: "X",
+        };
+        const regex = (0, services_1.toPiiRegex)(props);
+        expect(regex.source).toBe("$a");
+        expect(regex.test("123")).toBe(false);
+    });
+    // ---------------------------------------------------------------------------
+    // 5️⃣ Asegura que el fallback nunca hace match con ejemplos comunes
+    // ---------------------------------------------------------------------------
+    it("el fallback nunca debe hacer match con strings comunes", () => {
+        const props = {
+            pattern: "\\", // clarísimamente inválido
+            replaceWith: "X",
+        };
+        const regex = (0, services_1.toPiiRegex)(props);
+        const samples = [
+            "",
+            "abc",
+            "123",
+            "user@test.com",
+            "tarjeta 4111-1111-1111-1111",
+        ];
+        for (const s of samples) {
+            expect(regex.test(s)).toBe(false);
+        }
+    });
+});

package/dist/tests/infrastructure/services/datasource.service.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/infrastructure/services/datasource.service.spec.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const infrastructure_1 = require("src/infrastructure");
+const src_1 = require("../../../src");
+describe("DataSourceService", () => {
+    const log = {
+        level: src_1.LogLevel.INFO,
+        message: "test log",
+        timestamp: Date.now(),
+        meta: {
+            userId: "12345",
+        },
+    };
+    const makeDsMock = () => ({
+        name: "mock",
+        save: jest.fn(),
+        find: jest.fn(),
+        flush: jest.fn(),
+        dispose: jest.fn(),
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    // -------------------------------------------------------------------------
+    // SAVE
+    // -------------------------------------------------------------------------
+    test("save() debe ejecutar save en todos los datasources", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        const service = new infrastructure_1.DataSourceService([ds1, ds2]);
+        await service.save(log);
+        expect(ds1.save).toHaveBeenCalledWith(log);
+        expect(ds2.save).toHaveBeenCalledWith(log);
+        expect(ds1.save).toHaveBeenCalledTimes(1);
+        expect(ds2.save).toHaveBeenCalledTimes(1);
+    });
+    test("save() debe continuar incluso si uno de los datasources falla y llamar al error handler", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        ds1.save.mockResolvedValue(undefined);
+        ds2.save.mockRejectedValue(new Error("failure"));
+        const onError = jest.fn();
+        const service = new infrastructure_1.DataSourceService([ds1, ds2], onError);
+        await service.save(log);
+        expect(ds1.save).toHaveBeenCalled();
+        expect(ds2.save).toHaveBeenCalled();
+        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+            operation: "save",
+            datasourceName: "mock",
+        }));
+        // Opcional: validar que la razón sea el Error original
+        expect(onError.mock.calls[0][0].reason).toBeInstanceOf(Error);
+        expect(onError.mock.calls[0][0].reason.message).toBe("failure");
+    });
+    // -------------------------------------------------------------------------
+    // FIND
+    // -------------------------------------------------------------------------
+    test("find() debe concatenar resultados de varios datasources y ordenarlos desc por timestamp", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        const logs1 = [
+            { level: src_1.LogLevel.INFO, message: "a", timestamp: 100 },
+            { level: src_1.LogLevel.WARN, message: "b", timestamp: 300 },
+        ];
+        const logs2 = [
+            { level: src_1.LogLevel.ERROR, message: "c", timestamp: 200 },
+        ];
+        ds1.find.mockResolvedValue(logs1);
+        ds2.find.mockResolvedValue(logs2);
+        const service = new infrastructure_1.DataSourceService([ds1, ds2]);
+        const result = await service.find();
+        expect(result).toHaveLength(3);
+        expect(result.map((l) => l.timestamp)).toEqual([300, 200, 100]);
+    });
+    test("find() ignora datasources que retornen error en find() y llama al error handler", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        ds1.find.mockRejectedValue(new Error("ds1 fail"));
+        ds2.find.mockResolvedValue([
+            { id: "1", level: src_1.LogLevel.INFO, message: "ok", timestamp: 123 },
+        ]);
+        const onError = jest.fn();
+        const service = new infrastructure_1.DataSourceService([ds1, ds2], onError);
+        const result = await service.find();
+        // Sigue devolviendo solo los logs válidos
+        expect(result).toHaveLength(1);
+        expect(result[0].level).toBe(src_1.LogLevel.INFO);
+        // Y registra el error del datasource que falló
+        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+            operation: "find",
+            datasourceName: "mock",
+        }));
+        expect(onError.mock.calls[0][0].reason).toBeInstanceOf(Error);
+        expect(onError.mock.calls[0][0].reason.message).toBe("ds1 fail");
+    });
+    // -------------------------------------------------------------------------
+    // FLUSH
+    // -------------------------------------------------------------------------
+    test("flush() debe llamar flush en todos los datasources que implementen flush()", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        const service = new infrastructure_1.DataSourceService([ds1, ds2]);
+        await service.flush();
+        expect(ds1.flush).toHaveBeenCalledTimes(1);
+        expect(ds2.flush).toHaveBeenCalledTimes(1);
+    });
+    // -------------------------------------------------------------------------
+    // DISPOSE
+    // -------------------------------------------------------------------------
+    test("dispose() debe llamar dispose en todos los datasources", async () => {
+        const ds1 = makeDsMock();
+        const ds2 = makeDsMock();
+        const service = new infrastructure_1.DataSourceService([ds1, ds2]);
+        await service.dispose();
+        expect(ds1.dispose).toHaveBeenCalledTimes(1);
+        expect(ds2.dispose).toHaveBeenCalledTimes(1);
+    });
+    // -------------------------------------------------------------------------
+    // CONSTRUCTOR DEFENSIVO
+    // -------------------------------------------------------------------------
+    test("constructor debe filtrar targets inválidos (null/undefined)", async () => {
+        const ds1 = makeDsMock();
+        const service = new infrastructure_1.DataSourceService([ds1, null, undefined]);
+        expect(service.targets).toHaveLength(1);
+    });
+});

package/dist/tests/test-utils/create-pii-redactor-mock.d.ts

@@ -0,0 +1,5 @@
+import { IPiiRedactor } from "../../src/domain/ports";
+export type PiiRedactorMock = IPiiRedactor & {
+    redact: jest.Mock;
+};
+export declare function createPiiRedactorMock(): PiiRedactorMock;

package/dist/tests/test-utils/create-pii-redactor-mock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPiiRedactorMock = createPiiRedactorMock;
+function createPiiRedactorMock() {
+    const redact = jest.fn((value) => value);
+    return {
+        redact,
+        updateOptions: jest.fn(),
+    };
+}

package/package.json

@@ -1,32 +1,40 @@
 {
   "name": "@jmlq/logger",
-  "version": "0.1.0-alpha.6",
-  "author": "MLahuasi",
-  "license": "MIT",
+  "description": "logger package with clean architecture",
+  "version": "0.1.0-alpha.8",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "test:cov": "jest --coverage"
+    "test:coverage": "jest --coverage",
+    "example:help": "tsx examples/index.example.ts help",
+    "example:all": "tsx examples/index.example.ts",
+    "example:domain-services": "tsx examples/index.example.ts domain-services",
+    "example:services": "tsx examples/index.example.ts services",
+    "example:use-cases": "tsx examples/index.example.ts use-cases",
+    "example:factories": "tsx examples/index.example.ts factories"
   },
+  "keywords": [
+    "logger",
+    "clean-architecture",
+    "typescript"
+  ],
+  "author": "MLahuasi",
+  "license": "MIT",
   "devDependencies": {
-    "@swc/core": "^1.13.5",
-    "@swc/jest": "^0.2.39",
-    "@types/jest": "^30.0.0",
-    "@types/node": "^24.3.0",
-    "jest": "^30.1.3",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.2"
+    "@swc/core": "^1.3.95",
+    "@swc/jest": "^0.2.29",
+    "@types/bcryptjs": "^2.4.5",
+    "@types/jest": "^29.5.8",
+    "@types/node": "^20.8.10",
+    "jest": "^29.7.0",
+    "tsx": "^4.1.4",
+    "typescript": "^5.2.2"
   },
-  "overrides": {
-    "test-exclude": "^7.0.1",
-    "glob": "^10.4.5",
-    "minimatch": "^9.0.5"
-  }
+  "files": [
+    "dist"
+  ]
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024-2025 mlahuasi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the “Software”), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/dist/application/use-cases/flush-buffers.d.ts

@@ -1,6 +0,0 @@
-import { ILogDatasource } from "../../domain/contracts";
-export declare class FlushBuffers {
-    private readonly ds;
-    constructor(ds: ILogDatasource);
-    execute(): Promise<void>;
-}

package/dist/application/use-cases/get-logs.d.ts

@@ -1,7 +0,0 @@
-import { ILogDatasource } from "../../domain/contracts";
-import { IGetLogsFilter, ILog } from "../../domain/types";
-export declare class GetLogs {
-    private readonly ds;
-    constructor(ds: ILogDatasource);
-    execute(filter?: IGetLogsFilter): Promise<ILog[]>;
-}

package/dist/application/use-cases/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./save-log";
-export * from "./get-logs";
-export * from "./flush-buffers";

package/dist/application/use-cases/save-log.d.ts

@@ -1,13 +0,0 @@
-import { ILogDatasource, IPiiRedactor } from "../../domain/contracts";
-import { LogMessage } from "../../domain/types";
-import { LogLevel } from "../../domain/value-objects";
-export interface SaveLogDeps {
-    ds: ILogDatasource;
-    minLevel: LogLevel;
-    redactor: IPiiRedactor;
-}
-export declare class SaveLog {
-    private readonly deps;
-    constructor(deps: SaveLogDeps);
-    execute(level: LogLevel, message: LogMessage, meta?: unknown): Promise<void>;
-}

package/dist/application/use-cases/save-log.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveLog = void 0;
-// Normaliza el mensaje: si es función, la evalúa; si es objeto, se redacta; si es string, se redacta
-function normalizeMessage(message, redactor) {
-    const resolved = typeof message === "function" ? message() : message; // eval laziness
-    return redactor.redact(resolved);
-}
-class SaveLog {
-    constructor(deps) {
-        this.deps = deps;
-    }
-    async execute(level, message, meta) {
-        // 1) Filtro por nivel (evita hacer trabajo innecesario)
-        if (level < this.deps.minLevel)
-            return; // no se loggea
-        // 2) Normalización + PII
-        const normalized = normalizeMessage(message, this.deps.redactor);
-        // 3) Construcción del evento
-        const log = {
-            level,
-            message: normalized,
-            meta: meta === undefined ? undefined : this.deps.redactor.redact(meta),
-            timestamp: Date.now(),
-        };
-        // 4) Persistencia (fan-out lo maneja el ds si es composite)
-        await this.deps.ds.save(log);
-    }
-}
-exports.SaveLog = SaveLog;

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

@@ -1,3 +0,0 @@
-export * from "./log.datasource";
-export * from "./logger";
-export * from "./pii";

package/dist/domain/contracts/log.datasource.d.ts

@@ -1,8 +0,0 @@
-import { IGetLogsFilter, ILog } from "../types";
-export interface ILogDatasource {
-    save(log: ILog): Promise<void>;
-    find?(filter?: IGetLogsFilter): Promise<ILog[]>;
-    flush?(): Promise<void>;
-    dispose?(): Promise<void>;
-    readonly name?: string;
-}

package/dist/domain/contracts/pii.d.ts

@@ -1,5 +0,0 @@
-import { PiiOptions } from "../types";
-export interface IPiiRedactor {
-    redact<T = unknown>(value: T): T;
-    updateOptions?(opts: PiiOptions): void;
-}

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

@@ -1 +0,0 @@
-export * from "./pii-redactor";

package/dist/domain/services/pii-redactor.d.ts

@@ -1,10 +0,0 @@
-import { IPiiRedactor } from "../contracts";
-import { PiiOptions } from "../types";
-export declare class PiiRedactor implements IPiiRedactor {
-    private options;
-    constructor(options?: PiiOptions);
-    updateOptions(opts: PiiOptions): void;
-    redact<T = unknown>(value: T): T;
-    private applyPatterns;
-    private redactDeep;
-}

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

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

package/dist/domain/types/log.types.d.ts

@@ -1,28 +0,0 @@
-import { LogLevel } from "../value-objects";
-export type LogMessage = string | Record<string, unknown> | (() => string | Record<string, unknown>);
-export interface ILog {
-    level: LogLevel;
-    message: string | Record<string, unknown>;
-    meta?: unknown;
-    timestamp: number;
-}
-export interface IGetLogsFilter {
-    levelMin?: LogLevel;
-    since?: number;
-    until?: number;
-    limit?: number;
-    offset?: number;
-    query?: string;
-}
-export interface PiiReplacement {
-    pattern: string;
-    flags?: string;
-    replaceWith: string;
-}
-export interface PiiOptions {
-    enabled?: boolean;
-    whitelistKeys?: string[];
-    blacklistKeys?: string[];
-    patterns?: PiiReplacement[];
-    deep?: boolean;
-}

package/dist/domain/value-objects/index.d.ts

@@ -1 +0,0 @@
-export * from "./log-level";

package/dist/domain/value-objects/log-level.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLevel = void 0;
-exports.toLogLevel = toLogLevel;
-var LogLevel;
-(function (LogLevel) {
-    // Orden creciente permite comparar por severidad (trace < debug < ...)
-    LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
-    LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 30] = "INFO";
-    LogLevel[LogLevel["WARN"] = 40] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
-    LogLevel[LogLevel["FATAL"] = 60] = "FATAL";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-// Convierte string a LogLevel con fallback seguro
-function toLogLevel(level, def = LogLevel.INFO) {
-    if (typeof level === "number")
-        return (Object.values(LogLevel).includes(level) ? level : def);
-    if (!level)
-        return def;
-    switch (String(level).toLowerCase()) {
-        case "trace":
-            return LogLevel.TRACE;
-        case "debug":
-            return LogLevel.DEBUG;
-        case "info":
-            return LogLevel.INFO;
-        case "warn":
-            return LogLevel.WARN;
-        case "error":
-            return LogLevel.ERROR;
-        case "fatal":
-            return LogLevel.FATAL;
-        default:
-            return def; // evita lanzar excepción por valores inesperados
-    }
-}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export { LogLevel, toLogLevel } from "./domain/value-objects";
-export type { LogMessage, ILog, IGetLogsFilter, PiiOptions, PiiReplacement, } from "./domain/types";
-export type { LogDatasourcePort, ILogger, ICreateLoggerOptions, ILogDatasource, } from "./domain/contracts";
-export { createLogger } from "./presentation/factory";
-export { CompositeDatasource } from "./infrastructure/adapters";

package/dist/index.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeDatasource = exports.createLogger = exports.toLogLevel = exports.LogLevel = void 0;
-var value_objects_1 = require("./domain/value-objects");
-Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return value_objects_1.LogLevel; } });
-Object.defineProperty(exports, "toLogLevel", { enumerable: true, get: function () { return value_objects_1.toLogLevel; } });
-var factory_1 = require("./presentation/factory");
-Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return factory_1.createLogger; } });
-var adapters_1 = require("./infrastructure/adapters");
-Object.defineProperty(exports, "CompositeDatasource", { enumerable: true, get: function () { return adapters_1.CompositeDatasource; } });

package/dist/infrastructure/adapters/composite.datasource.d.ts

@@ -1,11 +0,0 @@
-import { ILogDatasource } from "../../domain/contracts";
-import { IGetLogsFilter, ILog } from "../../domain/types";
-export declare class CompositeDatasource implements ILogDatasource {
-    private readonly targets;
-    readonly name = "composite";
-    constructor(targets: ILogDatasource[]);
-    save(log: ILog): Promise<void>;
-    find(filter?: IGetLogsFilter): Promise<ILog[]>;
-    flush(): Promise<void>;
-    dispose(): Promise<void>;
-}

package/dist/infrastructure/adapters/composite.datasource.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeDatasource = void 0;
-// CompositeDatasource: fan-out hacia múltiples datasources
-class CompositeDatasource {
-    constructor(targets) {
-        this.targets = targets;
-        this.name = "composite";
-        // Filtro targets válidos (defensivo). Evita null/undefined
-        this.targets = (targets ?? []).filter(Boolean);
-    }
-    async save(log) {
-        // Ejecuta todos en paralelo y NO falla el todo si uno falla
-        const results = await Promise.allSettled(this.targets.map((ds) => ds.save(log)));
-        // Log de errores silencioso (el logger real no debe auto-dependerse)
-        for (let i = 0; i < results.length; i++) {
-            const r = results[i];
-            if (r.status === "rejected") {
-                // Preferible: exponer un hook externo; aquí solo console.warn por simplicidad
-                // eslint-disable-next-line no-console
-                console.warn(`[CompositeDatasource] save error in ds#${i} (${this.targets[i]?.name ?? "unknown"})`, r.reason);
-            }
-        }
-    }
-    async find(filter) {
-        // Si varios ds soportan find, se concatena y ordena por timestamp desc
-        const results = await Promise.allSettled(this.targets.map((ds) => ds.find?.(filter)));
-        const logs = [];
-        for (const r of results) {
-            if (r.status === "fulfilled" && Array.isArray(r.value))
-                logs.push(...r.value);
-        }
-        // Orden descendente por timestamp (más recientes primero)
-        logs.sort((a, b) => b.timestamp - a.timestamp);
-        return logs;
-    }
-    async flush() {
-        // Ejecuta flush donde esté disponible
-        await Promise.allSettled(this.targets.map((ds) => ds.flush?.()));
-    }
-    async dispose() {
-        // Libera recursos en todos los ds
-        await Promise.allSettled(this.targets.map((ds) => ds.dispose?.()));
-    }
-}
-exports.CompositeDatasource = CompositeDatasource;

package/dist/infrastructure/adapters/index.d.ts

@@ -1 +0,0 @@
-export * from "./composite.datasource";

package/dist/presentation/factory/index.d.ts

@@ -1 +0,0 @@
-export * from "./create-logger";