@bluelibs/runner 2.2.3 → 3.0.0

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

@@ -127,4 +127,44 @@ describe("Store", () => {
       /Store already initialized/i
     );
   });
+
+  it("should access overrides and overrideRequests getters", () => {
+    // Test the overrides getter (line 56)
+    const overrides = store.overrides;
+    expect(overrides).toBeDefined();
+    expect(overrides instanceof Map).toBe(true);
+
+    // Test the overrideRequests getter (line 57)
+    const overrideRequests = store.overrideRequests;
+    expect(overrideRequests).toBeDefined();
+    expect(overrideRequests instanceof Set).toBe(true);
+  });
+
+  it("should call processOverrides method", () => {
+    // Test processOverrides method (line 149)
+    expect(() => store.processOverrides()).not.toThrow();
+  });
+
+  it("should call getEverywhereMiddlewareForTasks method", () => {
+    // Test getEverywhereMiddlewareForTasks method (lines 152-153)
+    const result = store.getEverywhereMiddlewareForTasks([]);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("should call getEverywhereMiddlewareForResources method", () => {
+    // Test getEverywhereMiddlewareForResources method (lines 156-157)
+    const result = store.getEverywhereMiddlewareForResources([]);
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("should call storeEventsForAllTasks method", () => {
+    // Test storeEventsForAllTasks method (line 165)
+    expect(() => store.storeEventsForAllTasks()).not.toThrow();
+  });
+
+  it("should call getDependentNodes method", () => {
+    // Test getDependentNodes method (line 169)
+    const result = store.getDependentNodes();
+    expect(Array.isArray(result)).toBe(true);
+  });
 });

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

@@ -4,6 +4,7 @@ import { EventManager } from "../../models/EventManager";
 import { defineTask, defineResource, defineMiddleware } from "../../define";
 import { ITask } from "../../defs";
 import { Logger } from "../../models";
+import { globalEvents } from "../../globals/globalEvents";
 
 describe("TaskRunner", () => {
   let store: Store;
@@ -42,16 +43,16 @@ describe("TaskRunner", () => {
   it("should run an task with middleware", async () => {
     const middleware1 = defineMiddleware({
       id: "middleware1",
-      run: async ({ next, input }) => {
-        const result = await next(input);
+      run: async ({ next, task }) => {
+        const result = await next(task?.input);
         return result + 1;
       },
     });
 
     const middleware2 = defineMiddleware({
       id: "middleware2",
-      run: async ({ input, next }) => {
-        const result = await next(input);
+      run: async ({ task, next }, deps, config) => {
+        const result = await next(task?.input);
         return result * 2;
       },
     });
@@ -104,8 +105,22 @@ describe("TaskRunner", () => {
       expect.objectContaining({ data: { input: 5 } })
     );
     expect(afterRunSpy).toHaveBeenCalledWith(
-      expect.objectContaining({ data: { input: 5, output: 10 } })
+      expect.objectContaining({
+        data: expect.objectContaining({
+          input: 5,
+          output: 10,
+          setOutput: expect.any(Function),
+        }),
+      })
     );
+
+    // Verify that the output getter actually works
+    const afterRunCall = afterRunSpy.mock.calls[0][0];
+    expect(afterRunCall.data.output).toBe(10);
+
+    // Also test the setOutput function to cover line 71
+    afterRunCall.data.setOutput(20);
+    expect(afterRunCall.data.output).toBe(20);
   });
 
   it("should handle errors and emit onError event", async () => {
@@ -137,4 +152,70 @@ describe("TaskRunner", () => {
       })
     );
   });
+
+  it("should handle error suppression", async () => {
+    const error = new Error("Test error");
+    const onErrorSpy = jest.fn().mockImplementation((event) => {
+      // Call suppress to cover line 113
+      event.data.suppress();
+    });
+
+    const task = defineTask({
+      id: "testTask",
+      run: async () => {
+        throw error;
+      },
+    });
+
+    store.tasks.set(task.id, {
+      task,
+      computedDependencies: {},
+      isInitialized: false,
+    });
+
+    eventManager.addListener(task.events.onError, onErrorSpy);
+
+    // The error should be suppressed, so no exception should be thrown
+    const result = await taskRunner.run(task, undefined);
+
+    expect(result).toBeUndefined();
+    expect(onErrorSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.objectContaining({
+          error,
+          suppress: expect.any(Function),
+        }),
+      })
+    );
+  });
+
+  it("should handle global events and access output getter", async () => {
+    const globalAfterRunSpy = jest.fn();
+
+    const task = defineTask({
+      id: "testTask",
+      run: async (input: number) => input * 2,
+    });
+
+    store.tasks.set(task.id, {
+      task,
+      computedDependencies: {},
+      isInitialized: false,
+    });
+
+    // Listen to global afterRun event
+    eventManager.addListener(globalEvents.tasks.afterRun, globalAfterRunSpy);
+
+    await taskRunner.run(task, 5);
+
+    expect(globalAfterRunSpy).toHaveBeenCalledTimes(1);
+
+    // Access the output property to trigger the getter
+    const globalCall = globalAfterRunSpy.mock.calls[0][0];
+    expect(globalCall.data.output).toBe(10);
+
+    // Test setOutput function as well
+    globalCall.data.setOutput(25);
+    expect(globalCall.data.output).toBe(25);
+  });
 });

package/src/__tests__/run.middleware.test.ts

@@ -1,5 +1,6 @@
 import { defineMiddleware, defineTask, defineResource } from "../define";
 import { run } from "../run";
+import { retryMiddleware } from "../globals/middleware/retry.middleware";
 
 // Middleware
 describe("Middleware", () => {
@@ -56,7 +57,7 @@ describe("Middleware", () => {
 
     const app = defineResource({
       id: "app",
-      register: [globalMiddleware.global(), testMiddleware, testTask],
+      register: [globalMiddleware.everywhere(), testMiddleware, testTask],
       dependencies: { testTask },
       async init(_, { testTask }) {
         const result = await testTask();
@@ -94,7 +95,7 @@ describe("Middleware", () => {
 
     const app = defineResource({
       id: "app",
-      register: [globalMiddleware.global(), testMiddleware, testTask],
+      register: [globalMiddleware.everywhere(), testMiddleware, testTask],
       dependencies: { testTask },
       async init(_, { testTask }) {
         const result = await testTask();
@@ -176,7 +177,7 @@ describe("Middleware", () => {
   it("Should work with resources", async () => {
     const middleware = defineMiddleware({
       id: "middleware",
-      run: async ({ resourceDefinition, config: resourceConfig, next }) => {
+      run: async ({ resource, next }) => {
         const result = await next();
         return `Middleware: ${result}`;
       },
@@ -190,14 +191,15 @@ describe("Middleware", () => {
       },
     });
 
-    expect(await run(app)).toBe("Middleware: App initialized");
+    const result = await run(app);
+    expect(result.value).toBe("Middleware: App initialized");
   });
 
   it("Should work with global middleware", async () => {
     const middleware = defineMiddleware({
       id: "middleware",
-      run: async ({ resourceDefinition, config: resourceConfig, next }) => {
-        const result = await next();
+      run: async ({ resource, next }) => {
+        const result = await next({});
         return `Middleware: ${result}`;
       },
     });
@@ -211,26 +213,29 @@ describe("Middleware", () => {
 
     const app = defineResource({
       id: "app",
-      register: [middleware.global(), sub],
+      register: [middleware.everywhere(), sub],
       dependencies: { sub },
       async init(_, { sub }) {
         return sub;
       },
     });
 
-    expect(await run(app)).toBe("Middleware: Middleware: Sub initialized");
+    const result = await run(app);
+    expect(String(result.value)).toBe(
+      "Middleware: Middleware: Sub initialized"
+    );
   });
 
   it("Should prevent circular dependencies when middleware depends on the same task", async () => {
-    const middleware = defineMiddleware({
+    const middleware: any = defineMiddleware({
       id: "middleware",
-      dependencies: () => ({ task }),
-      run: async (_, { task }) => {
+      dependencies: (): any => ({ task }),
+      run: async (_: any, { task }: any) => {
         // example
       },
     });
 
-    const task = defineTask({
+    const task: any = defineTask({
       id: "task",
       middleware: [middleware],
       run: async () => "Task executed",
@@ -247,3 +252,152 @@ describe("Middleware", () => {
     expect(run(app)).rejects.toThrowError(/Circular dependencies detected/);
   });
 });
+
+describe("Configurable Middleware (.with)", () => {
+  it("should allow using middleware usage in a task and pass config to run", async () => {
+    let receivedConfig: any;
+    const validate = defineMiddleware({
+      id: "validate",
+      run: async ({ next }, deps, config: { schema: string }) => {
+        receivedConfig = config;
+        return next();
+      },
+    });
+    const usage = validate.with({ schema: "user" });
+    const task = defineTask({
+      id: "task",
+      middleware: [usage],
+      run: async () => "ok",
+    });
+    const app = defineResource({
+      id: "app",
+      register: [validate, task],
+      dependencies: { task },
+      async init(_, { task }) {
+        const result = await task();
+        expect(result).toBe("ok");
+        expect(receivedConfig).toEqual({ schema: "user" });
+      },
+    });
+    await run(app);
+  });
+
+  it("should allow multiple usages of the same middleware definition with different configs", async () => {
+    const calls: (string | undefined)[] = [];
+    const validate = defineMiddleware({
+      id: "validate",
+      run: async ({ next }, deps, config: { schema: string }) => {
+        calls.push(config.schema);
+        return next();
+      },
+    });
+    const usage1 = validate.with({ schema: "user" });
+    const usage2 = validate.with({ schema: "admin" });
+    const task1 = defineTask({
+      id: "task1",
+      middleware: [usage1],
+      run: async () => "ok1",
+    });
+    const task2 = defineTask({
+      id: "task2",
+      middleware: [usage2],
+      run: async () => "ok2",
+    });
+    const app = defineResource({
+      id: "app",
+      register: [validate, task1, task2],
+      dependencies: { task1, task2 },
+      async init(_, { task1, task2 }) {
+        await task1();
+        await task2();
+        expect(calls).toEqual(["user", "admin"]);
+      },
+    });
+    await run(app);
+  });
+
+  it("should work in an integration scenario with global and per-task middleware", async () => {
+    const calls: string[] = [];
+    const log = defineMiddleware({
+      id: "log",
+      run: async ({ next }) => {
+        calls.push("global");
+        return next();
+      },
+    });
+    const validate = defineMiddleware({
+      id: "validate",
+      run: async ({ next }, deps, config: { schema: string }) => {
+        expect(config).toBeDefined();
+        calls.push(config!.schema);
+        return next();
+      },
+    });
+    const usage = validate.with({ schema: "user" });
+    const task = defineTask({
+      id: "task",
+      middleware: [usage],
+      run: async () => "ok",
+    });
+    const app = defineResource({
+      id: "app",
+      register: [log.everywhere(), validate, task],
+      dependencies: { task },
+      async init(_, { task }) {
+        const result = await task();
+        expect(result).toBe("ok");
+        expect(calls).toContain("global");
+        expect(calls).toContain("user");
+      },
+    });
+    await run(app);
+  });
+
+  it("should enforce type safety for config in .with()", () => {
+    const validate = defineMiddleware({
+      id: "validate",
+      run: async ({ next }, deps, config: { schema: string }) => next(),
+    });
+
+    // Should error if config type is not correct
+    // @ts-expect-error
+    validate.with({ schema: 123 });
+  });
+
+  it("should modify task outputs independently based on middleware configs", async () => {
+    const prefixMiddleware = defineMiddleware({
+      id: "prefixer",
+      run: async ({ next }, deps, config: { prefix: string }) => {
+        const result = await next();
+        return `${config.prefix}: ${result}`;
+      },
+    });
+
+    const taskA = defineTask({
+      id: "taskA",
+      middleware: [prefixMiddleware.with({ prefix: "Alpha" })],
+      run: async () => "Result",
+    });
+
+    const taskB = defineTask({
+      id: "taskB",
+      middleware: [prefixMiddleware.with({ prefix: "Beta" })],
+      run: async () => "Result",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [prefixMiddleware, taskA, taskB],
+      dependencies: { taskA, taskB },
+      async init(_, deps) {
+        const resultA = await deps.taskA();
+        const resultB = await deps.taskB();
+
+        expect(resultA).toBe("Alpha: Result");
+        expect(resultB).toBe("Beta: Result");
+      },
+    });
+
+    await run(app);
+  });
+});

package/src/__tests__/run.overrides.test.ts

@@ -34,7 +34,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(app);
-    expect(result).toBe("Task overridden");
+    expect(result.value).toBe("Task overridden");
   });
 
   it("Should work with a deep override", async () => {
@@ -64,7 +64,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(root);
-    expect(result).toBe("Task overridden");
+    expect(result.value).toBe("Task overridden");
   });
 
   it("Should work with a deep override with config", async () => {
@@ -94,7 +94,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(root);
-    expect(result).toBe("Task overridden");
+    expect(result.value).toBe("Task overridden");
   });
 
   it("Should work with a override that has an override", async () => {
@@ -133,7 +133,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(root);
-    expect(result).toBe("Task overridden");
+    expect(result.value).toBe("Task overridden");
   });
 
   it("Should work with a override that has an override with config", async () => {
@@ -175,7 +175,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(root);
-    expect(result).toBe("Task overridden");
+    expect(result.value).toBe("Task overridden");
   });
 
   it("should work overriding a middleware", async () => {
@@ -210,7 +210,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(resource);
-    expect(result).toBe("Override: Task executed");
+    expect(result.value).toBe("Override: Task executed");
   });
 
   it("should throw, when you try to override something unregistered", async () => {
@@ -301,7 +301,7 @@ describe("run.overrides", () => {
     });
 
     const result = await run(app);
-    expect(result).toBe("Task super-overridden");
+    expect(result.value).toBe("Task super-overridden");
   });
 
   it("should override if I have a previously registered normal resource with a resource with config", async () => {
@@ -326,7 +326,8 @@ describe("run.overrides", () => {
       },
     });
 
-    await expect(run(app)).resolves.toBe("Task overriden.");
+    const result = await run(app);
+    expect(result.value).toBe("Task overriden.");
   });
 
   it("should override if I have a previously registered normal resource with a resource with config", async () => {
@@ -351,7 +352,8 @@ describe("run.overrides", () => {
       },
     });
 
-    await expect(run(app)).resolves.toBe("Task overriden.");
+    const result = await run(app);
+    expect(result.value).toBe("Task overriden.");
   });
 
   it("should override something deeply registered, with a with config", async () => {
@@ -387,6 +389,7 @@ describe("run.overrides", () => {
       },
     });
 
-    await expect(run(app)).resolves.toBe("Task overriden.");
+    const result = await run(app);
+    expect(result.value).toBe("Task overriden.");
   });
 });