@bluelibs/runner 3.4.2 → 4.0.1

package/src/__tests__/globals/queue.resource.test.ts

@@ -1,141 +0,0 @@
-import { defineResource } from "../../define";
-import { run } from "../../run";
-import { queueResource } from "../../globals/resources/queue.resource";
-
-describe("Queue Resource", () => {
-  it("should provide queue functionality with proper isolation and disposal", async () => {
-    let callCount = 0;
-    const executionOrder: number[] = [];
-    let successCallCount = 0;
-
-    const app = defineResource({
-      id: "app",
-      // Don't register queueResource - it's already registered globally
-      dependencies: { queue: queueResource },
-      async init(_, { queue }) {
-        // Test 1: Initialize with empty queue map
-        expect(queue.map).toBeInstanceOf(Map);
-        expect(queue.map.size).toBe(0);
-        expect(typeof queue.run).toBe("function");
-
-        // Test 2: Create and reuse queues by ID
-        const task = async () => {
-          callCount++;
-          return `result-${callCount}`;
-        };
-
-        const result1 = await queue.run("test-queue", task);
-        expect(queue.map.size).toBe(1);
-        expect(queue.map.has("test-queue")).toBe(true);
-
-        const result2 = await queue.run("test-queue", task);
-        expect(queue.map.size).toBe(1);
-        expect(result1).toBe("result-1");
-        expect(result2).toBe("result-2");
-
-        // Test 3: Create separate queues for different IDs
-        const task1 = async () => "queue1-result";
-        const task2 = async () => "queue2-result";
-
-        await queue.run("queue-1", task1);
-        await queue.run("queue-2", task2);
-
-        expect(queue.map.size).toBe(3); // test-queue, queue-1, queue-2
-        expect(queue.map.has("queue-1")).toBe(true);
-        expect(queue.map.has("queue-2")).toBe(true);
-
-        // Test 4: Ensure tasks run sequentially within the same queue
-        const taskFactory = (id: number) => async () => {
-          executionOrder.push(id);
-          await new Promise((resolve) => setTimeout(resolve, 1));
-          return id;
-        };
-
-        const promises = [
-          queue.run("sequential-queue", taskFactory(1)),
-          queue.run("sequential-queue", taskFactory(2)),
-          queue.run("sequential-queue", taskFactory(3)),
-        ];
-
-        const results = await Promise.all(promises);
-        expect(results).toEqual([1, 2, 3]);
-        expect(executionOrder).toEqual([1, 2, 3]);
-        expect(queue.map.size).toBe(4); // Added sequential-queue
-
-        // Test 5: Handle async tasks properly
-        const asyncTask = async () => {
-          await new Promise((resolve) => setTimeout(resolve, 5));
-          return "async-result";
-        };
-
-        const asyncResult = await queue.run("async-queue", asyncTask);
-        expect(asyncResult).toBe("async-result");
-        expect(queue.map.size).toBe(5); // Added async-queue
-
-        // Test 6: Handle errors in tasks without breaking the queue
-        const errorTask = async () => {
-          throw new Error("Task failed");
-        };
-
-        const successTask = async () => {
-          successCallCount++;
-          return `success-${successCallCount}`;
-        };
-
-        await expect(queue.run("error-queue", errorTask)).rejects.toThrow(
-          "Task failed"
-        );
-
-        const successResult = await queue.run("error-queue", successTask);
-        expect(successResult).toBe("success-1");
-        expect(queue.map.size).toBe(6); // Added error-queue
-
-        return queue;
-      },
-    });
-
-    const result = await run(app);
-
-    // Test 7: Dispose all queues when resource is disposed
-    expect(result.value.map.size).toBe(6);
-
-    await result.dispose();
-
-    // Try to run a task on a disposed queue - should reject
-    await expect(
-      result.value.run("test-queue", async () => "test")
-    ).rejects.toThrow(/disposed/);
-  });
-
-  it("should propagate task exceptions to the caller", async () => {
-    const app = defineResource({
-      id: "exception-test-app",
-      dependencies: { queue: queueResource },
-      async init(_, { queue }) {
-        // Test that exceptions from tasks are properly propagated
-        const errorTask = async () => {
-          throw new Error("Queue resource task error");
-        };
-
-        const successTask = async () => "success";
-
-        // Exception should be catchable by the caller
-        await expect(queue.run("error-queue", errorTask)).rejects.toThrow(
-          "Queue resource task error"
-        );
-
-        // Queue should still work for subsequent tasks
-        await expect(queue.run("error-queue", successTask)).resolves.toBe(
-          "success"
-        );
-
-        // Multiple exceptions should all be catchable
-        await expect(queue.run("error-queue", errorTask)).rejects.toThrow(
-          "Queue resource task error"
-        );
-      },
-    });
-
-    await run(app);
-  });
-});

package/src/__tests__/globals/requireContext.middleware.test.ts

@@ -1,98 +0,0 @@
-import { requireContextMiddleware } from "../../globals/middleware/requireContext.middleware";
-import { ContextError } from "../../context";
-
-/**
- * Utility function to build a fake Context implementation that allows us to
- * control the behaviour of the `use()` call during each test.
- */
-function createFakeContext<T>(useImplementation: () => T) {
-  return {
-    /** unique id is irrelevant for tests */
-    id: Symbol("fake-context"),
-    // `use` is what we care about – we wire whatever behaviour the test needs
-    use: jest.fn(useImplementation),
-    // The following members are not used by the middleware but are required
-    // to satisfy the `Context` interface.
-    provide: jest.fn(),
-    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-    require: jest.fn() as any,
-  } as any;
-}
-
-describe("requireContextMiddleware", () => {
-  it("throws if the middleware receives no context in its config", async () => {
-    // Arrange → no context passed
-    const next = jest.fn();
-
-    // Act & Assert
-    await expect(
-      requireContextMiddleware.run({ next } as any, {} as any, {} as any)
-    ).rejects.toThrow(
-      "Context not available. Did you forget to pass 'context' to the middleware?"
-    );
-  });
-
-  it("throws ContextError when the context has not been provided", async () => {
-    // Arrange → a context whose `use` returns undefined, simulating missing provider
-    const fakeContext = createFakeContext(() => undefined);
-    const next = jest.fn();
-
-    // Act & Assert
-    await expect(
-      requireContextMiddleware.run(
-        { next } as any,
-        {} as any,
-        { context: fakeContext } as any
-      )
-    ).rejects.toBeInstanceOf(ContextError);
-  });
-
-  it("passes task.input to next() and returns its result when called within a task", async () => {
-    const fakeContext = createFakeContext(() => ({ user: "alice" }));
-    const task = { input: "payload" };
-    const expectedResult = "task-result";
-    const next = jest.fn().mockResolvedValue(expectedResult);
-
-    const result = await requireContextMiddleware.run(
-      { task, next } as any,
-      {} as any,
-      { context: fakeContext } as any
-    );
-
-    expect(next).toHaveBeenCalledTimes(1);
-    expect(next).toHaveBeenCalledWith(task.input);
-    expect(result).toBe(expectedResult);
-  });
-
-  it("passes resource.config to next() and returns its result when called within a resource", async () => {
-    const fakeContext = createFakeContext(() => ({ user: "bob" }));
-    const resource = { config: { url: "https://example.com" } };
-    const expectedResult = "resource-result";
-    const next = jest.fn().mockResolvedValue(expectedResult);
-
-    const result = await requireContextMiddleware.run(
-      { resource, next } as any,
-      {} as any,
-      { context: fakeContext } as any
-    );
-
-    expect(next).toHaveBeenCalledTimes(1);
-    expect(next).toHaveBeenCalledWith(resource.config);
-    expect(result).toBe(expectedResult);
-  });
-
-  it("calls next() with no arguments when neither task nor resource is provided", async () => {
-    const fakeContext = createFakeContext(() => ({ user: "charlie" }));
-    const next = jest.fn().mockResolvedValue("noop-result");
-
-    const result = await requireContextMiddleware.run(
-      { next } as any,
-      {} as any,
-      { context: fakeContext } as any
-    );
-
-    expect(next).toHaveBeenCalledTimes(1);
-    expect(next).toHaveBeenCalledWith();
-    expect(result).toBe("noop-result");
-  });
-});

package/src/__tests__/globals/retry.middleware.test.ts

@@ -1,157 +0,0 @@
-import { defineResource, defineTask } from "../../define";
-import { retryMiddleware } from "../../globals/middleware/retry.middleware";
-import { run } from "../../run";
-
-describe("Retry Middleware", () => {
-  it("should retry failed operations with exponential backoff", async () => {
-    let attempt = 0;
-    const task = defineTask({
-      id: "flakyTask",
-      middleware: [
-        retryMiddleware.with({
-          retries: 3,
-          stopRetryIf: (e) => e.message.includes("FATAL"),
-        }),
-      ],
-      run: async () => {
-        attempt++;
-        if (attempt < 3) throw new Error("Temporary failure");
-        return "Success";
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [task],
-      dependencies: { task },
-      async init(_, { task }) {
-        const result = await task();
-        expect(result).toBe("Success");
-        expect(attempt).toBe(3);
-      },
-    });
-
-    await run(app);
-  });
-
-  it("should respect stopRetryIf condition", async () => {
-    const errorSpy = jest.fn();
-    const task = defineTask({
-      id: "fatalTask",
-      middleware: [
-        retryMiddleware.with({
-          retries: 3,
-          stopRetryIf: (e) => e.message === "FATAL",
-        }),
-      ],
-      run: async () => {
-        throw new Error("FATAL");
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [task],
-      dependencies: { task },
-      async init(_, { task }) {
-        await expect(task()).rejects.toThrow("FATAL");
-        expect(errorSpy).not.toHaveBeenCalled();
-        throw new Error("FATAL");
-      },
-    });
-
-    await run(app).catch(errorSpy);
-    expect(errorSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("should use custom delay strategy", async () => {
-    jest.useFakeTimers();
-    const delays: number[] = [];
-    const start = Date.now();
-
-    const task = defineTask({
-      id: "delayedTask",
-      middleware: [
-        retryMiddleware.with({
-          retries: 3,
-          delayStrategy: (attempt) => (attempt + 1) * 100, // Linear delay
-        }),
-      ],
-      run: async () => {
-        throw new Error("Retry me");
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [task],
-      dependencies: { task },
-      async init(_, { task }) {
-        task().catch(() => {});
-      },
-    });
-
-    await run(app);
-
-    // Advance timers through all retries
-    jest.advanceTimersByTime(1000);
-    const elapsed = Date.now() - start;
-
-    // Verify delay sequence: 100ms, 200ms, 300ms
-    expect(elapsed).toBeGreaterThanOrEqual(600); // 100+200+300=600
-    jest.useRealTimers();
-  });
-
-  it("should work with resource initialization", async () => {
-    let attempts = 0;
-    const resource = defineResource({
-      id: "flakyResource",
-      middleware: [
-        retryMiddleware.with({
-          retries: 2,
-        }),
-      ],
-      async init() {
-        attempts++;
-        if (attempts < 2) throw new Error("Resource init failed");
-        return "Resource ready";
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [resource],
-      dependencies: { resource },
-      async init(_, { resource }) {
-        expect(resource).toBe("Resource ready");
-        expect(attempts).toBe(2);
-      },
-    });
-
-    await run(app);
-  });
-
-  it("Should default to 3 retries", async () => {
-    let attempt = 0;
-    const task = defineTask({
-      id: "flakyTask",
-      middleware: [retryMiddleware],
-      run: async () => {
-        attempt++;
-        throw new Error("Temporary failure");
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [task],
-      dependencies: { task },
-      async init(_, { task }) {
-        await expect(task()).rejects.toThrow("Temporary failure");
-      },
-    });
-
-    await run(app);
-    expect(attempt).toBe(4); // fails once and retries 3 more times, logically
-  });
-});

package/src/__tests__/globals/timeout.middleware.test.ts

@@ -1,88 +0,0 @@
-import { defineResource, defineTask } from "../../define";
-import { run } from "../../run";
-import { timeoutMiddleware } from "../../globals/middleware/timeout.middleware";
-
-const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));
-
-describe("Timeout Middleware", () => {
-  it("should abort long-running tasks after ttl", async () => {
-    const slowTask = defineTask({
-      id: "timeout.slowTask",
-      middleware: [timeoutMiddleware.with({ ttl: 20 })],
-      run: async () => {
-        await sleep(50);
-        return "done";
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [slowTask],
-      dependencies: { slowTask },
-      async init(_, { slowTask }) {
-        await expect(slowTask()).rejects.toThrow(/timed out/i);
-      },
-    });
-
-    await run(app);
-  });
-
-  it("should allow tasks to complete before ttl", async () => {
-    const fastTask = defineTask({
-      id: "timeout.fastTask",
-      middleware: [timeoutMiddleware.with({ ttl: 50 })],
-      run: async () => {
-        await sleep(10);
-        return "ok";
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [fastTask],
-      dependencies: { fastTask },
-      async init(_, { fastTask }) {
-        await expect(fastTask()).resolves.toBe("ok");
-      },
-    });
-
-    await run(app);
-  });
-
-  it("should timeout resource initialization", async () => {
-    const slowResource = defineResource({
-      id: "timeout.slowResource",
-      middleware: [timeoutMiddleware.with({ ttl: 20 })],
-      async init() {
-        await sleep(50);
-        return "ready";
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [slowResource],
-    });
-
-    await expect(run(app)).rejects.toThrow(/timed out/i);
-  });
-
-  it("should throw immediately when ttl is 0", async () => {
-    const task = defineTask({
-      id: "timeout.immediate",
-      middleware: [timeoutMiddleware.with({ ttl: 0 })],
-      run: async () => "never",
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [task],
-      dependencies: { task },
-      async init(_, { task }) {
-        await expect(task()).rejects.toThrow(/timed out/i);
-      },
-    });
-
-    await run(app);
-  });
-});

package/src/__tests__/index.helper.test.ts

@@ -1,55 +0,0 @@
-import { defineTask, defineResource, defineIndex } from "../define";
-import { run } from "../run";
-import { index } from "../index";
-
-describe("index helper", () => {
-  it("should aggregate dependencies and expose proper types", async () => {
-    const userService = defineResource({
-      id: "user.service",
-      async init() {
-        return "USER";
-      },
-    });
-
-    const configuredService = defineResource({
-      id: "configured.service",
-      async init(config: { name: string }) {
-        return config.name;
-      },
-    });
-
-    const getUserTask = defineTask({
-      id: "task.getUser",
-      dependencies: { userService },
-      async run(_, { userService }) {
-        return userService;
-      },
-    });
-
-    // The helper under test
-    const services = index({
-      userService,
-      getUserTask,
-      configuredService: configuredService.with({ name: "configured" }),
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [services],
-      dependencies: { services },
-      async init(_, { services }) {
-        // Runtime assertions
-        expect(services.userService).toBe("USER");
-        const result = await services.getUserTask();
-        expect(result).toBe("USER");
-        expect(services.configuredService).toBe("configured");
-        // Type assertions
-        services.userService as string;
-        // @ts-expect-error – assigning to never should error
-        const neverValue: never = "bad";
-      },
-    });
-
-    await run(app);
-  });
-});