@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/keys.test.js

@@ -1,336 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SQLiteDB = require("better-sqlite3");
-const nacl = require("tweetnacl");
-const tweetnacl_util_1 = require("tweetnacl-util");
-const zod_1 = require("zod");
-const sql_data_source_1 = require("./data/orm/sql.data-source");
-const types_1 = require("./data/orm/types");
-const keys_1 = require("./keys");
-const serial_json_1 = require("./serial-json");
-const zod_types_1 = require("./types/zod-types");
-const utils_1 = require("./utils");
-describe("keys", () => {
-    it("should allow creating a new key pair", () => {
-        const keys = (0, keys_1.newKeys)();
-        expect(keys.publicKey).toBeTruthy();
-        expect(keys.secretKey).toBeTruthy();
-        expect(keys.publicBoxKey).toBeTruthy();
-    });
-    describe("message signing", () => {
-        it("should allow signing a message with a secret key and opening it with the corresponding public key", () => {
-            const keys = (0, keys_1.newKeys)();
-            const msg = "hello world";
-            const signed = (0, keys_1.signMessageWithSecretKey)(msg, keys.secretKey);
-            expect(signed).toBeTruthy();
-            expect(signed).not.toEqual(msg);
-            const opened = (0, keys_1.openMessageWithPublicKey)(signed, keys.publicKey);
-            expect(opened).toEqual(msg);
-        });
-    });
-    describe("object signing", () => {
-        it("should allow signing an object with a secret key and opening it with the corresponding public key", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { hello: "world" };
-            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
-            expect(signed).toBeTruthy();
-            expect(signed).not.toEqual(obj);
-            const opened = (0, keys_1.openSignedObject)(signed);
-            expect(opened).toEqual(obj);
-        });
-        it("should throw an error if the data changes after the signature", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { hello: "world" };
-            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
-            expect(signed).toBeTruthy();
-            signed.contents = { hello: "world2" };
-            expect(signed).not.toEqual(obj);
-            expect(() => (0, keys_1.openSignedObject)(signed)).toThrow(/signature/i);
-        });
-        it("should handle null and undefined gracefully", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = undefined;
-            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
-            expect(signed).toBeTruthy();
-            expect(signed).not.toEqual(obj);
-            const opened = (0, keys_1.openSignedObject)(signed);
-            expect(opened).toEqual(obj);
-        });
-        it.each([
-            false,
-            true,
-            0,
-            1,
-            Math.PI,
-            "",
-            "s",
-        ])(`should handle simple values: \`%s\``, (value) => {
-            const keys = (0, keys_1.newKeys)();
-            const signed = (0, keys_1.signObjectWithSecretKey)(value, keys.secretKey);
-            expect(signed).toBeTruthy();
-            expect(signed).not.toEqual(value);
-            const opened = (0, keys_1.openSignedObject)(signed);
-            expect(opened).toEqual(value);
-        });
-    });
-    describe("message boxing", () => {
-        it("should allow boxing data with a public key so it can only be opened with the secret key", () => {
-            const from = (0, keys_1.newKeys)();
-            const to = (0, keys_1.newKeys)();
-            const msg = "hello world";
-            const boxed = (0, keys_1.boxDataWithKeys)(msg, to.publicBoxKey, from.secretKey);
-            expect(boxed).toBeTruthy();
-            const opened = (0, keys_1.openBoxWithSecretKey)(boxed, to.secretKey);
-            expect(opened).toEqual(msg);
-        });
-        it("should allow boxing objects", () => {
-            const from = (0, keys_1.newKeys)();
-            const to = (0, keys_1.newKeys)();
-            const msg = { hello: "world" };
-            const boxed = (0, keys_1.boxDataWithKeys)(msg, to.publicBoxKey, from.secretKey);
-            expect(boxed).toBeTruthy();
-            const opened = (0, keys_1.openBoxWithSecretKey)(boxed, to.secretKey);
-            expect(opened).toEqual(msg);
-        });
-    });
-    describe("message encryption", () => {
-        it("should allow encrypting a message with a secret key so it can only be decrypted with that same secret key", () => {
-            const keys = (0, keys_1.newKeys)();
-            const msg = "hello world";
-            const boxed = (0, keys_1.encryptData)(msg, keys.secretKey);
-            expect(boxed).toBeTruthy();
-            const opened = (0, keys_1.decryptData)(boxed, keys.secretKey);
-            expect(opened).toEqual(msg);
-        });
-        it("should allow encrypting objects", () => {
-            const keys = (0, keys_1.newKeys)();
-            const msg = { hello: "world" };
-            const boxed = (0, keys_1.encryptData)(msg, keys.secretKey);
-            expect(boxed).toBeTruthy();
-            const opened = (0, keys_1.decryptData)(boxed, keys.secretKey);
-            expect(opened).toEqual(msg);
-        });
-    });
-    describe("loading keys", () => {
-        it("should allow loading keys from a secret key", () => {
-            const keys = (0, keys_1.newKeys)();
-            const loadedKeys = (0, keys_1.hydrateKeys)(keys.secretKey);
-            expect(loadedKeys.secretKey).toEqual(keys.secretKey);
-            expect(loadedKeys.publicKey).toEqual(keys.publicKey);
-            expect(loadedKeys.publicBoxKey).toEqual(keys.publicBoxKey);
-        });
-    });
-    describe("hashBytes", () => {
-        it("should hash buffer data consistently", () => {
-            const data = Buffer.from("Hello, World!", "utf8");
-            const hash1 = (0, keys_1.hashBytes)(data);
-            const hash2 = (0, keys_1.hashBytes)(data);
-            expect(hash1).toBe(hash2);
-            expect(hash1).toBeTruthy();
-        });
-        it("should produce different hashes for different data", () => {
-            const data1 = Buffer.from("Hello, World!", "utf8");
-            const data2 = Buffer.from("Hello, World?", "utf8");
-            const hash1 = (0, keys_1.hashBytes)(data1);
-            const hash2 = (0, keys_1.hashBytes)(data2);
-            expect(hash1).not.toBe(hash2);
-        });
-        it("should work with binary data", () => {
-            // Create binary data with all byte values
-            const binaryData = Buffer.alloc(256);
-            for (let i = 0; i < 256; i++) {
-                binaryData[i] = i;
-            }
-            const hash = (0, keys_1.hashBytes)(binaryData);
-            expect(hash).toBeTruthy();
-            // Verify consistency
-            const hash2 = (0, keys_1.hashBytes)(binaryData);
-            expect(hash).toBe(hash2);
-        });
-        it("should be equivalent to hashValue for string data", () => {
-            const text = "Hello, World!";
-            const stringBuffer = Buffer.from(text, "utf8");
-            const bufferHash = (0, keys_1.hashBytes)(stringBuffer);
-            const stringHash = (0, keys_1.hashValue)(text);
-            expect(bufferHash).toBe(stringHash);
-        });
-        it("should handle empty buffer", () => {
-            const emptyBuffer = Buffer.alloc(0);
-            const hash = (0, keys_1.hashBytes)(emptyBuffer);
-            expect(hash).toBeTruthy();
-        });
-        it("should handle large buffers", () => {
-            // 1MB of data
-            const largeBuffer = Buffer.alloc(1024 * 1024, "A");
-            const hash = (0, keys_1.hashBytes)(largeBuffer);
-            expect(hash).toBeTruthy();
-        });
-    });
-    describe("object signature embedding", () => {
-        it("should add signature to object and verify it successfully", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { name: "test", value: 42 };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            expect(signedObj).toHaveProperty("signature");
-            expect(signedObj.name).toBe("test");
-            expect(signedObj.value).toBe(42);
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
-        });
-        it("should fail verification if object is modified after signing", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { name: "test", value: 42 };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            signedObj.value = 999; // modify after signing
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(false);
-        });
-        it("should fail verification if signature is tampered with", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { name: "test", value: 42 };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            signedObj.signature = `${signedObj.signature}tampered`;
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(false);
-        });
-        it("should extract public key from signature", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { name: "test", value: 42 };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedObj);
-            expect(extractedPublicKey).toBe(keys.publicKey);
-        });
-        it("should return undefined for malformed signature", () => {
-            const obj = { name: "test", value: 42, signature: "malformed" };
-            const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(obj);
-            expect(extractedPublicKey).toBeUndefined();
-        });
-        it("should handle objects with existing signature property", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = { name: "test", value: 42, signature: "old-signature" };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            expect(signedObj.signature).not.toBe("old-signature");
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
-        });
-        it("should work with complex nested objects", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = {
-                user: { name: "Alice", age: 30 },
-                settings: { theme: "dark", notifications: true },
-                data: [1, 2, 3, { nested: true }],
-            };
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
-            expect(signedObj.user.name).toBe("Alice");
-            expect(signedObj.data[3].nested).toBe(true);
-        });
-        it("should handle empty objects", () => {
-            const keys = (0, keys_1.newKeys)();
-            const obj = {};
-            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
-            expect((0, keys_1.getPublicKeyFromObjectSignature)(signedObj)).toBe(keys.publicKey);
-        });
-    });
-    describe("canonical signatures", () => {
-        it("canonicalJSONString sorts keys at every level and drops null/undefined keys", () => {
-            const a = { z: 1, a: { y: [3, { q: 1, p: 2 }], x: undefined, w: null }, m: undefined };
-            const b = { a: { y: [3, { p: 2, q: 1 }] }, z: 1 };
-            expect((0, keys_1.canonicalJSONString)(a)).toBe((0, keys_1.canonicalJSONString)(b));
-            expect((0, keys_1.canonicalJSONString)(a)).toBe('{"a":{"y":[3,{"p":2,"q":1}]},"z":1}');
-        });
-        it("canonicalJSONString keeps array elements and encodes extended types", () => {
-            const date = new Date("2026-01-02T03:04:05.000Z");
-            expect((0, keys_1.canonicalJSONString)([1, null, undefined])).toBe('[1,null,"__UNDEFINED"]');
-            expect((0, keys_1.canonicalJSONString)({ when: date })).toBe(`{"when":"__DATE ${date.toISOString()}"}`);
-            expect((0, keys_1.canonicalJSONString)({ b: Buffer.from("hi") })).toBe('{"b":"__BUFFER aGk="}');
-        });
-        it("verifies after the keys are reordered", () => {
-            const keys = (0, keys_1.newKeys)();
-            const signed = (0, keys_1.addSignatureToObject)({ userId: "u1", name: "Alice", publicKey: keys.publicKey }, keys.secretKey);
-            // Same fields, different insertion order (as a row read back from SQLite would be).
-            const reordered = {
-                publicKey: signed.publicKey,
-                signature: signed.signature,
-                name: signed.name,
-                userId: signed.userId,
-            };
-            expect(() => (0, keys_1.verifyObjectSignature)(reordered)).not.toThrow();
-        });
-        it("treats an absent, undefined, and null optional field identically", () => {
-            const keys = (0, keys_1.newKeys)();
-            const signed = (0, keys_1.addSignatureToObject)({ userId: "u1", name: "Alice" }, keys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)({ ...signed, avatar: undefined })).toBe(true);
-            expect((0, keys_1.isObjectSignatureValid)({ ...signed, avatar: null })).toBe(true);
-            // A real value change still fails.
-            expect((0, keys_1.isObjectSignatureValid)({ ...signed, avatar: "x" })).toBe(false);
-        });
-        it("still fails when a value changes, regardless of order", () => {
-            const keys = (0, keys_1.newKeys)();
-            const signed = (0, keys_1.addSignatureToObject)({ a: 1, b: 2 }, keys.secretKey);
-            expect((0, keys_1.isObjectSignatureValid)({ b: 3, a: 1, signature: signed.signature })).toBe(false);
-        });
-        it("accepts legacy insertion-order signatures written before canonicalization", () => {
-            const keys = (0, keys_1.newKeys)();
-            // Key order deliberately not sorted, so canonical and legacy bytes differ.
-            const contents = { userId: "u1", name: "Alice", publicKey: keys.publicKey, maybe: undefined };
-            const legacyBytes = (0, tweetnacl_util_1.decodeUTF8)((0, serial_json_1.toJSONString)(contents));
-            expect((0, serial_json_1.toJSONString)(contents)).not.toBe((0, keys_1.canonicalJSONString)(contents));
-            const legacySig = nacl.sign.detached(legacyBytes, (0, keys_1.decodeBase64)(keys.secretKey));
-            const signature = Buffer.from(legacySig).toString("base64url");
-            expect(() => (0, keys_1.openSignedObject)({ contents, signature, publicKey: keys.publicKey })).not.toThrow();
-            expect(() => (0, keys_1.verifyObjectSignature)({ ...contents, signature: `${keys.publicKey}:${signature}` })).not.toThrow();
-            // Tampering is still caught on the legacy path.
-            expect(() => (0, keys_1.openSignedObject)({
-                contents: { ...contents, name: "Mallory" },
-                signature,
-                publicKey: keys.publicKey,
-            })).toThrow(/signature/i);
-        });
-        it("survives a round trip through a SQLite table", async () => {
-            const db = new SQLiteDB(":memory:");
-            const harness = {
-                get: async (sql, params = []) => db.prepare(sql).get(params),
-                all: async (sql, params = []) => db.prepare(sql).all(params),
-                exec: async (sql, params = []) => ({
-                    changes: db.prepare(sql).run(params).changes,
-                }),
-                close: async () => {
-                    db.close();
-                },
-            };
-            const schema = zod_1.z.object({
-                userId: zod_types_1.zodPeerId,
-                name: zod_1.z.string(),
-                publicKey: zod_1.z.string(),
-                publicBoxKey: zod_1.z.string(),
-                avatar: zod_1.z.string().optional(),
-                signature: zod_1.z.string(),
-            });
-            const metaData = {
-                name: "test_signed_users",
-                description: "signed users",
-                primaryKeyName: "userId",
-                fields: (0, types_1.schemaToFields)(schema),
-            };
-            const table = new sql_data_source_1.SQLDataSource(harness, metaData);
-            try {
-                const keys = (0, keys_1.newKeys)();
-                // Signed with keys in an order that differs from the schema's column order and with an
-                // optional field omitted; SQLite will hand back column order and `avatar: undefined`.
-                const signed = (0, keys_1.addSignatureToObject)({
-                    publicBoxKey: keys.publicBoxKey,
-                    name: "Alice",
-                    userId: (0, utils_1.newid)(),
-                    publicKey: keys.publicKey,
-                }, keys.secretKey);
-                await table.save(signed);
-                const stored = await table.get(signed.userId);
-                if (!stored)
-                    throw new Error("row was not stored");
-                expect(Object.keys(stored)).not.toEqual(Object.keys(signed));
-                expect(() => (0, keys_1.verifyObjectSignature)(stored)).not.toThrow();
-            }
-            finally {
-                await harness.close();
-            }
-        });
-    });
-});

package/dist/logging/console-logger.test.d.ts

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

package/dist/logging/console-logger.test.js

@@ -1,300 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const console_logger_1 = require("./console-logger");
-// Mock the ConsoleLogs table
-jest.mock("./console-logs.table", () => {
-    const mockTable = {
-        insert: jest.fn().mockResolvedValue(undefined),
-        dataChanged: {
-            subscribe: jest.fn(),
-        },
-    };
-    return {
-        ConsoleLogs: jest.fn().mockResolvedValue(mockTable),
-        __mockTable: mockTable, // Export for test access
-    };
-});
-// Get reference to mock table
-const { __mockTable: mockTable } = require("./console-logs.table");
-// Mock utils
-jest.mock("../utils", () => ({
-    newid: () => "test-id-123",
-    getTimestamp: () => "2024-01-01T00:00:00.000Z",
-    sleep: jest.fn().mockResolvedValue(undefined),
-}));
-describe("console-logger", () => {
-    let originalConsole;
-    describe("extractCoreMessage", () => {
-        it("should extract core message from messages with [prefix] tags", () => {
-            expect((0, console_logger_1.extractCoreMessage)("[main] Error message")).toBe("Error message");
-            expect((0, console_logger_1.extractCoreMessage)("[renderer] [main] Error message")).toBe("Error message");
-            expect((0, console_logger_1.extractCoreMessage)("[process-1] [process-2] [process-3] Error message")).toBe("Error message");
-        });
-        it("should remove Error: prefix", () => {
-            expect((0, console_logger_1.extractCoreMessage)("Error: Something went wrong")).toBe("Something went wrong");
-            expect((0, console_logger_1.extractCoreMessage)("[main] Error: Something went wrong")).toBe("Something went wrong");
-        });
-        it("should remove timestamp patterns", () => {
-            expect((0, console_logger_1.extractCoreMessage)("2024-01-01T12:00:00.000Z Error message")).toBe("Error message");
-            expect((0, console_logger_1.extractCoreMessage)("2024-01-01 12:00:00 Error message")).toBe("Error message");
-        });
-        it("should handle combinations of prefixes", () => {
-            expect((0, console_logger_1.extractCoreMessage)("[renderer] 2024-01-01T12:00:00.000Z Error: Failed to write log")).toBe("Failed to write log");
-            expect((0, console_logger_1.extractCoreMessage)("[main] [renderer] Error: Failed to write log")).toBe("Failed to write log");
-        });
-        it("should return the same message if no prefixes found", () => {
-            expect((0, console_logger_1.extractCoreMessage)("Plain error message")).toBe("Plain error message");
-        });
-        it("should handle empty or whitespace messages", () => {
-            expect((0, console_logger_1.extractCoreMessage)("")).toBe("");
-            expect((0, console_logger_1.extractCoreMessage)("   ")).toBe("");
-            expect((0, console_logger_1.extractCoreMessage)("[main]")).toBe("");
-        });
-    });
-    beforeAll(() => {
-        // Save original console methods
-        originalConsole = {
-            debug: console.debug,
-            info: console.info,
-            log: console.log,
-            warn: console.warn,
-            error: console.error,
-        };
-    });
-    beforeEach(() => {
-        // Clear all mocks
-        jest.clearAllMocks();
-        // Restore console before each test
-        (0, console_logger_1.restoreConsole)();
-        // Reset mock table
-        mockTable.insert.mockClear();
-    });
-    afterAll(() => {
-        // Restore original console methods
-        console.debug = originalConsole.debug;
-        console.info = originalConsole.info;
-        console.log = originalConsole.log;
-        console.warn = originalConsole.warn;
-        console.error = originalConsole.error;
-    });
-    describe("Single-process infinite loop detection", () => {
-        it("should detect infinite loop when logging from within log handler", async () => {
-            // Setup mock to throw error that triggers another log
-            let callCount = 0;
-            mockTable.insert.mockImplementation(() => {
-                callCount++;
-                if (callCount < 10) {
-                    // This would trigger another log attempt
-                    throw new Error("Database error");
-                }
-                return Promise.resolve();
-            });
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup to complete
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // This should trigger the loop
-            console.error("Initial error");
-            // Wait for async operations
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should have called insert but stopped early due to recursion guard
-            expect(mockTable.insert).toHaveBeenCalled();
-            // The calls should be limited
-            expect(callCount).toBeLessThanOrEqual(5);
-        });
-    });
-    describe("Cross-process infinite loop detection", () => {
-        it("should detect when same log is written too many times in window", async () => {
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            // Log the same message many times quickly (simulating cross-process loop)
-            for (let i = 0; i < 15; i++) {
-                console.error("Same error message");
-                // Small delay to ensure they're processed
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-            // Wait for async operations
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should have stopped writing after threshold (10)
-            expect(mockTable.insert.mock.calls.length).toBeLessThan(15);
-            expect(mockTable.insert.mock.calls.length).toBeGreaterThan(0);
-        });
-        it("should NOT detect loop for different messages", async () => {
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Clear setup log
-            mockTable.insert.mockClear();
-            // Log different messages
-            for (let i = 0; i < 15; i++) {
-                console.error(`Different error message ${i}`);
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-            // Wait for async operations
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should have written most/all messages (allow for timing variance)
-            expect(mockTable.insert.mock.calls.length).toBeGreaterThanOrEqual(14);
-            expect(mockTable.insert.mock.calls.length).toBeLessThanOrEqual(15);
-        });
-        it("should detect loop even with modified messages (prefix added)", async () => {
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            // Simulate cross-process loop where each process adds a prefix
-            // This represents Process A logging "Error X"
-            // Process B seeing it and logging "[main] Error X"
-            // Process A seeing that and logging "[renderer] [main] Error X"
-            const baseMessage = "Failed to write log to database";
-            const messages = [
-                baseMessage,
-                `[main] ${baseMessage}`,
-                `[renderer] [main] ${baseMessage}`,
-                `[main] [renderer] [main] ${baseMessage}`,
-                `[renderer] [main] [renderer] [main] ${baseMessage}`,
-            ];
-            // Log these messages in sequence, simulating the loop
-            // Need enough to trigger the threshold (MAX_IDENTICAL_LOGS_IN_WINDOW = 10)
-            for (let cycle = 0; cycle < 3; cycle++) {
-                for (const msg of messages) {
-                    console.error(msg);
-                    await new Promise((resolve) => setTimeout(resolve, 10));
-                }
-            }
-            // Wait for async operations
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should detect this as a loop even though messages have different prefixes
-            // because extractCoreMessage normalizes them all to the same core message
-            // We logged 15 messages (5 variants x 3 cycles), but they all have the same core
-            // So after 10, it should start blocking
-            const insertCount = mockTable.insert.mock.calls.length;
-            // Should be: 1 (setup) + 10 (threshold) = 11, might be a bit more due to timing
-            expect(insertCount).toBeGreaterThan(1); // At least setup + some logs
-            expect(insertCount).toBeLessThan(17); // Definitely less than all 15 + setup
-        });
-    });
-    describe("Loop detection recovery", () => {
-        it("should allow logging again after window expires", async () => {
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            // Trigger loop detection
-            for (let i = 0; i < 12; i++) {
-                console.error("Same error");
-                await new Promise((resolve) => setTimeout(resolve, 10));
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            const firstBatchCount = mockTable.insert.mock.calls.length;
-            // Wait for window to expire (5 seconds in real code, but we can't easily test that)
-            // Just verify the blocking is in place
-            console.error("Same error");
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should still be blocked
-            expect(mockTable.insert.mock.calls.length).toBe(firstBatchCount);
-        });
-    });
-    describe("Normal logging behavior", () => {
-        it("should write logs to database for normal usage", async () => {
-            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
-            // Wait for setup to complete
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            console.log("Test message");
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            console.error("Test error");
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            console.warn("Test warning");
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            // Verify at least the logs were attempted
-            expect(mockTable.insert).toHaveBeenCalled();
-            expect(mockTable.insert.mock.calls.length).toBeGreaterThanOrEqual(1);
-            expect(mockTable.insert.mock.calls.length).toBeLessThanOrEqual(3);
-        });
-    });
-    describe("Logger class", () => {
-        it("should create logger with specified source", async () => {
-            const logger = new console_logger_1.Logger("MyModule");
-            // Wait for Logger to initialize
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            logger.log("Test message");
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            expect(mockTable.insert).toHaveBeenCalled();
-            const call = mockTable.insert.mock.calls[0];
-            expect(call[0].source).toBe("MyModule");
-            expect(call[0].message).toBe("Test message");
-        });
-        it("should support all log levels", async () => {
-            const logger = new console_logger_1.Logger("TestModule");
-            // Wait for Logger to initialize
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            logger.debug("Debug message");
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            logger.info("Info message");
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            logger.log("Log message");
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            logger.warn("Warn message");
-            await new Promise((resolve) => setTimeout(resolve, 20));
-            logger.error("Error message");
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            // Should have most/all logs
-            expect(mockTable.insert.mock.calls.length).toBeGreaterThanOrEqual(4);
-            // Check that different levels were used
-            const levels = mockTable.insert.mock.calls.map((call) => call[0].level);
-            const uniqueLevels = new Set(levels);
-            expect(uniqueLevels.size).toBeGreaterThanOrEqual(4);
-        });
-        it("should queue logs before initialization and flush after", async () => {
-            // Create a delayed promise for ConsoleLogs
-            let resolveConsoleLogs;
-            const delayedPromise = new Promise((resolve) => {
-                resolveConsoleLogs = resolve;
-            });
-            const { ConsoleLogs } = require("./console-logs.table");
-            ConsoleLogs.mockReturnValueOnce(delayedPromise);
-            const logger = new console_logger_1.Logger("EarlyModule");
-            // Log before initialization
-            logger.log("Early message 1");
-            logger.warn("Early message 2");
-            logger.error("Early message 3");
-            // Small delay to ensure logs are queued
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            // Should not have written yet
-            expect(mockTable.insert).not.toHaveBeenCalled();
-            // Now resolve the ConsoleLogs promise
-            resolveConsoleLogs(mockTable);
-            // Wait for flush
-            await new Promise((resolve) => setTimeout(resolve, 300));
-            // Should have flushed pending logs
-            expect(mockTable.insert.mock.calls.length).toBeGreaterThanOrEqual(2);
-        });
-        it("should write logs directly after initialization", async () => {
-            const logger = new console_logger_1.Logger("LateModule");
-            // Wait for initialization
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            logger.log("Direct message");
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            expect(mockTable.insert).toHaveBeenCalledTimes(1);
-            expect(mockTable.insert.mock.calls[0][0].message).toBe("Direct message");
-        });
-        it("should use reliable source from constructor", async () => {
-            const logger1 = new console_logger_1.Logger("SourceA");
-            const logger2 = new console_logger_1.Logger("SourceB");
-            // Wait for initialization
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            mockTable.insert.mockClear();
-            logger1.log("From A");
-            await new Promise((resolve) => setTimeout(resolve, 50));
-            logger2.log("From B");
-            await new Promise((resolve) => setTimeout(resolve, 100));
-            expect(mockTable.insert).toHaveBeenCalledTimes(2);
-            expect(mockTable.insert.mock.calls[0][0].source).toBe("SourceA");
-            expect(mockTable.insert.mock.calls[1][0].source).toBe("SourceB");
-        });
-    });
-});

package/dist/logging/console-logs.table.test.d.ts

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