@bluelibs/runner 3.0.0 → 3.1.1

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

@@ -1,10 +1,10 @@
-import { IEvent, IEventDefinition, symbolEvent } from "../../defs";
+import { IEvent, IEventEmission, symbolEvent } from "../../defs";
 import { Errors } from "../../errors";
 import { EventManager } from "../../models/EventManager";
 
 describe("EventManager", () => {
   let eventManager: EventManager;
-  let eventDefinition: IEventDefinition<string>;
+  let eventDefinition: IEvent<string>;
 
   beforeEach(() => {
     eventManager = new EventManager();
@@ -69,7 +69,7 @@ describe("EventManager", () => {
 
   it("should apply filters correctly", async () => {
     const handler = jest.fn();
-    const filter = (event: IEvent<string>) => event.data === "allowed";
+    const filter = (event: IEventEmission<string>) => event.data === "allowed";
 
     eventManager.addListener(eventDefinition, handler, { filter });
 
@@ -97,6 +97,7 @@ describe("EventManager", () => {
       expect.objectContaining({
         id: "testEvent",
         data: "testData",
+        timestamp: expect.any(Date),
       })
     );
   });
@@ -161,11 +162,11 @@ describe("EventManager", () => {
   });
 
   it("should handle multiple events", async () => {
-    const eventDef1: IEventDefinition<string> = {
+    const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
     };
-    const eventDef2: IEventDefinition<string> = {
+    const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
     };
@@ -184,6 +185,7 @@ describe("EventManager", () => {
       expect.objectContaining({
         id: "event1",
         data: "data1",
+        timestamp: expect.any(Date),
       })
     );
 
@@ -210,11 +212,11 @@ describe("EventManager", () => {
   });
 
   it("should handle listeners added to multiple events", async () => {
-    const eventDef1: IEventDefinition<string> = {
+    const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
     };
-    const eventDef2: IEventDefinition<string> = {
+    const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
     };
@@ -244,11 +246,11 @@ describe("EventManager", () => {
   });
 
   it("should not affect other events when emitting one", async () => {
-    const eventDef1: IEventDefinition<string> = {
+    const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
     };
-    const eventDef2: IEventDefinition<string> = {
+    const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
     };
@@ -367,7 +369,7 @@ describe("EventManager", () => {
 
   it("should handle filters in global listeners", async () => {
     const handler = jest.fn();
-    const filter = (event: IEvent<string>) => event.data === "allowed";
+    const filter = (event: IEventEmission<string>) => event.data === "allowed";
 
     eventManager.addGlobalListener(handler, { filter });
 
@@ -387,7 +389,7 @@ describe("EventManager", () => {
   it("should handle listeners with no data", async () => {
     const handler = jest.fn();
 
-    const voidEventDefinition: IEventDefinition<void> = {
+    const voidEventDefinition: IEvent<void> = {
       id: "voidEvent",
       [symbolEvent]: true,
     };
@@ -401,6 +403,7 @@ describe("EventManager", () => {
       expect.objectContaining({
         id: "voidEvent",
         data: undefined,
+        timestamp: expect.any(Date),
       })
     );
   });
@@ -409,15 +412,15 @@ describe("EventManager", () => {
     it("should cache merged listeners for repeated emits", async () => {
       const handler1 = jest.fn();
       const handler2 = jest.fn();
-      
+
       eventManager.addListener(eventDefinition, handler1, { order: 1 });
       eventManager.addGlobalListener(handler2, { order: 2 });
-      
+
       // First emit should build cache
       await eventManager.emit(eventDefinition, "test1", "source");
       // Second emit should use cache
       await eventManager.emit(eventDefinition, "test2", "source");
-      
+
       expect(handler1).toHaveBeenCalledTimes(2);
       expect(handler2).toHaveBeenCalledTimes(2);
     });
@@ -426,55 +429,55 @@ describe("EventManager", () => {
       const handler1 = jest.fn();
       const handler2 = jest.fn();
       const handler3 = jest.fn();
-      
+
       eventManager.addListener(eventDefinition, handler1, { order: 2 });
       await eventManager.emit(eventDefinition, "test1", "source");
-      
+
       // Add new listener - should invalidate cache for this event
       eventManager.addListener(eventDefinition, handler2, { order: 1 });
       eventManager.addGlobalListener(handler3, { order: 3 });
-      
+
       await eventManager.emit(eventDefinition, "test2", "source");
-      
+
       expect(handler1).toHaveBeenCalledTimes(2);
       expect(handler2).toHaveBeenCalledTimes(1);
       expect(handler3).toHaveBeenCalledTimes(1);
     });
 
     it("should invalidate all caches when adding global listeners", async () => {
-      const event1: IEventDefinition<string> = { id: "event1", [symbolEvent]: true };
-      const event2: IEventDefinition<string> = { id: "event2", [symbolEvent]: true };
-      
+      const event1: IEvent<string> = { id: "event1", [symbolEvent]: true };
+      const event2: IEvent<string> = { id: "event2", [symbolEvent]: true };
+
       const handler1 = jest.fn();
       const handler2 = jest.fn();
       const globalHandler = jest.fn();
-      
+
       eventManager.addListener(event1, handler1);
       eventManager.addListener(event2, handler2);
-      
+
       // Emit to build caches
       await eventManager.emit(event1, "test1", "source");
       await eventManager.emit(event2, "test2", "source");
-      
+
       // Add global listener - should invalidate all caches
       eventManager.addGlobalListener(globalHandler);
-      
+
       // Emit again - global handler should be called
       await eventManager.emit(event1, "test3", "source");
       await eventManager.emit(event2, "test4", "source");
-      
+
       expect(globalHandler).toHaveBeenCalledTimes(2);
     });
 
     it("should optimize for empty listener scenarios", async () => {
-      const emptyEventDef: IEventDefinition<string> = {
+      const emptyEventDef: IEvent<string> = {
         id: "emptyEvent",
         [symbolEvent]: true,
       };
-      
+
       // Should return immediately without creating event object
       await eventManager.emit(emptyEventDef, "test", "source");
-      
+
       // No errors should occur
       expect(true).toBe(true);
     });
@@ -483,17 +486,17 @@ describe("EventManager", () => {
       const handler = jest.fn();
       eventManager.addListener(eventDefinition, handler);
       eventManager.addGlobalListener(jest.fn());
-      
+
       const emitCount = 1000;
       const startTime = Date.now();
-      
+
       for (let i = 0; i < emitCount; i++) {
         await eventManager.emit(eventDefinition, `test${i}`, "source");
       }
-      
+
       const endTime = Date.now();
       const duration = endTime - startTime;
-      
+
       expect(handler).toHaveBeenCalledTimes(emitCount);
       // Should complete reasonably fast (adjust threshold as needed)
       expect(duration).toBeLessThan(5000); // 5 seconds max for 1000 emissions
@@ -501,7 +504,7 @@ describe("EventManager", () => {
 
     it("should efficiently handle mixed event and global listeners", async () => {
       const results: string[] = [];
-      
+
       // Add many listeners with different orders
       for (let i = 0; i < 10; i++) {
         eventManager.addListener(
@@ -509,14 +512,13 @@ describe("EventManager", () => {
           () => results.push(`event${i}`),
           { order: i * 2 }
         );
-        eventManager.addGlobalListener(
-          () => results.push(`global${i}`),
-          { order: i * 2 + 1 }
-        );
+        eventManager.addGlobalListener(() => results.push(`global${i}`), {
+          order: i * 2 + 1,
+        });
       }
-      
+
       await eventManager.emit(eventDefinition, "test", "source");
-      
+
       // Should maintain correct order and call all listeners
       expect(results).toHaveLength(20);
       expect(results[0]).toBe("event0");
@@ -526,23 +528,23 @@ describe("EventManager", () => {
     });
 
     it("should reuse cached results across different event types", async () => {
-      const event1: IEventDefinition<string> = { id: "event1", [symbolEvent]: true };
-      const event2: IEventDefinition<string> = { id: "event2", [symbolEvent]: true };
-      
+      const event1: IEvent<string> = { id: "event1", [symbolEvent]: true };
+      const event2: IEvent<string> = { id: "event2", [symbolEvent]: true };
+
       const handler1 = jest.fn();
       const handler2 = jest.fn();
       const globalHandler = jest.fn();
-      
+
       eventManager.addListener(event1, handler1);
       eventManager.addListener(event2, handler2);
       eventManager.addGlobalListener(globalHandler);
-      
+
       // Multiple emits should use cached merged listeners
       await eventManager.emit(event1, "test1", "source");
       await eventManager.emit(event2, "test2", "source");
       await eventManager.emit(event1, "test3", "source");
       await eventManager.emit(event2, "test4", "source");
-      
+
       expect(handler1).toHaveBeenCalledTimes(2);
       expect(handler2).toHaveBeenCalledTimes(2);
       expect(globalHandler).toHaveBeenCalledTimes(4);

package/src/__tests__/recursion/README.md

@@ -0,0 +1,3 @@
+This is a test, tsc build will fail if the code is not correct.
+
+These files are not ran they are just used to test the tsc build.

package/src/__tests__/recursion/a.resource.ts

@@ -0,0 +1,25 @@
+import { defineResource, defineTask } from "../../define";
+import { bResource } from "./b.resource";
+
+export const aResource = defineResource({
+  id: "a.resource",
+  dependencies: {
+    b: bResource,
+  },
+  async init(_, { b }) {
+    const result: string = b;
+    // @ts-expect-error
+    const result2: number = b;
+    return `A depends on ${b}`;
+  },
+});
+
+export const aTask = defineTask({
+  id: "a.task",
+  dependencies: {
+    a: aResource,
+  },
+  async run(_, { a }) {
+    return `Task A executed with dependency: ${a}`;
+  },
+});

package/src/__tests__/recursion/b.resource.ts

@@ -0,0 +1,33 @@
+import { defineResource } from "../../define";
+import { cResource } from "./c.resource";
+
+export const bResource = defineResource({
+  id: "b.resource",
+  dependencies: {
+    c: cResource,
+  },
+  async init(_, { c }) {
+    const result: string = c;
+    // @ts-expect-error
+    const result2: number = c;
+    return `B depends on ${c}`;
+  },
+});
+export const b1Resource = defineResource({
+  id: "b.resource",
+  dependencies: {
+    c: cResource,
+  },
+  async init(_, { c }) {
+    return 123;
+  },
+});
+export const b2Resource = defineResource({
+  id: "b.resource",
+  dependencies: {
+    c: cResource,
+  },
+  async init(_, { c }) {
+    return true;
+  },
+});

package/src/__tests__/recursion/c.resource.ts

@@ -0,0 +1,18 @@
+import { defineResource } from "../../define";
+import { IResource } from "../../defs";
+import { aResource, aTask } from "./a.resource";
+import { b1Resource, b2Resource } from "./b.resource";
+
+const value = Math.random() > 0.5 ? b1Resource : b2Resource;
+
+export const cResource = defineResource({
+  id: "c.resource",
+  dependencies: {
+    aTask,
+    customResource: value,
+  },
+  async init(_, { aTask, customResource }) {
+    const result: string = await aTask(); // Still benefits of autocompletion
+    return `C depends on ${result}`;
+  },
+}) as IResource<void, string>; // This is the key change.