@bluelibs/runner 2.2.3 → 3.0.0

package/src/models/StoreRegistry.ts

@@ -0,0 +1,217 @@
+import {
+  DependencyMapType,
+  IMiddlewareDefinition,
+  IEventDefinition,
+  IResource,
+  ITask,
+  IResourceWithConfig,
+  RegisterableItems,
+  IMiddleware,
+  symbolMiddlewareEverywhereResources,
+  symbolMiddlewareEverywhereTasks,
+} from "../defs";
+import * as utils from "../define";
+import { Errors } from "../errors";
+import { 
+  TaskStoreElementType, 
+  MiddlewareStoreElementType, 
+  ResourceStoreElementType, 
+  EventStoreElementType 
+} from "./StoreTypes";
+import { StoreValidator } from "./StoreValidator";
+
+export class StoreRegistry {
+  public tasks: Map<string, TaskStoreElementType> = new Map();
+  public resources: Map<string, ResourceStoreElementType> = new Map();
+  public events: Map<string, EventStoreElementType> = new Map();
+  public middlewares: Map<string, MiddlewareStoreElementType> = new Map();
+
+  private validator: StoreValidator;
+
+  constructor() {
+    this.validator = new StoreValidator(this.tasks, this.resources, this.events, this.middlewares);
+  }
+
+  getValidator(): StoreValidator {
+    return this.validator;
+  }
+
+  storeGenericItem<C>(item: RegisterableItems) {
+    if (utils.isTask(item)) {
+      this.storeTask<C>(item);
+    } else if (utils.isResource(item)) {
+      this.storeResource<C>(item);
+    } else if (utils.isEvent(item)) {
+      this.storeEvent<C>(item);
+    } else if (utils.isMiddleware(item)) {
+      this.storeMiddleware<C>(item);
+    } else if (utils.isResourceWithConfig(item)) {
+      this.storeResourceWithConfig<C>(item);
+    } else {
+      throw Errors.unknownItemType(item);
+    }
+  }
+
+  storeMiddleware<C>(item: IMiddleware<any>, check = true) {
+    check && this.validator.checkIfIDExists(item.id);
+
+    item.dependencies =
+      typeof item.dependencies === "function"
+        ? item.dependencies()
+        : item.dependencies;
+
+    this.middlewares.set(item.id, {
+      middleware: item,
+      computedDependencies: {},
+    });
+  }
+
+  storeEvent<C>(item: IEventDefinition<void>) {
+    this.validator.checkIfIDExists(item.id);
+    this.events.set(item.id, { event: item });
+  }
+
+  storeResourceWithConfig<C>(
+    item: IResourceWithConfig<any, any, any>,
+    check = true
+  ) {
+    check && this.validator.checkIfIDExists(item.resource.id);
+
+    this.prepareResource(item.resource, item.config);
+
+    this.resources.set(item.resource.id, {
+      resource: item.resource,
+      config: item.config,
+      value: undefined,
+      isInitialized: false,
+      context: {},
+    });
+
+    this.computeRegistrationDeeply(item.resource, item.config);
+    return item.resource;
+  }
+
+  computeRegistrationDeeply<C>(element: IResource<C>, config?: C) {
+    const items =
+      typeof element.register === "function"
+        ? element.register(config as C)
+        : element.register;
+
+    // if it was a computed function ensure the registered terms are stored, not the function.
+    element.register = items;
+
+    for (const item of items) {
+      // will call registration if it detects another resource.
+      this.storeGenericItem<C>(item);
+    }
+  }
+
+  storeResource<C>(item: IResource<any, any, any>, check = true) {
+    check && this.validator.checkIfIDExists(item.id);
+
+    this.prepareResource(item, {});
+
+    this.resources.set(item.id, {
+      resource: item,
+      config: {},
+      value: undefined,
+      isInitialized: false,
+      context: item.context?.() || {},
+    });
+
+    this.computeRegistrationDeeply(item, {});
+    return item;
+  }
+
+  storeTask<C>(item: ITask<any, any, {}>, check = true) {
+    check && this.validator.checkIfIDExists(item.id);
+
+    item.dependencies =
+      typeof item.dependencies === "function"
+        ? item.dependencies()
+        : item.dependencies;
+
+    this.tasks.set(item.id, {
+      task: item,
+      computedDependencies: {},
+      isInitialized: false,
+    });
+  }
+
+  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);
+    }
+  }
+
+  getEverywhereMiddlewareForTasks(excludingIds: string[]): IMiddleware[] {
+    return Array.from(this.middlewares.values())
+      .filter((x) => x.middleware[symbolMiddlewareEverywhereTasks])
+      .filter((x) => !excludingIds.includes(x.middleware.id))
+      .map((x) => x.middleware);
+  }
+
+  getEverywhereMiddlewareForResources(excludingIds: string[]): IMiddleware[] {
+    return Array.from(this.middlewares.values())
+      .filter((x) => x.middleware[symbolMiddlewareEverywhereResources])
+      .filter((x) => !excludingIds.includes(x.middleware.id))
+      .map((x) => x.middleware);
+  }
+
+  private prepareResource<C>(
+    item: IResource<any, any, any>,
+    config: any
+  ): IResource<any, any, any> {
+    item.dependencies =
+      typeof item.dependencies === "function"
+        ? item.dependencies(config)
+        : item.dependencies;
+
+    return item;
+  }
+
+  private middlewareAsMap(middleware: IMiddlewareDefinition[]) {
+    return middleware.reduce((acc, item) => {
+      acc[item.id] = item;
+      return acc;
+    }, {} as Record<string, IMiddlewareDefinition>);
+  }
+
+  getDependentNodes() {
+    const depenedants: any[] = [];
+    for (const task of this.tasks.values()) {
+      depenedants.push({
+        id: task.task.id,
+        dependencies: {
+          ...task.task.dependencies,
+          ...this.middlewareAsMap(task.task.middleware),
+        },
+      });
+    }
+    for (const middleware of this.middlewares.values()) {
+      depenedants.push({
+        id: middleware.middleware.id,
+        dependencies: middleware.middleware.dependencies,
+      });
+    }
+    for (const resource of this.resources.values()) {
+      depenedants.push({
+        id: resource.resource.id,
+        dependencies: {
+          ...resource.resource.dependencies,
+          ...this.middlewareAsMap(resource.resource.middleware),
+        },
+      });
+    }
+
+    return depenedants;
+  }
+}

package/src/models/StoreTypes.ts

@@ -0,0 +1,46 @@
+import {
+  DependencyMapType,
+  DependencyValuesType,
+  IMiddlewareDefinition,
+  IEventDefinition,
+  IResource,
+  ITask,
+  IResourceWithConfig,
+  RegisterableItems,
+  IMiddleware,
+} from "../defs";
+
+export type ResourceStoreElementType<
+  C = any,
+  V = any,
+  D extends DependencyMapType = {},
+  TContext = any
+> = {
+  resource: IResource<C, V, D>;
+  computedDependencies?: DependencyValuesType<D>;
+  config: C;
+  value: V;
+  context: TContext;
+  isInitialized?: boolean;
+};
+
+export type TaskStoreElementType<
+  Input = any,
+  Output extends Promise<any> = any,
+  D extends DependencyMapType = any,
+  TOn extends "*" | IEventDefinition | undefined = any
+> = {
+  task: ITask<Input, Output, D, TOn>;
+  computedDependencies: DependencyValuesType<D>;
+  isInitialized: boolean;
+};
+
+export type MiddlewareStoreElementType<TDeps extends DependencyMapType = any> =
+  {
+    middleware: IMiddleware<TDeps>;
+    computedDependencies: DependencyValuesType<TDeps>;
+  };
+
+export type EventStoreElementType = {
+  event: IEventDefinition;
+};

package/src/models/StoreValidator.ts

@@ -0,0 +1,38 @@
+import { Errors } from "../errors";
+import { TaskStoreElementType, MiddlewareStoreElementType, ResourceStoreElementType, EventStoreElementType } from "./StoreTypes";
+
+export class StoreValidator {
+  constructor(
+    private tasks: Map<string, TaskStoreElementType>,
+    private resources: Map<string, ResourceStoreElementType>,
+    private events: Map<string, EventStoreElementType>,
+    private middlewares: Map<string, MiddlewareStoreElementType>
+  ) {}
+
+  checkIfIDExists(id: string): void | never {
+    if (this.tasks.has(id)) {
+      throw Errors.duplicateRegistration("Task", id);
+    }
+    if (this.resources.has(id)) {
+      throw Errors.duplicateRegistration("Resource", id);
+    }
+    if (this.events.has(id)) {
+      throw Errors.duplicateRegistration("Event", id);
+    }
+    if (this.middlewares.has(id)) {
+      throw Errors.duplicateRegistration("Middleware", id);
+    }
+  }
+
+  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}`
+          );
+        }
+      });
+    }
+  }
+}

package/src/models/TaskRunner.ts

@@ -1,12 +1,9 @@
 import { DependencyMapType, DependencyValuesType, ITask } from "../defs";
 import { Errors } from "../errors";
 import { EventManager } from "./EventManager";
-import { globalEvents } from "../globalEvents";
-import {
-  MiddlewareStoreElementType,
-  Store,
-  TaskStoreElementType,
-} from "./Store";
+import { globalEvents } from "../globals/globalEvents";
+import { Store } from "./Store";
+import { MiddlewareStoreElementType } from "./StoreTypes";
 import { Logger } from "./Logger";
 
 export class TaskRunner {
@@ -68,12 +65,24 @@ export class TaskRunner {
     let error;
     try {
       // craft the next function starting from the first next function
-      const output = await runner(input);
-
+      const result = {
+        output: await runner(input),
+      };
+      const setOutput = (newOutput: any) => {
+        result.output = newOutput;
+      };
+
+      // If it's a global event listener, we stop emitting so we don't get into an infinite loop.
       if (!isGlobalEventListener) {
         await this.eventManager.emit(
           task.events.afterRun,
-          { input, output },
+          {
+            input,
+            get output() {
+              return result.output;
+            },
+            setOutput,
+          },
           task.id
         );
       }
@@ -83,18 +92,22 @@ export class TaskRunner {
         task.on !== globalEvents.tasks.beforeRun &&
         task.on !== globalEvents.tasks.afterRun
       ) {
+        // If it's a lifecycle listener we prevent from emitting further events.
         await this.eventManager.emit(
           globalEvents.tasks.afterRun,
           {
             task,
             input,
-            output,
+            get output() {
+              return result.output;
+            },
+            setOutput,
           },
           task.id
         );
       }
 
-      return output;
+      return result.output;
     } catch (e) {
       let isSuppressed = false;
       function suppress() {
@@ -136,46 +149,46 @@ export class TaskRunner {
     TDeps extends DependencyMapType
   >(task: ITask<TInput, TOutput, TDeps>) {
     const storeTask = this.store.tasks.get(task.id);
-    // this is the final next()
-    let next = async (input) => {
-      this.logger.debug(
-        {
-          message: `Running task ${task.id}`,
-          input,
-        },
-        task.id
-      );
 
+    // this is the final next()
+    let next = async (input: any) => {
       return task.run.call(null, input, storeTask?.computedDependencies as any);
     };
 
     const existingMiddlewares = task.middleware;
     const createdMiddlewares = [
-      ...this.store.getGlobalMiddlewares(existingMiddlewares.map((x) => x.id)),
+      ...this.store.getEverywhereMiddlewareForTasks(
+        existingMiddlewares.map((x) => x.id)
+      ),
       ...existingMiddlewares,
     ];
 
-    if (createdMiddlewares.length > 0) {
-      // we need to run the middleware in reverse order
-      // so we can chain the next function
-      for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
-        const middleware = createdMiddlewares[i];
-        const storeMiddleware = this.store.middlewares.get(
-          middleware.id
-        ) as MiddlewareStoreElementType; // we know it exists because at this stage all sanity checks have been done.
-
-        const nextFunction = next;
-        next = async (input) => {
-          return storeMiddleware.middleware.run(
-            {
-              taskDefinition: task as any,
+    if (createdMiddlewares.length === 0) {
+      return next;
+    }
+
+    // we need to run the middleware in reverse order
+    // so we can chain the next function
+    for (let i = createdMiddlewares.length - 1; i >= 0; i--) {
+      const middleware = createdMiddlewares[i];
+      const storeMiddleware = this.store.middlewares.get(
+        middleware.id
+      ) as MiddlewareStoreElementType; // we know it exists because at this stage all sanity checks have been done.
+
+      const nextFunction = next;
+      next = async (input) => {
+        return storeMiddleware.middleware.run(
+          {
+            task: {
+              definition: task as any,
               input,
-              next: nextFunction,
             },
-            storeMiddleware.computedDependencies
-          );
-        };
-      }
+            next: nextFunction,
+          },
+          storeMiddleware.computedDependencies,
+          middleware.config
+        );
+      };
     }
 
     return next;

package/src/models/index.ts

@@ -3,3 +3,6 @@ export * from "./EventManager";
 export * from "./Logger";
 export * from "./Store";
 export * from "./TaskRunner";
+export * from "./ResourceInitializer";
+export * from "./Semaphore";
+export * from "./Queue";

package/src/run.ts

@@ -10,11 +10,11 @@ import {
 } from "./defs";
 import { DependencyProcessor } from "./models/DependencyProcessor";
 import { EventManager } from "./models/EventManager";
-import { globalEvents } from "./globalEvents";
+import { globalEvents } from "./globals/globalEvents";
 import { Store } from "./models/Store";
 import { findCircularDependencies } from "./tools/findCircularDependencies";
 import { Errors } from "./errors";
-import { globalResources } from "./globalResources";
+import { globalResources } from "./globals/globalResources";
 import { Logger } from "./models/Logger";
 
 export type ResourcesStoreElementType<
@@ -55,7 +55,7 @@ export type RunnerState = {
 export async function run<C, V>(
   resource: IResource<C, V>,
   config?: C
-): Promise<V> {
+): Promise<{ value: V; dispose: () => Promise<void> }> {
   const eventManager = new EventManager();
 
   // ensure for logger, that it can be used only after: computeAllDependencies() has executed
@@ -106,5 +106,8 @@ export async function run<C, V>(
   // disallow manipulation or attaching more
   store.lock();
 
-  return store.root.value;
+  return {
+    value: store.root.value,
+    dispose: () => store.dispose(),
+  };
 }

package/src/__tests__/index.ts

@@ -1,15 +0,0 @@
-import "./models/EventManager.test";
-import "./models/ResourceInitializer.test";
-import "./models/TaskRunner.test";
-import "./models/Store.test";
-import "./models/Logger.test";
-
-import "./tools/findCircularDependencies.test";
-import "./tools/getCallerFile.test";
-
-import "./run.test";
-import "./run.overrides.test";
-import "./run.middleware.test";
-import "./globalEvents.test";
-import "./errors.test";
-import "./typesafety.test";

package/src/examples/express-mongo/index.ts

@@ -1 +0,0 @@
-// TODO