@bluelibs/runner 1.5.4 → 2.0.0

package/src/__tests__/globalEvents.test.ts

@@ -23,30 +23,55 @@ describe("Global Events", () => {
       },
     });
 
+    const taskBeforeInit = defineTask({
+      id: "task.beforeInit",
+      on: globalEvents.beforeInit,
+      run: globalBeforeInitHandler,
+    });
+
+    const taskAfterInit = defineTask({
+      id: "task.afterInit",
+      on: globalEvents.afterInit,
+      run: globalAfterInitHandler,
+    });
+
+    const taskBeforeRun = defineTask({
+      id: "task.beforeRun",
+      on: globalEvents.tasks.beforeRun,
+      run: globalTaskBeforeRunHandler,
+    });
+
+    const taskAfterRun = defineTask({
+      id: "task.afterRun",
+      on: globalEvents.tasks.afterRun,
+      run: globalTaskAfterRunHandler,
+    });
+
+    const resourceBeforeInit = defineTask({
+      id: "resource.beforeInit",
+      on: globalEvents.resources.beforeInit,
+      run: globalResourceBeforeInitHandler,
+    });
+
+    const resourceAfterInit = defineTask({
+      id: "resource.afterInit",
+      on: globalEvents.resources.afterInit,
+      run: globalResourceAfterInitHandler,
+    });
+
     const app = defineResource({
       id: "app",
-      register: [testResource, testTask],
-      dependencies: { testResource, testTask },
-      hooks: [
-        { event: globalEvents.beforeInit, run: globalBeforeInitHandler },
-        { event: globalEvents.afterInit, run: globalAfterInitHandler },
-        {
-          event: globalEvents.tasks.beforeRun,
-          run: globalTaskBeforeRunHandler,
-        },
-        {
-          event: globalEvents.tasks.afterRun,
-          run: globalTaskAfterRunHandler,
-        },
-        {
-          event: globalEvents.resources.beforeInit,
-          run: globalResourceBeforeInitHandler,
-        },
-        {
-          event: globalEvents.resources.afterInit,
-          run: globalResourceAfterInitHandler,
-        },
+      register: [
+        testResource,
+        testTask,
+        taskBeforeInit,
+        taskAfterInit,
+        taskBeforeRun,
+        taskAfterRun,
+        resourceBeforeInit,
+        resourceAfterInit,
       ],
+      dependencies: { testResource, testTask },
       async init(_, { testResource, testTask }) {
         expect(testResource).toBe("Resource Value");
         const response = await testTask();
@@ -73,16 +98,16 @@ describe("Global Events", () => {
       },
     });
 
+    const onErrorHandler = defineTask({
+      id: "on.error.handler",
+      on: globalEvents.tasks.onError,
+      run: globalTaskOnErrorHandler,
+    });
+
     const app = defineResource({
       id: "app",
-      register: [errorTask],
+      register: [errorTask, onErrorHandler],
       dependencies: { errorTask },
-      hooks: [
-        {
-          event: globalEvents.tasks.onError,
-          run: globalTaskOnErrorHandler,
-        },
-      ],
       async init(_, { errorTask }) {
         try {
           await errorTask();

package/src/__tests__/index.ts

@@ -7,7 +7,6 @@ import "./models/Logger.test";
 import "./tools/findCircularDependencies.test";
 
 import "./run.test";
-import "./run.hooks.test";
 import "./run.overrides.test";
 import "./run.middleware.test";
 import "./globalEvents.test";

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

@@ -22,6 +22,7 @@ describe("EventManager", () => {
       expect.objectContaining({
         id: "testEvent",
         data: "testData",
+        timestamp: expect.any(Date),
       })
     );
   });

package/src/__tests__/run.test.ts

@@ -72,15 +72,15 @@ describe("run", () => {
         },
       });
 
+      const handlerTask = defineTask({
+        id: "handler.task",
+        on: testEvent,
+        run: eventHandler,
+      });
+
       const app = defineResource({
         id: "app",
-        register: [testEvent, testTask],
-        hooks: [
-          {
-            event: testEvent,
-            run: eventHandler,
-          },
-        ],
+        register: [testEvent, testTask, handlerTask],
         dependencies: { testTask },
         async init(_, { testTask }) {
           await testTask();
@@ -101,15 +101,28 @@ describe("run", () => {
         run: async () => "Task executed",
       });
 
+      const onBeforeRun = defineTask({
+        id: "on.before.run",
+        on: testTask.events.beforeRun,
+        run: beforeRunHandler,
+      });
+
+      const onAfterRun = defineTask({
+        id: "on.after.run",
+        on: testTask.events.afterRun,
+        run: afterRunHandler,
+      });
+
+      const onError = defineTask({
+        id: "on.error",
+        on: testTask.events.onError,
+        run: onErrorHandler,
+      });
+
       const app = defineResource({
         id: "app",
-        register: [testTask],
+        register: [testTask, onBeforeRun, onAfterRun, onError],
         dependencies: { testTask },
-        hooks: [
-          { event: testTask.events.beforeRun, run: beforeRunHandler },
-          { event: testTask.events.afterRun, run: afterRunHandler },
-          { event: testTask.events.onError, run: onErrorHandler },
-        ],
         async init(_, { testTask }) {
           await testTask();
           expect(beforeRunHandler).toHaveBeenCalled();
@@ -132,56 +145,23 @@ describe("run", () => {
       let value = false;
       const errorHook = jest.fn();
 
-      const app = defineResource({
-        id: "app",
-        register: [testTask],
-        dependencies: { testTask },
-        hooks: [
-          {
-            event: testTask.events.onError,
-            run: errorHook,
-          },
-        ],
-        async init(_, { testTask }) {
-          await testTask();
-        },
-      });
-
-      await expect(run(app)).rejects.toThrow("Task failed");
-      expect(errorHook).toHaveBeenCalled();
-    });
-
-    it("should allow suppression of an error", async () => {
-      const supressMock = jest.fn();
-      const testTask = defineTask({
-        id: "test.task",
-        run: async () => {
-          throw new Error("Task failed");
-        },
+      const handler = defineTask({
+        id: "handler",
+        on: testTask.events.onError,
+        run: errorHook,
       });
 
       const app = defineResource({
         id: "app",
-        register: [testTask],
+        register: [testTask, handler],
         dependencies: { testTask },
-        hooks: [
-          {
-            event: testTask.events.onError,
-            run: async (event, deps) => {
-              supressMock();
-              event.data.suppress();
-            },
-          },
-        ],
         async init(_, { testTask }) {
           await testTask();
-
-          return "ok";
         },
       });
 
-      await expect(run(app)).resolves.toBe("ok");
-      expect(supressMock).toHaveBeenCalled();
+      await expect(run(app)).rejects.toThrow("Task failed");
+      expect(errorHook).toHaveBeenCalled();
     });
 
     it("should be able to register an task with middleware and execute it, ensuring the middleware is called in the correct order", async () => {
@@ -307,58 +287,86 @@ describe("run", () => {
 
       await expect(run(app)).rejects.toThrow(/Circular dependencies detected/);
     });
-  });
 
-  it("should be able to listen to an event through the 'on' property", async () => {
-    const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
-    const eventHandler = jest.fn();
+    it("should be able to listen to an event through the 'on' property", async () => {
+      const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
+      const eventHandler = jest.fn();
 
-    const task = defineTask({
-      id: "app",
-      on: testEvent,
-      async run(event) {
-        eventHandler();
-      },
-    });
+      const task = defineTask({
+        id: "app",
+        on: testEvent,
+        async run(event) {
+          eventHandler();
+        },
+      });
 
-    const app = defineResource({
-      id: "app.resource",
-      register: [testEvent, task],
-      dependencies: { task, testEvent },
-      async init(_, deps) {
-        await deps.testEvent({ message: "Event emitted" });
-      },
+      const app = defineResource({
+        id: "app.resource",
+        register: [testEvent, task],
+        dependencies: { task, testEvent },
+        async init(_, deps) {
+          await deps.testEvent({ message: "Event emitted" });
+        },
+      });
+
+      await run(app);
+      expect(eventHandler).toHaveBeenCalled();
     });
 
-    await run(app);
-    expect(eventHandler).toHaveBeenCalled();
-  });
+    it("should avoid infinite recursion by omitting task emissions recursively", async () => {
+      const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
+      const eventHandler = jest.fn();
 
-  it("should be able to listen to global events", async () => {
-    const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
-    const eventHandler = jest.fn();
+      const task = defineTask({
+        id: "app",
+        on: testEvent,
+        dependencies: { testEvent },
+        async run(event, { testEvent }) {
+          eventHandler();
+          await testEvent({ message: "Event emitted" });
+        },
+      });
 
-    const resource = defineResource({
-      id: "app",
-      hooks: [
-        {
-          event: "*",
-          run: eventHandler,
+      const app = defineResource({
+        id: "app.resource",
+        register: [testEvent, task],
+        dependencies: { task, testEvent },
+        async init(_, deps) {
+          await deps.testEvent({ message: "Event emitted" });
         },
-      ],
-    });
+      });
 
-    const app = defineResource({
-      id: "app.resource",
-      register: [testEvent, resource],
-      dependencies: { resource, testEvent },
-      async init(_, deps) {
-        await deps.testEvent({ message: "Event emitted" });
-      },
+      await run(app);
+      expect(eventHandler).toHaveBeenCalled();
     });
 
-    await run(app);
-    expect(eventHandler).toHaveBeenCalled();
+    it("should be able to listen to global events", async () => {
+      const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
+      const eventHandler = jest.fn();
+      let isReady = false;
+
+      const task = defineTask({
+        id: "app",
+        on: "*",
+        async run(event) {
+          event.data;
+          isReady && eventHandler();
+        },
+      });
+
+      const app = defineResource({
+        id: "app.resource",
+        register: [testEvent, task],
+        dependencies: { task, testEvent },
+        async init(_, deps) {
+          isReady = true;
+          await deps.testEvent({ message: "Event emitted" });
+        },
+      });
+
+      await run(app);
+      expect(eventHandler).toHaveBeenCalled();
+    });
   });
 
   // Resources
@@ -462,8 +470,8 @@ describe("run", () => {
 
     it("should allow suppression of an error", async () => {
       const supressMock = jest.fn();
-      const testResource = defineResource({
-        id: "test.resource",
+      const erroringResource = defineResource({
+        id: "error.resource",
         init: async () => {
           // we do this so it doesn't become a never.
           if (true === true) {
@@ -471,29 +479,52 @@ describe("run", () => {
           }
         },
       });
+      const erroringTask = defineTask({
+        id: "error.task",
+        run: async (event) => {
+          if (true === true) {
+            throw new Error("Run failed");
+          }
+        },
+      });
+
+      const resourceErrorHandler = defineTask({
+        id: "resourcehandler",
+        on: erroringResource.events.onError,
+        run: async (event) => {
+          supressMock();
+          event.data.suppress();
+        },
+      });
+
+      const taskErrorHandler = defineTask({
+        id: "taskhandler",
+        on: erroringTask.events.onError,
+        run: async (event) => {
+          supressMock();
+          event.data.suppress();
+        },
+      });
 
       const app = defineResource({
         id: "app",
-        register: [testResource],
-        dependencies: { testResource },
-        hooks: [
-          {
-            event: testResource.events.onError,
-            run: async (event, deps) => {
-              supressMock();
-              event.data.suppress();
-            },
-          },
+        register: [
+          erroringResource,
+          erroringTask,
+          resourceErrorHandler,
+          taskErrorHandler,
         ],
-        async init(_, { testResource }) {
-          expect(testResource).toBeUndefined();
+        dependencies: { erroringResource, erroringTask },
+        async init(_, { erroringResource, erroringTask }) {
+          expect(erroringResource).toBeUndefined();
+          expect(await erroringTask()).toBeUndefined();
 
           return "ok";
         },
       });
 
       await expect(run(app)).resolves.toBe("ok");
-      expect(supressMock).toHaveBeenCalled();
+      expect(supressMock).toHaveBeenCalledTimes(2);
     });
   });
 

package/src/__tests__/typesafety.test.ts

@@ -51,6 +51,10 @@ describe("typesafety", () => {
       id: "dummy.resource",
       init: async () => "Resource Value",
     });
+    const dummyResourceOptionalConfig = defineResource({
+      id: "dummy.resource",
+      init: async (config?: string) => "Resource Value",
+    });
 
     const testResource = defineResource({
       id: "test.resource",
@@ -91,6 +95,9 @@ describe("typesafety", () => {
         dummyResource.with({ ok: 123 }),
         // @ts-expect-error
         dummyResource.with(),
+
+        // should work
+        dummyResourceOptionalConfig.with("hello"),
       ],
     });
 
@@ -105,24 +112,18 @@ describe("typesafety", () => {
       run: async () => "Task executed",
     });
 
-    const testResource = defineResource({
+    const testResource = defineTask({
       id: "test.resource",
       dependencies: { task },
-      init: async () => "Resource Value",
-      hooks: [
-        {
-          event: hookEvent,
-          run: (event, deps) => {
-            // @ts-expect-error
-            event.data.x;
-
-            event.data.message;
-            deps.task;
-            // @ts-expect-error
-            deps.task2;
-          },
-        },
-      ],
+      on: hookEvent,
+      run: async (_, deps) => {
+        _.data.message;
+        // @ts-expect-error
+        _.data.messagex;
+        deps.task();
+        // @ts-expect-error
+        deps.task2;
+      },
     });
 
     expect(true).toBe(true);

package/src/define.ts

@@ -21,10 +21,10 @@ export function defineTask<
   Input = undefined,
   Output extends Promise<any> = any,
   Deps extends DependencyMapType = any,
-  Test = any
+  TOn extends "*" | IEventDefinition | undefined = undefined
 >(
-  taskConfig: ITaskDefinition<Input, Output, Deps, Test>
-): ITask<Input, Output, Deps, Test> {
+  taskConfig: ITaskDefinition<Input, Output, Deps, TOn>
+): ITask<Input, Output, Deps, TOn> {
   return {
     [symbols.task]: true,
     id: taskConfig.id,
@@ -60,7 +60,6 @@ export function defineResource<
     [symbols.resource]: true,
     id: constConfig.id,
     dependencies: constConfig.dependencies,
-    hooks: constConfig.hooks || [],
     dispose: constConfig.dispose,
     register: constConfig.register || [],
     overrides: constConfig.overrides || [],

package/src/defs.ts

@@ -32,7 +32,7 @@ export interface IMiddlewareMeta extends IMeta {}
 // DependencyMap types
 export type DependencyMapType = Record<
   string,
-  ITask<any, any, any> | IResource<any, any, any> | IEventDefinition<any>
+  ITask<any, any, any, any> | IResource<any, any, any> | IEventDefinition<any>
 >;
 
 // Helper Types for Extracting Generics
@@ -61,19 +61,39 @@ export type DependencyValuesType<T extends DependencyMapType> = {
   [K in keyof T]: DependencyValueType<T[K]>;
 };
 
+type Optional<T> = {
+  [K in keyof T]?: T[K];
+};
+
+// Utility type to check if a type is void
+type IsVoid<T> = [T] extends [void] ? true : false;
+
+// Utility type to check if a type is optional (can be undefined)
+type IsOptional<T> = undefined extends T ? true : false;
+
+// IReso
+
+// Conditional type to allow `void`, optional, or any type
+type OptionalOrVoidOrAnything<T> = IsVoid<T> extends true
+  ? void
+  : IsOptional<T> extends true
+  ? Optional<T>
+  : T;
+
 // RegisterableItems Type with Conditional Inclusion
-export type RegisterableItems =
+export type RegisterableItems<T = any> =
   | IResourceWithConfig<any>
   | IResource<void, any, any>
-  | ITaskDefinition
-  | IMiddlewareDefinition
-  | IEventDefinition;
+  | IResource<OptionalOrVoidOrAnything<T>, any, any>
+  | ITaskDefinition<any, any, any, any>
+  | IMiddlewareDefinition<any>
+  | IEventDefinition<any>;
 
 export interface ITaskDefinition<
   TInput = any,
   TOutput extends Promise<any> = any,
   TDependencies extends DependencyMapType = {},
-  TEventDefinitionInput = null
+  TOn extends "*" | IEventDefinition<any> | undefined = undefined // Adding a generic to track 'on' type
 > {
   id: string;
   dependencies?: TDependencies | (() => TDependencies);
@@ -81,7 +101,7 @@ export interface ITaskDefinition<
   /**
    * Listen to events in a simple way
    */
-  on?: IEventDefinition<TEventDefinitionInput>;
+  on?: TOn;
   /**
    * This makes sense only when `on` is specified to provide the order of the execution.
    * The event with the lowest order will be executed first.
@@ -89,7 +109,12 @@ export interface ITaskDefinition<
   listenerOrder?: number;
   meta?: ITaskMeta;
   run: (
-    input: TEventDefinitionInput extends null ? TInput : TEventDefinitionInput,
+    input: TOn extends undefined ? TInput : IEvent<ExtractEventParams<TOn>>,
+    // input: TOn extends "*"
+    //   ? IEvent<any>
+    //   : TEventDefinitionInput extends null | void
+    //   ? TInput
+    // : IEvent<TEventDefinitionInput>,
     dependencies: DependencyValuesType<TDependencies>
   ) => TOutput;
 }
@@ -127,13 +152,8 @@ export interface ITask<
   TInput = any,
   TOutput extends Promise<any> = any,
   TDependencies extends DependencyMapType = {},
-  TEventDefinitionInput = null
-> extends ITaskDefinition<
-    TInput,
-    TOutput,
-    TDependencies,
-    TEventDefinitionInput
-  > {
+  TOn extends "*" | IEventDefinition<any> | undefined = undefined
+> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn> {
   dependencies: TDependencies | (() => TDependencies);
   computedDependencies?: DependencyValuesType<TDependencies>;
   middleware: IMiddlewareDefinition[];
@@ -156,9 +176,6 @@ export interface IResourceDefinition<
 > {
   id: string;
   dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-  hooks?:
-    | IHookDefinition<TDependencies, THooks>[]
-    | ((config: TConfig) => IHookDefinition<TDependencies, THooks>[]);
   register?:
     | Array<RegisterableItems>
     | ((config: TConfig) => Array<RegisterableItems>);
@@ -201,10 +218,6 @@ export interface IResource<
     afterInit: IEventDefinition<AfterInitEventPayload<TConfig, TValue>>;
     onError: IEventDefinition<OnErrorEventPayload>;
   };
-  hooks:
-    | IHookDefinition<TDependencies>[]
-    | ((config: TConfig) => IHookDefinition<TDependencies>[]);
-
   overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
   middleware: IMiddlewareDefinition[];
 }