@bluelibs/runner 3.4.2 → 4.0.1

package/src/models/Semaphore.ts

@@ -1,208 +0,0 @@
-interface WaitingOperation {
-  resolve: () => void;
-  reject: (error: Error) => void;
-  timeout?: NodeJS.Timeout;
-  abortController?: AbortController;
-}
-
-/**
- * A semaphore that limits the number of concurrent operations.
- * Used to prevent connection pool exhaustion by limiting concurrent
- * database operations to the pool size.
- */
-export class Semaphore {
-  private permits: number;
-  private readonly waitingQueue: Array<WaitingOperation> = [];
-  private disposed = false;
-  private readonly maxPermits: number;
-
-  constructor(maxPermits: number) {
-    if (maxPermits <= 0) {
-      throw new Error("maxPermits must be greater than 0");
-    }
-    this.permits = maxPermits;
-    this.maxPermits = maxPermits;
-  }
-
-  /**
-   * Acquire a permit. If no permits are available, waits until one becomes available.
-   */
-  async acquire(options?: {
-    timeout?: number;
-    signal?: AbortSignal;
-  }): Promise<void> {
-    if (this.disposed) {
-      throw new Error("Semaphore has been disposed");
-    }
-
-    if (options?.signal?.aborted) {
-      throw new Error("Operation was aborted");
-    }
-
-    if (this.permits > 0) {
-      this.permits--;
-      return;
-    }
-
-    // No permits available, wait in queue
-    return new Promise<void>((resolve, reject) => {
-      const operation: WaitingOperation = { resolve, reject };
-
-      // Set up timeout if provided
-      if (options?.timeout && options.timeout > 0) {
-        operation.timeout = setTimeout(() => {
-          this.removeFromQueue(operation);
-          reject(
-            new Error(`Semaphore acquire timeout after ${options.timeout}ms`)
-          );
-        }, options.timeout);
-      }
-
-      // Set up abort signal if provided
-      if (options?.signal) {
-        const abortHandler = () => {
-          this.removeFromQueue(operation);
-          reject(new Error("Operation was aborted"));
-        };
-        options.signal.addEventListener("abort", abortHandler, { once: true });
-
-        // Clean up the abort listener when operation completes
-        const originalResolve = operation.resolve;
-        const originalReject = operation.reject;
-
-        operation.resolve = () => {
-          options.signal!.removeEventListener("abort", abortHandler);
-          originalResolve();
-        };
-
-        operation.reject = (error: Error) => {
-          options.signal!.removeEventListener("abort", abortHandler);
-          originalReject(error);
-        };
-      }
-
-      this.waitingQueue.push(operation);
-    });
-  }
-
-  /**
-   * Release a permit, allowing waiting operations to proceed.
-   */
-  release(): void {
-    if (this.disposed) {
-      return;
-    }
-
-    if (this.waitingQueue.length > 0) {
-      // Give permit directly to next waiting operation
-      const nextOperation = this.waitingQueue.shift()!;
-
-      // Clear timeout if it exists
-      if (nextOperation.timeout) {
-        clearTimeout(nextOperation.timeout);
-      }
-
-      nextOperation.resolve();
-    } else {
-      // No one waiting, increment available permits (but don't exceed max)
-      this.permits = Math.min(this.permits + 1, this.maxPermits);
-    }
-  }
-
-  private removeFromQueue(operation: WaitingOperation): void {
-    const index = this.waitingQueue.indexOf(operation);
-    if (index !== -1) {
-      this.waitingQueue.splice(index, 1);
-
-      // Clear timeout if it exists
-      if (operation.timeout) {
-        clearTimeout(operation.timeout);
-      }
-    }
-  }
-
-  /**
-   * Execute a function with a permit, automatically releasing it afterwards.
-   */
-  async withPermit<T>(
-    fn: () => Promise<T>,
-    options?: { timeout?: number; signal?: AbortSignal }
-  ): Promise<T> {
-    await this.acquire(options);
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-
-  /**
-   * Dispose the semaphore, rejecting all waiting operations and preventing new ones.
-   */
-  dispose(): void {
-    if (this.disposed) {
-      return;
-    }
-
-    this.disposed = true;
-
-    // Reject all waiting operations
-    while (this.waitingQueue.length > 0) {
-      const operation = this.waitingQueue.shift()!;
-
-      // Clear timeout if it exists
-      if (operation.timeout) {
-        clearTimeout(operation.timeout);
-      }
-
-      operation.reject(new Error("Semaphore has been disposed"));
-    }
-  }
-
-  /**
-   * Get current number of available permits (for debugging)
-   */
-  getAvailablePermits(): number {
-    return this.permits;
-  }
-
-  /**
-   * Get current number of waiting operations (for debugging)
-   */
-  getWaitingCount(): number {
-    return this.waitingQueue.length;
-  }
-
-  /**
-   * Get maximum number of permits
-   */
-  getMaxPermits(): number {
-    return this.maxPermits;
-  }
-
-  /**
-   * Check if the semaphore has been disposed
-   */
-  isDisposed(): boolean {
-    return this.disposed;
-  }
-
-  /**
-   * Get metrics about the current state of the semaphore
-   */
-  getMetrics(): {
-    availablePermits: number;
-    waitingCount: number;
-    maxPermits: number;
-    utilization: number;
-    disposed: boolean;
-  } {
-    return {
-      availablePermits: this.permits,
-      waitingCount: this.waitingQueue.length,
-      maxPermits: this.maxPermits,
-      utilization: (this.maxPermits - this.permits) / this.maxPermits,
-      disposed: this.disposed,
-    };
-  }
-}

package/src/models/Store.ts

@@ -1,193 +0,0 @@
-import {
-  DependencyMapType,
-  IResource,
-  RegisterableItems,
-  IMiddleware,
-  ITag,
-} from "../defs";
-import { IDependentNode } from "../tools/findCircularDependencies";
-import { globalEventsArray } from "../globals/globalEvents";
-import { StoreAlreadyInitializedError } from "../errors";
-import { EventManager } from "./EventManager";
-import { Logger } from "./Logger";
-import { StoreRegistry } from "./StoreRegistry";
-import { OverrideManager } from "./OverrideManager";
-import { StoreValidator } from "./StoreValidator";
-import {
-  ResourceStoreElementType,
-  TaskStoreElementType,
-  MiddlewareStoreElementType,
-  EventStoreElementType,
-} from "./StoreTypes";
-import { getBuiltInResources, getBuiltInMiddlewares } from "./StoreConstants";
-
-// Re-export types for backward compatibility
-export {
-  ResourceStoreElementType,
-  TaskStoreElementType,
-  MiddlewareStoreElementType,
-  EventStoreElementType,
-};
-
-/**
- * Store class which is used to store all the resources, tasks, middleware and events.
- */
-export class Store {
-  root!: ResourceStoreElementType;
-  private registry: StoreRegistry;
-  private overrideManager: OverrideManager;
-  private validator: StoreValidator;
-
-  #isLocked = false;
-  #isInitialized = false;
-
-  constructor(
-    protected readonly eventManager: EventManager,
-    protected readonly logger: Logger
-  ) {
-    this.registry = new StoreRegistry();
-    this.validator = this.registry.getValidator();
-    this.overrideManager = new OverrideManager(this.registry);
-  }
-
-  // Delegate properties to registry
-  get tasks() {
-    return this.registry.tasks;
-  }
-  get resources() {
-    return this.registry.resources;
-  }
-  get events() {
-    return this.registry.events;
-  }
-  get middlewares() {
-    return this.registry.middlewares;
-  }
-  get overrides() {
-    return this.overrideManager.overrides;
-  }
-  get overrideRequests() {
-    return this.overrideManager.overrideRequests;
-  }
-
-  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.");
-    }
-  }
-
-  private registerGlobalComponents() {
-    // Register built-in resources
-    const builtInResources = getBuiltInResources(this.eventManager, this);
-    builtInResources.forEach((resource) => {
-      this.registry.storeGenericItem(resource);
-    });
-
-    // Register global events
-    globalEventsArray.forEach((event) => {
-      this.registry.storeEvent(event);
-    });
-
-    // Register built-in middlewares
-    const builtInMiddlewares = getBuiltInMiddlewares();
-    builtInMiddlewares.forEach((middleware) => {
-      this.registry.middlewares.set(middleware.id, {
-        middleware,
-        computedDependencies: {},
-      });
-    });
-  }
-
-  private setupRootResource(root: IResource<any>, config: any) {
-    root.dependencies =
-      typeof root.dependencies === "function"
-        ? root.dependencies(config)
-        : root.dependencies;
-
-    this.root = {
-      resource: root,
-      computedDependencies: {},
-      config,
-      value: undefined,
-      isInitialized: false,
-      context: {},
-    };
-
-    this.registry.computeRegistrationDeeply(root, config);
-    this.registry.resources.set(root.id, this.root);
-  }
-
-  initializeStore(root: IResource<any, any, any, any, any>, config: any) {
-    if (this.#isInitialized) {
-      throw new StoreAlreadyInitializedError();
-    }
-
-    this.registerGlobalComponents();
-    this.setupRootResource(root, config);
-    this.validator.runSanityChecks();
-
-    for (const resource of this.resources.values()) {
-      this.overrideManager.storeOverridesDeeply(resource.resource);
-    }
-
-    this.#isInitialized = true;
-  }
-
-  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,
-          resource.context
-        );
-      }
-    }
-  }
-
-  public processOverrides() {
-    this.overrideManager.processOverrides();
-  }
-
-  public getEverywhereMiddlewareForTasks(
-    excludingIds: Array<string | symbol>
-  ): IMiddleware[] {
-    return this.registry.getEverywhereMiddlewareForTasks(excludingIds);
-  }
-
-  public getEverywhereMiddlewareForResources(
-    excludingIds: Array<string | symbol>
-  ): IMiddleware[] {
-    return this.registry.getEverywhereMiddlewareForResources(excludingIds);
-  }
-
-  public storeGenericItem<C>(item: RegisterableItems) {
-    return this.registry.storeGenericItem<C>(item);
-  }
-
-  public storeEventsForAllTasks() {
-    this.registry.storeEventsForAllTasks();
-  }
-
-  public getTasksWithTag(tag: string | ITag) {
-    return this.registry.getTasksWithTag(tag);
-  }
-
-  public getResourcesWithTag(tag: string | ITag) {
-    return this.registry.getResourcesWithTag(tag);
-  }
-
-  getDependentNodes(): IDependentNode[] {
-    return this.registry.getDependentNodes();
-  }
-}

package/src/models/StoreConstants.ts

@@ -1,18 +0,0 @@
-import { globalResources } from "../globals/globalResources";
-import { requireContextMiddleware } from "../globals/middleware/requireContext.middleware";
-import { retryMiddleware } from "../globals/middleware/retry.middleware";
-import { timeoutMiddleware } from "../globals/middleware/timeout.middleware";
-import { EventManager } from "./EventManager";
-import { Store } from "./Store";
-
-export function getBuiltInResources(eventManager: EventManager, store: Store) {
-  return [
-    globalResources.eventManager.with(eventManager),
-    globalResources.store.with(store),
-    globalResources.queue,
-  ];
-}
-
-export function getBuiltInMiddlewares() {
-  return [requireContextMiddleware, retryMiddleware, timeoutMiddleware];
-}

package/src/models/StoreRegistry.ts

@@ -1,253 +0,0 @@
-import {
-  DependencyMapType,
-  IMiddlewareDefinition,
-  IEventDefinition,
-  IResource,
-  ITask,
-  IResourceWithConfig,
-  RegisterableItems,
-  IMiddleware,
-  symbolMiddlewareEverywhereResources,
-  symbolMiddlewareEverywhereTasks,
-  IEvent,
-  ITag,
-} from "../defs";
-import * as utils from "../define";
-import { UnknownItemTypeError } from "../errors";
-import {
-  TaskStoreElementType,
-  MiddlewareStoreElementType,
-  ResourceStoreElementType,
-  EventStoreElementType,
-} from "./StoreTypes";
-import { StoreValidator } from "./StoreValidator";
-
-export class StoreRegistry {
-  public tasks: Map<string | symbol, TaskStoreElementType> = new Map();
-  public resources: Map<string | symbol, ResourceStoreElementType> = new Map();
-  public events: Map<string | symbol, EventStoreElementType> = new Map();
-  public middlewares: Map<string | symbol, 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 new UnknownItemTypeError(item);
-    }
-  }
-
-  storeMiddleware<C>(item: IMiddleware<any>, check = true) {
-    check && this.validator.checkIfIDExists(item.id);
-
-    item.dependencies =
-      typeof item.dependencies === "function"
-        ? item.dependencies(item.config)
-        : item.dependencies;
-
-    this.middlewares.set(item.id, {
-      middleware: item,
-      computedDependencies: {},
-    });
-  }
-
-  storeEvent<C>(item: IEvent<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: Array<string | symbol>
-  ): 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: Array<string | symbol>
-  ): 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: IMiddleware[]) {
-    return middleware.reduce((acc, item) => {
-      acc[item.id] = item;
-      return acc;
-    }, {} as Record<string | symbol, IMiddleware>);
-  }
-
-  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;
-  }
-
-  getTasksWithTag(tag: string | ITag) {
-    if (typeof tag === "string") {
-      return Array.from(this.tasks.values()).filter((x) =>
-        x.task.meta?.tags?.includes(tag)
-      );
-    }
-
-    return Array.from(this.tasks.values())
-      .filter((x) => tag.extract(x.task.meta?.tags))
-      .map((x) => x.task);
-  }
-
-  getResourcesWithTag(tag: string | ITag) {
-    if (typeof tag === "string") {
-      return Array.from(this.resources.values()).filter((x) =>
-        x.resource.meta?.tags?.includes(tag)
-      );
-    }
-
-    return Array.from(this.resources.values())
-      .filter((x) => tag.extract(x.resource.meta?.tags))
-      .map((x) => x.resource);
-  }
-}

package/src/models/StoreTypes.ts

@@ -1,47 +0,0 @@
-import {
-  DependencyMapType,
-  DependencyValuesType,
-  IMiddlewareDefinition,
-  IEventDefinition,
-  IResource,
-  ITask,
-  IResourceWithConfig,
-  RegisterableItems,
-  IMiddleware,
-  IEvent,
-} from "../defs";
-
-export type ResourceStoreElementType<
-  C = any,
-  V extends Promise<any> = 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: IEvent<any>;
-};