@bluelibs/runner 1.2.0 → 1.4.0

package/src/models/Store.ts

@@ -17,6 +17,7 @@ import { Errors } from "../errors";
 import { globalResources } from "../globalResources";
 import { EventManager } from "./EventManager";
 import { TaskRunner } from "./TaskRunner";
+import { Logger } from "./Logger";
 
 export type ResourceStoreElementType<
   C = any,
@@ -67,7 +68,10 @@ export class Store {
   #isLocked = false;
   #isInitialized = false;
 
-  constructor(protected readonly eventManager: EventManager) {}
+  constructor(
+    protected readonly eventManager: EventManager,
+    protected readonly logger: Logger
+  ) {}
 
   get isLocked() {
     return this.#isLocked;
@@ -118,6 +122,8 @@ export class Store {
     this.computeRegistrationDeeply(root, config);
     this.resources.set(root.id, this.root);
 
+    this.runSanityChecks();
+
     for (const resource of this.resources.values()) {
       this.storeOverridesDeeply(resource.resource);
     }
@@ -125,6 +131,18 @@ export class Store {
     this.#isInitialized = true;
   }
 
+  private runSanityChecks() {
+    for (const task of this.tasks.values()) {
+      task.task.middleware.forEach((middleware) => {
+        if (!this.middlewares.has(middleware.id)) {
+          throw Errors.dependencyNotFound(
+            `Middleware ${middleware.id} in Task ${task.task.id}`
+          );
+        }
+      });
+    }
+  }
+
   /**
    * Beginning with the root, we perform registering to the container all the resources, tasks, middleware and events.
    * @param element
@@ -364,12 +382,22 @@ export class Store {
     });
   }
 
+  private middlewareAsMap(middleware: IMiddlewareDefinition[]) {
+    return middleware.reduce((acc, item) => {
+      acc[item.id] = item;
+      return acc;
+    }, {} as Record<string, IMiddlewareDefinition>);
+  }
+
   getDependentNodes(): IDependentNode[] {
     const depenedants: IDependentNode[] = [];
     for (const task of this.tasks.values()) {
       depenedants.push({
         id: task.task.id,
-        dependencies: task.task.dependencies,
+        dependencies: {
+          ...task.task.dependencies,
+          ...this.middlewareAsMap(task.task.middleware),
+        },
       });
     }
     for (const middleware of this.middlewares.values()) {
@@ -381,7 +409,10 @@ export class Store {
     for (const resource of this.resources.values()) {
       depenedants.push({
         id: resource.resource.id,
-        dependencies: resource.resource.dependencies || {},
+        dependencies: {
+          ...resource.resource.dependencies,
+          ...this.middlewareAsMap(resource.resource.middleware),
+        },
       });
     }
 

package/src/models/TaskRunner.ts

@@ -7,6 +7,7 @@ import {
   Store,
   TaskStoreElementType,
 } from "./Store";
+import { Logger } from "./Logger";
 
 export class TaskRunner {
   protected readonly runnerStore = new Map<
@@ -16,7 +17,8 @@ export class TaskRunner {
 
   constructor(
     protected readonly store: Store,
-    protected readonly eventManager: EventManager
+    protected readonly eventManager: EventManager,
+    protected readonly logger: Logger
   ) {}
 
   /**
@@ -71,16 +73,19 @@ export class TaskRunner {
 
       return output;
     } catch (e) {
+      let isSuppressed = false;
+      const suppress = () => (isSuppressed = true);
       error = e;
 
       // If you want to rewthrow the error, this should be done inside the onError event.
-      await this.eventManager.emit(task.events.onError, { error });
+      await this.eventManager.emit(task.events.onError, { error, suppress });
       await this.eventManager.emit(globalEvents.tasks.onError, {
         task,
         error,
+        suppress,
       });
 
-      throw e;
+      if (!isSuppressed) throw e;
     }
   }
 
@@ -101,6 +106,11 @@ export class TaskRunner {
   ) {
     // this is the final next()
     let next = async (input) => {
+      this.logger.debug({
+        message: `Running task ${task.id}`,
+        input,
+      });
+
       return task.run.call(null, input, taskDependencies as any);
     };
 

package/src/run.ts

@@ -52,22 +52,24 @@ export type RunnerState = {
   middleware: Record<string, MiddlewareStoreElementType>;
 };
 
-export type RunnerType = {
-  store: Store;
-  eventManager: EventManager;
-  taskRunner: TaskRunner;
-};
-
 export async function run<C, V>(
   resource: IResource<C, V>,
   config?: C
 ): Promise<V> {
   const eventManager = new EventManager();
-  const store = new Store(eventManager);
-  const taskRunner = new TaskRunner(store, eventManager);
-  const processor = new DependencyProcessor(store, eventManager, taskRunner);
+
+  // ensure for logger, that it can be used only after: computeAllDependencies() has executed
   const logger = new Logger(eventManager);
 
+  const store = new Store(eventManager, logger);
+  const taskRunner = new TaskRunner(store, eventManager, logger);
+  const processor = new DependencyProcessor(
+    store,
+    eventManager,
+    taskRunner,
+    logger
+  );
+
   // In the registration phase we register deeply all the resources, tasks, middleware and events
   store.initializeStore(resource, config);
   store.storeGenericItem(globalResources.logger.with(logger));
@@ -80,24 +82,25 @@ export async function run<C, V>(
     throw Errors.circularDependencies(circularDependencies.cycles);
   }
 
+  // the overrides that were registered now will override the other registered resources
   await store.processOverrides();
 
-  // a form of hooking, we store the events for all tasks
+  // 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.computeAllDependencies();
 
+  await logger.debug("All elements have been initalized..");
+
   // Now we can safely compute dependencies without being afraid of an infinite loop.
   // The hooking part is done here.
   await eventManager.emit(globalEvents.beforeInit);
 
-  // leftovers that were registered but not depended upon, except root
-  await processor.initializeUninitializedResources();
-
   // Now we can initialise the root resource
   await processor.initializeRoot();
 
   await eventManager.emit(globalEvents.afterInit);
+  await logger.debug("System initialized and operational.");
 
   // disallow manipulation or attaching more
   store.lock();