@jmlq/logger 0.1.0-alpha.11 → 0.1.0-alpha.13

package/dist/tests/domain/services/log-level.service.spec.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-describe("toLogLevel()", () => {
-    // --------------------------------------------------------------------------
-    // 1. Strings válidos
-    // --------------------------------------------------------------------------
-    it("debe convertir strings válidos al LogLevel correcto", () => {
-        expect((0, domain_1.toLogLevel)("trace")).toBe(domain_1.LogLevel.TRACE);
-        expect((0, domain_1.toLogLevel)("debug")).toBe(domain_1.LogLevel.DEBUG);
-        expect((0, domain_1.toLogLevel)("info")).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)("warn")).toBe(domain_1.LogLevel.WARN);
-        expect((0, domain_1.toLogLevel)("error")).toBe(domain_1.LogLevel.ERROR);
-        expect((0, domain_1.toLogLevel)("fatal")).toBe(domain_1.LogLevel.FATAL);
-    });
-    // --------------------------------------------------------------------------
-    // 2. Insensibilidad a mayúsculas/minúsculas
-    // --------------------------------------------------------------------------
-    it("debe aceptar strings en cualquier tipo de casing", () => {
-        expect((0, domain_1.toLogLevel)("TRACE")).toBe(domain_1.LogLevel.TRACE);
-        expect((0, domain_1.toLogLevel)("DeBuG")).toBe(domain_1.LogLevel.DEBUG);
-        expect((0, domain_1.toLogLevel)("Warn")).toBe(domain_1.LogLevel.WARN);
-    });
-    // --------------------------------------------------------------------------
-    // 3. Valores numéricos válidos
-    // --------------------------------------------------------------------------
-    it("debe aceptar valores numéricos válidos del enum", () => {
-        expect((0, domain_1.toLogLevel)(domain_1.LogLevel.TRACE)).toBe(domain_1.LogLevel.TRACE);
-        expect((0, domain_1.toLogLevel)(domain_1.LogLevel.FATAL)).toBe(domain_1.LogLevel.FATAL);
-    });
-    // --------------------------------------------------------------------------
-    // 4. Valores numéricos inválidos
-    // --------------------------------------------------------------------------
-    it("debe retornar el valor por defecto si el número no pertenece al enum", () => {
-        expect((0, domain_1.toLogLevel)(999)).toBe(domain_1.LogLevel.INFO); // default implícito
-        expect((0, domain_1.toLogLevel)(999, domain_1.LogLevel.ERROR)).toBe(domain_1.LogLevel.ERROR); // default explícito
-    });
-    // --------------------------------------------------------------------------
-    // 5. Valores undefined o null
-    // --------------------------------------------------------------------------
-    it("debe usar el valor por defecto si el valor es undefined o null", () => {
-        expect((0, domain_1.toLogLevel)(undefined)).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)(null)).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)(undefined, domain_1.LogLevel.WARN)).toBe(domain_1.LogLevel.WARN);
-    });
-    // --------------------------------------------------------------------------
-    // 6. Strings desconocidos
-    // --------------------------------------------------------------------------
-    it("debe retornar el default si recibe un string no reconocido", () => {
-        expect((0, domain_1.toLogLevel)("unknown")).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)("invalid-level", domain_1.LogLevel.ERROR)).toBe(domain_1.LogLevel.ERROR);
-    });
-    // --------------------------------------------------------------------------
-    // 7. Otros tipos no soportados
-    // --------------------------------------------------------------------------
-    it("debe retornar el default si recibe objetos, booleanos u otros tipos", () => {
-        expect((0, domain_1.toLogLevel)({})).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)([])).toBe(domain_1.LogLevel.INFO);
-        expect((0, domain_1.toLogLevel)(true)).toBe(domain_1.LogLevel.INFO);
-    });
-    // --------------------------------------------------------------------------
-    // 8. Verifica que el default param funciona correctamente
-    // --------------------------------------------------------------------------
-    it("debe aplicar correctamente el default proporcionado", () => {
-        expect((0, domain_1.toLogLevel)("something", domain_1.LogLevel.WARN)).toBe(domain_1.LogLevel.WARN);
-        expect((0, domain_1.toLogLevel)(undefined, domain_1.LogLevel.FATAL)).toBe(domain_1.LogLevel.FATAL);
-    });
-});

package/dist/tests/domain/services/normalize-message.spec.d.ts

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

package/dist/tests/domain/services/normalize-message.spec.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-describe("normalizeMessage()", () => {
-    let redactorMock;
-    beforeEach(() => {
-        redactorMock = {
-            redact: jest.fn((value) => value), // por defecto retorna lo mismo
-        };
-    });
-    // -----------------------------------------------------------------------
-    // 1️⃣ Si el mensaje es string
-    // -----------------------------------------------------------------------
-    it("debe redactor un mensaje tipo string", () => {
-        const msg = "hello world";
-        const result = (0, domain_1.normalizeMessage)(msg, redactorMock);
-        expect(redactorMock.redact).toHaveBeenCalledWith("hello world");
-        expect(result).toBe("hello world");
-    });
-    // -----------------------------------------------------------------------
-    // 2️⃣ Si el mensaje es objeto
-    // -----------------------------------------------------------------------
-    it("debe redactor un objeto", () => {
-        const msg = { user: "test", email: "a@b.com" };
-        const redactedObj = { user: "test", email: "***" };
-        // Redactor retorna un valor distinto
-        redactorMock.redact.mockReturnValue(redactedObj);
-        const result = (0, domain_1.normalizeMessage)(msg, redactorMock);
-        expect(redactorMock.redact).toHaveBeenCalledWith(msg);
-        expect(result).toEqual(redactedObj);
-    });
-    // -----------------------------------------------------------------------
-    // 3️⃣ Si el mensaje es una función perezosa
-    // -----------------------------------------------------------------------
-    it("debe evaluar funciones perezosas y redactor su resultado", () => {
-        const lazyFn = jest.fn(() => "lazy-result");
-        const result = (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
-        expect(lazyFn).toHaveBeenCalledTimes(1);
-        expect(redactorMock.redact).toHaveBeenCalledWith("lazy-result");
-        expect(result).toBe("lazy-result");
-    });
-    // -----------------------------------------------------------------------
-    // 4️⃣ Función perezosa retornando un objeto
-    // -----------------------------------------------------------------------
-    it("debe procesar funciones perezosas que retornan objetos", () => {
-        const lazyObj = jest.fn(() => ({ ok: true }));
-        const result = (0, domain_1.normalizeMessage)(lazyObj, redactorMock);
-        expect(lazyObj).toHaveBeenCalledTimes(1);
-        expect(redactorMock.redact).toHaveBeenCalledWith({ ok: true });
-        expect(result).toEqual({ ok: true });
-    });
-    // -----------------------------------------------------------------------
-    // 5️⃣ El redactor puede transformar el valor
-    // -----------------------------------------------------------------------
-    it("debe retornar el valor transformado por el redactor", () => {
-        redactorMock.redact.mockReturnValue("***redacted***");
-        const result = (0, domain_1.normalizeMessage)("secret", redactorMock);
-        expect(result).toBe("***redacted***");
-    });
-    // -----------------------------------------------------------------------
-    // 6️⃣ Verifica que no ejecuta funciones más de una vez
-    // -----------------------------------------------------------------------
-    it("solo debe evaluar una vez la función perezosa", () => {
-        const lazyFn = jest.fn(() => "value");
-        (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
-        (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
-        // Cada llamada a normalizeMessage ejecuta UNA vez la función
-        expect(lazyFn).toHaveBeenCalledTimes(2);
-    });
-    // -----------------------------------------------------------------------
-    // 7️⃣ Mensajes complejos
-    // -----------------------------------------------------------------------
-    it("debe soportar objetos complejos anidados", () => {
-        const complexObj = {
-            user: {
-                id: 1,
-                profile: { email: "a@b.com", phone: "12345" },
-            },
-        };
-        (0, domain_1.normalizeMessage)(complexObj, redactorMock);
-        expect(redactorMock.redact).toHaveBeenCalledWith(complexObj);
-    });
-});

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

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

package/dist/tests/domain/services/pii-redactor.spec.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const services_1 = require("../../../src/domain/services");
-describe("PiiRedactor", () => {
-    // -------------------------------------------------------------------------
-    // 1️⃣ Desactivado: debe retornar el valor sin modificar
-    // -------------------------------------------------------------------------
-    it("debe retornar el valor original si enabled=false", () => {
-        const redactor = new services_1.PiiRedactor({ enabled: false });
-        expect(redactor.redact("secret 123")).toBe("secret 123");
-        expect(redactor.redact({ email: "a@b.com" })).toEqual({
-            email: "a@b.com",
-        });
-    });
-    // -------------------------------------------------------------------------
-    // 2️⃣ Aplicación de patrones sobre strings
-    // -------------------------------------------------------------------------
-    it("debe aplicar patrones sobre strings cuando está enabled", () => {
-        const patterns = [
-            { pattern: "\\d+", replaceWith: "[NUM]" },
-            { pattern: "[\\w.-]+@[\\w.-]+\\.[A-Za-z]{2,}", replaceWith: "[EMAIL]" },
-        ];
-        const redactor = new services_1.PiiRedactor({ enabled: true, patterns });
-        const result = redactor.redact("Pago 123 por usuario test@example.com");
-        expect(result).toBe("Pago [NUM] por usuario [EMAIL]");
-    });
-    // -------------------------------------------------------------------------
-    // 3️⃣ Redacción profunda con objetos anidados
-    // -------------------------------------------------------------------------
-    it("debe aplicar redacción profunda en objetos con deep=true", () => {
-        const patterns = [
-            { pattern: "\\d{10}", replaceWith: "[PHONE]" },
-        ];
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            deep: true,
-            patterns,
-        });
-        const input = {
-            level1: {
-                phone: "0987654321",
-                nested: {
-                    phone2: "0987654321",
-                },
-            },
-        };
-        const output = redactor.redact(input);
-        expect(output.level1.phone).toBe("[PHONE]");
-        expect(output.level1.nested.phone2).toBe("[PHONE]");
-        // Verifica que no muta el objeto original
-        expect(input.level1.phone).toBe("0987654321");
-    });
-    // -------------------------------------------------------------------------
-    // 4️⃣ whitelistKeys debe impedir redacción
-    // -------------------------------------------------------------------------
-    it("whitelistKeys debe evitar la redacción de claves específicas", () => {
-        const patterns = [
-            { pattern: "\\d+", replaceWith: "*" },
-        ];
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            patterns,
-            whitelistKeys: ["safeField"],
-        });
-        const input = {
-            safeField: "12345",
-            normalField: "12345",
-        };
-        const result = redactor.redact(input);
-        expect(result.safeField).toBe("12345"); // No redactor
-        expect(result.normalField).toBe("*"); // Sí redactor
-    });
-    // -------------------------------------------------------------------------
-    // 5️⃣ blacklistKeys debe forzar redacción total
-    // -------------------------------------------------------------------------
-    it("blacklistKeys debe forzar '[REDACTED]'", () => {
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            blacklistKeys: ["password"],
-        });
-        const input = {
-            password: "super-secret",
-            other: "hello",
-        };
-        const result = redactor.redact(input);
-        expect(result.password).toBe("[REDACTED]");
-        expect(result.other).toBe("hello");
-    });
-    // -------------------------------------------------------------------------
-    // 6️⃣ Redacción profunda con arrays
-    // -------------------------------------------------------------------------
-    it("debe procesar arrays de forma profunda", () => {
-        const patterns = [
-            { pattern: "\\d+", replaceWith: "X" },
-        ];
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            deep: true,
-            patterns,
-        });
-        const input = {
-            arr: ["123", "abc", { phone: "456" }],
-        };
-        const result = redactor.redact(input);
-        expect(result.arr[0]).toBe("X");
-        expect(result.arr[1]).toBe("abc");
-        expect(result.arr[2]).toEqual({ phone: "X" });
-    });
-    // -------------------------------------------------------------------------
-    // 7️⃣ deep=false → no debe entrar a objetos anidados
-    // -------------------------------------------------------------------------
-    it("deep=false no debe redactor objetos anidados", () => {
-        const patterns = [
-            { pattern: "\\d+", replaceWith: "*" },
-        ];
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            deep: false,
-            patterns,
-        });
-        const input = {
-            inner: {
-                code: "123",
-            },
-        };
-        const result = redactor.redact(input);
-        expect(result.inner.code).toBe("123"); // No redactor en objetos internos
-    });
-    // -------------------------------------------------------------------------
-    // 8️⃣ Patrón inválido → no debe romper procesamiento
-    // -------------------------------------------------------------------------
-    it("si un patrón es inválido debe usar fallback y no romper redacción", () => {
-        const patterns = [
-            { pattern: "[invalid", replaceWith: "X" }, // inválido
-            { pattern: "\\d+", replaceWith: "#" },
-        ];
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            patterns,
-        });
-        const result = redactor.redact("abc123");
-        expect(result).toBe("abc#"); // Se aplicó el patrón válido
-    });
-    // -------------------------------------------------------------------------
-    // 9️⃣ updateOptions debe fusionar superficialmente props
-    // -------------------------------------------------------------------------
-    it("updateOptions debe fusionar opciones sin mutar referencia previa", () => {
-        const redactor = new services_1.PiiRedactor({
-            enabled: true,
-            deep: false,
-        });
-        redactor.updateOptions({
-            deep: true,
-            whitelistKeys: ["email"],
-        });
-        const after = redactor.props;
-        expect(after.enabled).toBe(true);
-        expect(after.deep).toBe(true);
-        expect(after.whitelistKeys).toEqual(["email"]);
-    });
-    // -------------------------------------------------------------------------
-    // 🔟 Tipos no soportados (number, boolean, function) no se redactan
-    // -------------------------------------------------------------------------
-    it("no debe redactor tipos primitivos no string/objeto", () => {
-        const redactor = new services_1.PiiRedactor({ enabled: true });
-        expect(redactor.redact(123)).toBe(123);
-        expect(redactor.redact(true)).toBe(true);
-        expect(redactor.redact(() => "hi")).toBeInstanceOf(Function);
-    });
-});

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

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

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

@@ -1,82 +0,0 @@
-"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

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

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

@@ -1,128 +0,0 @@
-"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

@@ -1,5 +0,0 @@
-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

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