@bluelibs/runner 3.3.0 → 3.3.2

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

@@ -1,4 +1,9 @@
-import { IEvent, IEventEmission, symbolEvent } from "../../defs";
+import {
+  IEvent,
+  IEventEmission,
+  symbolEvent,
+  symbolFilePath,
+} from "../../defs";
 import { Errors } from "../../errors";
 import { EventManager } from "../../models/EventManager";
 
@@ -8,7 +13,11 @@ describe("EventManager", () => {
 
   beforeEach(() => {
     eventManager = new EventManager();
-    eventDefinition = { id: "testEvent", [symbolEvent]: true };
+    eventDefinition = {
+      id: "testEvent",
+      [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
+    };
   });
 
   it("should add and emit event listener", async () => {
@@ -165,10 +174,12 @@ describe("EventManager", () => {
     const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
     const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
 
     const handler1 = jest.fn();
@@ -215,10 +226,12 @@ describe("EventManager", () => {
     const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
     const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
 
     const handler = jest.fn();
@@ -249,10 +262,12 @@ describe("EventManager", () => {
     const eventDef1: IEvent<string> = {
       id: "event1",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
     const eventDef2: IEvent<string> = {
       id: "event2",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
 
     const handler1 = jest.fn();
@@ -392,6 +407,7 @@ describe("EventManager", () => {
     const voidEventDefinition: IEvent<void> = {
       id: "voidEvent",
       [symbolEvent]: true,
+      [symbolFilePath]: "test.ts",
     };
 
     eventManager.addListener(voidEventDefinition, handler);
@@ -445,8 +461,16 @@ describe("EventManager", () => {
     });
 
     it("should invalidate all caches when adding global listeners", async () => {
-      const event1: IEvent<string> = { id: "event1", [symbolEvent]: true };
-      const event2: IEvent<string> = { id: "event2", [symbolEvent]: true };
+      const event1: IEvent<string> = {
+        id: "event1",
+        [symbolEvent]: true,
+        [symbolFilePath]: "test.ts",
+      };
+      const event2: IEvent<string> = {
+        id: "event2",
+        [symbolEvent]: true,
+        [symbolFilePath]: "test.ts",
+      };
 
       const handler1 = jest.fn();
       const handler2 = jest.fn();
@@ -473,6 +497,7 @@ describe("EventManager", () => {
       const emptyEventDef: IEvent<string> = {
         id: "emptyEvent",
         [symbolEvent]: true,
+        [symbolFilePath]: "test.ts",
       };
 
       // Should return immediately without creating event object
@@ -528,8 +553,16 @@ describe("EventManager", () => {
     });
 
     it("should reuse cached results across different event types", async () => {
-      const event1: IEvent<string> = { id: "event1", [symbolEvent]: true };
-      const event2: IEvent<string> = { id: "event2", [symbolEvent]: true };
+      const event1: IEvent<string> = {
+        id: "event1",
+        [symbolEvent]: true,
+        [symbolFilePath]: "test.ts",
+      };
+      const event2: IEvent<string> = {
+        id: "event2",
+        [symbolEvent]: true,
+        [symbolFilePath]: "test.ts",
+      };
 
       const handler1 = jest.fn();
       const handler2 = jest.fn();

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

@@ -4,7 +4,7 @@ import {
   defineMiddleware,
   defineEvent,
 } from "../../define";
-import { symbols } from "../../defs";
+import { symbolFilePath } from "../../defs";
 import {
   getCallerFile,
   generateCallerIdFromFile,
@@ -41,17 +41,15 @@ describe("getCallerFile", () => {
       id: "event",
     });
 
-    expect((task as any)[symbols.filePath]).toBeDefined();
-    expect((resource as any)[symbols.filePath]).toBeDefined();
-    expect((middleware as any)[symbols.filePath]).toBeDefined();
-    expect((event as any)[symbols.filePath]).toBeDefined();
+    expect((task as any)[symbolFilePath]).toBeDefined();
+    expect((resource as any)[symbolFilePath]).toBeDefined();
+    expect((middleware as any)[symbolFilePath]).toBeDefined();
+    expect((event as any)[symbolFilePath]).toBeDefined();
 
-    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((event as any)[symbols.filePath]).toContain("getCallerFile.test");
+    expect((task as any)[symbolFilePath]).toContain("getCallerFile.test");
+    expect((resource as any)[symbolFilePath]).toContain("getCallerFile.test");
+    expect((middleware as any)[symbolFilePath]).toContain("getCallerFile.test");
+    expect((event as any)[symbolFilePath]).toContain("getCallerFile.test");
   });
 });
 

package/src/define.ts

@@ -13,7 +13,6 @@ import {
   IResourceDefinition,
   IEventDefinition,
   IMiddlewareDefinition,
-  symbols,
   DependencyMapType,
   DependencyValuesType,
   IMiddleware,
@@ -28,6 +27,12 @@ import {
   ITagWithConfig,
   TagType,
   ITaggable,
+  symbolTask,
+  symbolMiddlewareEverywhereTasks,
+  symbolMiddlewareEverywhereResources,
+  symbolResourceWithConfig,
+  symbolResource,
+  symbolMiddleware,
 } from "./defs";
 import { Errors } from "./errors";
 import { generateCallerIdFromFile, getCallerFile } from "./tools/getCallerFile";
@@ -52,8 +57,8 @@ export function defineTask<
   const isAnonymous = !Boolean(taskConfig.id);
   const id = taskConfig.id || generateCallerIdFromFile(filePath, "task");
   return {
-    [symbols.task]: true,
-    [symbols.filePath]: filePath,
+    [symbolTask]: true,
+    [symbolFilePath]: filePath,
     id,
     dependencies: taskConfig.dependencies || ({} as Deps),
     middleware: taskConfig.middleware || [],
@@ -67,7 +72,7 @@ export function defineTask<
             ? Symbol(`anonymous-task.events.beforeRun`)
             : `${id as string}.events.beforeRun`,
         }),
-        [symbols.filePath]: getCallerFile(),
+        [symbolFilePath]: getCallerFile(),
       },
       afterRun: {
         ...defineEvent({
@@ -75,7 +80,7 @@ export function defineTask<
             ? Symbol(`anonymous-task.events.afterRun`)
             : `${id as string}.events.afterRun`,
         }),
-        [symbols.filePath]: getCallerFile(),
+        [symbolFilePath]: getCallerFile(),
       },
       onError: {
         ...defineEvent({
@@ -83,7 +88,7 @@ export function defineTask<
             ? Symbol(`anonymous-task.events.onError`)
             : `${id as string}.events.onError`,
         }),
-        [symbols.filePath]: getCallerFile(),
+        [symbolFilePath]: getCallerFile(),
       },
     },
     meta: taskConfig.meta || {},
@@ -112,9 +117,11 @@ export function defineResource<
   const id =
     constConfig.id ||
     generateCallerIdFromFile(filePath, isIndexResource ? "index" : "resource");
+
   return {
-    [symbols.resource]: true,
-    [symbols.filePath]: filePath,
+    [symbolResource]: true,
+    [symbolFilePath]: filePath,
+    [symbolIndexResource]: isIndexResource,
     id,
     dependencies: constConfig.dependencies,
     dispose: constConfig.dispose,
@@ -124,7 +131,7 @@ export function defineResource<
     context: constConfig.context,
     with: function (config: TConfig) {
       return {
-        [symbols.resourceWithConfig]: true,
+        [symbolResourceWithConfig]: true,
         id: this.id,
         resource: this,
         config,
@@ -138,7 +145,7 @@ export function defineResource<
             ? Symbol(`anonymous-resource.events.beforeInit`)
             : `${id as string}.events.beforeInit`,
         }),
-        [symbols.filePath]: filePath,
+        [symbolFilePath]: filePath,
       },
       afterInit: {
         ...defineEvent({
@@ -146,7 +153,7 @@ export function defineResource<
             ? Symbol(`anonymous-resource.events.afterInit`)
             : `${id as string}.events.afterInit`,
         }),
-        [symbols.filePath]: filePath,
+        [symbolFilePath]: filePath,
       },
       onError: {
         ...defineEvent({
@@ -154,7 +161,7 @@ export function defineResource<
             ? Symbol(`anonymous-resource.events.onError`)
             : `${id as string}.events.onError`,
         }),
-        [symbols.filePath]: filePath,
+        [symbolFilePath]: filePath,
       },
     },
     meta: constConfig.meta || {},
@@ -198,8 +205,8 @@ export function defineIndex<
     async init(_, deps) {
       return deps as any;
     },
-    [symbols.filePath]: callerFilePath,
-    [symbols.indexResource]: true,
+    [symbolFilePath]: callerFilePath,
+    [symbolIndexResource]: true,
   });
 }
 
@@ -215,7 +222,7 @@ export function defineEvent<TPayload = void>(
   return {
     ...eventConfig,
     id: eventConfig.id || generateCallerIdFromFile(callerFilePath, "event"),
-    [symbols.filePath]: callerFilePath,
+    [symbolFilePath]: callerFilePath,
     [symbolEvent]: true, // This is a workaround
   };
 }
@@ -245,8 +252,8 @@ export function defineMiddleware<
    */
   const filePath = getCallerFile();
   const object = {
-    [symbols.filePath]: filePath,
-    [symbols.middleware]: true,
+    [symbolFilePath]: filePath,
+    [symbolMiddleware]: true,
     config: {} as TConfig,
     id: middlewareDef.id || generateCallerIdFromFile(filePath, "middleware"),
     ...middlewareDef,
@@ -270,8 +277,8 @@ export function defineMiddleware<
 
       return {
         ...object,
-        [symbols.middlewareEverywhereTasks]: tasks,
-        [symbols.middlewareEverywhereResources]: resources,
+        [symbolMiddlewareEverywhereTasks]: tasks,
+        [symbolMiddlewareEverywhereResources]: resources,
         everywhere() {
           throw Errors.middlewareAlreadyGlobal(object.id);
         },
@@ -281,25 +288,25 @@ export function defineMiddleware<
 }
 
 export function isTask(definition: any): definition is ITask {
-  return definition && definition[symbols.task];
+  return definition && definition[symbolTask];
 }
 
 export function isResource(definition: any): definition is IResource {
-  return definition && definition[symbols.resource];
+  return definition && definition[symbolResource];
 }
 
 export function isResourceWithConfig(
   definition: any
 ): definition is IResourceWithConfig {
-  return definition && definition[symbols.resourceWithConfig];
+  return definition && definition[symbolResourceWithConfig];
 }
 
 export function isEvent(definition: any): definition is IEvent {
-  return definition && definition[symbols.event];
+  return definition && definition[symbolEvent];
 }
 
 export function isMiddleware(definition: any): definition is IMiddleware {
-  return definition && definition[symbols.middleware];
+  return definition && definition[symbolMiddleware];
 }
 
 /**

package/src/defs.ts

@@ -18,7 +18,7 @@ import { MiddlewareEverywhereOptions } from "./define";
 
 // Re-export public cache type so consumers don’t import from internals.
 export { ICacheInstance } from "./globals/middleware/cache.middleware";
-
+export * from "./models/StoreTypes";
 /**
  * Internal brand symbols used to tag created objects at runtime and help with
  * type‑narrowing. Prefer the `isTask`/`isResource`/`isEvent`/`isMiddleware`
@@ -57,24 +57,6 @@ export const symbolIndexResource: unique symbol = Symbol(
   "runner.indexResource"
 );
 
-/**
- * Convenience bag of internal symbols. Intended for framework internals;
- * consumers should not rely on this shape.
- * @internal
- */
-export const symbols = {
-  task: symbolTask,
-  resource: symbolResource,
-  resourceWithConfig: symbolResourceWithConfig,
-  indexResource: symbolIndexResource,
-  event: symbolEvent,
-  middleware: symbolMiddleware,
-  middlewareEverywhereTasks: symbolMiddlewareEverywhereTasks,
-  middlewareEverywhereResources: symbolMiddlewareEverywhereResources,
-  filePath: symbolFilePath,
-  dispose: symbolDispose,
-  store: symbolStore,
-};
 export interface ITagDefinition<TConfig = void> {
   id: string | symbol;
 }
@@ -104,6 +86,7 @@ export interface ITag<TConfig = void> extends ITagDefinition<TConfig> {
    * or from a taggable object (`{ meta: { tags?: [] } }`).
    */
   extract(target: TagType[] | ITaggable): ExtractedTagResult<TConfig> | null;
+  [symbolFilePath]: string;
 }
 
 /**
@@ -315,6 +298,8 @@ export interface ITask<
     afterRun: IEvent<AfterRunEventPayload<TInput, TOutput>>;
     onError: IEvent<OnErrorEventPayload>;
   };
+  [symbolFilePath]: string;
+  [symbolTask]: true;
 }
 
 export interface IResourceDefinition<
@@ -374,6 +359,7 @@ export interface IResourceDefinition<
   context?: () => TContext;
   /**
    * This is optional and used from an index resource to get the correct caller.
+   * This is the reason we allow it here as well.
    */
   [symbolFilePath]?: string;
   /**
@@ -403,6 +389,9 @@ export interface IResource<
   };
   overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
   middleware: MiddlewareAttachments[];
+  [symbolFilePath]: string;
+  [symbolIndexResource]: boolean;
+  [symbolResource]: true;
 }
 
 export interface IResourceWithConfig<
@@ -434,6 +423,7 @@ export interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
    * We use this event to discriminate between resources with just 'id' and 'events' as they collide. This is a workaround, should be redone using classes and instanceof.
    */
   [symbolEvent]: true;
+  [symbolFilePath]: string;
 }
 
 /**
@@ -511,6 +501,8 @@ export interface IMiddleware<
   config: TConfig;
   /** Configure the middleware and return a marked, configured instance. */
   with: (config: TConfig) => IMiddlewareConfigured<TConfig, TDependencies>;
+  [symbolFilePath]: string;
+  [symbolMiddleware]: true;
 }
 
 export interface IMiddlewareConfigured<

package/src/models/StoreTypes.ts

@@ -8,6 +8,7 @@ import {
   IResourceWithConfig,
   RegisterableItems,
   IMiddleware,
+  IEvent,
 } from "../defs";
 
 export type ResourceStoreElementType<
@@ -42,5 +43,5 @@ export type MiddlewareStoreElementType<TDeps extends DependencyMapType = any> =
   };
 
 export type EventStoreElementType = {
-  event: IEventDefinition;
-};
+  event: IEvent<any>;
+};