@bluelibs/runner 3.2.0 → 3.3.0

package/src/models/DependencyProcessor.ts

@@ -139,11 +139,7 @@ export class DependencyProcessor {
             return;
           }
 
-          return this.taskRunner.run(
-            task.task,
-            receivedEvent,
-            task.computedDependencies
-          );
+          return this.taskRunner.run(task.task, receivedEvent);
         };
 
         if (eventDefinition === "*") {
@@ -217,11 +213,7 @@ export class DependencyProcessor {
     }
 
     return (input: any) => {
-      return this.taskRunner.run(
-        storeTask.task,
-        input,
-        storeTask.computedDependencies
-      );
+      return this.taskRunner.run(storeTask.task, input);
     };
   }
 

package/src/models/StoreConstants.ts

@@ -1,6 +1,7 @@
 import { globalResources } from "../globals/globalResources";
 import { requireContextMiddleware } from "../globals/middleware/requireContext.middleware";
 import { retryMiddleware } from "../globals/middleware/retry.middleware";
+import { timeoutMiddleware } from "../globals/middleware/timeout.middleware";
 import { EventManager } from "./EventManager";
 import { Store } from "./Store";
 
@@ -13,5 +14,5 @@ export function getBuiltInResources(eventManager: EventManager, store: Store) {
 }
 
 export function getBuiltInMiddlewares() {
-  return [requireContextMiddleware, retryMiddleware];
+  return [requireContextMiddleware, retryMiddleware, timeoutMiddleware];
 }

package/src/models/TaskRunner.ts

@@ -23,7 +23,6 @@ export class TaskRunner {
    * This function can throw only if any of the event listeners or run function throws
    * @param task the task to be run
    * @param input the input to be passed to the task
-   * @param taskDependencies optional dependencies to be passed to the task, if not provided, the dependencies will be the ones already computed from the store.
    */
   public async run<
     TInput,
@@ -31,8 +30,7 @@ export class TaskRunner {
     TDeps extends DependencyMapType
   >(
     task: ITask<TInput, TOutput, TDeps>,
-    input: TInput,
-    taskDependencies?: DependencyValuesType<TDeps>
+    input: TInput
   ): Promise<TOutput | undefined> {
     let runner = this.runnerStore.get(task.id);
     if (!runner) {

package/src/testing.ts

@@ -0,0 +1,66 @@
+import { defineResource } from "./define";
+import { globalResources } from "./globals/globalResources";
+import {
+  IResource,
+  IResourceWithConfig,
+  IMiddleware,
+  ITask,
+  RegisterableItems,
+  IEvent,
+  IEventEmission,
+  DependencyMapType,
+  DependencyValuesType,
+} from "./defs";
+import { EventManager, Logger, Store, TaskRunner } from "./models";
+
+let testResourceCounter = 0;
+
+/**
+ * Helper to create a minimal test harness resource that wraps a root app (or any registerable)
+ * and exposes convenient testing utilities while running the full ecosystem
+ * (registration, overrides, middleware, events) without modifying the core API.
+ */
+export function createTestResource(
+  root: RegisterableItems,
+  options?: {
+    overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
+  }
+): IResource<void, ReturnType<typeof buildTestFacade>> {
+  return defineResource({
+    id: `tests.createTestResource.${++testResourceCounter}`,
+    register: [root],
+    overrides: options?.overrides || [],
+    dependencies: {
+      taskRunner: globalResources.taskRunner,
+      store: globalResources.store,
+      logger: globalResources.logger,
+      eventManager: globalResources.eventManager,
+    },
+    async init(_, deps) {
+      return buildTestFacade(deps);
+    },
+  });
+}
+
+function buildTestFacade(deps: {
+  taskRunner: TaskRunner;
+  store: Store;
+  logger: Logger;
+  eventManager: EventManager;
+}) {
+  return {
+    // Run a task within the fully initialized ecosystem
+    runTask: <I, O extends Promise<any>, D extends DependencyMapType>(
+      task: ITask<I, O, D>,
+      input: I
+    ): Promise<Awaited<O> | undefined> =>
+      deps.taskRunner.run(task, input) as any,
+    // Access a resource value by id (string or symbol)
+    getResource: (id: string | symbol) => deps.store.resources.get(id)?.value,
+    // Expose internals when needed in tests (not recommended for app usage)
+    taskRunner: deps.taskRunner,
+    store: deps.store,
+    logger: deps.logger,
+    eventManager: deps.eventManager,
+  };
+}