@bluelibs/runner 3.0.0 → 3.1.0

package/src/__tests__/run.middleware.test.ts

@@ -401,3 +401,149 @@ describe("Configurable Middleware (.with)", () => {
     await run(app);
   });
 });
+
+describe("Middleware.everywhere()", () => {
+  it("should work with { tasks: true, resources: true }", async () => {
+    const calls: string[] = [];
+    const everywhereMiddleware = defineMiddleware({
+      id: "everywhere.middleware",
+      run: async ({ next, task, resource }) => {
+        if (task) {
+          calls.push(`task:${String(task.definition.id)}`);
+        }
+        if (resource) {
+          calls.push(`resource:${String(resource.definition.id)}`);
+        }
+        return next();
+      },
+    });
+
+    const testTask = defineTask({
+      id: "test.task",
+      run: async () => "Task executed",
+    });
+
+    const testResource = defineResource({
+      id: "test.resource",
+      async init() {
+        return "Resource initialized";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [
+        everywhereMiddleware.everywhere({ tasks: true, resources: true }),
+        testTask,
+        testResource,
+      ],
+      dependencies: { testTask, testResource },
+      async init(_, { testTask, testResource }) {
+        await testTask();
+        expect(testResource).toBe("Resource initialized");
+      },
+    });
+
+    await run(app);
+
+    expect(calls).toContain("resource:app");
+    expect(calls).toContain("resource:test.resource");
+    expect(calls).toContain("task:test.task");
+  });
+
+  it("should work with { tasks: true, resources: false }", async () => {
+    const calls: string[] = [];
+    const everywhereMiddleware = defineMiddleware({
+      id: "everywhere.middleware",
+      run: async ({ next, task, resource }) => {
+        if (task) {
+          calls.push(`task:${String(task.definition.id)}`);
+        }
+        if (resource) {
+          calls.push(`resource:${String(resource.definition.id)}`);
+        }
+        return next();
+      },
+    });
+
+    const testTask = defineTask({
+      id: "test.task",
+      run: async () => "Task executed",
+    });
+
+    const testResource = defineResource({
+      id: "test.resource",
+      async init() {
+        return "Resource initialized";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [
+        everywhereMiddleware.everywhere({ tasks: true, resources: false }),
+        testTask,
+        testResource,
+      ],
+      dependencies: { testTask, testResource },
+      async init(_, { testTask, testResource }) {
+        await testTask();
+        expect(testResource).toBe("Resource initialized");
+      },
+    });
+
+    await run(app);
+
+    expect(calls).not.toContain("resource:app");
+    expect(calls).not.toContain("resource:test.resource");
+    expect(calls).toContain("task:test.task");
+  });
+
+  it("should work with { tasks: false, resources: true }", async () => {
+    const calls: string[] = [];
+    const everywhereMiddleware = defineMiddleware({
+      id: "everywhere.middleware",
+      run: async ({ next, task, resource }) => {
+        if (task) {
+          calls.push(`task:${String(task.definition.id)}`);
+        }
+        if (resource) {
+          calls.push(`resource:${String(resource.definition.id)}`);
+        }
+        return next();
+      },
+    });
+
+    const testTask = defineTask({
+      id: "test.task",
+      run: async () => "Task executed",
+    });
+
+    const testResource = defineResource({
+      id: "test.resource",
+      async init() {
+        return "Resource initialized";
+      },
+    });
+
+    const app = defineResource({
+      id: "app",
+      register: [
+        everywhereMiddleware.everywhere({ tasks: false, resources: true }),
+        testTask,
+        testResource,
+      ],
+      dependencies: { testTask, testResource },
+      async init(_, { testTask, testResource }) {
+        await testTask();
+        expect(testResource).toBe("Resource initialized");
+      },
+    });
+
+    await run(app);
+
+    expect(calls).toContain("resource:app");
+    expect(calls).toContain("resource:test.resource");
+    expect(calls).not.toContain("task:test.task");
+  });
+});

package/src/__tests__/run.test.ts

@@ -93,7 +93,7 @@ describe("run", () => {
     });
 
     it("should be able to register an task that emits an event", async () => {
-      const testEvent = defineEvent({ id: "test.event" });
+      const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
       const eventHandler = jest.fn();
 
       const testTask = defineTask({

package/src/__tests__/tools/getCallerFile.test.ts

@@ -5,7 +5,10 @@ import {
   defineEvent,
 } from "../../define";
 import { symbols } from "../../defs";
-import { getCallerFile } from "../../tools/getCallerFile";
+import {
+  getCallerFile,
+  generateCallerIdFromFile,
+} from "../../tools/getCallerFile";
 
 describe("getCallerFile", () => {
   it("should return the file name of the caller", () => {
@@ -45,7 +48,119 @@ describe("getCallerFile", () => {
 
     expect((task as any)[symbols.filePath]).toContain("getCallerFile.test");
     expect((resource as any)[symbols.filePath]).toContain("getCallerFile.test");
-    expect((middleware as any)[symbols.filePath]).toContain("getCallerFile.test");
+    expect((middleware as any)[symbols.filePath]).toContain(
+      "getCallerFile.test"
+    );
     expect((event as any)[symbols.filePath]).toContain("getCallerFile.test");
   });
 });
+
+describe("generateCallerIdFromFile", () => {
+  it("should generate a symbol from a path containing src", () => {
+    const filePath =
+      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource.ts";
+    const expectedDescription = "globals.resources.queue.resource";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should generate a symbol from a path not containing src", () => {
+    const filePath =
+      "/Users/theodordiaconu/Projects/runner/dist/globals/resources/queue.resource.ts";
+    const expectedDescription = "dist.globals.resources.queue.resource";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should handle paths with few parts when src is not present", () => {
+    const filePath = "a/b/c.ts";
+    const expectedDescription = "a.b.c";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should handle paths with backslashes", () => {
+    const filePath =
+      "C:\\Users\\theodordiaconu\\Projects\\runner\\src\\globals\\resources\\queue.resource.ts";
+    const expectedDescription = "globals.resources.queue.resource";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should handle file names without extensions", () => {
+    const filePath =
+      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource";
+    const expectedDescription = "globals.resources.queue.resource";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should handle file names with multiple dots", () => {
+    const filePath =
+      "/Users/theodordiaconu/Projects/runner/src/globals/resources/queue.resource.test.ts";
+    const expectedDescription = "globals.resources.queue.resource.test";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should generate a symbol from a path containing node_modules", () => {
+    const filePath =
+      "/Users/theodordiaconu/Projects/runner/node_modules/some-package/dist/index.js";
+    const expectedDescription = "some-package.dist.index";
+    expect(generateCallerIdFromFile(filePath).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should respect the fallbackParts argument", () => {
+    const filePath = "a/b/c/d/e.ts";
+    const expectedDescription = "d.e";
+    expect(generateCallerIdFromFile(filePath, "", 2).description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should append the suffix to the symbol description", () => {
+    const filePath = "a/b/c.ts";
+    const expectedDescription = "a.b.c.my-suffix";
+    expect(generateCallerIdFromFile(filePath, "my-suffix").description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should not append the suffix if it is already in the file name", () => {
+    const filePath = "a/b/c.resource.ts";
+    const expectedDescription = "a.b.c.resource";
+    expect(generateCallerIdFromFile(filePath, "resource").description).toEqual(
+      expectedDescription
+    );
+  });
+
+  it("should handle empty path or path with no relevant parts", () => {
+    // Test with empty string - this creates relevantParts = [""] which is not empty
+    const filePath = "";
+    const expectedDescription = ".suffix";
+    expect(generateCallerIdFromFile(filePath, "suffix").description).toEqual(
+      expectedDescription
+    );
+
+    // Test case where 'src' is at the end, making relevantParts empty (triggers line 77 else branch)
+    const result = generateCallerIdFromFile("/some/path/src", "suffix");
+    expect(result.description).toEqual(".suffix");
+  });
+
+  it("should use fallback parts when no src or node_modules found", () => {
+    // Test path without src or node_modules to trigger the else branch (line 59)
+    const filePath = "/some/other/deep/path/file.js";
+    const expectedDescription = "other.deep.path.file";
+    expect(generateCallerIdFromFile(filePath, "", 4).description).toEqual(
+      expectedDescription
+    );
+  });
+});

package/src/__tests__/typesafety.test.ts

@@ -4,7 +4,14 @@ import {
   defineResource,
   defineMiddleware,
 } from "../define";
-import { RegisterableItems } from "../defs";
+import {
+  IEventDefinition,
+  IMiddlewareDefinition,
+  IResource,
+  IResourceWithConfig,
+  ITaskDefinition,
+  RegisterableItems,
+} from "../defs";
 
 describe("typesafety", () => {
   it("tasks, resources: should have propper type safety for dependeices", async () => {
@@ -45,6 +52,10 @@ describe("typesafety", () => {
       id: "event",
     });
 
+    const eventWithoutArguments = defineEvent({
+      id: "event",
+    });
+
     const baseTask = defineTask({
       id: "task",
       run: async (input: InputTask) => "Task executed",
@@ -104,7 +115,7 @@ describe("typesafety", () => {
         // @ts-expect-error
         middlewareWithOptionalConfig.with({ message: 123 }),
       ],
-      dependencies: { task, dummyResource, event },
+      dependencies: { task, dummyResource, event, eventWithoutArguments },
       init: async (_, deps) => {
         const result = await deps.task({
           message: "Hello, World!",
@@ -115,6 +126,10 @@ describe("typesafety", () => {
         deps.event();
         // @ts-expect-error
         deps.event({ messagex: "Hello, World!" });
+        deps.eventWithoutArguments();
+        deps.eventWithoutArguments({});
+        // @ts-expect-error
+        deps.eventWithoutArguments({ something: false });
 
         // @ts-expect-error
         deps.dummyResource as number;

package/src/define.ts

@@ -1,4 +1,3 @@
-import { get } from "node:http";
 import {
   ITask,
   ITaskDefinition,
@@ -11,15 +10,15 @@ import {
   DependencyMapType,
   DependencyValuesType,
   IMiddleware,
-  IHookDefinition,
   IEvent,
-  IEventDefinitionConfig,
   symbolEvent,
   RegisterableItems,
   symbolMiddlewareConfigured,
+  symbolFilePath,
+  symbolIndexResource,
 } from "./defs";
 import { Errors } from "./errors";
-import { getCallerFile } from "./tools/getCallerFile";
+import { generateCallerIdFromFile, getCallerFile } from "./tools/getCallerFile";
 
 // Helper function to get the caller file
 
@@ -32,10 +31,12 @@ export function defineTask<
   taskConfig: ITaskDefinition<Input, Output, Deps, TOn>
 ): ITask<Input, Output, Deps, TOn> {
   const filePath = getCallerFile();
+  const isAnonymous = !Boolean(taskConfig.id);
+  const id = taskConfig.id || generateCallerIdFromFile(filePath, "task");
   return {
     [symbols.task]: true,
     [symbols.filePath]: filePath,
-    id: taskConfig.id,
+    id,
     dependencies: taskConfig.dependencies || ({} as Deps),
     middleware: taskConfig.middleware || [],
     run: taskConfig.run,
@@ -44,19 +45,25 @@ export function defineTask<
     events: {
       beforeRun: {
         ...defineEvent({
-          id: `${taskConfig.id}.events.beforeRun`,
+          id: isAnonymous
+            ? Symbol(`anonymous-task.events.beforeRun`)
+            : `${id as string}.events.beforeRun`,
         }),
         [symbols.filePath]: getCallerFile(),
       },
       afterRun: {
         ...defineEvent({
-          id: `${taskConfig.id}.events.afterRun`,
+          id: isAnonymous
+            ? Symbol(`anonymous-task.events.afterRun`)
+            : `${id as string}.events.afterRun`,
         }),
         [symbols.filePath]: getCallerFile(),
       },
       onError: {
         ...defineEvent({
-          id: `${taskConfig.id}.events.onError`,
+          id: isAnonymous
+            ? Symbol(`anonymous-task.events.onError`)
+            : `${id as string}.events.onError`,
         }),
         [symbols.filePath]: getCallerFile(),
       },
@@ -74,11 +81,17 @@ export function defineResource<
 >(
   constConfig: IResourceDefinition<TConfig, TValue, TDeps, TPrivate>
 ): IResource<TConfig, TValue, TDeps, TPrivate> {
-  const filePath = getCallerFile();
+  // The symbolFilePath might already come from defineIndex() for example
+  const filePath: string = constConfig[symbolFilePath] || getCallerFile();
+  const isIndexResource = constConfig[symbolIndexResource] || false;
+  const isAnonymous = !Boolean(constConfig.id);
+  const id =
+    constConfig.id ||
+    generateCallerIdFromFile(filePath, isIndexResource ? "index" : "resource");
   return {
     [symbols.resource]: true,
     [symbols.filePath]: filePath,
-    id: constConfig.id,
+    id,
     dependencies: constConfig.dependencies,
     dispose: constConfig.dispose,
     register: constConfig.register || [],
@@ -97,19 +110,25 @@ export function defineResource<
     events: {
       beforeInit: {
         ...defineEvent({
-          id: `${constConfig.id}.events.beforeInit`,
+          id: isAnonymous
+            ? Symbol(`anonymous-resource.events.beforeInit`)
+            : `${id as string}.events.beforeInit`,
         }),
         [symbols.filePath]: filePath,
       },
       afterInit: {
         ...defineEvent({
-          id: `${constConfig.id}.events.afterInit`,
+          id: isAnonymous
+            ? Symbol(`anonymous-resource.events.afterInit`)
+            : `${id as string}.events.afterInit`,
         }),
         [symbols.filePath]: filePath,
       },
       onError: {
         ...defineEvent({
-          id: `${constConfig.id}.events.onError`,
+          id: isAnonymous
+            ? Symbol(`anonymous-resource.events.onError`)
+            : `${id as string}.events.onError`,
         }),
         [symbols.filePath]: filePath,
       },
@@ -146,24 +165,28 @@ export function defineIndex<
       (dependencies as any)[key] = item as any;
     }
   }
+  const callerFilePath = getCallerFile();
 
   return defineResource({
-    id: `index.${Math.random().toString(36).slice(2)}`,
     register,
     dependencies,
     async init(_, deps) {
       return deps as any;
     },
+    [symbols.filePath]: callerFilePath,
+    [symbols.indexResource]: true,
   });
 }
 
-export function defineEvent<TPayload = any>(
-  config: IEventDefinitionConfig<TPayload>
-): IEventDefinition<TPayload> {
+export function defineEvent<TPayload = void>(
+  config: IEventDefinition<TPayload>
+): IEvent<TPayload> {
+  const callerFilePath = getCallerFile();
   return {
-    [symbols.filePath]: getCallerFile(),
-    [symbolEvent]: true,
     ...config,
+    id: config.id || generateCallerIdFromFile(callerFilePath, "event"),
+    [symbols.filePath]: callerFilePath,
+    [symbolEvent]: true, // This is a workaround
   };
 }
 
@@ -184,10 +207,12 @@ export function defineMiddleware<
 >(
   middlewareDef: IMiddlewareDefinition<TConfig, TDependencies>
 ): IMiddleware<TConfig, TDependencies> {
+  const filePath = getCallerFile();
   const object = {
-    [symbols.filePath]: getCallerFile(),
+    [symbols.filePath]: filePath,
     [symbols.middleware]: true,
     config: {} as TConfig,
+    id: middlewareDef.id || generateCallerIdFromFile(filePath, "middleware"),
     ...middlewareDef,
     dependencies: middlewareDef.dependencies || ({} as TDependencies),
   } as IMiddleware<TConfig, TDependencies>;
@@ -212,7 +237,7 @@ export function defineMiddleware<
         [symbols.middlewareEverywhereTasks]: tasks,
         [symbols.middlewareEverywhereResources]: resources,
         everywhere() {
-          throw Errors.middlewareAlreadyGlobal(middlewareDef.id);
+          throw Errors.middlewareAlreadyGlobal(object.id);
         },
       };
     },
@@ -233,7 +258,7 @@ export function isResourceWithConfig(
   return definition && definition[symbols.resourceWithConfig];
 }
 
-export function isEvent(definition: any): definition is IEventDefinition {
+export function isEvent(definition: any): definition is IEvent {
   return definition && definition[symbols.event];
 }