@bluelibs/runner 1.0.0

package/dist/run.d.ts

@@ -0,0 +1,32 @@
+import { TaskRunner } from "./TaskRunner";
+import { DependencyMapType, ITaskDefinition, IResourceDefinintion, IEventDefinition, IMiddlewareDefinition, DependencyValuesType, IResource } from "./defs";
+import { EventManager } from "./EventManager";
+import { Store } from "./Store";
+export type ResourcesStoreElementType<C = any, V = any, D extends DependencyMapType = {}> = {
+    resource: IResourceDefinintion<C, V, D>;
+    computedDependencies?: DependencyValuesType<D>;
+    config: C;
+    value: V;
+};
+export type TasksStoreElementType<Input = any, Output extends Promise<any> = any, D extends DependencyMapType = {}> = {
+    task: ITaskDefinition<Input, Output, D>;
+    computedDependencies?: DependencyValuesType<D>;
+};
+export type MiddlewareStoreElementType = {
+    middleware: IMiddlewareDefinition;
+};
+export type EventStoreElementType = {
+    event: IEventDefinition;
+};
+export type RunnerState = {
+    tasks: Record<string, TasksStoreElementType>;
+    resources: Record<string, ResourcesStoreElementType>;
+    events: Record<string, EventStoreElementType>;
+    middleware: Record<string, MiddlewareStoreElementType>;
+};
+export type RunnerType = {
+    store: Store;
+    eventManager: EventManager;
+    taskRunner: TaskRunner;
+};
+export declare function run<C, V>(resource: IResource<C>, config?: C): Promise<V>;

package/dist/run.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const TaskRunner_1 = require("./TaskRunner");
+const DependencyProcessor_1 = require("./DependencyProcessor");
+const EventManager_1 = require("./EventManager");
+const globalEvents_1 = require("./globalEvents");
+const Store_1 = require("./Store");
+const findCircularDependencies_1 = require("./tools/findCircularDependencies");
+const errors_1 = require("./errors");
+const globalResources_1 = require("./globalResources");
+async function run(resource, config) {
+    const eventManager = new EventManager_1.EventManager();
+    const store = new Store_1.Store(eventManager);
+    const taskRunner = new TaskRunner_1.TaskRunner(store, eventManager);
+    const processor = new DependencyProcessor_1.DependencyProcessor(store, eventManager, taskRunner);
+    // In the registration phase we register deeply all the resources, tasks, middleware and events
+    store.initializeStore(resource, config);
+    store.storeGenericItem(globalResources_1.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();
+    const circularDependencies = (0, findCircularDependencies_1.findCircularDependencies)(dependentNodes);
+    if (circularDependencies.cycles.length > 0) {
+        throw errors_1.Errors.circularDependencies(circularDependencies.cycles);
+    }
+    await processor.processHooks();
+    // Now we can safely compute dependencies without being afraid of an infinite loop.
+    // The hooking part is done here.
+    await eventManager.emit(globalEvents_1.globalEvents.beforeInit);
+    await processor.computeAllDependencies();
+    // 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_1.globalEvents.afterInit);
+    return store.root.value;
+}
+//# sourceMappingURL=run.js.map

package/dist/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":";;AA2DA,kBAsCC;AAjGD,6CAA0C;AAU1C,+DAA4D;AAC5D,iDAA8C;AAC9C,iDAA8C;AAC9C,mCAAgC;AAChC,+EAA4E;AAC5E,qCAAkC;AAClC,uDAAoD;AA2C7C,KAAK,UAAU,GAAG,CACvB,QAAsB,EACtB,MAAU;IAEV,MAAM,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,aAAK,CAAC,YAAY,CAAC,CAAC;IACtC,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;IACvD,MAAM,SAAS,GAAG,IAAI,yCAAmB,CAAC,KAAK,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;IAE3E,+FAA+F;IAC/F,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACxC,KAAK,CAAC,gBAAgB,CAAC,iCAAe,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;IACpE,KAAK,CAAC,yBAAyB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAElD,kGAAkG;IAClG,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAG,IAAA,mDAAwB,EAAC,cAAc,CAAC,CAAC;IACtE,IAAI,oBAAoB,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,eAAM,CAAC,oBAAoB,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACjE,CAAC;IAED,MAAM,SAAS,CAAC,YAAY,EAAE,CAAC;IAE/B,mFAAmF;IACnF,iCAAiC;IACjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,UAAU,CAAC,CAAC;IAEjD,MAAM,SAAS,CAAC,sBAAsB,EAAE,CAAC;IAEzC,oEAAoE;IACpE,MAAM,SAAS,CAAC,gCAAgC,EAAE,CAAC;IAEnD,0CAA0C;IAC1C,MAAM,SAAS,CAAC,cAAc,EAAE,CAAC;IAEjC,MAAM,YAAY,CAAC,IAAI,CAAC,2BAAY,CAAC,SAAS,CAAC,CAAC;IAEhD,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;AAC1B,CAAC"}

package/dist/tools/findCircularDependencies.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A node that has dependencies.
+ */
+export interface IDependentNode {
+    id: string;
+    dependencies: Record<string, IDependentNode>;
+}
+interface FindCircularDependenciesResult {
+    cycles: string[];
+    missingDependencies: Array<{
+        nodeId: string;
+        dependencyId: string;
+    }>;
+}
+export declare function findCircularDependencies(nodes: IDependentNode[]): FindCircularDependenciesResult;
+export {};

package/dist/tools/findCircularDependencies.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCircularDependencies = findCircularDependencies;
+function findCircularDependencies(nodes) {
+    const result = {
+        cycles: [],
+        missingDependencies: [],
+    };
+    const visited = new Set();
+    const stack = new Set();
+    const path = [];
+    function dfs(node) {
+        if (stack.has(node.id)) {
+            const cycleStartIndex = path.indexOf(node.id);
+            const cycle = path.slice(cycleStartIndex).concat(node.id).join(" -> ");
+            result.cycles.push(cycle);
+            return;
+        }
+        if (visited.has(node.id))
+            return;
+        visited.add(node.id);
+        stack.add(node.id);
+        path.push(node.id);
+        if (node.dependencies && typeof node.dependencies === "object") {
+            for (const [depKey, dependentNode] of Object.entries(node.dependencies)) {
+                if (!dependentNode) {
+                    result.missingDependencies.push({
+                        nodeId: node.id,
+                        dependencyId: depKey,
+                    });
+                    continue;
+                }
+                dfs(dependentNode);
+            }
+        }
+        else {
+            result.missingDependencies.push({
+                nodeId: node.id,
+                dependencyId: "unknown",
+            });
+        }
+        stack.delete(node.id);
+        path.pop();
+    }
+    for (const node of nodes) {
+        if (!visited.has(node.id)) {
+            dfs(node);
+        }
+    }
+    result.cycles = Array.from(new Set(result.cycles)); // Remove duplicate cycles
+    return result;
+}
+//# sourceMappingURL=findCircularDependencies.js.map

package/dist/tools/findCircularDependencies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findCircularDependencies.js","sourceRoot":"","sources":["../../src/tools/findCircularDependencies.ts"],"names":[],"mappings":";;AAaA,4DAuDC;AAvDD,SAAgB,wBAAwB,CACtC,KAAuB;IAEvB,MAAM,MAAM,GAAmC;QAC7C,MAAM,EAAE,EAAE;QACV,mBAAmB,EAAE,EAAE;KACxB,CAAC;IACF,MAAM,OAAO,GAAgB,IAAI,GAAG,EAAE,CAAC;IACvC,MAAM,KAAK,GAAgB,IAAI,GAAG,EAAE,CAAC;IACrC,MAAM,IAAI,GAAa,EAAE,CAAC;IAE1B,SAAS,GAAG,CAAC,IAAoB;QAC/B,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YACvB,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC1B,OAAO;QACT,CAAC;QAED,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAAE,OAAO;QAEjC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACrB,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACnB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEnB,IAAI,IAAI,CAAC,YAAY,IAAI,OAAO,IAAI,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;YAC/D,KAAK,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;gBACxE,IAAI,CAAC,aAAa,EAAE,CAAC;oBACnB,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC;wBAC9B,MAAM,EAAE,IAAI,CAAC,EAAE;wBACf,YAAY,EAAE,MAAM;qBACrB,CAAC,CAAC;oBACH,SAAS;gBACX,CAAC;gBACD,GAAG,CAAC,aAAa,CAAC,CAAC;YACrB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC;gBAC9B,MAAM,EAAE,IAAI,CAAC,EAAE;gBACf,YAAY,EAAE,SAAS;aACxB,CAAC,CAAC;QACL,CAAC;QAED,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACtB,IAAI,CAAC,GAAG,EAAE,CAAC;IACb,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAC1B,GAAG,CAAC,IAAI,CAAC,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,0BAA0B;IAC9E,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@bluelibs/runner",
+  "version": "1.0.0",
+  "description": "BlueLibs Runner",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluelibs/bluelibs"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "pretest": "npm run build",
+    "test": "jest --verbose dist/__tests__/index.js",
+    "test:dev": "jest --verbose src/__tests__/index.ts --watch",
+    "coverage": "jest --verbose src/__tests__/index.ts --coverage",
+    "test:clean": "jest --clearCache",
+    "testonly": "npm test",
+    "test:ci": "npm run coverage -- --ci --maxWorkers=2  --reporters=default --reporters=jest-junit",
+    "coverage:upload": "codecov",
+    "prepublishOnly": "npm run build",
+    "typedoc": "typedoc",
+    "benchmark": "jest --testMatch=\"**/__tests__/benchmark/benchmark.test.ts\" --testTimeout 10000"
+  },
+  "devDependencies": {
+    "@types/benchmark": "^2.1.5",
+    "@types/graphql": "^0.11.3",
+    "@types/jest": "^27.0.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "2.3.0",
+    "@typescript-eslint/parser": "2.3.0",
+    "benchmark": "^2.1.4",
+    "eslint": "^6.6.0",
+    "eslint-config-prettier": "6.3.0",
+    "eslint-plugin-prettier": "3.1.1",
+    "jest": "^29.0.0",
+    "jest-junit": "^10.0.0",
+    "prettier": "^2.0.5",
+    "reflect-metadata": "^0.2.2",
+    "source-map-support": "^0.5.13",
+    "ts-jest": "^29.0.0",
+    "typedoc": "^0.26.7",
+    "typescript": "^5.6.2"
+  },
+  "typings": "dist/index.d.ts",
+  "typescript": {
+    "definition": "dist/index.d.ts"
+  },
+  "license": "MIT"
+}

package/src/DependencyProcessor.ts

@@ -0,0 +1,243 @@
+import {
+  DependencyMapType,
+  DependencyValuesType,
+  ITask,
+  IResource,
+  IHookDefinition,
+  IEventDefinition,
+} from "./defs";
+import { ResourceStoreElementType, Store } from "./Store";
+import * as utils from "./define";
+import { EventManager } from "./EventManager";
+import { ResourceInitializer } from "./ResourceInitializer";
+import { TaskRunner } from "./TaskRunner";
+import { Errors } from "./errors";
+
+/**
+ * This class is responsible of setting up dependencies with their respective computedValues.
+ * Note that all elements must have been previously registered otherwise errors will be thrown
+ * when trying to depend on something not in the store.
+ */
+export class DependencyProcessor {
+  protected readonly resourceInitializer: ResourceInitializer;
+
+  constructor(
+    protected readonly store: Store,
+    protected readonly eventManager: EventManager,
+    protected readonly taskRunner: TaskRunner
+  ) {
+    this.resourceInitializer = new ResourceInitializer(store, eventManager);
+  }
+
+  /**
+   * This function is going to go through all the resources, tasks and middleware to compute their required dependencies.
+   */
+  async computeAllDependencies() {
+    for (const middleware of this.store.middlewares.values()) {
+      const deps = middleware.middleware.dependencies as DependencyMapType;
+      middleware.computedDependencies = await this.extractDependencies(deps);
+    }
+
+    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
+            );
+          }
+        );
+      }
+    }
+
+    for (const resource of this.store.resources.values()) {
+      await this.processResourceDependencies(resource);
+    }
+  }
+
+  // Most likely these are resources that no-one has dependencies towards
+  // We need to ensure they work too!
+  public async initializeUninitializedResources() {
+    for (const resource of this.store.resources.values()) {
+      if (
+        resource.isInitialized === false &&
+        // The root is the last one to be initialized and is done in a separate process.
+        resource.resource.id !== this.store.root.resource.id
+      ) {
+        await this.processResourceDependencies(resource);
+        resource.value = await this.resourceInitializer.initializeResource(
+          resource.resource,
+          resource.config,
+          resource.computedDependencies as DependencyValuesType<{}>
+        );
+      }
+    }
+  }
+
+  /**
+   * Processes dependencies and hooks
+   * @param resource
+   */
+  protected async processResourceDependencies(
+    resource: ResourceStoreElementType<any, any, {}>
+  ) {
+    const deps = resource.resource.dependencies as DependencyMapType;
+    resource.computedDependencies = await this.extractDependencies(deps);
+  }
+
+  public async initializeRoot() {
+    const storeResource = this.store.root;
+
+    storeResource.value = await this.resourceInitializer.initializeResource(
+      storeResource.resource,
+      storeResource.config,
+      // They are already computed
+      storeResource.computedDependencies as DependencyValuesType<{}>
+    );
+
+    storeResource.isInitialized = true;
+  }
+
+  /**
+   * Processes all hooks, should run before emission of any event.
+   * @returns
+   */
+  public processHooks() {
+    // iterate through resources and send them to processHooks
+    for (const resource of this.store.resources.values()) {
+      if (resource.resource.hooks) {
+        this.processHooksForResource(resource);
+      }
+    }
+  }
+
+  /**
+   * Processes the hooks for resources
+   * @param hooks
+   * @param deps
+   */
+  public processHooksForResource(
+    resourceStoreElement: ResourceStoreElementType<any, any, {}>
+  ) {
+    let hooks = resourceStoreElement.resource.hooks;
+    if (typeof hooks === "function") {
+      hooks = hooks(resourceStoreElement.config);
+    }
+
+    if (hooks.length === 0) {
+      return;
+    }
+
+    for (const hook of hooks) {
+      const event = hook.event;
+      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<{}>
+        );
+      });
+    }
+  }
+
+  async extractDependencies<T extends DependencyMapType>(
+    map: T
+  ): Promise<DependencyValuesType<T>> {
+    const object = {} as DependencyValuesType<T>;
+
+    for (const key in map) {
+      object[key] = await this.extractDependency(map[key]);
+    }
+
+    return object;
+  }
+
+  async extractDependency(object) {
+    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);
+    } else {
+      throw Errors.unknownItemType(object);
+    }
+  }
+
+  /**
+   * Converts the event into a running functions with real inputs
+   * @param object
+   * @returns
+   */
+  extractEventDependency(object: IEventDefinition<Record<string, any>>) {
+    return async (input) => {
+      return this.eventManager.emit(object, input);
+    };
+  }
+
+  async extractTaskDependency(object: ITask<any, any, {}>) {
+    const storeTask = this.store.tasks.get(object.id);
+    if (storeTask === undefined) {
+      throw Errors.dependencyNotFound(`Task ${object.id}`);
+    }
+
+    if (!storeTask.isInitialized) {
+      storeTask.isInitialized = true;
+
+      // it's sanitised
+      const dependencies = object.dependencies as DependencyMapType;
+
+      storeTask.computedDependencies = await this.extractDependencies(
+        dependencies
+      );
+    }
+
+    return (input) => {
+      return this.taskRunner.run(
+        storeTask.task,
+        input,
+        storeTask.computedDependencies
+      );
+    };
+  }
+
+  async extractResourceDependency(object: IResource<any, any, any>) {
+    // check if it exists in the store with the value
+    const storeResource = this.store.resources.get(object.id);
+    if (storeResource === undefined) {
+      throw Errors.dependencyNotFound(`Resource ${object.id}`);
+    }
+
+    const { resource, config } = storeResource;
+    if (storeResource.isInitialized) {
+      return storeResource.value;
+    } else {
+      // we need to initialize the resource
+      storeResource.isInitialized = true;
+
+      // check if it has an initialisation function that provides the value
+      if (resource.init) {
+        storeResource.value = await this.resourceInitializer.initializeResource(
+          resource,
+          config,
+          await this.extractDependencies(resource.dependencies || {})
+        );
+      }
+    }
+
+    return storeResource.value;
+  }
+}

package/src/EventManager.ts

@@ -0,0 +1,84 @@
+import { EventHandlerType, IEvent, IEventDefinition } from "./defs";
+
+const HandlerOptionsDefaults = { order: 0 };
+
+interface IListenerStorage {
+  order: number;
+  filter?: (event: IEvent<any>) => boolean;
+  handler: EventHandlerType;
+}
+
+export interface IEventHandlerOptions<T = any> {
+  order?: number;
+  filter?: (event: IEvent<T>) => boolean;
+}
+
+export class EventManager {
+  private listeners: Map<string, IListenerStorage[]> = new Map();
+  private globalListeners: IListenerStorage[] = [];
+
+  async emit<TInput>(
+    eventDefinition: IEventDefinition<TInput>,
+    ...args: TInput extends void ? [] : [TInput]
+  ): Promise<void> {
+    const data = args[0];
+    const eventListeners = this.listeners.get(eventDefinition.id) || [];
+    const allListeners = this.sortListeners([
+      ...eventListeners,
+      ...this.globalListeners,
+    ]);
+
+    const event: IEvent = {
+      id: eventDefinition.id,
+      data,
+    };
+
+    for (const listener of allListeners) {
+      const ok = !listener.filter || listener.filter(event);
+      if (ok) {
+        await listener.handler(event);
+      }
+    }
+  }
+
+  addListener<T>(
+    event: IEventDefinition | Array<IEventDefinition>,
+    handler: EventHandlerType<T>,
+    options: IEventHandlerOptions<T> = HandlerOptionsDefaults
+  ): void {
+    if (Array.isArray(event)) {
+      event.forEach((id) => this.addListener(id, handler, options));
+    } else {
+      const eventId = event.id;
+      const listeners = this.listeners.get(eventId) || [];
+      const newListener: IListenerStorage = {
+        handler,
+        order: options.order || 0,
+        filter: options.filter,
+      };
+
+      const newListeners = this.sortListeners([...listeners, newListener]);
+      this.listeners.set(eventId, newListeners);
+    }
+  }
+
+  addGlobalListener(
+    handler: EventHandlerType,
+    options: IEventHandlerOptions = HandlerOptionsDefaults
+  ): void {
+    const newListener: IListenerStorage = {
+      handler,
+      order: options.order || 0,
+      filter: options.filter,
+    };
+
+    this.globalListeners = this.sortListeners([
+      ...this.globalListeners,
+      newListener,
+    ]);
+  }
+
+  private sortListeners(listeners: IListenerStorage[]): IListenerStorage[] {
+    return [...listeners].sort((a, b) => a.order - b.order);
+  }
+}

package/src/ResourceInitializer.ts

@@ -0,0 +1,69 @@
+import {
+  DependencyMapType,
+  DependencyValuesType,
+  ITask,
+  IResource,
+} from "./defs";
+import { EventManager } from "./EventManager";
+import { globalEvents } from "./globalEvents";
+import { Store } from "./Store";
+
+export class ResourceInitializer {
+  constructor(
+    protected readonly store: Store,
+    protected readonly eventManager: EventManager
+  ) {}
+
+  /**
+   * 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
+   */
+  public async initializeResource<
+    TConfig = null,
+    TValue = any,
+    TDeps extends DependencyMapType = {}
+  >(
+    resource: IResource<TConfig, TValue, TDeps>,
+    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 });
+
+    let error, value;
+    try {
+      if (resource.init) {
+        value = await resource.init(config, dependencies);
+      }
+
+      await this.eventManager.emit(resource.events.afterInit, {
+        config,
+        value,
+      });
+      await this.eventManager.emit(globalEvents.resources.afterInit, {
+        config,
+        resource,
+        value,
+      });
+
+      return value;
+    } catch (e) {
+      error = e;
+
+      // If you want to rewthrow the error, this should be done inside the onError event.
+      await this.eventManager.emit(resource.events.onError, { error });
+      await this.eventManager.emit(globalEvents.resources.onError, {
+        error,
+        resource,
+      });
+
+      throw e;
+    }
+  }
+}