@bluelibs/runner 2.2.3 → 3.0.0

package/src/models/Logger.ts

@@ -1,4 +1,4 @@
-import { globalEvents } from "../globalEvents";
+import { globalEvents } from "../globals/globalEvents";
 import { EventManager } from "./EventManager";
 
 export type LogLevels =
@@ -9,17 +9,32 @@ export type LogLevels =
   | "error"
   | "critical";
 
+export interface LogInfo {
+  source?: string;
+  error?: Error;
+  data?: Record<string, any>;
+  [key: string]: any;
+}
+
 export interface ILog {
   level: string;
   source?: string;
-  data: any;
+  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 severity = {
+  public static Severity = {
     trace: 0,
     debug: 1,
     info: 2,
@@ -28,32 +43,71 @@ export class Logger {
     critical: 5,
   };
 
-  constructor(protected eventManager: EventManager) {}
+  constructor(
+    protected eventManager: EventManager,
+    boundContext: Record<string, any> = {}
+  ) {
+    this.boundContext = { ...boundContext };
+  }
 
   /**
-   * @param level
-   * @param message
+   * Creates a new logger instance with additional bound context
    */
-  public async log(
-    level: LogLevels,
-    data: any,
-    source?: string
-  ): Promise<void> {
+  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,
-      data,
-      source: source,
+      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 &&
-      this.severity[level] >= this.severity[this.printThreshold]
+      Logger.Severity[level] >= Logger.Severity[this.printThreshold]
     ) {
       this.print(log);
     }
 
-    await this.eventManager.emit(globalEvents.log, log, source || "unknown");
+    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);
+          });
+      });
+    }
   }
 
   /**
@@ -65,56 +119,124 @@ export class Logger {
   }
 
   public print(log: ILog) {
-    // Extract the relevant information from the log
-    const { level, source: context, data, timestamp } = log;
-
-    // Format the timestamp to a more readable format
-    const formattedTimestamp = timestamp.toISOString();
+    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
+    };
 
-    // Format the log level for better visibility
-    const levelStr = `[${level.toUpperCase()}]`;
+    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);
+    }
 
-    // Format the context, if provided
-    const contextStr = context ? `(${context})` : "";
+    // 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}`);
+        });
+      }
+    }
 
-    // Handle different data types, especially if it's an error
-    let dataStr: string;
-    if (data instanceof Error) {
-      dataStr = `Error: ${data.name} - ${data.message}\nStack Trace:\n${data.stack}`;
-    } else if (typeof data === "object") {
-      dataStr = JSON.stringify(data, null, 2); // Pretty-print JSON objects
-    } else {
-      dataStr = String(data); // Convert any other type to string
+    // 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}`);
+      });
     }
 
-    // Construct the final log message
-    const logMessage = `${formattedTimestamp} ${levelStr} ${contextStr} - ${dataStr}`;
+    // 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}`);
+      });
+    }
 
-    // Print the log message
-    console.log(logMessage);
+    // 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 async info(data: any, source?: string) {
-    await this.log("info", data, source);
+  public info(message: any, logInfo: LogInfo = {}) {
+    this.log("info", message, logInfo);
   }
 
-  public async error(data: any, source?: string) {
-    await this.log("error", data, source);
+  public error(message: any, logInfo: LogInfo = {}) {
+    this.log("error", message, logInfo);
   }
 
-  public async warn(data: any, source?: string) {
-    await this.log("warn", data, source);
+  public warn(message: any, logInfo: LogInfo = {}) {
+    this.log("warn", message, logInfo);
   }
 
-  public async debug(data: any, source?: string) {
-    await this.log("debug", data, source);
+  public debug(message: any, logInfo: LogInfo = {}) {
+    this.log("debug", message, logInfo);
   }
 
-  public async trace(data: any, source?: string) {
-    await this.log("trace", data, source);
+  public trace(message: any, logInfo: LogInfo = {}) {
+    this.log("trace", message, logInfo);
   }
 
-  public async critical(data: any, source?: string) {
-    await this.log("critical", data, source);
+  public critical(message: any, logInfo: LogInfo = {}) {
+    this.log("critical", message, logInfo);
   }
 }

package/src/models/OverrideManager.ts

@@ -0,0 +1,84 @@
+import {
+  IResource,
+  IMiddleware,
+  ITask,
+  IResourceWithConfig,
+  RegisterableItems,
+} from "../defs";
+import * as utils from "../define";
+import { Errors } from "../errors";
+import {
+  TaskStoreElementType,
+  MiddlewareStoreElementType,
+  ResourceStoreElementType,
+} from "./StoreTypes";
+import { StoreRegistry } from "./StoreRegistry";
+
+export class OverrideManager {
+  public overrides: Map<
+    string,
+    IResource | IMiddleware | ITask | IResourceWithConfig
+  > = new Map();
+
+  public overrideRequests: Set<{
+    source: string;
+    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;
+      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 Errors.dependencyNotFound(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

@@ -0,0 +1,66 @@
+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

@@ -5,8 +5,9 @@ import {
   IResource,
 } from "../defs";
 import { EventManager } from "./EventManager";
-import { globalEvents } from "../globalEvents";
-import { MiddlewareStoreElementType, Store } from "./Store";
+import { globalEvents } from "../globals/globalEvents";
+import { Store } from "./Store";
+import { MiddlewareStoreElementType } from "./StoreTypes";
 import { Logger } from "./Logger";
 
 export class ResourceInitializer {
@@ -23,12 +24,14 @@ export class ResourceInitializer {
   public async initializeResource<
     TConfig = null,
     TValue = any,
-    TDeps extends DependencyMapType = {}
+    TDeps extends DependencyMapType = {},
+    TContext = any
   >(
     resource: IResource<TConfig, TValue, TDeps>,
     config: TConfig,
     dependencies: DependencyValuesType<TDeps>
-  ): Promise<TValue | undefined> {
+  ): Promise<{ value: TValue; context: TContext }> {
+    const context = resource.context?.();
     await this.eventManager.emit(
       globalEvents.resources.beforeInit,
       {
@@ -44,15 +47,22 @@ export class ResourceInitializer {
       resource.id
     );
 
-    let error, value;
+    let error: any, value: TValue | undefined;
     try {
-      value = await this.initWithMiddleware(resource, config, dependencies);
+      if (resource.init) {
+        value = await this.initWithMiddleware(
+          resource,
+          config,
+          dependencies,
+          context
+        );
+      }
 
       await this.eventManager.emit(
         resource.events.afterInit,
         {
           config,
-          value,
+          value: value as TValue,
         },
         resource.id
       );
@@ -61,14 +71,14 @@ export class ResourceInitializer {
         {
           config,
           resource,
-          value,
+          value: value as TValue,
         },
         resource.id
       );
 
-      this.logger.debug(`Resource ${resource.id} initialized`, resource.id);
+      this.logger.debug(`Resource ${resource.id} initialized`, { source: resource.id });
 
-      return value;
+      return { value: value as TValue, context };
     } catch (e) {
       error = e;
       let isSuppressed = false;
@@ -80,7 +90,7 @@ export class ResourceInitializer {
       await this.eventManager.emit(
         resource.events.onError,
         {
-          error,
+          error: error as Error,
           suppress,
         },
         resource.id
@@ -88,7 +98,7 @@ export class ResourceInitializer {
       await this.eventManager.emit(
         globalEvents.resources.onError,
         {
-          error,
+          error: error as Error,
           resource,
           suppress,
         },
@@ -96,23 +106,28 @@ export class ResourceInitializer {
       );
 
       if (!isSuppressed) throw e;
+
+      return { value: undefined as TValue, context: {} as TContext };
     }
   }
 
-  public async initWithMiddleware<C, V, D extends DependencyMapType>(
-    resource: IResource<C, V>,
+  public async initWithMiddleware<C, V, D extends DependencyMapType, TContext>(
+    resource: IResource<C, V, D, TContext>,
     config: C,
-    dependencies: D
+    dependencies: DependencyValuesType<D>,
+    context: TContext
   ) {
     let next = async (config: C): Promise<V | undefined> => {
       if (resource.init) {
-        return resource.init.call(null, config, dependencies);
+        return resource.init.call(null, config, dependencies, context);
       }
     };
 
     const existingMiddlewares = resource.middleware;
     const createdMiddlewares = [
-      ...this.store.getGlobalMiddlewares(existingMiddlewares.map((x) => x.id)),
+      ...this.store.getEverywhereMiddlewareForResources(
+        existingMiddlewares.map((x) => x.id)
+      ),
       ...existingMiddlewares,
     ];
 
@@ -126,11 +141,14 @@ export class ResourceInitializer {
       next = async (config: C) => {
         return storeMiddleware.middleware.run(
           {
-            resourceDefinition: resource as any,
-            config: config,
+            resource: {
+              definition: resource,
+              config,
+            },
             next: nextFunction,
           },
-          storeMiddleware.computedDependencies
+          storeMiddleware.computedDependencies,
+          middleware.config
         );
       };
     }