@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -1,4 +1,4 @@
-type ConsoleLevel = 'debug' | 'info' | 'log' | 'warn' | 'error';
+type ConsoleLevel = "debug" | "info" | "log" | "warn" | "error";
 /**
  * Setup console proxy to capture all console output and write to ConsoleLogs table.
  * Also subscribes to dataChanged events to output logs from other process instances.

package/dist/logging/console-logger.js

@@ -17,8 +17,8 @@ const originalConsole = {
     error: console.error,
 };
 let isConsoleLogsProxySetup = false;
-let currentProcessName = 'unknown';
-let currentProcessInstanceId = '';
+let currentProcessName = "unknown";
+let currentProcessInstanceId = "";
 // Guard against cross-process infinite loops
 // Track recent log signatures (hash of message + level + source)
 const recentLogSignatures = new Map();
@@ -26,8 +26,8 @@ const LOG_SIGNATURE_WINDOW_MS = 5000; // 5 second window
 const MAX_IDENTICAL_LOGS_IN_WINDOW = 10; // Max same log in window
 // Track initialization state
 const MAX_PENDING_LOGS = 1000; // Prevent memory buildup if initialization never happens
-let defaultLogger = undefined;
-let consoleLogsProxySubscription = undefined;
+let defaultLogger;
+let consoleLogsProxySubscription;
 /**
  * Setup console proxy to capture all console output and write to ConsoleLogs table.
  * Also subscribes to dataChanged events to output logs from other process instances.
@@ -35,21 +35,21 @@ let consoleLogsProxySubscription = undefined;
  */
 function setupConsoleLogsProxy(processName) {
     if (isConsoleLogsProxySetup) {
-        originalConsole.warn('Console logs proxy already setup, skipping...');
+        originalConsole.warn("Console logs proxy already setup, skipping...");
         return;
     }
     isConsoleLogsProxySetup = true;
     currentProcessName = processName;
     currentProcessInstanceId = (0, utils_1.newid)(); // Unique ID for this process instance
     defaultLogger = new Logger(currentProcessName);
-    const levels = ['debug', 'info', 'log', 'warn', 'error'];
+    const levels = ["debug", "info", "log", "warn", "error"];
     // Monkey-patch console methods to capture local logs
     levels.forEach((level) => {
         const original = originalConsole[level];
-        console[level] = function (...args) {
+        console[level] = (...args) => {
             // Always call original console method first (preserve terminal output)
             original.apply(console, args);
-            defaultLogger.writeLog(level, args);
+            defaultLogger?.writeLog(level, args);
         };
     });
     // Subscribe to dataChanged events to output logs from OTHER process instances
@@ -62,8 +62,8 @@ function setupConsoleLogsProxy(processName) {
                     return;
                 }
                 // Output log from another process with prefix
-                const colorCode = log.process === 'renderer' ? '\x1b[36m' : '\x1b[35m'; // cyan for renderer, magenta for main
-                const resetCode = '\x1b[0m';
+                const colorCode = log.process === "renderer" ? "\x1b[36m" : "\x1b[35m"; // cyan for renderer, magenta for main
+                const resetCode = "\x1b[0m";
                 const prefix = `${colorCode}[${log.process}]${resetCode}`;
                 const logLevel = log.level;
                 const logArgs = [prefix, log.message];
@@ -83,7 +83,7 @@ function setupConsoleLogsProxy(processName) {
             });
         }
         catch (err) {
-            originalConsole.error('Failed to subscribe to console logs dataChanged:', err);
+            originalConsole.error("Failed to subscribe to console logs dataChanged:", err);
         }
     });
     originalConsole.log(`Console proxy initialized for process: ${processName} (instance: ${currentProcessInstanceId})`);
@@ -103,7 +103,7 @@ function restoreConsole() {
     console.warn = originalConsole.warn;
     console.error = originalConsole.error;
     isConsoleLogsProxySetup = false;
-    originalConsole.log('Console proxy removed, original console restored');
+    originalConsole.log("Console proxy removed, original console restored");
 }
 /**
  * Extract core message by removing common prefixes that might be added by different processes
@@ -114,15 +114,15 @@ function extractCoreMessage(message) {
     let core = message;
     // Remove common process/context prefixes like [main], [renderer], [process-name]
     // Keep removing until no more matches found
-    let previousCore = '';
+    let previousCore = "";
     while (core !== previousCore) {
         previousCore = core;
         // Remove [xxx] prefixes
-        core = core.replace(/^\[[^\]]+\]\s*/g, '');
+        core = core.replace(/^\[[^\]]+\]\s*/g, "");
         // Remove common timestamp patterns
-        core = core.replace(/^\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[^\s]*\s*/g, '');
+        core = core.replace(/^\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}[^\s]*\s*/g, "");
         // Remove "Error: " prefix that might be added
-        core = core.replace(/^Error:\s*/i, '');
+        core = core.replace(/^Error:\s*/i, "");
     }
     return core.trim();
 }
@@ -163,8 +163,8 @@ function getStackTrace() {
         if (!stack)
             return undefined;
         // Remove first few lines (Error message and this function's frames)
-        const lines = stack.split('\n');
-        return lines.slice(4).join('\n');
+        const lines = stack.split("\n");
+        return lines.slice(4).join("\n");
     }
     catch {
         return undefined;
@@ -177,7 +177,7 @@ function extractSource(stackTrace) {
     if (!stackTrace)
         return undefined;
     try {
-        const lines = stackTrace.split('\n');
+        const lines = stackTrace.split("\n");
         if (lines.length === 0)
             return undefined;
         // Get first line of stack (caller's location)
@@ -189,7 +189,7 @@ function extractSource(stackTrace) {
         if (match) {
             const path = match[1] || match[2];
             // Extract just the filename
-            const filename = path.split('/').pop()?.split('?')[0];
+            const filename = path.split("/").pop()?.split("?")[0];
             return filename;
         }
     }
@@ -205,9 +205,7 @@ async function writeLogToDatabaseWithSource(level, source, args) {
     try {
         const timestamp = (0, utils_1.getTimestamp)();
         // Format message from arguments
-        let message = typeof args[0] === 'string' ?
-            args.shift() :
-            (0, serial_json_1.toJSONString)(args[0]);
+        let message = typeof args[0] === "string" ? args.shift() : (0, serial_json_1.toJSONString)(args[0]);
         // Check for infinite loop before writing
         // Extract core message to detect cross-process loops where prefixes are added
         const coreMessage = extractCoreMessage(message);
@@ -218,17 +216,14 @@ async function writeLogToDatabaseWithSource(level, source, args) {
         }
         // Extract context objects from arguments
         for (const a of [...args]) {
-            if (typeof a === 'object' && !((0, lodash_1.isDate)(a) || a === null)) {
+            if (typeof a === "object" && !((0, lodash_1.isDate)(a) || a === null)) {
                 break;
             }
-            message += ' ' + args.shift();
+            message += ` ${args.shift()}`;
         }
-        let context = args.length === 0 ?
-            undefined : args.length === 1 ?
-            args[0] :
-            args;
+        const context = args.length === 0 ? undefined : args.length === 1 ? args[0] : args;
         // Get stack trace for errors
-        const stackTrace = level === 'error' ? getStackTrace() : undefined;
+        const stackTrace = level === "error" ? getStackTrace() : undefined;
         const logRecord = {
             logId: (0, utils_1.newid)(),
             timestamp,
@@ -244,7 +239,7 @@ async function writeLogToDatabaseWithSource(level, source, args) {
         await consoleLogsTable.insert(logRecord);
     }
     catch (err) {
-        originalConsole.error('[console-logger] Failed to write log to database:', err);
+        originalConsole.error("[console-logger] Failed to write log to database:", err);
     }
 }
 /**
@@ -265,7 +260,7 @@ class Logger {
         // If no source provided, try to extract from caller's location
         if (!source) {
             const stack = new Error().stack;
-            source = extractSource(stack) || 'unknown';
+            source = extractSource(stack) || "unknown";
         }
         this.source = source;
         (0, console_logs_table_1.ConsoleLogs)().then(() => {
@@ -278,35 +273,35 @@ class Logger {
      */
     debug(...args) {
         originalConsole.debug(...args);
-        this.writeLog('debug', args);
+        this.writeLog("debug", args);
     }
     /**
      * Log an info message
      */
     info(...args) {
         originalConsole.info(...args);
-        this.writeLog('info', args);
+        this.writeLog("info", args);
     }
     /**
      * Log a general message
      */
     log(...args) {
         originalConsole.log(...args);
-        this.writeLog('log', args);
+        this.writeLog("log", args);
     }
     /**
      * Log a warning message
      */
     warn(...args) {
         originalConsole.warn(...args);
-        this.writeLog('warn', args);
+        this.writeLog("warn", args);
     }
     /**
      * Log an error message
      */
     error(...args) {
         originalConsole.error(...args);
-        this.writeLog('error', args);
+        this.writeLog("error", args);
     }
     /**
      * Internal method to write log to database
@@ -320,14 +315,14 @@ class Logger {
             else {
                 // Drop logs if queue is full to prevent memory issues
                 if (this.pendingLogs.length === MAX_PENDING_LOGS) {
-                    originalConsole.warn('[console-logger] Pending log queue is full, dropping new logs until initialization');
+                    originalConsole.warn("[console-logger] Pending log queue is full, dropping new logs until initialization");
                 }
             }
             return;
         }
         // System is initialized, write directly
         writeLogToDatabaseWithSource(level, this.source, args).catch((err) => {
-            originalConsole.error('[console-logger] Failed to write log:', err);
+            originalConsole.error("[console-logger] Failed to write log:", err);
         });
     }
     async flushPendingLogs() {
@@ -336,7 +331,7 @@ class Logger {
         for (const { level, args } of _pendingLogs) {
             await (0, utils_1.sleep)(10); // small delay to avoid stampede
             await writeLogToDatabaseWithSource(level, this.source, args).catch((err) => {
-                originalConsole.error('[console-logger] Failed to flush pending log:', err);
+                originalConsole.error("[console-logger] Failed to flush pending log:", err);
             });
         }
     }

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const console_logger_1 = require("./console-logger");
 // Mock the ConsoleLogs table
-jest.mock('./console-logs.table', () => {
+jest.mock("./console-logs.table", () => {
     const mockTable = {
         insert: jest.fn().mockResolvedValue(undefined),
         dataChanged: {
@@ -15,40 +15,40 @@ jest.mock('./console-logs.table', () => {
     };
 });
 // Get reference to mock table
-const { __mockTable: mockTable } = require('./console-logs.table');
+const { __mockTable: mockTable } = require("./console-logs.table");
 // Mock utils
-jest.mock('../utils', () => ({
-    newid: () => 'test-id-123',
-    getTimestamp: () => '2024-01-01T00:00:00.000Z',
+jest.mock("../utils", () => ({
+    newid: () => "test-id-123",
+    getTimestamp: () => "2024-01-01T00:00:00.000Z",
     sleep: jest.fn().mockResolvedValue(undefined),
 }));
-describe('console-logger', () => {
+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');
+    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 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 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 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 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('');
+        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(() => {
@@ -77,76 +77,76 @@ describe('console-logger', () => {
         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 () => {
+    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');
+                    throw new Error("Database error");
                 }
                 return Promise.resolve();
             });
-            (0, console_logger_1.setupConsoleLogsProxy)('test-process');
+            (0, console_logger_1.setupConsoleLogsProxy)("test-process");
             // Wait for setup to complete
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
             // This should trigger the loop
-            console.error('Initial error');
+            console.error("Initial error");
             // Wait for async operations
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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');
+    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));
+            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');
+                console.error("Same error message");
                 // Small delay to ensure they're processed
-                await new Promise(resolve => setTimeout(resolve, 10));
+                await new Promise((resolve) => setTimeout(resolve, 10));
             }
             // Wait for async operations
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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');
+        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));
+            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));
+                await new Promise((resolve) => setTimeout(resolve, 10));
             }
             // Wait for async operations
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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');
+        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));
+            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 baseMessage = "Failed to write log to database";
             const messages = [
                 baseMessage,
                 `[main] ${baseMessage}`,
@@ -159,11 +159,11 @@ describe('console-logger', () => {
             for (let cycle = 0; cycle < 3; cycle++) {
                 for (const msg of messages) {
                     console.error(msg);
-                    await new Promise(resolve => setTimeout(resolve, 10));
+                    await new Promise((resolve) => setTimeout(resolve, 10));
                 }
             }
             // Wait for async operations
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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
@@ -174,73 +174,73 @@ describe('console-logger', () => {
             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');
+    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));
+            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));
+                console.error("Same error");
+                await new Promise((resolve) => setTimeout(resolve, 10));
             }
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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));
+            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');
+    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));
+            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));
+            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');
+    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));
+            await new Promise((resolve) => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
-            logger.log('Test message');
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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');
+            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');
+        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));
+            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));
+            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
@@ -248,53 +248,53 @@ describe('console-logger', () => {
             const uniqueLevels = new Set(levels);
             expect(uniqueLevels.size).toBeGreaterThanOrEqual(4);
         });
-        it('should queue logs before initialization and flush after', async () => {
+        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');
+            const { ConsoleLogs } = require("./console-logs.table");
             ConsoleLogs.mockReturnValueOnce(delayedPromise);
-            const logger = new console_logger_1.Logger('EarlyModule');
+            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');
+            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));
+            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));
+            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');
+        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));
+            await new Promise((resolve) => setTimeout(resolve, 100));
             mockTable.insert.mockClear();
-            logger.log('Direct message');
-            await new Promise(resolve => setTimeout(resolve, 100));
+            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');
+            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');
+        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));
+            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));
+            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');
+            expect(mockTable.insert.mock.calls[0][0].source).toBe("SourceA");
+            expect(mockTable.insert.mock.calls[1][0].source).toBe("SourceB");
         });
     });
 });