@bluelibs/runner 1.5.4 → 2.1.0

package/dist/run.js

@@ -31,7 +31,7 @@ async function run(resource, config) {
     await store.processOverrides();
     // a form of hooking, we create the events for all tasks and store them so they can be referenced
     await store.storeEventsForAllTasks();
-    await processor.attachHooks();
+    await processor.attachListeners();
     await processor.computeAllDependencies();
     // After this stage, logger print policy could have been set.
     await logger.debug("All elements have been initalized..");

package/dist/run.js.map

@@ -1 +1 @@
-{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AAsDA,kBAuDC;AA7GD,oDAAiD;AAUjD,sEAAmE;AACnE,wDAAqD;AACrD,iDAA8C;AAC9C,0CAAuC;AACvC,+EAA4E;AAC5E,qCAAkC;AAClC,uDAAoD;AACpD,4CAAyC;AAqClC,KAAK,UAAU,GAAG,CACvB,QAAyB,EACzB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IAExC,2FAA2F;IAC3F,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IAExC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC9C,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,IAAI,yCAAmB,CACvC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,MAAM,CACP,CAAC;IAEF,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,sFAAsF;IACtF,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAE/B,iGAAiG;IACjG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC;IACrC,MAAM,SAAS,CAAC,WAAW,EAAE,CAAC;IAC9B,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,6DAA6D;IAC7D,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEpE,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC"}
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AAsDA,kBAuDC;AA7GD,oDAAiD;AAUjD,sEAAmE;AACnE,wDAAqD;AACrD,iDAA8C;AAC9C,0CAAuC;AACvC,+EAA4E;AAC5E,qCAAkC;AAClC,uDAAoD;AACpD,4CAAyC;AAqClC,KAAK,UAAU,GAAG,CACvB,QAAyB,EACzB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IAExC,2FAA2F;IAC3F,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IAExC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC9C,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,IAAI,yCAAmB,CACvC,KAAK,EACL,YAAY,EACZ,UAAU,EACV,MAAM,CACP,CAAC;IAEF,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAC5D,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IAEpE,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,sFAAsF;IACtF,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAE/B,iGAAiG;IACjG,MAAM,KAAK,CAAC,sBAAsB,EAAE,CAAC;IACrC,MAAM,SAAS,CAAC,eAAe,EAAE,CAAC;IAClC,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,6DAA6D;IAC7D,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IAEpE,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;IACnE,MAAM,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;IAE1D,0CAA0C;IAC1C,KAAK,CAAC,IAAI,EAAE,CAAC;IAEb,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC"}

package/dist/tools/getCallerFile.d.ts

@@ -0,0 +1 @@
+export declare function getCallerFile(): string | undefined;

package/dist/tools/getCallerFile.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCallerFile = getCallerFile;
+function getCallerFile() {
+    const originalFunc = Error.prepareStackTrace;
+    try {
+        const err = new Error();
+        let callerfile;
+        let currentfile;
+        // Safeguard prepareStackTrace
+        Error.prepareStackTrace = (err, stack) => stack;
+        const stack = err.stack;
+        // Don't know how to test this.
+        // if (stack.length < 3) {
+        //   // We need at least 3 frames: current function, its caller, and one above
+        //   return undefined;
+        // }
+        // Remove the first frame (getCallerFile itself)
+        stack.shift();
+        // Remove the second frame (the direct caller of getCallerFile)
+        currentfile = stack.shift()?.getFileName();
+        // The third frame (the caller above the immediate one)
+        callerfile = stack.shift()?.getFileName();
+        return callerfile; // Return the file name of the caller above
+    }
+    finally {
+        Error.prepareStackTrace = originalFunc;
+    }
+}
+//# sourceMappingURL=getCallerFile.js.map

package/dist/tools/getCallerFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCallerFile.js","sourceRoot":"","sources":["../../src/tools/getCallerFile.ts"],"names":[],"mappings":";;AAAA,sCAgCC;AAhCD,SAAgB,aAAa;IAC3B,MAAM,YAAY,GAAG,KAAK,CAAC,iBAAiB,CAAC;IAE7C,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IAAI,UAAU,CAAC;QACf,IAAI,WAAW,CAAC;QAEhB,8BAA8B;QAC9B,KAAK,CAAC,iBAAiB,GAAG,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC;QAEhD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAqC,CAAC;QAExD,+BAA+B;QAC/B,0BAA0B;QAC1B,8EAA8E;QAC9E,sBAAsB;QACtB,IAAI;QAEJ,gDAAgD;QAChD,KAAK,CAAC,KAAK,EAAE,CAAC;QAEd,+DAA+D;QAC/D,WAAW,GAAG,KAAK,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,CAAC;QAE3C,uDAAuD;QACvD,UAAU,GAAG,KAAK,CAAC,KAAK,EAAE,EAAE,WAAW,EAAE,CAAC;QAE1C,OAAO,UAAU,CAAC,CAAC,2CAA2C;IAChE,CAAC;YAAS,CAAC;QACT,KAAK,CAAC,iBAAiB,GAAG,YAAY,CAAC;IACzC,CAAC;AACH,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "1.5.4",
+  "version": "2.1.0",
   "description": "BlueLibs Runner",
   "main": "dist/index.js",
   "repository": {

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

@@ -78,16 +78,18 @@ describe("Benchmarks", () => {
     const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
     const eventHandler = jest.fn();
 
+    const handlerTask = defineTask({
+      id: "handler.task",
+      on: testEvent,
+      run: async ({ data }) => {
+        eventHandler(data.message);
+      },
+    });
+
     const app = defineResource({
       id: "app",
-      register: [testEvent],
+      register: [testEvent, handlerTask],
       dependencies: { testEvent },
-      hooks: [
-        {
-          event: testEvent,
-          run: eventHandler,
-        },
-      ],
       async init(_, { testEvent }) {
         await testEvent({ message: "Event emitted" });
       },

package/src/__tests__/errors.test.ts

@@ -191,19 +191,6 @@ describe("Errors", () => {
     );
   });
 
-  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",

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

@@ -5,9 +5,9 @@ import "./models/Store.test";
 import "./models/Logger.test";
 
 import "./tools/findCircularDependencies.test";
+import "./tools/getCallerFile.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__/tools/getCallerFile.test.ts

@@ -0,0 +1,51 @@
+import {
+  defineTask,
+  defineResource,
+  defineMiddleware,
+  defineEvent,
+} from "../../define";
+import { symbols } from "../../defs";
+import { getCallerFile } from "../../tools/getCallerFile";
+
+describe("getCallerFile", () => {
+  it("should return the file name of the caller", () => {
+    function testFunction() {
+      return getCallerFile();
+    }
+
+    const callerFile = testFunction();
+
+    expect(callerFile).toBeDefined();
+    expect(callerFile).toContain("getCallerFile.test"); // we don't use .ts because for coverage it gets compiled to js
+  });
+
+  it("Should work with tasks, resources, middleware and events", () => {
+    const task = defineTask({
+      id: "task",
+      run: async () => {},
+    });
+    const resource = defineResource({
+      id: "resource",
+      init: async () => {},
+    });
+
+    const middleware = defineMiddleware({
+      id: "middleware",
+      run: async () => {},
+    });
+
+    const event = defineEvent({
+      id: "event",
+    });
+
+    expect(task[symbols.filePath]).toBeDefined();
+    expect(resource[symbols.filePath]).toBeDefined();
+    expect(middleware[symbols.filePath]).toBeDefined();
+    expect(event[symbols.filePath]).toBeDefined();
+
+    expect(task[symbols.filePath]).toContain("getCallerFile.test");
+    expect(resource[symbols.filePath]).toContain("getCallerFile.test");
+    expect(middleware[symbols.filePath]).toContain("getCallerFile.test");
+    expect(event[symbols.filePath]).toContain("getCallerFile.test");
+  });
+});

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);