@bluelibs/runner 1.0.0 → 1.2.0

package/src/{Store.ts → models/Store.ts}

@@ -9,12 +9,12 @@ import {
   RegisterableItems,
   symbols,
   IMiddleware,
-} from "./defs";
-import * as utils from "./define";
-import { IDependentNode } from "./tools/findCircularDependencies";
-import { globalEventsArray } from "./globalEvents";
-import { Errors } from "./errors";
-import { globalResources } from "./globalResources";
+} from "../defs";
+import * as utils from "../define";
+import { IDependentNode } from "../tools/findCircularDependencies";
+import { globalEventsArray } from "../globalEvents";
+import { Errors } from "../errors";
+import { globalResources } from "../globalResources";
 import { EventManager } from "./EventManager";
 import { TaskRunner } from "./TaskRunner";
 
@@ -51,7 +51,7 @@ export type EventStoreElementType = {
 };
 
 /**
- * @internal This should be used for testing purposes only.
+ * Store class which is used to store all the resources, tasks, middleware and events.
  */
 export class Store {
   root!: ResourceStoreElementType;
@@ -59,15 +59,41 @@ export class Store {
   public resources: Map<string, ResourceStoreElementType> = new Map();
   public events: Map<string, EventStoreElementType> = new Map();
   public middlewares: Map<string, MiddlewareStoreElementType> = new Map();
+  public overrides: Map<
+    string,
+    IResource | IMiddleware | ITask | IResourceWithConfig
+  > = new Map();
+
+  #isLocked = false;
+  #isInitialized = false;
 
   constructor(protected readonly eventManager: EventManager) {}
 
+  get isLocked() {
+    return this.#isLocked;
+  }
+
+  lock() {
+    this.#isLocked = true;
+    this.eventManager.lock();
+  }
+
+  checkLock() {
+    if (this.#isLocked) {
+      throw new Error("Cannot modify the Store when it is locked.");
+    }
+  }
+
   /**
    * Store the root before beginning registration
    * @param root
    * @param config
    */
   initializeStore(root: IResource<any>, config: any) {
+    if (this.#isInitialized) {
+      throw Errors.storeAlreadyInitialized();
+    }
+
     this.storeGenericItem(globalResources.eventManager.with(this.eventManager));
     this.storeGenericItem(globalResources.store.with(this));
 
@@ -89,7 +115,14 @@ export class Store {
       this.storeEvent(event);
     });
 
+    this.computeRegistrationDeeply(root, config);
     this.resources.set(root.id, this.root);
+
+    for (const resource of this.resources.values()) {
+      this.storeOverridesDeeply(resource.resource);
+    }
+
+    this.#isInitialized = true;
   }
 
   /**
@@ -97,17 +130,37 @@ export class Store {
    * @param element
    * @param config
    */
-  computeRegisterOfResource<C>(element: IResource<C>, config?: C) {
+  private computeRegistrationDeeply<C>(element: IResource<C>, config?: C) {
     const items =
       typeof element.register === "function"
         ? element.register(config as C)
         : element.register;
 
     for (const item of items) {
+      // will call registration if it detects another resource.
       this.storeGenericItem<C>(item);
     }
   }
 
+  /**
+   * @param element
+   */
+  private storeOverridesDeeply<C>(element: IResource<C, any, any>) {
+    element.overrides.forEach((override) => {
+      // the one on top has priority of setting the last override.
+      if (utils.isResource(override)) {
+        this.storeOverridesDeeply(override);
+      }
+
+      if (utils.isResourceWithConfig(override)) {
+        this.storeOverridesDeeply(override.resource);
+        this.overrides.set(override.resource.id, override);
+      } else {
+        this.overrides.set(override.id, override);
+      }
+    });
+  }
+
   /**
    * middlewares are already stored in their final form and the check for them would be redundant
    * @param id
@@ -122,6 +175,63 @@ export class Store {
     if (this.events.has(id)) {
       throw Errors.duplicateRegistration("Event", id);
     }
+    if (this.middlewares.has(id)) {
+      throw Errors.duplicateRegistration("Middleware", id);
+    }
+  }
+
+  /**
+   * Cleanup
+   */
+  public async dispose() {
+    for (const resource of this.resources.values()) {
+      if (resource.resource.dispose) {
+        await resource.resource.dispose(
+          resource.value,
+          resource.config,
+          resource.computedDependencies as DependencyMapType
+        );
+      }
+    }
+  }
+
+  /**
+   * When this is called, all overrides should have been stored in the "overrides" store.
+   */
+  public processOverrides() {
+    // If we are trying to use override on something that wasn't previously registered, we throw an error.
+    for (const override of this.overrides.values()) {
+      let hasAnyItem = false;
+      if (utils.isTask(override)) {
+        hasAnyItem = this.tasks.has(override.id);
+      } else if (utils.isResource(override)) {
+        hasAnyItem = this.resources.has(override.id);
+      } else if (utils.isMiddleware(override)) {
+        hasAnyItem = this.middlewares.has(override.id);
+      } else if (utils.isResourceWithConfig(override)) {
+        hasAnyItem = this.resources.has(override.resource.id);
+      }
+
+      if (!hasAnyItem) {
+        const id = utils.isResourceWithConfig(override)
+          ? override.resource.id
+          : override.id;
+
+        throw Errors.dependencyNotFound(id);
+      }
+    }
+
+    for (const override of this.overrides.values()) {
+      if (utils.isTask(override)) {
+        this.storeTask(override, false);
+      } else if (utils.isResource(override)) {
+        this.storeResource(override, false);
+      } else if (utils.isMiddleware(override)) {
+        this.storeMiddleware(override, false);
+      } else if (utils.isResourceWithConfig(override)) {
+        this.storeResourceWithConfig(override, false);
+      }
+    }
   }
 
   public getGlobalMiddlewares(excludingIds: string[]): IMiddleware[] {
@@ -144,19 +254,7 @@ export class Store {
     } else if (utils.isEvent(item)) {
       this.storeEvent<C>(item);
     } else if (utils.isMiddleware(item)) {
-      if (this.middlewares.has(item.id)) {
-        throw Errors.duplicateRegistration("Middleware", item.id);
-      }
-
-      item.dependencies =
-        typeof item.dependencies === "function"
-          ? item.dependencies()
-          : item.dependencies;
-
-      this.middlewares.set(item.id, {
-        middleware: item,
-        computedDependencies: {},
-      });
+      this.storeMiddleware<C>(item);
     } else if (utils.isResourceWithConfig(item)) {
       this.storeResourceWithConfig<C>(item);
     } else {
@@ -164,14 +262,33 @@ export class Store {
     }
   }
 
+  private storeMiddleware<C>(item: IMiddleware<any>, check = true) {
+    check && this.checkIfIDExists(item.id);
+
+    item.dependencies =
+      typeof item.dependencies === "function"
+        ? item.dependencies()
+        : item.dependencies;
+
+    this.middlewares.set(item.id, {
+      middleware: item,
+      computedDependencies: {},
+    });
+  }
+
   public storeEvent<C>(item: IEventDefinition<void>) {
     this.checkIfIDExists(item.id);
 
     this.events.set(item.id, { event: item });
   }
 
-  private storeResourceWithConfig<C>(item: IResourceWithConfig<any, any, any>) {
-    this.checkIfIDExists(item.resource.id);
+  private storeResourceWithConfig<C>(
+    item: IResourceWithConfig<any, any, any>,
+    check = true
+  ) {
+    check && this.checkIfIDExists(item.resource.id);
+
+    this.prepareResource(item.resource, item.config);
 
     this.resources.set(item.resource.id, {
       resource: item.resource,
@@ -180,20 +297,17 @@ export class Store {
       isInitialized: false,
     });
 
-    this.computeRegisterOfResource(item.resource, item.config);
+    this.computeRegistrationDeeply(item.resource, item.config);
   }
 
-  private storeResource<C>(item: IResource<any, any, any>) {
-    this.checkIfIDExists(item.id);
-
-    this.storeEvent(item.events.beforeInit);
-    this.storeEvent(item.events.afterInit);
-    this.storeEvent(item.events.onError);
+  /**
+   * This is for storing a resource without a config.
+   * @param item
+   */
+  private storeResource<C>(item: IResource<any, any, any>, check = true) {
+    check && this.checkIfIDExists(item.id);
 
-    item.dependencies =
-      typeof item.dependencies === "function"
-        ? item.dependencies()
-        : item.dependencies;
+    this.prepareResource(item, {});
 
     this.resources.set(item.id, {
       resource: item,
@@ -202,20 +316,46 @@ export class Store {
       isInitialized: false,
     });
 
-    this.computeRegisterOfResource(item, {});
+    this.computeRegistrationDeeply(item, {});
   }
 
-  private storeTask<C>(item: ITask<any, any, {}>) {
-    this.checkIfIDExists(item.id);
+  public storeEventsForAllTasks() {
+    for (const task of this.tasks.values()) {
+      this.storeEvent(task.task.events.beforeRun);
+      this.storeEvent(task.task.events.afterRun);
+      this.storeEvent(task.task.events.onError);
+    }
 
+    for (const resource of this.resources.values()) {
+      this.storeEvent(resource.resource.events.beforeInit);
+      this.storeEvent(resource.resource.events.afterInit);
+      this.storeEvent(resource.resource.events.onError);
+    }
+  }
+
+  /**
+   * This is for storing a resource without a config.
+   * @param item
+   */
+  private prepareResource<C>(
+    item: IResource<any, any, any>,
+    config: any
+  ): IResource<any, any, any> {
     item.dependencies =
       typeof item.dependencies === "function"
-        ? item.dependencies()
+        ? item.dependencies(config)
         : item.dependencies;
 
-    this.storeEvent(item.events.beforeRun);
-    this.storeEvent(item.events.afterRun);
-    this.storeEvent(item.events.onError);
+    return item;
+  }
+
+  private storeTask<C>(item: ITask<any, any, {}>, check = true) {
+    check && this.checkIfIDExists(item.id);
+
+    item.dependencies =
+      typeof item.dependencies === "function"
+        ? item.dependencies()
+        : item.dependencies;
 
     this.tasks.set(item.id, {
       task: item,

package/src/{TaskRunner.ts → models/TaskRunner.ts}

@@ -1,7 +1,7 @@
-import { DependencyMapType, DependencyValuesType, ITask } from "./defs";
-import { Errors } from "./errors";
+import { DependencyMapType, DependencyValuesType, ITask } from "../defs";
+import { Errors } from "../errors";
 import { EventManager } from "./EventManager";
-import { globalEvents } from "./globalEvents";
+import { globalEvents } from "../globalEvents";
 import {
   MiddlewareStoreElementType,
   Store,
@@ -22,6 +22,9 @@ export class TaskRunner {
   /**
    * Begins the execution of an task. These are registered tasks and all sanity checks have been performed at this stage to ensure consistency of the object.
    * 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,

package/src/models/index.ts

@@ -0,0 +1,5 @@
+export * from "./DependencyProcessor";
+export * from "./EventManager";
+export * from "./Logger";
+export * from "./Store";
+export * from "./TaskRunner";

package/src/run.ts

@@ -1,4 +1,4 @@
-import { TaskRunner } from "./TaskRunner";
+import { TaskRunner } from "./models/TaskRunner";
 import {
   DependencyMapType,
   ITaskDefinition,
@@ -8,13 +8,14 @@ import {
   DependencyValuesType,
   IResource,
 } from "./defs";
-import { DependencyProcessor } from "./DependencyProcessor";
-import { EventManager } from "./EventManager";
+import { DependencyProcessor } from "./models/DependencyProcessor";
+import { EventManager } from "./models/EventManager";
 import { globalEvents } from "./globalEvents";
-import { Store } from "./Store";
+import { Store } from "./models/Store";
 import { findCircularDependencies } from "./tools/findCircularDependencies";
 import { Errors } from "./errors";
 import { globalResources } from "./globalResources";
+import { Logger } from "./models/Logger";
 
 export type ResourcesStoreElementType<
   C = any,
@@ -58,18 +59,19 @@ export type RunnerType = {
 };
 
 export async function run<C, V>(
-  resource: IResource<C>,
+  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);
+  const logger = new Logger(eventManager);
 
   // In the registration phase we register deeply all the resources, tasks, middleware and events
   store.initializeStore(resource, config);
+  store.storeGenericItem(globalResources.logger.with(logger));
   store.storeGenericItem(globalResources.taskRunner.with(taskRunner));
-  store.computeRegisterOfResource(resource, config);
 
   // We verify that there isn't any circular dependencies before we begin computing the dependencies
   const dependentNodes = store.getDependentNodes();
@@ -78,14 +80,17 @@ export async function run<C, V>(
     throw Errors.circularDependencies(circularDependencies.cycles);
   }
 
-  await processor.processHooks();
+  await store.processOverrides();
+
+  // a form of hooking, we store the events for all tasks
+  await store.storeEventsForAllTasks();
+  await processor.attachHooks();
+  await processor.computeAllDependencies();
 
   // Now we can safely compute dependencies without being afraid of an infinite loop.
   // The hooking part is done here.
   await eventManager.emit(globalEvents.beforeInit);
 
-  await processor.computeAllDependencies();
-
   // leftovers that were registered but not depended upon, except root
   await processor.initializeUninitializedResources();
 
@@ -94,5 +99,8 @@ export async function run<C, V>(
 
   await eventManager.emit(globalEvents.afterInit);
 
+  // disallow manipulation or attaching more
+  store.lock();
+
   return store.root.value;
 }

package/src/__tests__/Store.test.ts

@@ -1,143 +0,0 @@
-import { EventManager } from "../EventManager";
-import { Store } from "../Store";
-import {
-  defineTask,
-  defineResource,
-  defineEvent,
-  defineMiddleware,
-} from "../define";
-
-describe("Store", () => {
-  let store: Store;
-  let eventManager: EventManager;
-
-  beforeEach(() => {
-    eventManager = new EventManager();
-    store = new Store(eventManager);
-  });
-
-  it("should register an task", () => {
-    const task = defineTask({
-      id: "testTask",
-      run: async () => {},
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [task],
-      })
-    );
-
-    expect(store.tasks.get("testTask")).toBeDefined();
-    expect(store.tasks.get("testTask")?.task).toBe(task);
-  });
-
-  it("should register a resource", () => {
-    const resource = defineResource({
-      id: "testResource",
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [resource],
-      })
-    );
-
-    expect(store.resources.get("testResource")).toBeDefined();
-    expect(store.resources.get("testResource")?.resource).toBe(resource);
-  });
-
-  it("should register an event", () => {
-    const event = defineEvent({
-      id: "testEvent",
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [event],
-      })
-    );
-
-    expect(store.events.get("testEvent")).toBeDefined();
-    expect(store.events.get("testEvent")?.event).toBe(event);
-  });
-
-  it("should register a middleware", () => {
-    const middleware = defineMiddleware({
-      id: "testMiddleware",
-      run: async () => {},
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [middleware],
-      })
-    );
-
-    expect(store.middlewares.get("testMiddleware")).toBeDefined();
-    expect(store.middlewares.get("testMiddleware")?.middleware).toBe(
-      middleware
-    );
-  });
-
-  it("should throw an error when registering duplicate items", () => {
-    const task = defineTask({
-      id: "duplicateItem",
-      run: async () => {},
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [task],
-      })
-    );
-
-    expect(() => {
-      store.computeRegisterOfResource(
-        defineResource({
-          id: "anotherRoot",
-          register: [task],
-        })
-      );
-    }).toThrow('Task "duplicateItem" already registered');
-  });
-
-  it("should return dependent nodes", () => {
-    const task1 = defineTask({
-      id: "task1",
-      dependencies: { dep1: {} as any },
-      run: async () => {},
-    });
-
-    const task2 = defineTask({
-      id: "task2",
-      dependencies: { dep2: {} as any },
-      run: async () => {},
-    });
-
-    store.computeRegisterOfResource(
-      defineResource({
-        id: "root",
-        register: [task1, task2],
-      })
-    );
-
-    const dependentNodes = store.getDependentNodes();
-
-    // global store, global event manager
-    expect(dependentNodes).toHaveLength(2);
-    expect(dependentNodes).toContainEqual({
-      id: "task1",
-      dependencies: { dep1: {} },
-    });
-    expect(dependentNodes).toContainEqual({
-      id: "task2",
-      dependencies: { dep2: {} },
-    });
-  });
-});