@bluelibs/runner 1.3.0 → 1.5.0

package/src/models/DependencyProcessor.ts

@@ -6,12 +6,13 @@ import {
   IHookDefinition,
   IEventDefinition,
 } from "../defs";
-import { ResourceStoreElementType, Store } from "./Store";
+import { ResourceStoreElementType, Store, TaskStoreElementType } from "./Store";
 import * as utils from "../define";
 import { EventManager } from "./EventManager";
 import { ResourceInitializer } from "./ResourceInitializer";
 import { TaskRunner } from "./TaskRunner";
 import { Errors } from "../errors";
+import { Logger } from "./Logger";
 
 /**
  * This class is responsible of setting up dependencies with their respective computedValues.
@@ -24,9 +25,14 @@ export class DependencyProcessor {
   constructor(
     protected readonly store: Store,
     protected readonly eventManager: EventManager,
-    protected readonly taskRunner: TaskRunner
+    protected readonly taskRunner: TaskRunner,
+    protected readonly logger: Logger
   ) {
-    this.resourceInitializer = new ResourceInitializer(store, eventManager);
+    this.resourceInitializer = new ResourceInitializer(
+      store,
+      eventManager,
+      logger
+    );
   }
 
   /**
@@ -35,35 +41,59 @@ export class DependencyProcessor {
   async computeAllDependencies() {
     for (const middleware of this.store.middlewares.values()) {
       const deps = middleware.middleware.dependencies as DependencyMapType;
-      middleware.computedDependencies = await this.extractDependencies(deps);
+      middleware.computedDependencies = await this.extractDependencies(
+        deps,
+        middleware.middleware.id
+      );
     }
 
     for (const task of this.store.tasks.values()) {
-      const deps = task.task.dependencies as DependencyMapType;
-      task.computedDependencies = await this.extractDependencies(deps);
-
-      let eventDefinition = task.task.on;
-      if (eventDefinition) {
-        if (this.store.events.get(eventDefinition.id) === undefined) {
-          throw Errors.eventNotFound(eventDefinition.id);
-        }
-
-        this.eventManager.addListener(
-          eventDefinition,
-          async (receivedEvent) => {
-            return this.taskRunner.run(
-              task.task,
-              receivedEvent,
-              task.computedDependencies
-            );
-          }
-        );
-      }
+      await this.computeTaskDependencies(task);
     }
 
     for (const resource of this.store.resources.values()) {
       await this.processResourceDependencies(resource);
     }
+
+    // leftovers that were registered but not depended upon, except root
+    // they should still be initialized as they might extend other
+    await this.initializeUninitializedResources();
+  }
+
+  private async computeTaskDependencies(
+    task: TaskStoreElementType<any, any, any>
+  ) {
+    const deps = task.task.dependencies as DependencyMapType;
+    task.computedDependencies = await this.extractDependencies(
+      deps,
+      task.task.id
+    );
+
+    let eventDefinition = task.task.on;
+    if (eventDefinition) {
+      if (this.store.events.get(eventDefinition.id) === undefined) {
+        throw Errors.eventNotFound(eventDefinition.id);
+      }
+
+      this.eventManager.addListener(
+        eventDefinition,
+        async (receivedEvent) => {
+          this.logger.debug({
+            message: `Task ${task.task.id} listened to event: ${eventDefinition.id}`,
+            event: receivedEvent,
+          });
+
+          return this.taskRunner.run(
+            task.task,
+            receivedEvent,
+            task.computedDependencies
+          );
+        },
+        {
+          order: task.task.listenerOrder || 0,
+        }
+      );
+    }
   }
 
   // Most likely these are resources that no-one has dependencies towards
@@ -93,7 +123,10 @@ export class DependencyProcessor {
     resource: ResourceStoreElementType<any, any, {}>
   ) {
     const deps = resource.resource.dependencies as DependencyMapType;
-    resource.computedDependencies = await this.extractDependencies(deps);
+    resource.computedDependencies = await this.extractDependencies(
+      deps,
+      resource.resource.id
+    );
   }
 
   public async initializeRoot() {
@@ -111,10 +144,8 @@ export class DependencyProcessor {
 
   /**
    * Processes all hooks, should run before emission of any event.
-   * @returns
    */
   public attachHooks() {
-    // iterate through resources and send them to processHooks
     for (const resource of this.store.resources.values()) {
       if (resource.resource.hooks) {
         this.attachHooksToResource(resource);
@@ -141,46 +172,59 @@ export class DependencyProcessor {
 
     for (const hook of hooks) {
       const event = hook.event;
+      const order = hook.order || 0;
       if (event === "*") {
-        this.eventManager.addGlobalListener(async (receivedEvent) => {
-          return hook.run(
-            receivedEvent,
-            resourceStoreElement.computedDependencies as DependencyValuesType<{}>
-          );
-        });
+        this.eventManager.addGlobalListener(
+          async (receivedEvent) => {
+            return hook.run(
+              receivedEvent,
+              resourceStoreElement.computedDependencies as DependencyValuesType<{}>
+            );
+          },
+          {
+            order,
+          }
+        );
       } else {
         if (this.store.events.has(event.id) === false) {
           throw Errors.eventNotFound(event.id);
         }
-        this.eventManager.addListener(event, async (receivedEvent) => {
-          return hook.run(
-            receivedEvent,
-            resourceStoreElement.computedDependencies as DependencyValuesType<{}>
-          );
-        });
+        this.eventManager.addListener(
+          event,
+          async (receivedEvent) => {
+            return hook.run(
+              receivedEvent,
+              resourceStoreElement.computedDependencies as DependencyValuesType<{}>
+            );
+          },
+          {
+            order,
+          }
+        );
       }
     }
   }
 
   async extractDependencies<T extends DependencyMapType>(
-    map: T
+    map: T,
+    source: string
   ): Promise<DependencyValuesType<T>> {
     const object = {} as DependencyValuesType<T>;
 
     for (const key in map) {
-      object[key] = await this.extractDependency(map[key]);
+      object[key] = await this.extractDependency(map[key], source);
     }
 
     return object;
   }
 
-  async extractDependency(object) {
+  async extractDependency(object, source: string) {
     if (utils.isResource(object)) {
       return this.extractResourceDependency(object);
     } else if (utils.isTask(object)) {
       return this.extractTaskDependency(object);
     } else if (utils.isEvent(object)) {
-      return this.extractEventDependency(object);
+      return this.extractEventDependency(object, source);
     } else {
       throw Errors.unknownItemType(object);
     }
@@ -191,9 +235,17 @@ export class DependencyProcessor {
    * @param object
    * @returns
    */
-  extractEventDependency(object: IEventDefinition<Record<string, any>>) {
+  extractEventDependency(
+    object: IEventDefinition<Record<string, any>>,
+    source: string
+  ) {
     return async (input) => {
-      return this.eventManager.emit(object, input);
+      // runs it in background.
+      this.logger.debug({
+        message: `Event ${object.id} was emitted from ${source}`,
+      });
+
+      return this.eventManager.emit(object, input, source);
     };
   }
 
@@ -210,7 +262,8 @@ export class DependencyProcessor {
       const dependencies = object.dependencies as DependencyMapType;
 
       storeTask.computedDependencies = await this.extractDependencies(
-        dependencies
+        dependencies,
+        storeTask.task.id
       );
     }
 
@@ -242,7 +295,10 @@ export class DependencyProcessor {
         storeResource.value = await this.resourceInitializer.initializeResource(
           resource,
           config,
-          await this.extractDependencies(resource.dependencies || {})
+          await this.extractDependencies(
+            resource.dependencies || {},
+            resource.id
+          )
         );
       }
     }

package/src/models/EventManager.ts

@@ -1,5 +1,6 @@
 import { EventHandlerType, IEvent, IEventDefinition } from "../defs";
 import { Errors } from "../errors";
+import { Logger } from "./Logger";
 
 const HandlerOptionsDefaults = { order: 0 };
 
@@ -54,9 +55,9 @@ export class EventManager {
 
   async emit<TInput>(
     eventDefinition: IEventDefinition<TInput>,
-    ...args: TInput extends void ? [] : [TInput]
+    data: TInput,
+    source: string
   ): Promise<void> {
-    const data = args[0];
     const eventListeners = this.listeners.get(eventDefinition.id) || [];
     const allListeners = this.mergeSortedListeners(
       eventListeners,
@@ -67,6 +68,7 @@ export class EventManager {
       id: eventDefinition.id,
       data,
       timestamp: new Date(),
+      source,
     };
 
     for (const listener of allListeners) {

package/src/models/Logger.ts

@@ -11,13 +11,13 @@ export type LogLevels =
 
 export interface ILog {
   level: string;
-  context?: string;
+  source?: string;
   data: any;
   timestamp: Date;
 }
 
 export class Logger {
-  public static defaultContext = "app";
+  printThreshold: LogLevels | null = null;
 
   public severity = {
     trace: 0,
@@ -28,25 +28,45 @@ export class Logger {
     critical: 5,
   };
 
-  constructor(private eventManager: EventManager) {}
+  constructor(protected eventManager: EventManager) {}
 
   /**
    * @param level
    * @param message
    */
-  public async log(level: LogLevels, data: any): Promise<void> {
+  public async log(
+    level: LogLevels,
+    data: any,
+    source?: string
+  ): Promise<void> {
     const log: ILog = {
       level,
       data,
+      source: source,
       timestamp: new Date(),
     };
 
-    await this.eventManager.emit(globalEvents.log, log);
+    if (
+      this.printThreshold &&
+      this.severity[level] >= this.severity[this.printThreshold]
+    ) {
+      this.print(log);
+    }
+
+    await this.eventManager.emit(globalEvents.log, log, source || "unknown");
+  }
+
+  /**
+   * Will print logs after that, use `null` to disable autoprinting.
+   * @param level
+   */
+  public setPrintThreshold(level: LogLevels | null) {
+    this.printThreshold = level;
   }
 
-  public async print(log: ILog) {
+  public print(log: ILog) {
     // Extract the relevant information from the log
-    const { level, context, data, timestamp } = log;
+    const { level, source: context, data, timestamp } = log;
 
     // Format the timestamp to a more readable format
     const formattedTimestamp = timestamp.toISOString();
@@ -74,27 +94,27 @@ export class Logger {
     console.log(logMessage);
   }
 
-  public async info(data: any) {
-    await this.log("info", data);
+  public async info(data: any, source?: string) {
+    await this.log("info", data, source);
   }
 
-  public async error(data: any) {
-    await this.log("error", data);
+  public async error(data: any, source?: string) {
+    await this.log("error", data, source);
   }
 
-  public async warn(data: any) {
-    await this.log("warn", data);
+  public async warn(data: any, source?: string) {
+    await this.log("warn", data, source);
   }
 
-  public async debug(data: any) {
-    await this.log("debug", data);
+  public async debug(data: any, source?: string) {
+    await this.log("debug", data, source);
   }
 
-  public async trace(data: any) {
-    await this.log("trace", data);
+  public async trace(data: any, source?: string) {
+    await this.log("trace", data, source);
   }
 
-  public async critical(data: any) {
-    await this.log("critical", data);
+  public async critical(data: any, source?: string) {
+    await this.log("critical", data, source);
   }
 }

package/src/models/ResourceInitializer.ts

@@ -7,11 +7,13 @@ import {
 import { EventManager } from "./EventManager";
 import { globalEvents } from "../globalEvents";
 import { MiddlewareStoreElementType, Store } from "./Store";
+import { Logger } from "./Logger";
 
 export class ResourceInitializer {
   constructor(
     protected readonly store: Store,
-    protected readonly eventManager: EventManager
+    protected readonly eventManager: EventManager,
+    protected readonly logger: Logger
   ) {}
 
   /**
@@ -27,14 +29,20 @@ export class ResourceInitializer {
     config: TConfig,
     dependencies: DependencyValuesType<TDeps>
   ): Promise<TValue | undefined> {
-    // begin by dispatching the event of creating it.
-    // then ensure the hooks are called
-    // then ensure the middleware are called
-    await this.eventManager.emit(globalEvents.resources.beforeInit, {
-      config,
-      resource,
-    });
-    await this.eventManager.emit(resource.events.beforeInit, { config });
+    await this.eventManager.emit(
+      globalEvents.resources.beforeInit,
+      {
+        config,
+        resource,
+      },
+      resource.id
+    );
+
+    await this.eventManager.emit(
+      resource.events.beforeInit,
+      { config },
+      resource.id
+    );
 
     let error, value;
     try {
@@ -42,15 +50,25 @@ export class ResourceInitializer {
         value = await this.initWithMiddleware(resource, config, dependencies);
       }
 
-      await this.eventManager.emit(resource.events.afterInit, {
-        config,
-        value,
-      });
-      await this.eventManager.emit(globalEvents.resources.afterInit, {
-        config,
-        resource,
-        value,
-      });
+      await this.eventManager.emit(
+        resource.events.afterInit,
+        {
+          config,
+          value,
+        },
+        resource.id
+      );
+      await this.eventManager.emit(
+        globalEvents.resources.afterInit,
+        {
+          config,
+          resource,
+          value,
+        },
+        resource.id
+      );
+
+      this.logger.debug(`Resource ${resource.id} initialized`);
 
       return value;
     } catch (e) {
@@ -59,15 +77,23 @@ export class ResourceInitializer {
       const suppress = () => (isSuppressed = true);
 
       // If you want to rewthrow the error, this should be done inside the onError event.
-      await this.eventManager.emit(resource.events.onError, {
-        error,
-        suppress,
-      });
-      await this.eventManager.emit(globalEvents.resources.onError, {
-        error,
-        resource,
-        suppress,
-      });
+      await this.eventManager.emit(
+        resource.events.onError,
+        {
+          error,
+          suppress,
+        },
+        resource.id
+      );
+      await this.eventManager.emit(
+        globalEvents.resources.onError,
+        {
+          error,
+          resource,
+          suppress,
+        },
+        resource.id
+      );
 
       if (!isSuppressed) throw e;
     }

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;
@@ -378,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()) {
@@ -395,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
   ) {}
 
   /**
@@ -51,23 +53,35 @@ export class TaskRunner {
     // begin by dispatching the event of creating it.
     // then ensure the hooks are called
     // then ensure the middleware are called
-    await this.eventManager.emit(task.events.beforeRun, { input });
-    await this.eventManager.emit(globalEvents.tasks.beforeRun, {
-      task,
-      input,
-    });
+    await this.eventManager.emit(task.events.beforeRun, { input }, task.id);
+    await this.eventManager.emit(
+      globalEvents.tasks.beforeRun,
+      {
+        task,
+        input,
+      },
+      task.id
+    );
 
     let error;
     try {
       // craft the next function starting from the first next function
       const output = await runner(input);
 
-      await this.eventManager.emit(task.events.afterRun, { input, output });
-      await this.eventManager.emit(globalEvents.tasks.afterRun, {
-        task,
-        input,
-        output,
-      });
+      await this.eventManager.emit(
+        task.events.afterRun,
+        { input, output },
+        task.id
+      );
+      await this.eventManager.emit(
+        globalEvents.tasks.afterRun,
+        {
+          task,
+          input,
+          output,
+        },
+        task.id
+      );
 
       return output;
     } catch (e) {
@@ -76,12 +90,20 @@ export class TaskRunner {
       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, suppress });
-      await this.eventManager.emit(globalEvents.tasks.onError, {
-        task,
-        error,
-        suppress,
-      });
+      await this.eventManager.emit(
+        task.events.onError,
+        { error, suppress },
+        task.id
+      );
+      await this.eventManager.emit(
+        globalEvents.tasks.onError,
+        {
+          task,
+          error,
+          suppress,
+        },
+        task.id
+      );
 
       if (!isSuppressed) throw e;
     }
@@ -104,6 +126,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);
     };