@bluelibs/runner 1.0.0

package/src/index.ts

@@ -0,0 +1,28 @@
+import {
+  defineTask,
+  defineResource,
+  defineEvent,
+  defineMiddleware,
+} from "./define";
+import { globalEvents } from "./globalEvents";
+import { globalResources } from "./globalResources";
+import { run } from "./run";
+
+const globals = {
+  events: globalEvents,
+  resources: globalResources,
+};
+
+export { globals };
+export {
+  defineTask as task,
+  defineResource as resource,
+  defineEvent as event,
+  defineMiddleware as middleware,
+  run,
+};
+
+export * as definitions from "./defs";
+export { Store } from "./Store";
+export { EventManager } from "./EventManager";
+export { TaskRunner } from "./TaskRunner";

package/src/run.ts

@@ -0,0 +1,98 @@
+import { TaskRunner } from "./TaskRunner";
+import {
+  DependencyMapType,
+  ITaskDefinition,
+  IResourceDefinintion,
+  IEventDefinition,
+  IMiddlewareDefinition,
+  DependencyValuesType,
+  IResource,
+} from "./defs";
+import { DependencyProcessor } from "./DependencyProcessor";
+import { EventManager } from "./EventManager";
+import { globalEvents } from "./globalEvents";
+import { Store } from "./Store";
+import { findCircularDependencies } from "./tools/findCircularDependencies";
+import { Errors } from "./errors";
+import { globalResources } from "./globalResources";
+
+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 async function run<C, V>(
+  resource: IResource<C>,
+  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);
+
+  // In the registration phase we register deeply all the resources, tasks, middleware and events
+  store.initializeStore(resource, config);
+  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();
+  const circularDependencies = findCircularDependencies(dependentNodes);
+  if (circularDependencies.cycles.length > 0) {
+    throw 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.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.afterInit);
+
+  return store.root.value;
+}

package/src/tools/findCircularDependencies.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 function findCircularDependencies(
+  nodes: IDependentNode[]
+): FindCircularDependenciesResult {
+  const result: FindCircularDependenciesResult = {
+    cycles: [],
+    missingDependencies: [],
+  };
+  const visited: Set<string> = new Set();
+  const stack: Set<string> = new Set();
+  const path: string[] = [];
+
+  function dfs(node: IDependentNode): void {
+    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;
+}