@bluelibs/runner 3.4.2 → 4.0.1

package/src/models/DependencyProcessor.ts

@@ -1,257 +0,0 @@
-import {
-  DependencyMapType,
-  DependencyValuesType,
-  ITask,
-  IResource,
-  IEventDefinition,
-  IEvent,
-  IEventEmission,
-} from "../defs";
-import { Store } from "./Store";
-import { ResourceStoreElementType, TaskStoreElementType } from "./StoreTypes";
-import * as utils from "../define";
-import { EventManager } from "./EventManager";
-import { ResourceInitializer } from "./ResourceInitializer";
-import { TaskRunner } from "./TaskRunner";
-import {
-  DependencyNotFoundError,
-  EventNotFoundError,
-  UnknownItemTypeError,
-} from "../errors";
-import { Logger } from "./Logger";
-
-/**
- * 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,
-    protected readonly logger: Logger
-  ) {
-    this.resourceInitializer = new ResourceInitializer(
-      store,
-      eventManager,
-      logger
-    );
-  }
-
-  /**
-   * 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,
-        middleware.middleware.id
-      );
-    }
-
-    for (const task of this.store.tasks.values()) {
-      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
-    );
-  }
-
-  // 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);
-        const { value, context } =
-          await this.resourceInitializer.initializeResource(
-            resource.resource,
-            resource.config,
-            resource.computedDependencies as DependencyValuesType<{}>
-          );
-        resource.context = context;
-        resource.value = value;
-      }
-    }
-  }
-
-  /**
-   * 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,
-      resource.resource.id
-    );
-  }
-
-  public async initializeRoot() {
-    const storeResource = this.store.root;
-
-    const { value, context } =
-      await this.resourceInitializer.initializeResource(
-        storeResource.resource,
-        storeResource.config,
-        // They are already computed
-        storeResource.computedDependencies as DependencyValuesType<{}>
-      );
-
-    storeResource.context = context;
-    storeResource.value = value;
-    storeResource.isInitialized = true;
-  }
-
-  /**
-   * Processes all hooks, should run before emission of any event.
-   */
-  public attachListeners() {
-    for (const task of this.store.tasks.values()) {
-      if (task.task.on) {
-        let eventDefinition = task.task.on;
-
-        const handler = async (receivedEvent: IEventEmission<any>) => {
-          if (receivedEvent.source === task.task.id) {
-            // we don't want to trigger the same task that emitted the event
-            // process.exit(0);
-            return;
-          }
-
-          return this.taskRunner.run(task.task, receivedEvent);
-        };
-
-        if (eventDefinition === "*") {
-          this.eventManager.addGlobalListener(handler, {
-            order: task.task.listenerOrder || 0,
-          });
-        } else {
-          if (this.store.events.get(eventDefinition.id) === undefined) {
-            throw new EventNotFoundError(eventDefinition.id);
-          }
-          this.eventManager.addListener(eventDefinition, handler, {
-            order: task.task.listenerOrder || 0,
-          });
-        }
-      }
-    }
-  }
-
-  async extractDependencies<T extends DependencyMapType>(
-    map: T,
-    source: string | symbol
-  ): Promise<DependencyValuesType<T>> {
-    const object = {} as DependencyValuesType<T>;
-
-    for (const key in map) {
-      object[key] = await this.extractDependency(map[key], source);
-    }
-
-    return object;
-  }
-
-  async extractDependency(object: any, source: string | symbol) {
-    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, source);
-    } else {
-      throw new UnknownItemTypeError(object);
-    }
-  }
-
-  /**
-   * Converts the event into a running functions with real inputs
-   * @param object
-   * @returns
-   */
-  extractEventDependency(object: IEvent<any>, source: string | symbol) {
-    return async (input: any) => {
-      return this.eventManager.emit(object, input, source);
-    };
-  }
-
-  async extractTaskDependency(object: ITask<any, any, {}>) {
-    const storeTask = this.store.tasks.get(object.id);
-    if (storeTask === undefined) {
-      throw new DependencyNotFoundError(`Task ${object.id.toString()}`);
-    }
-
-    if (!storeTask.isInitialized) {
-      storeTask.isInitialized = true;
-
-      // it's sanitised
-      const dependencies = object.dependencies as DependencyMapType;
-
-      storeTask.computedDependencies = await this.extractDependencies(
-        dependencies,
-        storeTask.task.id
-      );
-    }
-
-    return (input: any) => {
-      return this.taskRunner.run(storeTask.task, input);
-    };
-  }
-
-  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 new DependencyNotFoundError(`Resource ${object.id.toString()}`);
-    }
-
-    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) {
-        const { value, context } =
-          await this.resourceInitializer.initializeResource(
-            resource,
-            config,
-            await this.extractDependencies(
-              resource.dependencies || {},
-              resource.id
-            )
-          );
-
-        storeResource.context = context;
-        storeResource.value = value;
-      }
-    }
-
-    return storeResource.value;
-  }
-}

package/src/models/EventManager.ts

@@ -1,210 +0,0 @@
-import {
-  EventHandlerType,
-  IEvent,
-  IEventDefinition,
-  IEventEmission,
-} from "../defs";
-import { LockedError, ValidationError } from "../errors";
-import { Logger } from "./Logger";
-
-const HandlerOptionsDefaults = { order: 0 };
-
-interface IListenerStorage {
-  order: number;
-  filter?: (event: IEventEmission<any>) => boolean;
-  handler: EventHandlerType;
-}
-
-export interface IEventHandlerOptions<T = any> {
-  order?: number;
-  filter?: (event: IEventEmission<T>) => boolean;
-  /**
-   * Represents the listener ID. Use this to avoid a listener calling himself.
-   */
-  id?: string;
-}
-
-export class EventManager {
-  private listeners: Map<string | symbol, IListenerStorage[]> = new Map();
-  private globalListeners: IListenerStorage[] = [];
-  private cachedMergedListeners: Map<string | symbol, IListenerStorage[]> =
-    new Map();
-  private globalListenersCacheValid = true;
-  #isLocked = false;
-
-  get isLocked() {
-    return this.#isLocked;
-  }
-
-  lock() {
-    this.#isLocked = true;
-  }
-
-  checkLock() {
-    if (this.#isLocked) {
-      throw new LockedError("EventManager");
-    }
-  }
-
-  private mergeSortedListeners(
-    a: IListenerStorage[],
-    b: IListenerStorage[]
-  ): IListenerStorage[] {
-    const result: IListenerStorage[] = [];
-    let i = 0,
-      j = 0;
-    while (i < a.length && j < b.length) {
-      if (a[i].order <= b[j].order) {
-        result.push(a[i++]);
-      } else {
-        result.push(b[j++]);
-      }
-    }
-    while (i < a.length) result.push(a[i++]);
-    while (j < b.length) result.push(b[j++]);
-    return result;
-  }
-
-  private getCachedMergedListeners(
-    eventId: string | symbol
-  ): IListenerStorage[] {
-    if (!this.globalListenersCacheValid) {
-      this.cachedMergedListeners.clear();
-      this.globalListenersCacheValid = true;
-    }
-
-    let cached = this.cachedMergedListeners.get(eventId);
-    if (!cached) {
-      const eventListeners = this.listeners.get(eventId) || [];
-      if (eventListeners.length === 0 && this.globalListeners.length === 0) {
-        cached = [];
-      } else if (eventListeners.length === 0) {
-        cached = this.globalListeners;
-      } else if (this.globalListeners.length === 0) {
-        cached = eventListeners;
-      } else {
-        cached = this.mergeSortedListeners(
-          eventListeners,
-          this.globalListeners
-        );
-      }
-      this.cachedMergedListeners.set(eventId, cached);
-    }
-    return cached;
-  }
-
-  private invalidateCache(eventId?: string | symbol): void {
-    if (eventId) {
-      this.cachedMergedListeners.delete(eventId);
-    } else {
-      this.globalListenersCacheValid = false;
-    }
-  }
-
-  async emit<TInput>(
-    eventDefinition: IEvent<TInput>,
-    data: TInput,
-    source: string | symbol
-  ): Promise<void> {
-    // Validate payload with schema if provided
-    if (eventDefinition.payloadSchema) {
-      try {
-        data = eventDefinition.payloadSchema.parse(data);
-      } catch (error) {
-        throw new ValidationError("Event payload", eventDefinition.id, error instanceof Error ? error : new Error(String(error)));
-      }
-    }
-    
-    const allListeners = this.getCachedMergedListeners(eventDefinition.id);
-
-    if (allListeners.length === 0) {
-      return;
-    }
-
-    let propagationStopped = false;
-
-    const event: IEventEmission = {
-      id: eventDefinition.id,
-      data,
-      timestamp: new Date(),
-      source,
-      meta: eventDefinition.meta || {},
-      stopPropagation: () => {
-        propagationStopped = true;
-      },
-      isPropagationStopped: () => propagationStopped,
-    };
-
-    for (const listener of allListeners) {
-      if (propagationStopped) {
-        break;
-      }
-
-      if (!listener.filter || listener.filter(event)) {
-        await listener.handler(event);
-      }
-    }
-  }
-
-  private insertListener(
-    listeners: IListenerStorage[],
-    newListener: IListenerStorage
-  ): void {
-    let low = 0;
-    let high = listeners.length;
-    while (low < high) {
-      const mid = (low + high) >>> 1;
-      if (listeners[mid].order < newListener.order) {
-        low = mid + 1;
-      } else {
-        high = mid;
-      }
-    }
-    listeners.splice(low, 0, newListener);
-  }
-
-  addListener<T>(
-    event: IEvent<T> | Array<IEvent<T>>,
-    handler: EventHandlerType<T>,
-    options: IEventHandlerOptions<T> = HandlerOptionsDefaults
-  ): void {
-    this.checkLock();
-    const newListener: IListenerStorage = {
-      handler,
-      order: options.order || 0,
-      filter: options.filter,
-    };
-
-    if (Array.isArray(event)) {
-      event.forEach((id) => this.addListener(id, handler, options));
-    } else {
-      const eventId = event.id;
-      const listeners = this.listeners.get(eventId);
-      if (listeners) {
-        this.insertListener(listeners, newListener);
-      } else {
-        this.listeners.set(eventId, [newListener]);
-      }
-      this.invalidateCache(eventId);
-    }
-  }
-
-  addGlobalListener(
-    handler: EventHandlerType,
-    options: IEventHandlerOptions = HandlerOptionsDefaults
-  ): void {
-    this.checkLock();
-    const newListener: IListenerStorage = {
-      handler,
-      order: options.order || 0,
-      filter: options.filter,
-    };
-    this.insertListener(this.globalListeners, newListener);
-    this.invalidateCache();
-  }
-
-  hasListeners<T>(eventDefinition: IEvent<T>): boolean {
-    const eventListeners = this.listeners.get(eventDefinition.id) || [];
-    return eventListeners.length > 0 || this.globalListeners.length > 0;
-  }
-}