@bluelibs/runner 2.2.3 → 3.0.0

package/src/__tests__/models/Logger.test.ts

@@ -1,7 +1,6 @@
 import { Logger, ILog, LogLevels } from "../../models/Logger";
 import { EventManager } from "../../models/EventManager";
-import { globalEvents } from "../../globalEvents";
-import { mock } from "node:test";
+import { globalEvents } from "../../globals/globalEvents";
 
 describe("Logger", () => {
   let logger: Logger;
@@ -16,15 +15,19 @@ describe("Logger", () => {
     it("should emit a log event with correct data", async () => {
       const testData = "Test log message";
       const testLevel = "info";
-      mockEventManager.emit = jest.fn();
+      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
 
-      await logger.log(testLevel, testData);
+      logger.log(testLevel, testData);
+
+      // Wait for setImmediate to execute
+      await new Promise(setImmediate);
 
       expect(mockEventManager.emit).toHaveBeenCalledWith(
         globalEvents.log,
         expect.objectContaining({
           level: testLevel,
-          data: testData,
+          message: testData,
           timestamp: expect.any(Date),
         }),
         "unknown"
@@ -41,21 +44,28 @@ describe("Logger", () => {
         "critical",
       ];
 
-      mockEventManager.emit = jest.fn();
+      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
 
       for (const level of levels) {
-        await logger.log(level, `Test ${level} message`, "testSource");
-
-        expect(mockEventManager.emit).toHaveBeenCalledWith(
-          globalEvents.log,
-          expect.objectContaining({
-            level,
-            data: `Test ${level} message`,
-            timestamp: expect.any(Date),
-          }),
-          "testSource"
-        );
+        logger.log(level, `Test ${level} message`, { source: "testSource" });
       }
+
+      // Wait for setImmediate to execute
+      await new Promise(setImmediate);
+
+      // Check all calls were made
+      expect(mockEventManager.emit).toHaveBeenCalledTimes(levels.length);
+    });
+
+    it("should not emit events when there are no listeners", () => {
+      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(false);
+
+      logger.log("info", "Test message");
+
+      // Should not emit events when no listeners
+      expect(mockEventManager.emit).not.toHaveBeenCalled();
     });
   });
 
@@ -74,47 +84,179 @@ describe("Logger", () => {
       const testLog: ILog = {
         level: "info",
         source: "test",
-        data: "Test log message",
+        message: "Test log message",
         timestamp: new Date("2023-01-01T00:00:00Z"),
       };
 
       await logger.print(testLog);
 
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("[INFO] (test) - Test log message")
+        expect.stringContaining("INFO")
       );
     });
 
-    it("should handle Error objects in log data", async () => {
+    it("should handle Error objects in log data", () => {
       const testError = new Error("Test error");
       const testLog: ILog = {
         level: "error",
-        data: testError,
+        message: "Operation failed",
+        error: {
+          name: testError.name,
+          message: testError.message,
+          stack: testError.stack,
+        },
         timestamp: new Date("2023-01-01T00:00:00Z"),
       };
 
-      await logger.print(testLog);
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("ERROR")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Error: Error")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Test error")
+      );
+    });
 
+    it("should handle error objects without stack trace", () => {
+      const testLog: ILog = {
+        level: "error",
+        message: "Operation failed",
+        error: {
+          name: "CustomError",
+          message: "Something went wrong",
+        },
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("ERROR")
+      );
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Error: Error - Test error")
+        expect.stringContaining("Error: CustomError")
       );
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining("Stack Trace:")
+        expect.stringContaining("Something went wrong")
       );
     });
 
-    it("should pretty-print JSON objects in log data", async () => {
+    it("should pretty-print structured data", () => {
       const testObject = { key: "value", nested: { foo: "bar" } };
       const testLog: ILog = {
         level: "debug",
+        message: "Debug info",
         data: testObject,
         timestamp: new Date("2023-01-01T00:00:00Z"),
       };
 
-      await logger.print(testLog);
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEBUG")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('"key": "value"')
+      );
+    });
+
+    it("should handle object message by stringifying it", () => {
+      const objectMessage = { type: "user", action: "login" };
+      const testLog: ILog = {
+        level: "info",
+        message: objectMessage as any,
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("INFO")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining(JSON.stringify(objectMessage, null, 2))
+      );
+    });
+
+    it("should print context information when present", () => {
+      const context = { userId: "123", requestId: "abc-def" };
+      const testLog: ILog = {
+        level: "warn",
+        message: "Warning message",
+        data: context,
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("WARN")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('"userId": "123"')
+      );
+    });
+
+    it("should print context from context field", () => {
+      const context = { userId: "456", feature: "login", source: "auth" };
+      const testLog: ILog = {
+        level: "info",
+        message: "User action",
+        context: context,
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("INFO")
+      );
+      // Should show context but filter out 'source' since it's shown separately
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Context:")
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('"userId": "456"')
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('"feature": "login"')
+      );
+    });
+
+    it("should handle empty context gracefully", () => {
+      const testLog: ILog = {
+        level: "debug",
+        message: "Debug message",
+        context: {},
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining("DEBUG")
+      );
+      // Should not print context section for empty context
+      expect(consoleLogSpy).not.toHaveBeenCalledWith(
+        expect.stringContaining("Context:")
+      );
+    });
+
+    it("should handle unknown log levels gracefully", () => {
+      const testLog: ILog = {
+        level: "unknown" as any,
+        message: "Unknown level message",
+        timestamp: new Date("2023-01-01T00:00:00Z"),
+      };
+
+      logger.print(testLog);
 
       expect(consoleLogSpy).toHaveBeenCalledWith(
-        expect.stringContaining(JSON.stringify(testObject, null, 2))
+        expect.stringContaining("UNKNOWN")
       );
     });
   });
@@ -130,21 +272,123 @@ describe("Logger", () => {
     ];
 
     for (const level of testLevels) {
-      it(`should call log method with ${level} level`, async () => {
+      it(`should call log method with ${level} level`, () => {
         const logSpy = jest.spyOn(logger, "log").mockImplementation();
 
-        await logger[level]("Test log message");
+        logger[level]("Test log message");
 
         expect(logSpy).toHaveBeenCalledWith(
           level,
           "Test log message",
-          undefined // the context parameter
+          {} // the LogInfo parameter
         );
       });
     }
   });
 
-  it("should auto-print logs based on autoPrintLogsAfter option", async () => {
+  describe("with method", () => {
+    it("should create a new logger with additional context", () => {
+      const initialContext = { source: "initial" };
+      const loggerWithContext = new Logger(mockEventManager, initialContext);
+
+      const additionalContext = { userId: "123", feature: "auth" };
+      const newLogger = loggerWithContext.with(additionalContext);
+
+      expect(newLogger).toBeInstanceOf(Logger);
+      expect(newLogger).not.toBe(loggerWithContext);
+
+      // Test that the context is merged by checking the log call
+      const logSpy = jest.spyOn(newLogger, "log").mockImplementation();
+      newLogger.info("test message");
+
+      expect(logSpy).toHaveBeenCalledWith("info", "test message", {});
+    });
+
+    it("should override context values when keys overlap", () => {
+      const initialContext = { source: "initial", common: "old" };
+      const loggerWithContext = new Logger(mockEventManager, initialContext);
+
+      const newContext = { source: "override", newProp: "value" };
+      const newLogger = loggerWithContext.with(newContext);
+
+      // The new logger should have the overridden context
+      expect(newLogger).toBeInstanceOf(Logger);
+    });
+
+    it("should use bound context in log calls", async () => {
+      const boundContext = { source: "testSource", userId: "123" };
+      const loggerWithContext = new Logger(mockEventManager, boundContext);
+      
+      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
+
+      loggerWithContext.log("info", "Test message");
+
+      await new Promise(setImmediate);
+
+      expect(mockEventManager.emit).toHaveBeenCalledWith(
+        globalEvents.log,
+        expect.objectContaining({
+          source: "testSource",
+          context: boundContext,
+        }),
+        "testSource"
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle event emission errors gracefully", async () => {
+      const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+      const emitError = new Error("Event emission failed");
+
+      mockEventManager.emit = jest.fn().mockRejectedValue(emitError);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
+
+      logger.log("error", "Test error message");
+
+      // Wait for setImmediate and promise rejection to be handled
+      await new Promise(setImmediate);
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        "Logger event emission failed:",
+        emitError
+      );
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it("should extract error information from Error objects", async () => {
+      mockEventManager.emit = jest.fn().mockResolvedValue(undefined);
+      mockEventManager.hasListeners = jest.fn().mockReturnValue(true);
+
+      const testError = new Error("Test error message");
+      testError.name = "CustomError";
+
+      logger.log("error", "Operation failed", { error: testError });
+
+      // Wait for setImmediate to execute
+      await new Promise(setImmediate);
+
+      expect(mockEventManager.emit).toHaveBeenCalledWith(
+        globalEvents.log,
+        expect.objectContaining({
+          level: "error",
+          message: "Operation failed",
+          error: {
+            name: "CustomError",
+            message: "Test error message",
+            stack: expect.any(String),
+          },
+          timestamp: expect.any(Date),
+        }),
+        "unknown"
+      );
+    });
+  });
+
+  it("should auto-print logs based on autoPrintLogsAfter option", () => {
     const autoPrintLevel: LogLevels = "warn";
     logger.setPrintThreshold(autoPrintLevel);
     const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
@@ -160,7 +404,7 @@ describe("Logger", () => {
 
     for (const level of levels) {
       logger.setPrintThreshold(level);
-      await logger.log(level, `Test ${level} message`);
+      logger.log(level, `Test ${level} message`);
 
       expect(consoleLogSpy).toHaveBeenCalledWith(
         expect.stringContaining(`Test ${level} message`)
@@ -169,8 +413,8 @@ describe("Logger", () => {
 
     // ensure events with a higher level thatn auto print level are printed, and lower levels are not
     logger.setPrintThreshold("error");
-    await logger.log("info", "xx Test info message");
-    await logger.log("error", "xx Test error message");
+    logger.log("info", "xx Test info message");
+    logger.log("error", "xx Test error message");
 
     expect(consoleLogSpy).toHaveBeenCalledWith(
       expect.stringContaining("xx Test error message")
@@ -182,4 +426,17 @@ describe("Logger", () => {
 
     consoleLogSpy.mockRestore();
   });
+
+  it("should disable auto-printing when setPrintThreshold is set to null", () => {
+    const consoleLogSpy = jest.spyOn(console, "log").mockImplementation();
+    
+    // Set to null to disable auto-printing
+    logger.setPrintThreshold(null);
+    
+    logger.log("error", "Should not be printed");
+    
+    expect(consoleLogSpy).not.toHaveBeenCalled();
+    
+    consoleLogSpy.mockRestore();
+  });
 });

package/src/__tests__/models/Queue.test.ts

@@ -0,0 +1,189 @@
+// queue.test.ts
+import { Queue } from "../.."; // <-- adjust path if needed
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+/** Flush native micro‑tasks once (Promise jobs / process.nextTick). */
+const flushMicroTasks = () => Promise.resolve();
+
+/** Small delay helper for tests */
+const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/* ------------------------------------------------------------------ */
+/* Tests                                                              */
+/* ------------------------------------------------------------------ */
+
+describe("Queue", () => {
+  it("runs tasks sequentially and returns their results in order", async () => {
+    const q = new Queue();
+
+    const started: number[] = [];
+    const finished: number[] = [];
+    let concurrent = 0;
+    let maxConcurrent = 0;
+
+    const taskFactory = (id: number) => async () => {
+      started.push(id);
+      concurrent++;
+      maxConcurrent = Math.max(maxConcurrent, concurrent);
+
+      // simulate async work with a real small delay
+      await delay(1);
+
+      finished.push(id);
+      concurrent--;
+      return id;
+    };
+
+    const p1 = q.run(taskFactory(1));
+    const p2 = q.run(taskFactory(2));
+    const p3 = q.run(taskFactory(3));
+
+    const results = await Promise.all([p1, p2, p3]);
+
+    expect(results).toEqual([1, 2, 3]);
+    expect(started).toEqual([1, 2, 3]);
+    expect(finished).toEqual([1, 2, 3]);
+    expect(maxConcurrent).toBe(1); // never overlapped
+  });
+
+  it("detects dead‑lock when a queued task enqueues another task", async () => {
+    const q = new Queue();
+
+    const deadlock = () => q.run(async () => "nested"); // <-- illegal
+
+    await expect(q.run(deadlock)).rejects.toThrow(/Dead‑lock/);
+  });
+
+  it("dispose() drains pending tasks and rejects new ones", async () => {
+    const q = new Queue();
+
+    const task = async () => {
+      await delay(1);
+      return "ok";
+    };
+
+    const p1 = q.run(task);
+    const p2 = q.run(task);
+
+    const disposeDone = q.dispose(); // default => { cancel: false }
+
+    await expect(disposeDone).resolves.toBeUndefined();
+    await expect(p1).resolves.toBe("ok");
+    await expect(p2).resolves.toBe("ok");
+
+    await expect(q.run(task)).rejects.toThrow(/disposed/);
+  });
+
+  it("dispose({ cancel: true }) aborts the running task", async () => {
+    jest.useFakeTimers();
+
+    const q = new Queue();
+
+    /** Long‑running task that cooperates with AbortSignal. */
+    const longTask = async (signal: AbortSignal) =>
+      new Promise<void>((_res, rej) => {
+        const tid = setTimeout(_res, 100); // never actually fires
+        signal.addEventListener("abort", () => {
+          clearTimeout(tid);
+          rej(new Error("aborted"));
+        });
+      });
+
+    const p = q.run(longTask);
+
+    // Let the task start
+    jest.advanceTimersByTime(0);
+    await flushMicroTasks();
+
+    const disposeDone = q.dispose({ cancel: true });
+
+    await flushMicroTasks(); // allow rejection to propagate
+
+    await expect(p).rejects.toThrow(/aborted/);
+    await expect(disposeDone).resolves.toBeUndefined();
+
+    jest.useRealTimers();
+  });
+
+  it("dispose() is idempotent - multiple calls should be safe", async () => {
+    const q = new Queue();
+
+    const task = async () => {
+      await delay(1);
+      return "ok";
+    };
+
+    const p = q.run(task);
+
+    // First dispose call
+    const dispose1 = q.dispose();
+    // Second dispose call should return immediately (if (this.disposed) return;)
+    const dispose2 = q.dispose();
+    // Third dispose call should also return immediately
+    const dispose3 = q.dispose();
+
+    await expect(dispose1).resolves.toBeUndefined();
+    await expect(dispose2).resolves.toBeUndefined();
+    await expect(dispose3).resolves.toBeUndefined();
+    await expect(p).resolves.toBe("ok");
+
+    // Further dispose calls after everything is settled should also be safe
+    const dispose4 = q.dispose();
+    await expect(dispose4).resolves.toBeUndefined();
+  });
+
+  it("dispose() properly handles rejected tail promises", async () => {
+    const q = new Queue();
+
+    // Run a task first to establish the normal tail chain
+    await q.run(async () => "setup");
+
+    // Directly set the tail to a promise that will reject
+    // This simulates an internal error scenario where the tail becomes rejected
+    const rejectingPromise = Promise.reject(
+      new Error("Simulated tail rejection")
+    );
+    (q as any).tail = rejectingPromise;
+
+    // Spy on the rejecting promise to verify the catch is called
+    const catchSpy = jest.spyOn(rejectingPromise, "catch");
+
+    // The dispose method should handle this rejection with: await this.tail.catch(() => {})
+    // This specifically tests the line: await this.tail.catch(() => {});
+    await expect(q.dispose()).resolves.toBeUndefined();
+
+    // Verify that the catch method was called (meaning the tail.catch() line was executed)
+    expect(catchSpy).toHaveBeenCalledWith(expect.any(Function));
+
+    // Verify the queue is properly disposed
+    await expect(q.run(async () => "test")).rejects.toThrow(/disposed/);
+  });
+
+  it("should propagate task exceptions to the caller", async () => {
+    const q = new Queue();
+
+    // Test that exceptions are propagated, not swallowed
+    const errorTask = async () => {
+      await delay(1);
+      throw new Error("Task exception");
+    };
+
+    const successTask = async () => {
+      await delay(1);
+      return "success";
+    };
+
+    // Exception should be catchable by the caller
+    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
+
+    // Queue should still work for subsequent tasks
+    await expect(q.run(successTask)).resolves.toBe("success");
+
+    // Multiple exceptions should all be catchable
+    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
+    await expect(q.run(errorTask)).rejects.toThrow("Task exception");
+  });
+});

package/src/__tests__/models/ResourceInitializer.test.ts

@@ -3,8 +3,8 @@ import { Store } from "../../models/Store";
 import { EventManager } from "../../models/EventManager";
 import { defineResource } from "../../define";
 import { Logger } from "../../models";
-import { globalResources } from "../../globalResources";
-import { globalEvents } from "../../globalEvents";
+import { globalResources } from "../../globals/globalResources";
+import { globalEvents } from "../../globals/globalEvents";
 
 describe("ResourceInitializer", () => {
   let store: Store;
@@ -36,10 +36,11 @@ describe("ResourceInitializer", () => {
       mockDependencies
     );
 
-    expect(result).toBe("initialized value");
+    expect(result).toEqual({ value: "initialized value", context: undefined });
     expect(mockResource.init).toHaveBeenCalledWith(
       mockConfig,
-      mockDependencies
+      mockDependencies,
+      undefined
     );
 
     expect(emitSpy).toHaveBeenCalledWith(
@@ -91,7 +92,8 @@ describe("ResourceInitializer", () => {
     expect(result).toBeUndefined();
     expect(mockResource.init).toHaveBeenCalledWith(
       mockConfig,
-      mockDependencies
+      mockDependencies,
+      undefined
     );
     expect(emitSpy).toHaveBeenCalledWith(
       mockResource.events.beforeInit,
@@ -126,7 +128,7 @@ describe("ResourceInitializer", () => {
       mockDependencies
     );
 
-    expect(result).toBeUndefined();
+    expect(result).toEqual({ value: undefined, context: undefined });
     expect(emitSpy).toHaveBeenCalledWith(
       mockResource.events.beforeInit,
       {