@bluelibs/runner 3.4.2 → 4.0.1

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

@@ -1,227 +0,0 @@
-import { Store } from "../../models/Store";
-import { EventManager } from "../../models/EventManager";
-import {
-  defineResource,
-  defineTask,
-  defineMiddleware,
-  defineEvent,
-  defineTag,
-} from "../../define";
-import { Logger } from "../../models";
-
-describe("Store", () => {
-  let eventManager: EventManager;
-  let store: Store;
-  let logger: Logger;
-
-  beforeEach(() => {
-    eventManager = new EventManager();
-    logger = new Logger(eventManager);
-    store = new Store(eventManager, logger);
-  });
-
-  it("should initialize the store with a root resource", () => {
-    const rootResource = defineResource({
-      id: "root",
-      init: async () => "Root Value",
-    });
-
-    store.initializeStore(rootResource, {});
-
-    expect(store.root.resource).toBe(rootResource);
-    expect(store.resources.has("root")).toBe(true);
-  });
-
-  it("should lock the store and prevent modifications", () => {
-    store.lock();
-    expect(store.isLocked).toBe(true);
-
-    expect(() => store.checkLock()).toThrow(
-      "Cannot modify the Store when it is locked."
-    );
-  });
-
-  it("should store a task and retrieve it", () => {
-    const testTask = defineTask({
-      id: "test.task",
-      run: async () => "Task executed",
-    });
-
-    store.storeGenericItem(testTask);
-
-    expect(store.tasks.has("test.task")).toBe(true);
-  });
-
-  it("should store a resource and retrieve it", () => {
-    const testResource = defineResource({
-      id: "test.resource",
-      init: async () => "Resource Value",
-    });
-
-    store.storeGenericItem(testResource);
-
-    expect(store.resources.has("test.resource")).toBe(true);
-  });
-
-  it("should store a middleware and retrieve it", () => {
-    const testMiddleware = defineMiddleware({
-      id: "test.middleware",
-      run: async ({ next }) => {
-        return `Middleware: ${await next()}`;
-      },
-    });
-
-    store.storeGenericItem(testMiddleware);
-
-    expect(store.middlewares.has("test.middleware")).toBe(true);
-  });
-
-  it("should store an event and retrieve it", () => {
-    const testEvent = defineEvent({ id: "test.event" });
-
-    store.storeGenericItem(testEvent);
-
-    expect(store.events.has("test.event")).toBe(true);
-  });
-
-  it("should dispose of resources correctly", async () => {
-    const disposeFn = jest.fn(async (...args: any[]) => {});
-    const testResource = defineResource({
-      id: "test.resource",
-      dispose: disposeFn,
-      init: async () => "Resource Value",
-    });
-
-    store.storeGenericItem(testResource);
-
-    // Simulate resource initialization
-    store.resources.get("test.resource")!.value = "Resource Value";
-    store.resources.get("test.resource")!.isInitialized = true;
-
-    await store.dispose();
-
-    expect(disposeFn).toHaveBeenCalled();
-  });
-
-  it("should throw an error for duplicate registration", () => {
-    const testTask = defineTask({
-      id: "duplicate.task",
-      run: async () => "Task executed",
-    });
-
-    store.storeGenericItem(testTask);
-
-    expect(() => store.storeGenericItem(testTask)).toThrow(
-      /already registered/i
-    );
-  });
-
-  it("should throw an error if you're trying to initialize the store twice", () => {
-    const rootResource = defineResource({
-      id: "root",
-      init: async () => "Root Value",
-    });
-
-    store.initializeStore(rootResource, {});
-
-    expect(() => store.initializeStore(rootResource, {})).toThrow(
-      /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);
-  });
-
-  it("should call getTasksWithTag method", () => {
-    const tag = defineTag({
-      id: "tags.test",
-    });
-    const taskTest = defineTask({
-      meta: {
-        tags: [tag, "test"],
-      },
-      async run() {
-        return "OK";
-      },
-    });
-    const unfindableTask = defineTask({
-      run: async () => 1,
-    });
-    const rootResource = defineResource({
-      id: "root",
-      register: [taskTest, unfindableTask],
-      init: async () => "Root Value",
-    });
-
-    store.initializeStore(rootResource, {});
-    const result = store.getTasksWithTag(tag);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result).toHaveLength(1);
-    const result2 = store.getTasksWithTag("test");
-    expect(result2).toHaveLength(1);
-  });
-
-  it("should call getResourcesWithTag method", () => {
-    const tag = defineTag({
-      id: "tags.test",
-    });
-    const resourceTest = defineResource({
-      meta: {
-        tags: [tag, "test"],
-      },
-    });
-
-    const unfindableResource = defineResource({
-      init: async () => 1,
-    });
-    const rootResource = defineResource({
-      id: "root",
-      register: [resourceTest, unfindableResource],
-      init: async () => "Root Value",
-    });
-
-    store.initializeStore(rootResource, {});
-    const result = store.getResourcesWithTag(tag);
-    expect(Array.isArray(result)).toBe(true);
-    expect(result).toHaveLength(1);
-    const result2 = store.getResourcesWithTag("test");
-    expect(result2).toHaveLength(1);
-  });
-});

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

@@ -1,221 +0,0 @@
-import { TaskRunner } from "../../models/TaskRunner";
-import { Store } from "../../models/Store";
-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;
-  let eventManager: EventManager;
-  let taskRunner: TaskRunner;
-  let logger: Logger;
-
-  beforeEach(() => {
-    eventManager = new EventManager();
-    logger = new Logger(eventManager);
-    store = new Store(eventManager, logger);
-    taskRunner = new TaskRunner(store, eventManager, logger);
-  });
-
-  it("should run an task without middleware", async () => {
-    const app = defineResource({
-      id: "app",
-      register: () => [task],
-    });
-
-    const task = defineTask({
-      id: "testTask",
-      run: async (input: number) => input * 2,
-    });
-
-    store.tasks.set(task.id, {
-      task,
-      computedDependencies: {},
-      isInitialized: false,
-    });
-
-    const result = await taskRunner.run(task, 5);
-    expect(result).toBe(10);
-  });
-
-  it("should run an task with middleware", async () => {
-    const middleware1 = defineMiddleware({
-      id: "middleware1",
-      run: async ({ next, task }) => {
-        const result = await next(task?.input);
-        return result + 1;
-      },
-    });
-
-    const middleware2 = defineMiddleware({
-      id: "middleware2",
-      run: async ({ task, next }, deps, config) => {
-        const result = await next(task?.input);
-        return result * 2;
-      },
-    });
-
-    const task = defineTask({
-      id: "testTask",
-      middleware: [middleware1, middleware2],
-      run: async (input: number) => input + 5,
-    });
-
-    store.tasks.set(task.id, {
-      task,
-      computedDependencies: {},
-      isInitialized: true,
-    });
-    store.middlewares.set(middleware1.id, {
-      middleware: middleware1,
-      computedDependencies: {},
-    });
-    store.middlewares.set(middleware2.id, {
-      middleware: middleware2,
-      computedDependencies: {},
-    });
-
-    const result = await taskRunner.run(task, 5);
-    expect(result).toBe(21); // ((5 + 5) * 2) + 1
-  });
-
-  it("should emit events during task execution", async () => {
-    const task = defineTask({
-      id: "testTask",
-      run: async (input: number) => input * 2,
-    });
-
-    store.tasks.set(task.id, {
-      task,
-      computedDependencies: {},
-      isInitialized: false,
-    });
-
-    const beforeRunSpy = jest.fn();
-    const afterRunSpy = jest.fn();
-
-    eventManager.addListener(task.events.beforeRun, beforeRunSpy);
-    eventManager.addListener(task.events.afterRun, afterRunSpy);
-
-    await taskRunner.run(task, 5);
-
-    expect(beforeRunSpy).toHaveBeenCalledWith(
-      expect.objectContaining({ data: { input: 5 } })
-    );
-    expect(afterRunSpy).toHaveBeenCalledWith(
-      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 () => {
-    const error = new Error("Test error");
-    const task = defineTask({
-      id: "testTask",
-      run: async () => {
-        throw error;
-      },
-    });
-
-    store.tasks.set(task.id, {
-      task,
-      computedDependencies: {},
-      isInitialized: false,
-    });
-
-    const onErrorSpy = jest.fn();
-    eventManager.addListener(task.events.onError, onErrorSpy);
-
-    expect(taskRunner.run(task, undefined)).rejects.toThrow(error);
-
-    // since it quickly throws and is not run asnc we might need to wait a bit
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    expect(onErrorSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        data: { error, suppress: expect.any(Function) },
-      })
-    );
-  });
-
-  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__/override.test.ts

@@ -1,104 +0,0 @@
-import { definitions, task, resource, middleware, override } from "..";
-
-describe("override() helper", () => {
-  it("should preserve id and override run for tasks", async () => {
-    const base = task({
-      id: "test.task",
-      run: async () => "base",
-    });
-
-    const changed = override(base, {
-      run: async () => "changed",
-      meta: { title: "Updated" },
-    });
-
-    expect(changed).not.toBe(base);
-    expect(changed.id).toBe(base.id);
-    expect(await base.run(undefined as any, {} as any)).toBe("base");
-    expect(await changed.run(undefined as any, {} as any)).toBe("changed");
-    expect(changed.meta?.title).toBe("Updated");
-  });
-
-  it("should preserve id and override init for resources", async () => {
-    const base = resource({
-      id: "test.resource",
-      init: async () => 1,
-    });
-
-    const changed = override(base, {
-      init: async () => 2,
-      meta: { description: "Updated" },
-    });
-
-    expect(changed).not.toBe(base);
-    expect(changed.id).toBe(base.id);
-    // Call the init functions directly (without runner) to validate override
-    // Signatures: init(config, deps, ctx)
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const v1 = await base.init!(undefined as any, {} as any, undefined as any);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const v2 = await changed.init!(
-      undefined as any,
-      {} as any,
-      undefined as any
-    );
-    expect(v1).toBe(1);
-    expect(v2).toBe(2);
-    expect(changed.meta?.description).toBe("Updated");
-  });
-
-  it("should preserve id and override run for middleware", async () => {
-    const mw = middleware({
-      id: "test.middleware",
-      run: async ({ next }) => {
-        return next();
-      },
-    });
-
-    const changed = override(mw, {
-      run: async ({ task, next }) => {
-        const result = await next(task?.input as any);
-        return { wrapped: result } as any;
-      },
-    });
-
-    expect(changed).not.toBe(mw);
-    expect(changed.id).toBe(mw.id);
-
-    const input = {
-      task: { definition: undefined as any, input: 123 },
-      next: async () => 456,
-    } as definitions.IMiddlewareExecutionInput<any, any>;
-
-    const baseResult = await mw.run(input, {} as any, undefined as any);
-    const changedResult = await changed.run(input, {} as any, undefined as any);
-    expect(baseResult).toBe(456);
-    expect(changedResult).toEqual({ wrapped: 456 });
-  });
-
-  it("should be type-safe: cannot override id on task/resource/middleware", () => {
-    const t = task({ id: "tt", run: async () => undefined });
-    const r = resource({ id: "rr", init: async () => undefined });
-    const m = middleware({ id: "mm", run: async ({ next }) => next() });
-
-    // @ts-expect-error id cannot be overridden
-    override(t, { id: "new" });
-
-    // @ts-expect-error id cannot be overridden
-    override(r, { id: "new" });
-
-    // @ts-expect-error id cannot be overridden
-    override(m, { id: "new" });
-
-    expect(true).toBe(true);
-  });
-
-  it("should handle undefined patch (robustness)", () => {
-    const base = task({ id: "robust.task", run: async () => 1 });
-    const changed = (override as any)(base, undefined);
-
-    expect(changed).not.toBe(base);
-    expect(changed.id).toBe(base.id);
-    expect(changed.run).toBe(base.run);
-  });
-});

package/src/__tests__/recursion/README.md

@@ -1,3 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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, Promise<string>>; // This is the key change.