@bluelibs/runner 3.4.2 → 4.0.1

package/src/models/Logger.ts

@@ -1,282 +0,0 @@
-import { globalEvents } from "../globals/globalEvents";
-import { EventManager } from "./EventManager";
-
-export type LogLevels =
-  | "trace"
-  | "debug"
-  | "info"
-  | "warn"
-  | "error"
-  | "critical";
-
-export interface LogInfo {
-  source?: string | symbol;
-  error?: Error;
-  data?: Record<string, any>;
-  [key: string]: any;
-}
-
-export interface ILog {
-  level: string;
-  source?: string;
-  message: any;
-  timestamp: Date;
-  error?: {
-    name: string;
-    message: string;
-    stack?: string;
-  };
-  data?: Record<string, any>;
-  context?: Record<string, any>;
-}
-
-export class Logger {
-  printThreshold: LogLevels | null = null;
-  private boundContext: Record<string, any> = {};
-
-  public static Severity = {
-    trace: 0,
-    debug: 1,
-    info: 2,
-    warn: 3,
-    error: 4,
-    critical: 5,
-  };
-
-  constructor(
-    protected eventManager: EventManager,
-    boundContext: Record<string, any> = {}
-  ) {
-    this.boundContext = { ...boundContext };
-    this.printThreshold = this.getDefaultPrintThreshold();
-  }
-
-  /**
-   * Determines the default print threshold based on environment variables
-   */
-  private getDefaultPrintThreshold(): LogLevels | null {
-    // Check if logging is explicitly disabled
-    const disableLogs = process.env.RUNNER_DISABLE_LOGS;
-    if (disableLogs === "true" || disableLogs === "1") {
-      return null;
-    }
-
-    // Check for specific log level override
-    const logLevel = process.env.RUNNER_LOG_LEVEL;
-    if (logLevel && this.isValidLogLevel(logLevel)) {
-      return logLevel as LogLevels;
-    }
-
-    // Default to 'info' level for better developer experience
-    return "info";
-  }
-
-  /**
-   * Validates if a string is a valid log level
-   */
-  private isValidLogLevel(level: string): boolean {
-    return Object.keys(Logger.Severity).includes(level);
-  }
-
-  /**
-   * Creates a new logger instance with additional bound context
-   */
-  public with(context: Record<string, any>): Logger {
-    return new Logger(this.eventManager, {
-      ...this.boundContext,
-      ...context,
-    });
-  }
-
-  private extractErrorInfo(error: Error): {
-    name: string;
-    message: string;
-    stack?: string;
-  } {
-    return {
-      name: error.name,
-      message: error.message,
-      stack: error.stack,
-    };
-  }
-
-  /**
-   * Core logging method with structured LogInfo
-   */
-  public log(level: LogLevels, message: any, logInfo: LogInfo = {}): void {
-    const { source, error, data, ...context } = logInfo;
-
-    const log: ILog = {
-      level,
-      message,
-      source: source || this.boundContext.source,
-      timestamp: new Date(),
-      error: error ? this.extractErrorInfo(error) : undefined,
-      data: data || undefined,
-      context: { ...this.boundContext, ...context },
-    };
-
-    if (
-      this.printThreshold &&
-      Logger.Severity[level] >= Logger.Severity[this.printThreshold]
-    ) {
-      this.print(log);
-    }
-
-    if (this.eventManager.hasListeners(globalEvents.log)) {
-      setImmediate(() => {
-        this.eventManager
-          .emit(
-            globalEvents.log,
-            log,
-            source || this.boundContext.source || "unknown"
-          )
-          .catch((err) => {
-            console.error("Logger event emission failed:", err);
-          });
-      });
-    }
-  }
-
-  /**
-   * Will print logs after that, use `null` to disable autoprinting.
-   * @param level
-   */
-  public setPrintThreshold(level: LogLevels | null) {
-    this.printThreshold = level;
-  }
-
-  public print(log: ILog) {
-    const { level, source, message, timestamp, error, data, context } = log;
-
-    // Color codes for different log levels
-    const colors = {
-      trace: "\x1b[90m", // bright black/gray
-      debug: "\x1b[36m", // cyan
-      info: "\x1b[32m", // green
-      warn: "\x1b[33m", // yellow
-      error: "\x1b[31m", // red
-      critical: "\x1b[35m", // magenta
-      reset: "\x1b[0m", // reset
-      bold: "\x1b[1m", // bold
-      dim: "\x1b[2m", // dim
-      blue: "\x1b[34m", // blue
-      red: "\x1b[31m", // red
-      cyan: "\x1b[36m", // cyan
-    };
-
-    const levelColor = colors[level as keyof typeof colors] || colors.info;
-
-    // Format timestamp
-    const time = timestamp.toLocaleTimeString("en-US", {
-      hour12: false,
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-    });
-    const ms = timestamp.getMilliseconds().toString().padStart(3, "0");
-    const formattedTime = `${colors.dim}${time}.${ms}${colors.reset}`;
-
-    // Format level with color and padding
-    const levelStr = `${levelColor}${colors.bold}${level
-      .toUpperCase()
-      .padEnd(8)}${colors.reset}`;
-
-    // Format source
-    const sourceStr = source ? `${colors.blue}[${source}]${colors.reset} ` : "";
-
-    // Format the main message
-    let messageStr: string;
-    if (typeof message === "object") {
-      messageStr = JSON.stringify(message, null, 2);
-    } else {
-      messageStr = String(message);
-    }
-
-    // Build the main log line
-    const mainLine = `${formattedTime} ${levelStr} ${sourceStr}${messageStr}`;
-
-    // Start building output lines
-    const lines = [mainLine];
-
-    // Add error information if present
-    if (error) {
-      lines.push(
-        `${colors.dim}├─ ${colors.red}Error: ${error.name}${colors.reset}`
-      );
-      lines.push(
-        `${colors.dim}├─ ${colors.red}${error.message}${colors.reset}`
-      );
-      if (error.stack) {
-        const stackLines = error.stack.split("\n").slice(1, 4); // Show first 3 stack frames
-        stackLines.forEach((line, index) => {
-          const prefix = index === stackLines.length - 1 ? "└─" : "├─";
-          lines.push(
-            `${colors.dim}${prefix} ${colors.red}${line.trim()}${colors.reset}`
-          );
-        });
-      }
-    }
-
-    // Add structured data if present
-    if (data && Object.keys(data).length > 0) {
-      lines.push(`${colors.dim}├─ ${colors.cyan}Data:${colors.reset}`);
-      const dataStr = JSON.stringify(data, null, 2);
-      const dataLines = dataStr.split("\n");
-      dataLines.forEach((line, index) => {
-        const prefix = index === dataLines.length - 1 ? "└─" : "├─";
-        lines.push(
-          `${colors.dim}${prefix}   ${colors.cyan}${line}${colors.reset}`
-        );
-      });
-    }
-
-    // Add context if present (excluding common context we already show)
-    const filteredContext = context ? { ...context } : {};
-    delete filteredContext.source; // Already shown in source
-
-    if (filteredContext && Object.keys(filteredContext).length > 0) {
-      lines.push(`${colors.dim}└─ ${colors.blue}Context:${colors.reset}`);
-      const contextStr = JSON.stringify(filteredContext, null, 2);
-      const contextLines = contextStr.split("\n");
-      contextLines.forEach((line, index) => {
-        const prefix = index === contextLines.length - 1 ? "  " : "  ";
-        lines.push(
-          `${colors.dim}${prefix}   ${colors.blue}${line}${colors.reset}`
-        );
-      });
-    }
-
-    // Output all lines
-    lines.forEach((line) => console.log(line));
-
-    // Add a subtle separator for multi-line logs
-    if (lines.length > 1) {
-      console.log(`${colors.dim}${colors.reset}`);
-    }
-  }
-
-  public info(message: any, logInfo: LogInfo = {}) {
-    this.log("info", message, logInfo);
-  }
-
-  public error(message: any, logInfo: LogInfo = {}) {
-    this.log("error", message, logInfo);
-  }
-
-  public warn(message: any, logInfo: LogInfo = {}) {
-    this.log("warn", message, logInfo);
-  }
-
-  public debug(message: any, logInfo: LogInfo = {}) {
-    this.log("debug", message, logInfo);
-  }
-
-  public trace(message: any, logInfo: LogInfo = {}) {
-    this.log("trace", message, logInfo);
-  }
-
-  public critical(message: any, logInfo: LogInfo = {}) {
-    this.log("critical", message, logInfo);
-  }
-}

package/src/models/OverrideManager.ts

@@ -1,79 +0,0 @@
-import {
-  IResource,
-  IMiddleware,
-  ITask,
-  IResourceWithConfig,
-  RegisterableItems,
-} from "../defs";
-import * as utils from "../define";
-import { DependencyNotFoundError } from "../errors";
-import { StoreRegistry } from "./StoreRegistry";
-
-export class OverrideManager {
-  public overrides: Map<
-    string | symbol,
-    IResource | IMiddleware | ITask | IResourceWithConfig
-  > = new Map();
-
-  public overrideRequests: Set<{
-    source: string | symbol;
-    override: RegisterableItems;
-  }> = new Set();
-
-  constructor(private readonly registry: StoreRegistry) {}
-
-  storeOverridesDeeply<C>(element: IResource<C, any, any>) {
-    element.overrides.forEach((override) => {
-      if (utils.isResource(override)) {
-        this.storeOverridesDeeply(override);
-      }
-
-      let id: string | symbol;
-      if (utils.isResourceWithConfig(override)) {
-        this.storeOverridesDeeply(override.resource);
-        id = override.resource.id;
-      } else {
-        id = override.id;
-      }
-
-      this.overrideRequests.add({ source: element.id, override });
-      this.overrides.set(id, override);
-    });
-  }
-
-  processOverrides() {
-    // If we are trying to use override on something that wasn't previously registered, we throw an error.
-    for (const override of this.overrides.values()) {
-      let hasAnyItem = false;
-      if (utils.isTask(override)) {
-        hasAnyItem = this.registry.tasks.has(override.id);
-      } else if (utils.isResource(override)) {
-        hasAnyItem = this.registry.resources.has(override.id);
-      } else if (utils.isMiddleware(override)) {
-        hasAnyItem = this.registry.middlewares.has(override.id);
-      } else if (utils.isResourceWithConfig(override)) {
-        hasAnyItem = this.registry.resources.has(override.resource.id);
-      }
-
-      if (!hasAnyItem) {
-        const id = utils.isResourceWithConfig(override)
-          ? override.resource.id
-          : override.id;
-
-        throw new DependencyNotFoundError(id);
-      }
-    }
-
-    for (const override of this.overrides.values()) {
-      if (utils.isTask(override)) {
-        this.registry.storeTask(override, false);
-      } else if (utils.isResource(override)) {
-        this.registry.storeResource(override, false);
-      } else if (utils.isMiddleware(override)) {
-        this.registry.storeMiddleware(override, false);
-      } else if (utils.isResourceWithConfig(override)) {
-        this.registry.storeResourceWithConfig(override, false);
-      }
-    }
-  }
-}

package/src/models/Queue.ts

@@ -1,66 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-/**
- * Cooperative task queue.
- *  • Tasks run one‑after‑another (FIFO ordering).
- *  • Dead‑lock detection prevents nesting.
- *  • dispose() drains or cancels outstanding tasks, then rejects new ones.
- */
-export class Queue {
-  private tail: Promise<unknown> = Promise.resolve();
-  private disposed = false;
-  private abortController = new AbortController();
-
-  // true while inside a queued task → helps detect "queue in queue"
-  private readonly executionContext = new AsyncLocalStorage<boolean>();
-
-  /**
-   * Schedule an asynchronous task.
-   * @param task – receives an AbortSignal so it can cancel early if desired.
-   */
-  public run<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T> {
-    // 1. refuse new work if we've disposed
-    if (this.disposed) {
-      return Promise.reject(new Error("Queue has been disposed"));
-    }
-
-    // 2. detect dead‑locks (a queued task adding another queued task)
-    if (this.executionContext.getStore()) {
-      return Promise.reject(
-        new Error(
-          "Dead‑lock detected: a queued task attempted to queue another task"
-        )
-      );
-    }
-
-    const { signal } = this.abortController;
-
-    // 3. chain task after the current tail
-    const result = this.tail.then(() =>
-      this.executionContext.run(true, () => task(signal))
-    );
-
-    // 4. preserve the chain even if the task rejects (swallow internally)
-    this.tail = result.catch(() => {});
-
-    return result;
-  }
-
-  /**
-   * Disposes the queue.
-   * @param options.cancel – if true, broadcasts AbortSignal to running task.
-   *                         default: false (waits for tasks to finish).
-   */
-  public async dispose(options: { cancel?: boolean } = {}): Promise<void> {
-    if (this.disposed) return;
-
-    this.disposed = true;
-
-    if (options.cancel) {
-      this.abortController.abort(); // notify cooperative tasks
-    }
-
-    // wait for everything already chained to settle
-    await this.tail.catch(() => {});
-  }
-}

package/src/models/ResourceInitializer.ts

@@ -1,165 +0,0 @@
-import {
-  DependencyMapType,
-  DependencyValuesType,
-  ITask,
-  IResource,
-} from "../defs";
-import { EventManager } from "./EventManager";
-import { globalEvents } from "../globals/globalEvents";
-import { Store } from "./Store";
-import { MiddlewareStoreElementType } from "./StoreTypes";
-import { Logger } from "./Logger";
-
-export class ResourceInitializer {
-  constructor(
-    protected readonly store: Store,
-    protected readonly eventManager: EventManager,
-    protected readonly logger: Logger
-  ) {}
-
-  /**
-   * 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 extends Promise<any> = Promise<any>,
-    TDeps extends DependencyMapType = {},
-    TContext = any
-  >(
-    resource: IResource<TConfig, TValue, TDeps>,
-    config: TConfig,
-    dependencies: DependencyValuesType<TDeps>
-  ): Promise<{ value: TValue; context: TContext }> {
-    const context = resource.context?.();
-    await this.eventManager.emit(
-      globalEvents.resources.beforeInit,
-      {
-        config,
-        resource,
-      },
-      resource.id
-    );
-
-    await this.eventManager.emit(
-      resource.events.beforeInit,
-      { config },
-      resource.id
-    );
-
-    let error: any, value: TValue | undefined;
-    try {
-      if (resource.init) {
-        value = await this.initWithMiddleware(
-          resource,
-          config,
-          dependencies,
-          context
-        );
-      }
-
-      await this.eventManager.emit(
-        resource.events.afterInit,
-        {
-          config,
-          value: value as TValue,
-        },
-        resource.id
-      );
-      await this.eventManager.emit(
-        globalEvents.resources.afterInit,
-        {
-          config,
-          resource,
-          value: value as TValue,
-        },
-        resource.id
-      );
-
-      this.logger.debug(`Resource ${resource.id.toString()} initialized`, {
-        source: resource.id,
-      });
-
-      return { value: value as TValue, context };
-    } catch (e) {
-      error = e;
-      let isSuppressed = false;
-      function suppress() {
-        isSuppressed = true;
-      }
-
-      // If you want to rewthrow the error, this should be done inside the onError event.
-      await this.eventManager.emit(
-        resource.events.onError,
-        {
-          error: error as Error,
-          suppress,
-        },
-        resource.id
-      );
-      await this.eventManager.emit(
-        globalEvents.resources.onError,
-        {
-          error: error as Error,
-          resource,
-          suppress,
-        },
-        resource.id
-      );
-
-      if (!isSuppressed) throw e;
-
-      return { value: undefined as unknown as TValue, context: {} as TContext };
-    }
-  }
-
-  public async initWithMiddleware<
-    C,
-    V extends Promise<any>,
-    D extends DependencyMapType,
-    TContext
-  >(
-    resource: IResource<C, V, D, TContext>,
-    config: C,
-    dependencies: DependencyValuesType<D>,
-    context: TContext
-  ) {
-    let next = async (config: C): Promise<V | undefined> => {
-      if (resource.init) {
-        return resource.init.call(null, config, dependencies, context);
-      }
-    };
-
-    const existingMiddlewares = resource.middleware;
-    const createdMiddlewares = [
-      ...this.store.getEverywhereMiddlewareForResources(
-        existingMiddlewares.map((x) => x.id)
-      ),
-      ...existingMiddlewares,
-    ];
-
-    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 (config: C) => {
-        return storeMiddleware.middleware.run(
-          {
-            resource: {
-              definition: resource,
-              config,
-            },
-            next: nextFunction,
-          },
-          storeMiddleware.computedDependencies,
-          middleware.config
-        );
-      };
-    }
-
-    return next(config);
-  }
-}