@bluelibs/runner 1.0.0

package/src/__tests__/Store.test.ts

@@ -0,0 +1,143 @@
+import { EventManager } from "../EventManager";
+import { Store } from "../Store";
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "../define";
+
+describe("Store", () => {
+  let store: Store;
+  let eventManager: EventManager;
+
+  beforeEach(() => {
+    eventManager = new EventManager();
+    store = new Store(eventManager);
+  });
+
+  it("should register an task", () => {
+    const task = defineTask({
+      id: "testTask",
+      run: async () => {},
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [task],
+      })
+    );
+
+    expect(store.tasks.get("testTask")).toBeDefined();
+    expect(store.tasks.get("testTask")?.task).toBe(task);
+  });
+
+  it("should register a resource", () => {
+    const resource = defineResource({
+      id: "testResource",
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [resource],
+      })
+    );
+
+    expect(store.resources.get("testResource")).toBeDefined();
+    expect(store.resources.get("testResource")?.resource).toBe(resource);
+  });
+
+  it("should register an event", () => {
+    const event = defineEvent({
+      id: "testEvent",
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [event],
+      })
+    );
+
+    expect(store.events.get("testEvent")).toBeDefined();
+    expect(store.events.get("testEvent")?.event).toBe(event);
+  });
+
+  it("should register a middleware", () => {
+    const middleware = defineMiddleware({
+      id: "testMiddleware",
+      run: async () => {},
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [middleware],
+      })
+    );
+
+    expect(store.middlewares.get("testMiddleware")).toBeDefined();
+    expect(store.middlewares.get("testMiddleware")?.middleware).toBe(
+      middleware
+    );
+  });
+
+  it("should throw an error when registering duplicate items", () => {
+    const task = defineTask({
+      id: "duplicateItem",
+      run: async () => {},
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [task],
+      })
+    );
+
+    expect(() => {
+      store.computeRegisterOfResource(
+        defineResource({
+          id: "anotherRoot",
+          register: [task],
+        })
+      );
+    }).toThrow('Task "duplicateItem" already registered');
+  });
+
+  it("should return dependent nodes", () => {
+    const task1 = defineTask({
+      id: "task1",
+      dependencies: { dep1: {} as any },
+      run: async () => {},
+    });
+
+    const task2 = defineTask({
+      id: "task2",
+      dependencies: { dep2: {} as any },
+      run: async () => {},
+    });
+
+    store.computeRegisterOfResource(
+      defineResource({
+        id: "root",
+        register: [task1, task2],
+      })
+    );
+
+    const dependentNodes = store.getDependentNodes();
+
+    // global store, global event manager
+    expect(dependentNodes).toHaveLength(2);
+    expect(dependentNodes).toContainEqual({
+      id: "task1",
+      dependencies: { dep1: {} },
+    });
+    expect(dependentNodes).toContainEqual({
+      id: "task2",
+      dependencies: { dep2: {} },
+    });
+  });
+});

package/src/__tests__/TaskRunner.test.ts

@@ -0,0 +1,135 @@
+import { TaskRunner } from "../TaskRunner";
+import { Store } from "../Store";
+import { EventManager } from "../EventManager";
+import { defineTask, defineResource, defineMiddleware } from "../define";
+import { ITask } from "../defs";
+
+describe("TaskRunner", () => {
+  let store: Store;
+  let eventManager: EventManager;
+  let taskRunner: TaskRunner;
+
+  beforeEach(() => {
+    eventManager = new EventManager();
+    store = new Store(eventManager);
+    taskRunner = new TaskRunner(store, eventManager);
+  });
+
+  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 ({ input, next }) => {
+        const result = await next(input);
+        return result + 1;
+      },
+    });
+
+    const middleware2 = defineMiddleware({
+      id: "middleware2",
+      run: async ({ input, next }) => {
+        const result = await next(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: { input: 5, output: 10 } })
+    );
+  });
+
+  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 } })
+    );
+  });
+});

package/src/__tests__/benchmark/benchmark.test.ts

@@ -0,0 +1,146 @@
+import * as Benchmark from "benchmark";
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "../../define";
+import { run } from "../../run";
+
+describe("Benchmarks", () => {
+  let suite: Benchmark.Suite;
+
+  beforeEach(() => {
+    suite = new Benchmark.Suite();
+  });
+
+  it("should benchmark task execution", (done) => {
+    const testTask = defineTask({
+      id: "test.task",
+      run: async () => "Hello, World!",
+    });
+
+    const app = defineResource({
+      id: "app",
+      dependencies: { testTask },
+      register: [testTask],
+      async init(_, { testTask }) {
+        await testTask();
+      },
+    });
+
+    suite.add("Task Execution", {
+      defer: true,
+      fn: (deferred: { resolve: () => void }) => {
+        run(app).then(() => deferred.resolve());
+      },
+    });
+
+    suite.on("complete", function () {
+      console.log("Task Execution:", this[0].hz.toFixed(2), "ops/sec");
+      done();
+    });
+
+    suite.run({ async: true });
+  });
+
+  it("should benchmark resource initialization", (done) => {
+    const testResource = defineResource({
+      id: "test.resource",
+      init: async () => "Resource Value",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [testResource],
+      dependencies: { testResource },
+      async init(_, { testResource }) {
+        expect(testResource).toBe("Resource Value");
+      },
+    });
+
+    suite.add("Resource Initialization", {
+      defer: true,
+      fn: (deferred: { resolve: () => void }) => {
+        run(app).then(() => deferred.resolve());
+      },
+    });
+
+    suite.on("complete", function () {
+      console.log("Resource Initialization:", this[0].hz.toFixed(2), "ops/sec");
+      done();
+    });
+
+    suite.run({ async: true });
+  });
+
+  it("should benchmark event emission", (done) => {
+    const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
+    const eventHandler = jest.fn();
+
+    const app = defineResource({
+      id: "app",
+      register: [testEvent],
+      dependencies: { testEvent },
+      hooks: [
+        {
+          event: testEvent,
+          run: eventHandler,
+        },
+      ],
+      async init(_, { testEvent }) {
+        await testEvent({ message: "Event emitted" });
+      },
+    });
+
+    suite.add("Event Emission", {
+      defer: true,
+      fn: (deferred: { resolve: () => void }) => {
+        run(app).then(() => deferred.resolve());
+      },
+    });
+
+    suite.on("complete", function () {
+      console.log("Event Emission:", this[0].hz.toFixed(2), "ops/sec");
+      done();
+    });
+
+    suite.run({ async: true });
+  });
+
+  it("should benchmark dependency resolution", (done) => {
+    const dep1 = defineResource({
+      id: "dep1",
+      init: async () => "Dep1 Value",
+    });
+
+    const dep2 = defineResource({
+      id: "dep2",
+      dependencies: { dep1 },
+      init: async (_, { dep1 }) => `Dep2 Value: ${dep1}`,
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [dep1, dep2],
+      dependencies: { dep2 },
+      async init(_, { dep2 }) {
+        expect(dep2).toBe("Dep2 Value: Dep1 Value");
+      },
+    });
+
+    suite.add("Dependency Resolution", {
+      defer: true,
+      fn: (deferred: { resolve: () => void }) => {
+        run(app).then(() => deferred.resolve());
+      },
+    });
+
+    suite.on("complete", function () {
+      console.log("Dependency Resolution:", this[0].hz.toFixed(2), "ops/sec");
+      done();
+    });
+
+    suite.run({ async: true });
+  });
+});

package/src/__tests__/errors.test.ts

@@ -0,0 +1,268 @@
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "../define";
+import { run } from "../run";
+import { Errors } from "../errors";
+
+describe("Errors", () => {
+  it("should throw duplicateRegistration error", async () => {
+    const task1 = defineTask({ id: "test.task", run: async () => {} });
+    const task2 = defineTask({ id: "test.task", run: async () => {} });
+
+    const app = defineResource({
+      id: "app",
+      register: [task1, task2],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.duplicateRegistration("Task", "test.task").message
+    );
+  });
+
+  it("should throw unknown item type error at task level", async () => {
+    const task = defineTask({
+      id: "test.task",
+      dependencies: { nonExistentDep: {} as any },
+      run: async () => {},
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: { task },
+      async init(_, { task }) {
+        await task();
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(Errors.unknownItemType({}).message);
+  });
+
+  it("should throw unknown item type error at resource level", async () => {
+    const app = defineResource({
+      id: "app",
+      register: [
+        {
+          id: "nonExistent",
+        } as any,
+      ],
+      async init(_, {}) {},
+    });
+
+    await expect(run(app)).rejects.toThrow(Errors.unknownItemType({}).message);
+  });
+
+  it("should throw circularDependencies error", async () => {
+    const task1 = defineTask({
+      id: "task1",
+      dependencies: () => ({ task2 }),
+      run: async () => {},
+    });
+
+    const task2 = defineTask({
+      id: "task2",
+      dependencies: { task1 },
+      run: async () => {},
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task1, task2],
+    });
+
+    await expect(run(app)).rejects.toThrow(/Circular dependencies detected/);
+  });
+
+  it("should throw eventNotFound error", async () => {
+    const nonExistentEvent = { id: "non.existent.event" } as any;
+
+    const task = defineTask({
+      id: "test.task",
+      on: nonExistentEvent,
+      run: async () => {},
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.eventNotFound("non.existent.event").message
+    );
+  });
+
+  it("should throw taskError", async () => {
+    const errorTask = defineTask({
+      id: "error.task",
+      run: async () => {
+        throw new Error("Task error");
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [errorTask],
+      dependencies: { errorTask },
+      async init(_, { errorTask }) {
+        await errorTask();
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(/Task error/);
+  });
+
+  it("should throw resourceError", async () => {
+    const errorResource = defineResource({
+      id: "error.resource",
+      init: async () => {
+        throw new Error("Resource error");
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [errorResource],
+    });
+
+    await expect(run(app)).rejects.toThrow(/Resource error/);
+  });
+
+  it("should throw an ambigous one", async () => {
+    const res1 = defineResource({
+      id: "res1",
+    });
+
+    const ev1 = defineEvent({
+      id: "res1",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [res1, ev1],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.duplicateRegistration("Resource", "res1").message
+    );
+  });
+
+  it("Should throw duplicate error for middlewares with the same id", async () => {
+    const middleware1 = defineMiddleware({
+      id: "middlewarex",
+      run: async () => {},
+    });
+
+    const middleware2 = defineMiddleware({
+      id: "middlewarex",
+      run: async () => {},
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [middleware1, middleware2],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.duplicateRegistration("Middleware", "middlewarex").message
+    );
+  });
+
+  it("Should throw duplicate error for events with the same id", async () => {
+    const ev1 = defineEvent({
+      id: "ev1",
+    });
+    const ev2 = defineEvent({
+      id: "ev1",
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [ev1, ev2],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.duplicateRegistration("Event", "ev1").message
+    );
+  });
+
+  it("should throw an error if a hook tries to use a non-reigstered event", async () => {
+    const hook = { event: { id: "non.existent.event" } as any, run: () => {} };
+
+    const app = defineResource({
+      id: "app",
+      hooks: [hook],
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.eventNotFound("non.existent.event").message
+    );
+  });
+
+  it("should throw an error when a task depends on a non-registered task", async () => {
+    const offTheGrid = defineTask({
+      id: "test.off.the.grid",
+      dependencies: { nonExistentTask: { id: "non" } as any },
+      run: async () => {},
+    });
+
+    const task = defineTask({
+      id: "test.task",
+      dependencies: { offTheGrid },
+      run: async (_, deps) => {
+        throw "Should not even be here";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: { task },
+      async init(_, { task }) {
+        await task();
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.dependencyNotFound("Task test.off.the.grid").message
+    );
+  });
+
+  it("should throw when a task depends on a non-registered resource", async () => {
+    const offTheGrid = defineResource({
+      id: "test.off.the.grid",
+      init: async () => {},
+    });
+
+    const task = defineTask({
+      id: "test.task",
+      dependencies: { offTheGrid },
+      run: async () => {
+        throw "Should not even be here";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [task],
+      dependencies: { task },
+      async init(_, { task }) {
+        await task();
+      },
+    });
+
+    await expect(run(app)).rejects.toThrow(
+      Errors.dependencyNotFound("Resource test.off.the.grid").message
+    );
+  });
+
+  it("should throw error, when a double global() is used on a middleware", async () => {
+    const first = defineMiddleware({ id: "x", run: async () => {} }).global();
+    expect(() => first.global()).toThrow(
+      Errors.middlewareAlreadyGlobal("x").message
+    );
+  });
+});