@apiquest/fracture 1.0.4 → 1.0.5

package/src/DagScheduler.ts

@@ -1,439 +0,0 @@
-import { EventEmitter } from 'events';
-import type { TaskNode } from './TaskGraph.js';
-import type { ExecutionContext, RequestResult, Request, Folder, ScriptResult } from '@apiquest/types';
-import { ScriptType } from '@apiquest/types';
-import { isNullOrWhitespace } from './utils.js';
-import { Logger } from './Logger.js';
-
-/**
- * Callback interface for DagScheduler to call back into CollectionRunner
- */
-export interface DagExecutionCallbacks {
-  // Flags are passed for every node execution.
-  // When skip is true: no script execution, emit skipped assertions only
-  // When bail is true: suppress assertions and scripts
-  // Script execution (always through queue)
-  executeScript(
-    script: string,
-    scriptType: ScriptType,
-    context: ExecutionContext,
-    node: TaskNode,
-    flags: { skip: boolean; bail: boolean }
-  ): Promise<ScriptResult>;
-  
-  // Folder lifecycle (always through queue)
-  executeFolderEnter(
-    node: TaskNode,
-    context: ExecutionContext,
-    flags: { skip: boolean; bail: boolean }
-  ): Promise<void>;
-  
-  executeFolderExit(
-    node: TaskNode,
-    context: ExecutionContext,
-    flags: { skip: boolean; bail: boolean }
-  ): Promise<void>;
-  
-  // Request execution (I/O only, scripts handled separately)
-  executeRequestIO(
-    node: TaskNode,
-    context: ExecutionContext,
-    flags: { skip: boolean; bail: boolean }
-  ): Promise<RequestResult>;
-  
-  // Condition evaluation
-  evaluateCondition(
-    condition: string,
-    context: ExecutionContext
-  ): Promise<boolean>;
-  
-  // Abort check
-  isAborted(): boolean;
-}
-
-/**
- * Async queue for workers
- */
-class AsyncQueue<T> extends EventEmitter {
-  private items: T[] = [];
-  private waiting: Array<(value: T | null) => void> = [];
-  private closed = false;
-
-  enqueue(item: T): void {
-    if (this.closed) {
-      throw new Error('Queue is closed');
-    }
-
-    // If someone is waiting, give it to them immediately
-    const resolver = this.waiting.shift();
-    if (resolver !== undefined) {
-      resolver(item);
-      return;
-    }
-
-    // Otherwise, queue it
-    this.items.push(item);
-    this.emit('item');
-  }
-
-  async dequeue(): Promise<T | null> {
-    // If items available, return immediately
-    if (this.items.length > 0) {
-      return this.items.shift()!;
-    }
-
-    // If closed and empty, return null
-    if (this.closed) {
-      return null;
-    }
-
-    // Wait for item or close
-    return new Promise<T | null>((resolve) => {
-      this.waiting.push(resolve);
-    });
-  }
-
-  close(): void {
-    this.closed = true;
-    // Resolve all waiting promises with null
-    for (const resolver of this.waiting) {
-      resolver(null);
-    }
-    this.waiting = [];
-  }
-
-  get length(): number {
-    return this.items.length;
-  }
-}
-
-/**
- * DagScheduler coordinates parallel execution via DAG
- */
-export class DagScheduler {
-  private callbacks: DagExecutionCallbacks;
-  private maxConcurrency: number;
-  private logger: Logger;
-  
-  // Tracking
-  private completedNodes = new Set<string>();
-  private totalNodes = 0;
-  private aborted = false;
-  private skippedNodes = new Set<string>();
-  private graph?: import('./TaskGraph.js').TaskGraph;
-
-  // Queues
-  private scriptQueue = new AsyncQueue<TaskNode>();
-  private requestQueue = new AsyncQueue<TaskNode>();
-
-  constructor(callbacks: DagExecutionCallbacks, maxConcurrency: number, baseLogger?: Logger) {
-    this.callbacks = callbacks;
-    this.maxConcurrency = maxConcurrency;
-    this.logger = baseLogger?.createLogger('DagScheduler') ?? new Logger('DagScheduler');
-  }
-
-  /**
-   * Execute the DAG
-   * Returns array of RequestResult for all requests that were executed
-   */
-  public async execute(
-    graph: import('./TaskGraph.js').TaskGraph,
-    context: ExecutionContext
-  ): Promise<RequestResult[]> {
-    const results: RequestResult[] = [];
-    
-    // Initialize tracking
-    this.totalNodes = graph.getNodes().size;
-    this.completedNodes.clear();
-    this.skippedNodes.clear();
-    this.aborted = false;
-    this.graph = graph;
-    
-    this.logger.debug(`Starting DAG execution: ${this.totalNodes} nodes, maxConcurrency=${this.maxConcurrency}`);
-
-    // Get initial ready nodes
-    const readyNodes = graph.getReadyNodes();
-    this.logger.debug(`Initial ready nodes: ${readyNodes.length}`);
-    
-    if (readyNodes.length === 0) {
-      // Empty DAG
-      return results;
-    }
-
-    // Enqueue initial ready nodes
-    for (const node of readyNodes) {
-      this.enqueueNode(node);
-    }
-
-    // Start workers
-    const workers: Promise<void>[] = [];
-    
-    // Script worker (single threaded)
-    workers.push(this.runScriptWorker(graph, context, results));
-    
-    // Request workers (parallel pool)
-    for (let i = 0; i < this.maxConcurrency; i++) {
-      workers.push(this.runRequestWorker(graph, context, results));
-    }
-
-    // Wait for all workers to complete
-    await Promise.all(workers);
-    
-    return results;
-  }
-
-  private async runScriptWorker(
-    graph: import('./TaskGraph.js').TaskGraph,
-    context: ExecutionContext,
-    results: RequestResult[]
-  ): Promise<void> {
-    while (true) {
-      const node = await this.scriptQueue.dequeue();
-      if (node === null) {
-        // Queue closed, we're done
-        break;
-      }
-
-      // Check abort
-      if (this.aborted || this.callbacks.isAborted()) {
-        this.markComplete(node.id, graph);
-        continue;
-      }
-
-      // Check if node was skipped (e.g., by folder condition)
-      if (this.skippedNodes.has(node.id)) {
-        // Node already skipped by skipSubtree(), just mark complete
-        this.markComplete(node.id, graph);
-        continue;
-      }
-
-      // Execute script node
-      await this.executeScriptNode(node, context, results);
-      
-      // Mark complete and enqueue newly-ready nodes
-      this.markComplete(node.id, graph);
-    }
-  }
-
-  private async runRequestWorker(
-    graph: import('./TaskGraph.js').TaskGraph,
-    context: ExecutionContext,
-    results: RequestResult[]
-  ): Promise<void> {
-    while (true) {
-      const node = await this.requestQueue.dequeue();
-      if (node === null) {
-        // Queue closed, we're done
-        break;
-      }
-
-      // Check abort
-      if (this.aborted || this.callbacks.isAborted()) {
-        this.markComplete(node.id, graph);
-        continue;
-      }
-
-      // Check if node was skipped (e.g., by folder condition)
-      if (this.skippedNodes.has(node.id)) {
-        // Node already skipped by skipSubtree(), just mark complete
-        this.markComplete(node.id, graph);
-        continue;
-      }
-
-      // Execute request node
-      await this.executeRequestNode(node, context, results);
-      
-      // Mark complete and enqueue newly-ready nodes
-      this.markComplete(node.id, graph);
-    }
-  }
-
-  private async executeScriptNode(
-    node: TaskNode,
-    context: ExecutionContext,
-    results: RequestResult[]
-  ): Promise<void> {
-    const flags = {
-      skip: false,
-      bail: this.aborted || this.callbacks.isAborted()
-    };
-    // Handle folder lifecycle nodes
-    if (node.type === 'folder-enter') {
-      if (node.condition !== undefined) {
-        this.logger.debug(`Evaluating folder condition for ${node.name}: ${node.condition}`);
-        const conditionPassed = await this.callbacks.evaluateCondition(node.condition, context);
-        this.logger.debug(`Folder condition result for ${node.name}: ${conditionPassed}`);
-        if (!conditionPassed) {
-          this.logger.debug(`Skipping folder subtree for ${node.name} (condition=false)`);
-          await this.skipSubtree(node.id, context, results, 'condition-false');
-          return;
-        }
-      }
-
-      // Execute folder enter lifecycle (PUSH scope + emit beforeFolder)
-      await this.callbacks.executeFolderEnter(node, context, flags);
-      return;
-    }
-    
-    if (node.type === 'folder-exit') {
-      // Execute folder exit lifecycle (POP scope + emit afterFolder)
-      await this.callbacks.executeFolderExit(node, context, flags);
-      return;
-    }
-
-    // Handle regular script nodes
-    // Evaluate condition if present
-    if (node.condition !== undefined) {
-      const conditionPassed = await this.callbacks.evaluateCondition(node.condition, context);
-      if (!conditionPassed) {
-        // Skip this node
-        return;
-      }
-    }
-
-    // Execute script if present
-    if (!isNullOrWhitespace(node.script) && node.scriptType !== undefined) {
-      const scriptResult = await this.callbacks.executeScript(
-        node.script!,
-        node.scriptType,
-        context,
-        node,
-        flags
-      );
-      
-      // Handle test failures (trigger bail if enabled)
-      // Note: callbacks.executeScript handles bail internally
-    }
-  }
-
-  private async executeRequestNode(
-    node: TaskNode,
-    context: ExecutionContext,
-    results: RequestResult[]
-  ): Promise<void> {
-    const flags = {
-      skip: false,
-      bail: this.aborted || this.callbacks.isAborted()
-    };
-
-    if (flags.bail) {
-      this.logger.debug(`Bail active, skipping request ${node.id}`);
-      return;
-    }
-    // Evaluate condition if present
-    if (node.condition !== undefined) {
-      const conditionPassed = await this.callbacks.evaluateCondition(node.condition, context);
-      if (!conditionPassed) {
-        flags.skip = true;
-        this.logger.debug(`Request ${node.id} skipped by condition`);
-        // Add skipped result
-        const request = node.item as Request;
-        const skippedResult: RequestResult = {
-          requestId: request.id,
-          requestName: request.name,
-          path: node.path,
-          success: true,
-          tests: [],
-          duration: 0,
-          iteration: context.iterationCurrent,
-          scriptError: 'Skipped by condition'
-        };
-        results.push(skippedResult);
-        return;
-      }
-    }
-
-    // Execute request I/O
-    const result = await this.callbacks.executeRequestIO(node, context, flags);
-    results.push(result);
-  }
-
-  private async skipSubtree(
-    rootNodeId: string,
-    context: ExecutionContext,
-    results: RequestResult[],
-    reason: string
-  ): Promise<void> {
-    const graph = this.graph;
-    if (graph === undefined) {
-      return;
-    }
-
-    const nodes = graph.getNodes();
-    const childrenByFolderId = graph.getChildrenByFolderId();
-    const stack: string[] = [rootNodeId];
-
-    this.logger.debug(`Skipping subtree from node ${rootNodeId} (${reason})`);
-
-    while (stack.length > 0) {
-      const currentId = stack.pop() as string;
-      if (this.skippedNodes.has(currentId)) {
-        continue;
-      }
-      this.skippedNodes.add(currentId);
-
-      const currentNode = nodes.get(currentId);
-      if (currentNode?.type === 'request') {
-        const request = currentNode.item as Request;
-        const result = await this.callbacks.executeRequestIO(currentNode, context, {
-          skip: true,
-          bail: false
-        });
-        results.push(result);
-      }
-
-      const childIds = currentNode?.path !== undefined
-        ? (childrenByFolderId.get(currentNode.path) ?? [])
-        : [];
-
-      for (const childId of childIds) {
-        stack.push(childId);
-      }
-
-      this.markComplete(currentId, graph);
-    }
-  }
-
-  private markComplete(
-    nodeId: string,
-    graph: import('./TaskGraph.js').TaskGraph
-  ): void {
-    this.completedNodes.add(nodeId);
-    
-    // Get newly-ready nodes
-    const nowReady = graph.completeNode(nodeId);
-    
-    // Only enqueue new nodes if not aborted (bail stops scheduling new work)
-    if (!this.aborted && !this.callbacks.isAborted()) {
-      for (const readyNode of nowReady) {
-        this.enqueueNode(readyNode);
-      }
-    } else {
-      // Mark skipped nodes as complete so we can finish
-      for (const readyNode of nowReady) {
-        this.completedNodes.add(readyNode.id);
-      }
-    }
-
-    // Check if all nodes complete OR if aborted and queues empty
-    const allComplete = this.completedNodes.size === this.totalNodes;
-    const abortedAndIdle = (this.aborted || this.callbacks.isAborted()) &&
-                            this.scriptQueue.length === 0 &&
-                            this.requestQueue.length === 0;
-    
-    if (allComplete || abortedAndIdle) {
-      // Close queues to signal workers to exit
-      this.scriptQueue.close();
-      this.requestQueue.close();
-    }
-  }
-
-  private enqueueNode(node: TaskNode): void {
-    // folder-enter and folder-exit are lifecycle nodes, must be serialized through script queue
-    if (node.type === 'folder-enter' || node.type === 'folder-exit' || node.type === 'script') {
-      this.scriptQueue.enqueue(node);
-    } else {
-      this.requestQueue.enqueue(node);
-    }
-  }
-}

package/src/Logger.ts

@@ -1,85 +0,0 @@
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { ILogger, LogLevel } from '@apiquest/types';
-
-/**
- * Logger for fracture runtime and host integrations.
- */
-export class Logger implements ILogger {
-  private level: LogLevel;
-  private component: string;
-  private emitter?: EventEmitter;
-
-  constructor(component: string, level: LogLevel = LogLevel.INFO, emitter?: EventEmitter) {
-    this.component = component;
-    this.level = level;
-    this.emitter = emitter;
-  }
-
-  createLogger(component: string): Logger {
-    return new Logger(component, this.level, this.emitter);
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level;
-  }
-
-  error(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.ERROR, message, ...args);
-  }
-
-  warn(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.WARN, message, ...args);
-  }
-
-  info(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.INFO, message, ...args);
-  }
-
-  debug(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.DEBUG, message, ...args);
-  }
-
-  trace(message: string, ...args: unknown[]): void {
-    this.log(LogLevel.TRACE, message, ...args);
-  }
-
-  private log(level: LogLevel, message: string, ...args: unknown[]): void {
-    if (level > this.level) return;
-
-    const levelNames = ['error', 'warn', 'info', 'debug', 'trace'];
-    const levelName = levelNames[level];
-    const prefix = `[${this.component}]`;
-    const fullMessage = `${prefix} ${message}`;
-
-    const formattedArgs = args.length > 0
-      ? ' ' + args.map(a => {
-        if (a instanceof Error) {
-          return a.message;
-        }
-        if (typeof a === 'object' && a !== null) {
-          try {
-            return JSON.stringify(a);
-          } catch {
-            return String(a);
-          }
-        }
-        return String(a);
-      }).join(' ')
-      : '';
-
-    const finalMessage = fullMessage + formattedArgs;
-
-    if (this.emitter !== null && this.emitter !== undefined) {
-      this.emitter.emit('console', {
-        id: randomUUID(),
-        level,
-        levelName,
-        component: this.component,
-        message: finalMessage,
-        args,
-        timestamp: new Date().toISOString()
-      });
-    }
-  }
-}

package/src/PluginLoader.ts

@@ -1,126 +0,0 @@
-import type { IProtocolPlugin, IAuthPlugin, IValueProviderPlugin } from '@apiquest/types';
-import { Logger } from './Logger.js';
-import { PluginManager } from './PluginManager.js';
-import type { ResolvedPlugin } from './PluginResolver.js';
-import type { PluginRequirements } from './CollectionAnalyzer.js';
-import { isNullOrEmpty } from './utils.js';
-
-export class PluginLoader {
-  private logger: Logger;
-  private pluginManager: PluginManager;
-  private loadedPlugins: Set<string> = new Set();
-
-  constructor(pluginManager: PluginManager, baseLogger?: Logger) {
-    this.pluginManager = pluginManager;
-    this.logger = baseLogger?.createLogger('PluginLoader') ?? new Logger('PluginLoader');
-  }
-
-  /**
-   * Load only plugins needed by the collection
-   */
-  async loadRequiredPlugins(
-    resolved: ResolvedPlugin[],
-    requirements: PluginRequirements
-  ): Promise<void> {
-    const needed = this.filterNeededPlugins(resolved, requirements);
-    
-    this.logger.info(`Loading ${needed.length} required plugins (${resolved.length} available)`);
-    
-    const loadPromises = needed.map(plugin =>
-      this.loadPlugin(plugin).catch(err => {
-        this.logger.error(`Failed to load ${plugin.name}:`, err);
-        throw err;
-      })
-    );
-    
-    await Promise.all(loadPromises);
-    this.logger.debug('Required plugins loaded');
-  }
-
-  /**
-   * Filter resolved plugins to only those needed by collection
-   */
-  private filterNeededPlugins(
-    resolved: ResolvedPlugin[],
-    requirements: PluginRequirements
-  ): ResolvedPlugin[] {
-    const needed: ResolvedPlugin[] = [];
-
-    for (const plugin of resolved) {
-      let isNeeded = false;
-
-      if (plugin.type === 'protocol') {
-        // Check if collection uses this protocol
-        if (plugin.protocols?.some(p => requirements.protocols.has(p)) === true) {
-          isNeeded = true;
-        }
-      } else if (plugin.type === 'auth') {
-        // Check if collection uses any of these auth types
-        if (plugin.authTypes?.some(a => requirements.authTypes.has(a)) === true) {
-          isNeeded = true;
-        }
-      } else if (plugin.type === 'value') {
-        // Check if collection uses this value provider
-        const provider = plugin.provider;
-        if (provider !== null && provider !== undefined && provider !== '' && requirements.valueProviders.has(provider)) {
-          isNeeded = true;
-        }
-      }
-
-      if (isNeeded) {
-        this.logger.debug(`Plugin needed: ${plugin.name} v${plugin.version} (${plugin.type})`);
-        needed.push(plugin);
-      }
-    }
-
-    return needed;
-  }
-
-  /**
-   * Dynamically import and register a single plugin
-   */
-  private async loadPlugin(plugin: ResolvedPlugin): Promise<void> {
-    const { pathToFileURL } = await import('url');
-
-    // Skip if already loaded
-    if (this.loadedPlugins.has(plugin.name)) {
-      this.logger.debug(`Already loaded: ${plugin.name}`);
-      return;
-    }
-
-    this.logger.debug(`Loading ${plugin.name} v${plugin.version} from ${plugin.path}`);
-
-    // Mark as loaded
-    this.loadedPlugins.add(plugin.name);
-
-    // Convert to file:// URL for Windows compatibility
-    const moduleUrl = pathToFileURL(plugin.entryPoint).href;
-    const pluginModule = await import(moduleUrl) as Record<string, unknown>;
-
-    // Handle different export patterns
-    const defaultExport = pluginModule.default;
-    const namedExport = pluginModule[Object.keys(pluginModule)[0]];
-    const exported = defaultExport ?? namedExport;
-
-    if (exported === null || exported === undefined) {
-      throw new Error(`Plugin ${plugin.name} has no exports`);
-    }
-
-    // Register based on plugin type
-    if (plugin.type === 'protocol') {
-      this.pluginManager.registerPlugin(exported as IProtocolPlugin);
-      this.logger.debug(`Registered protocol plugin: ${plugin.protocols?.join(', ') ?? ''}`);
-    } else if (plugin.type === 'auth') {
-      // Auth plugins might export array or single
-      const authArray = Array.isArray(exported) ? (exported as IAuthPlugin[]) : [exported as IAuthPlugin];
-
-      for (const authPlugin of authArray) {
-        this.pluginManager.registerAuthPlugin(authPlugin);
-        this.logger.debug(`Registered auth plugin: ${authPlugin.authTypes.join(', ')}`);
-      }
-    } else if (plugin.type === 'value') {
-      this.pluginManager.registerVariableProvider(exported as IValueProviderPlugin);
-      this.logger.debug(`Registered value provider: ${plugin.provider ?? ''}`);
-    }
-  }
-}