@bluelibs/runner 2.2.4 → 3.1.0

package/src/__tests__/run.test.ts

@@ -5,7 +5,40 @@ import {
   defineMiddleware,
 } from "../define";
 import { run } from "../run";
-import { globalResources } from "../globalResources";
+import { globalResources } from "../globals/globalResources";
+
+describe("main exports", () => {
+  it("should export all public APIs correctly", async () => {
+    // Test main index exports for 100% coverage
+    const mainExports = await import("../index");
+
+    expect(typeof mainExports.task).toBe("function");
+    expect(typeof mainExports.resource).toBe("function");
+    expect(typeof mainExports.event).toBe("function");
+    expect(typeof mainExports.middleware).toBe("function");
+    expect(typeof mainExports.run).toBe("function");
+    expect(typeof mainExports.globals).toBe("object");
+    expect(typeof mainExports.definitions).toBe("object");
+    expect(typeof mainExports.Store).toBe("function");
+    expect(typeof mainExports.EventManager).toBe("function");
+    expect(typeof mainExports.TaskRunner).toBe("function");
+
+    // Test that aliases work the same as direct imports
+    const directTask = defineTask({ id: "test", run: async () => "direct" });
+    const aliasTask = mainExports.task({
+      id: "test2",
+      run: async () => "alias",
+    });
+
+    expect(directTask.id).toBe("test");
+    expect(aliasTask.id).toBe("test2");
+
+    // Test globals sub-properties for complete coverage
+    expect(typeof mainExports.globals.events).toBe("object");
+    expect(typeof mainExports.globals.resources).toBe("object");
+    expect(typeof mainExports.globals.middlewares).toBe("object");
+  });
+});
 
 describe("run", () => {
   // Tasks
@@ -60,7 +93,7 @@ describe("run", () => {
     });
 
     it("should be able to register an task that emits an event", async () => {
-      const testEvent = defineEvent({ id: "test.event" });
+      const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
       const eventHandler = jest.fn();
 
       const testTask = defineTask({
@@ -251,22 +284,22 @@ describe("run", () => {
     });
 
     it("should throw an error if there's an infinite dependency", async () => {
-      const task1 = defineTask({
+      const task1: any = defineTask({
         id: "task1",
-        dependencies: () => ({ task2 }), // Corrected line
+        dependencies: (): any => ({ task2 }), // Corrected line
         run: async () => "Task 1",
       });
 
-      const task2 = defineTask({
+      const task2: any = defineTask({
         id: "task2",
         dependencies: { task1 },
         run: async () => "Task 2",
       });
 
       // define circular dependency resources
-      const resource1 = defineResource({
+      const resource1: any = defineResource({
         id: "resource1",
-        dependencies: () => ({
+        dependencies: (): any => ({
           resource2,
         }),
         init: async () => "Resource 1",
@@ -532,7 +565,8 @@ describe("run", () => {
         },
       });
 
-      await expect(run(app)).resolves.toBe("ok");
+      const result = await run(app);
+      expect(result.value).toBe("ok");
       expect(supressMock).toHaveBeenCalledTimes(2);
     });
   });
@@ -653,18 +687,335 @@ describe("run", () => {
       const app = defineResource({
         id: "app",
         register: [testResource],
-        dependencies: { testResource, store: globalResources.store },
-        async init(_, { testResource, store }) {
+        dependencies: { testResource },
+        async init(_, { testResource }) {
           expect(testResource).toBe("Resource Value");
+          return testResource;
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe("Resource Value");
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalledWith(
+        "Resource Value",
+        {},
+        {},
+        undefined
+      );
+    });
+
+    it("should work with primitive return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return 42; // primitive number
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value + 1).toBe(43); // should work as number
+      expect(result.value).toBe(42);
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with object return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return { api: "server", value: 42 };
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value.api).toBe("server");
+      expect(result.value.value).toBe(42);
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with null return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return null; // null return value
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe(null);
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with undefined return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return undefined; // undefined return value
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe(undefined);
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with boolean return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return true; // boolean return value
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe(true);
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should forward string methods correctly", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
 
-          return {
-            dispose: () => store.dispose(),
-          };
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return "hello world test"; // string return value
         },
       });
 
       const result = await run(app);
+      expect(result.value).toBe("hello world test");
       await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with symbol return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return Symbol("test"); // symbol return value
+        },
+      });
+
+      const result = await run(app);
+      expect(typeof result.value).toBe("symbol");
+      expect(result.value.toString()).toBe("Symbol(test)");
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work with bigint return values", async () => {
+      const disposeFn = jest.fn();
+      const testResource = defineResource({
+        id: "test.resource",
+        dispose: disposeFn,
+        init: async () => "Resource Value",
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [testResource],
+        dependencies: { testResource },
+        async init(_, { testResource }) {
+          return BigInt(123); // bigint return value
+        },
+      });
+
+      const result = await run(app);
+      expect(typeof result.value).toBe("bigint");
+      expect(result.value).toBe(BigInt(123));
+      expect(result.value.toString()).toBe("123");
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+  });
+
+  describe("private context resources", () => {
+    it("should share private context between init and dispose", async () => {
+      const disposeFn = jest.fn();
+      const dbResource = defineResource({
+        id: "db.resource",
+        context: () => ({ connections: [] as string[] }),
+        async init(config, deps, context) {
+          context.connections.push("main-db");
+          // @ts-expect-error - should not allow access to non-existent properties
+          context.nonExistentProperty;
+          // @ts-expect-error - should not allow writing to non-existent properties
+          context.anotherProperty = "test";
+          return "connected";
+        },
+        async dispose(value, config, deps, context) {
+          expect(context.connections).toEqual(["main-db"]);
+          disposeFn();
+
+          context.connections.length = 0; // cleanup
+          // @ts-expect-error - should not allow access to non-existent properties in dispose
+          context.undefinedProperty;
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [dbResource],
+        dependencies: { dbResource },
+        async init(_, { dbResource }) {
+          return dbResource;
+        },
+      });
+
+      const result = await run(app);
+      await result.dispose();
+
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should work without context", async () => {
+      const simpleResource = defineResource({
+        id: "simple.resource",
+        async init(config, deps) {
+          return "simple value";
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [simpleResource],
+        dependencies: { simpleResource },
+        async init(_, { simpleResource }) {
+          return simpleResource;
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe("simple value");
+      await result.dispose();
+    });
+
+    it("should work with private context and dispose only", async () => {
+      const disposeFn = jest.fn();
+
+      // Test dispose function with private context but no init
+      const contextOnlyResource = defineResource({
+        id: "context.only",
+        context: () => ({ cleanupTasks: ["task1", "task2"] }),
+        // This resource only has dispose, testing the private context in dispose scenario
+        dispose: async function (value, config, deps, context) {
+          // When there's no init, dispose still gets called but private context should be available
+          // Note: This won't have private context since init wasn't called
+          disposeFn();
+        },
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [contextOnlyResource],
+        dependencies: { contextOnlyResource },
+        async init(_, { contextOnlyResource }) {
+          // Resource without init should be undefined
+          expect(contextOnlyResource).toBeUndefined();
+          return "app started";
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe("app started");
+      await result.dispose();
+      expect(disposeFn).toHaveBeenCalled();
+    });
+
+    it("should handle resources without init method and proper disposal types", async () => {
+      const disposeFn = jest.fn();
+
+      // Resource without init - just registers other resources
+      const registrationOnlyResource = defineResource({
+        id: "registration.only",
+        // No init method
+        dispose: disposeFn,
+        register: [],
+      });
+
+      const app = defineResource({
+        id: "app",
+        register: [registrationOnlyResource],
+        dependencies: { registrationOnlyResource },
+        async init(_, { registrationOnlyResource }) {
+          // registrationOnlyResource should be undefined since no init
+          expect(registrationOnlyResource).toBeUndefined();
+          return 42;
+        },
+      });
+
+      const result = await run(app);
+      expect(result.value).toBe(42);
+      await result.dispose();
+
+      // dispose should be called with undefined value since no init
+      expect(disposeFn).toHaveBeenCalledWith(undefined, {}, {}, {});
     });
   });
 });

package/src/__tests__/setOutput.test.ts

@@ -0,0 +1,244 @@
+import { defineTask, defineResource } from "../define";
+import { run } from "../run";
+
+describe("setOutput functionality", () => {
+  it("should allow afterRun event listeners to modify task output", async () => {
+    const originalTask = defineTask({
+      id: "original.task",
+      run: async (input: string) => `Hello, ${input}!`,
+    });
+
+    const transformListener = defineTask({
+      id: "transform.listener",
+      on: originalTask.events.afterRun,
+      run: async (event) => {
+        const transformedOutput = event.data.output.toUpperCase();
+        event.data.setOutput(transformedOutput);
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [originalTask, transformListener],
+      dependencies: { originalTask },
+      async init(_, { originalTask }) {
+        const result = await originalTask("World");
+        expect(result).toBe("HELLO, WORLD!");
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+
+  it("should preserve original output if setOutput is not called", async () => {
+    const originalTask = defineTask({
+      id: "original.task",
+      run: async (input: string) => `Hello, ${input}!`,
+    });
+
+    const observerListener = defineTask({
+      id: "observer.listener",
+      on: originalTask.events.afterRun,
+      run: async (event) => {
+        // Just observe, don't modify
+        expect(event.data.output).toBe("Hello, World!");
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [originalTask, observerListener],
+      dependencies: { originalTask },
+      async init(_, { originalTask }) {
+        const result = await originalTask("World");
+        expect(result).toBe("Hello, World!");
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+
+  it("should handle multiple afterRun listeners with setOutput (last one wins)", async () => {
+    const originalTask = defineTask({
+      id: "original.task",
+      run: async (input: number) => input * 2,
+    });
+
+    const firstTransform = defineTask({
+      id: "first.transform",
+      on: originalTask.events.afterRun,
+      listenerOrder: 1,
+      run: async (event) => {
+        event.data.setOutput(event.data.output + 10);
+      },
+    });
+
+    const secondTransform = defineTask({
+      id: "second.transform",
+      on: originalTask.events.afterRun,
+      listenerOrder: 2,
+      run: async (event) => {
+        event.data.setOutput(event.data.output * 3);
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [originalTask, firstTransform, secondTransform],
+      dependencies: { originalTask },
+      async init(_, { originalTask }) {
+        const result = await originalTask(5);
+        // Original: 5 * 2 = 10
+        // First transform: 10 + 10 = 20
+        // Second transform: 20 * 3 = 60
+        expect(result).toBe(60);
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+
+  it("should work with external library scenario", async () => {
+    // Simulate an external library task
+    const externalLibraryTask = defineTask({
+      id: "external.library.task",
+      run: async (data: { name: string; age: number }) => {
+        return {
+          id: Math.random(),
+          name: data.name,
+          age: data.age,
+          timestamp: Date.now(),
+        };
+      },
+    });
+
+    // Create a transformer for the external task
+    const resultTransformer = defineTask({
+      id: "result.transformer",
+      on: externalLibraryTask.events.afterRun,
+      run: async (event) => {
+        const result = event.data.output;
+        // Add some computed fields
+        const enrichedResult = {
+          ...result,
+          displayName: `${result.name} (${result.age} years old)`,
+          isAdult: result.age >= 18,
+        };
+        event.data.setOutput(enrichedResult);
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [externalLibraryTask, resultTransformer],
+      dependencies: { externalLibraryTask },
+      async init(_, { externalLibraryTask }) {
+        const result = await externalLibraryTask({ name: "Alice", age: 25 });
+
+        expect(result).toMatchObject({
+          name: "Alice",
+          age: 25,
+          displayName: "Alice (25 years old)",
+          isAdult: true,
+        });
+        expect(result.id).toBeDefined();
+        expect(result.timestamp).toBeDefined();
+
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+
+  it("should handle type safety with setOutput", async () => {
+    interface TaskOutput {
+      message: string;
+      count: number;
+    }
+
+    const typedTask = defineTask({
+      id: "typed.task",
+      run: async (input: string): Promise<TaskOutput> => ({
+        message: `Hello, ${input}!`,
+        count: input.length,
+      }),
+    });
+
+    const typedTransformer = defineTask({
+      id: "typed.transformer",
+      on: typedTask.events.afterRun,
+      run: async (event) => {
+        const result = event.data.output;
+        const newResult: TaskOutput = {
+          message: result.message.toUpperCase(),
+          count: result.count * 2,
+        };
+        event.data.setOutput(newResult);
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [typedTask, typedTransformer],
+      dependencies: { typedTask },
+      async init(_, { typedTask }) {
+        const result = await typedTask("World");
+        expect(result).toEqual({
+          message: "HELLO, WORLD!",
+          count: 10, // "World".length * 2
+        });
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+
+  it("should work with middleware and setOutput together", async () => {
+    const { defineMiddleware } = await import("../define");
+
+    const testMiddleware = defineMiddleware({
+      id: "test.middleware",
+      run: async ({ next, task }) => {
+        const result = await next(task?.input);
+        return `[middleware: ${result}]`;
+      },
+    });
+
+    const originalTask = defineTask({
+      id: "original.task",
+      middleware: [testMiddleware],
+      run: async (input: string) => `Hello, ${input}!`,
+    });
+
+    const outputTransformer = defineTask({
+      id: "output.transformer",
+      on: originalTask.events.afterRun,
+      run: async (event) => {
+        // The output here already includes middleware processing
+        const transformed = event.data.output.replace(
+          "middleware:",
+          "processed:"
+        );
+        event.data.setOutput(transformed);
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [testMiddleware, originalTask, outputTransformer],
+      dependencies: { originalTask },
+      async init(_, { originalTask }) {
+        const result = await originalTask("World");
+        expect(result).toBe("[processed: Hello, World!]");
+        return result;
+      },
+    });
+
+    await run(app);
+  });
+});