@apiquest/fracture 1.0.4 → 1.0.5

package/src/QuestAPI.types.ts

@@ -1,33 +0,0 @@
-// Type definitions for Quest API
-
-export interface RequestConfig {
-  url: string;
-  method?: string;
-  header?: Record<string, string>;
-  headers?: Record<string, string>;
-  body?: string | RequestBody;
-}
-
-export interface RequestBody {
-  mode?: 'raw' | 'urlencoded' | 'formdata';
-  raw?: string;
-  urlencoded?: Array<{ key: string; value: string }>;
-  formdata?: Array<{ key: string; value: string }>;
-}
-
-export interface ResponseObject {
-  status: number;
-  statusText: string;
-  body: string;
-  headers: Record<string, string | string[]>;
-  time: number;
-  json(): unknown | null;
-  text(): string;
-}
-
-export interface HistoryFilterCriteria {
-  path?: string;
-  name?: string;
-  iteration?: number;
-  id?: string;
-}

package/src/QuestTestAPI.ts

@@ -1,164 +0,0 @@
-import type { TestResult } from '@apiquest/types';
-import { ScriptType } from '@apiquest/types';
-
-/**
- * Special error class for quest.skip()
- */
-class SkipError extends Error {
-  public readonly skipReason: string;
-  
-  constructor(message: string) {
-    super(message);
-    this.name = 'SkipError';
-    this.skipReason = message;
-  }
-}
-
-function isPromise(value: unknown): value is Promise<void> {
-  return value !== null &&
-         value !== undefined &&
-         typeof value === 'object' &&
-         typeof (value as { then?: unknown }).then === 'function';
-}
-
-/**
- * Creates the test API methods (quest.test, quest.skip, quest.fail)
- * These methods allow scripts to define and control test assertions
- */
-export function createQuestTestAPI(
-  tests: TestResult[],
-  scriptType: ScriptType,
-  emitAssertion: (test: TestResult) => void,
-  abortSignal?: AbortSignal
-): {
-  test: (name: string, fn: () => void | Promise<void>) => void;
-  skip: (reason: string) => never;
-  fail: (message: string) => never;
-} {
-  let isInsideTest = false;
-
-  return {
-    /**
-     * Define a test assertion
-     * Can only be called in postRequestScript or plugin event scripts
-     */
-    test(name: string, fn: () => void | Promise<void>) {
-      // Enforce: tests can only be called in request post scripts (never pre, folder, or collection)
-      const allowedScriptTypes = [
-        ScriptType.PostRequest,
-        ScriptType.PluginEvent
-      ];
-      if (!allowedScriptTypes.includes(scriptType)) {
-        throw new Error(
-          `quest.test() can only be called in request post scripts. ` +
-          `Current script type: ${scriptType}. ` +
-          `Tests require request/response context and cannot be used in ` +
-          `collectionPost, folderPost, or pre-request scripts.`
-        );
-      }
-      
-      // Check abort signal - skip test if already aborted
-      if (abortSignal?.aborted === true) {
-        const testResult: TestResult = {
-          name,
-          passed: false,
-          skipped: true,
-          error: 'Test skipped - execution aborted'
-        };
-        tests.push(testResult);
-        emitAssertion(testResult);
-        return;
-      }
-      
-      isInsideTest = true;
-      try {
-        const result = fn();
-        
-        // If fn returns a Promise, handle it
-        if (isPromise(result)) {
-          result
-            .then(() => {
-              const testResult: TestResult = {
-                name,
-                passed: true,
-                skipped: false
-              };
-              tests.push(testResult);
-              emitAssertion(testResult);
-            })
-            .catch((error: unknown) => {
-              // Check if this is a skip error
-              const testResult: TestResult = error instanceof SkipError
-                ? {
-                    name,
-                    passed: false,
-                    skipped: true,
-                    error: error.skipReason
-                  }
-                : {
-                    name,
-                    passed: false,
-                    skipped: false,
-                    error: (error as { message?: string }).message ?? String(error)
-                  };
-              tests.push(testResult);
-              emitAssertion(testResult);
-            })
-            .finally(() => {
-              isInsideTest = false;
-            });
-        } else {
-          // Synchronous test
-          const testResult: TestResult = {
-            name,
-            passed: true,
-            skipped: false
-          };
-          tests.push(testResult);
-          emitAssertion(testResult);
-          isInsideTest = false;
-        }
-      } catch (error: unknown) {
-        // Check if this is a skip error
-        const testResult: TestResult = error instanceof SkipError
-          ? {
-              name,
-              passed: false,
-              skipped: true,
-              error: error.skipReason  // Include skip reason in error field
-            }
-          : {
-              name,
-              passed: false,
-              skipped: false,
-              error: (error as { message?: string }).message ?? String(error)
-            };
-        tests.push(testResult);
-        emitAssertion(testResult);
-        isInsideTest = false;
-      }
-    },
-
-    /**
-     * Skip the current test
-     * Must be called inside quest.test() callback
-     */
-    skip(reason: string): never {
-      if (!isInsideTest) {
-        throw new Error('quest.skip() must be called inside quest.test() callback');
-      }
-      throw new SkipError(reason);
-    },
-
-    /**
-     * Fail the current test with custom message
-     * Must be called inside quest.test() callback
-     */
-    fail(message: string): never {
-      if (!isInsideTest) {
-        throw new Error('quest.fail() must be called inside quest.test() callback');
-      }
-      throw new Error(message);
-    }
-  };
-}

package/src/RequestFilter.ts

@@ -1,224 +0,0 @@
-import type { Collection, CollectionItem, Folder, Request, PathType } from '@apiquest/types';
-
-export interface FilterOptions {
-  filter?: string;
-  excludeDeps?: boolean;
-  pruneEmptyFolders?: boolean;  // Default: true
-}
-
-interface ItemWithPath {
-  item: CollectionItem;
-  path: PathType;
-}
-
-export class RequestFilter {
-  /**
-   * Filter collection removing non-matching requests and empty folders
-   * Returns filtered copy or original if no filtering
-   */
-  static filterCollection(collection: Collection, options: FilterOptions): Collection {
-    if (options.filter === undefined) {
-      return collection;
-    }
-    
-    const filterSet = this.getFilterSet(collection, options);
-    if (filterSet === null) {
-      return collection;
-    }
-    
-    const pruneEmpty = options.pruneEmptyFolders !== false;
-    
-    // Clone collection and filter items
-    const filtered: Collection = {
-      ...collection,
-      items: this.filterItems(collection.items, filterSet, pruneEmpty)
-    };
-    
-    return filtered;
-  }
-  
-  /**
-   * Recursively filter items keeping only requests in filterSet
-   * Optionally prune empty folders
-   */
-  private static filterItems(
-    items: CollectionItem[],
-    filterSet: Set<string>,
-    pruneEmpty: boolean
-  ): CollectionItem[] {
-    const filtered: CollectionItem[] = [];
-    
-    for (const item of items) {
-      if (item.type === 'request') {
-        if (filterSet.has(item.id)) {
-          filtered.push(item);
-        }
-      } else {
-        // Folder: recursively filter children
-        const filteredChildren = this.filterItems(item.items, filterSet, pruneEmpty);
-        
-        if (!pruneEmpty || filteredChildren.length > 0) {
-          filtered.push({
-            ...item,
-            items: filteredChildren
-          });
-        }
-      }
-    }
-    
-    return filtered;
-  }
-  
-  /**
-   * Get set of request IDs to execute
-   * Returns null if no filtering needed
-   */
-  private static getFilterSet(collection: Collection, options: FilterOptions): Set<string> | null {
-    if (options.filter === undefined) {
-      return null;
-    }
-    
-    // Collect requests matching filter
-    const matchingIds = new Set<string>();
-    try {
-      const filterRegex = new RegExp(options.filter);
-      
-      // Walk collection structure and match paths
-      this.collectMatchingRequests(collection.items, 'collection:/', filterRegex, matchingIds);
-    } catch (error) {
-      // Invalid regex - no filtering
-      return null;
-    }
-
-    if (options.excludeDeps !== true) {
-      return this.includeDependencies(collection, matchingIds);
-    }
-    
-    return matchingIds;
-  }
-  
-  /**
-   * Build path with proper type prefix (same logic as TaskGraph.buildPath)
-   */
-  private static buildPath(parent: string, name: string, type: 'folder' | 'request'): PathType {
-    // If parent is collection:/
-    if (parent === 'collection:/') {
-      return `${type}:/${name}` as PathType;
-    }
-    
-    // Remove type prefix from parent path
-    const basePath = parent.replace(/^(folder|request):\//, '');
-    return `${type}:/${basePath}/${name}` as PathType;
-  }
-  
-  /**
-   * Collect requests matching path filter (regex)
-   * Matches against both folder and request paths
-   * If a folder matches, all requests in that folder are included
-   */
-  private static collectMatchingRequests(
-    items: CollectionItem[],
-    parentPath: string,
-    filterRegex: RegExp,
-    result: Set<string>
-  ): void {
-    for (const item of items) {
-      if (item.type === 'folder') {
-        const folderPath = this.buildPath(parentPath, item.name, 'folder');
-        const folderMatches = filterRegex.test(folderPath);
-        
-        if (folderMatches) {
-          // Folder matches - include ALL requests in this folder
-          this.collectAllRequests(item.items, result);
-        }
-        
-        // Always recurse to children
-        this.collectMatchingRequests(item.items, folderPath, filterRegex, result);
-      } else {
-        // Request
-        const requestPath = this.buildPath(parentPath, item.name, 'request');
-        const requestMatches = filterRegex.test(requestPath);
-        
-        if (requestMatches) {
-          result.add(item.id);
-        }
-      }
-    }
-  }
-  
-  /**
-   * Collect all requests from items (helper for when folder matches)
-   */
-  private static collectAllRequests(items: CollectionItem[], result: Set<string>): void {
-    for (const item of items) {
-      if (item.type === 'request') {
-        result.add(item.id);
-      } else {
-        this.collectAllRequests(item.items, result);
-      }
-    }
-  }
-  
-  /**
-   * Include dependencies by walking collection and resolving dependsOn
-   */
-  private static includeDependencies(
-    collection: Collection,
-    matchingIds: Set<string>
-  ): Set<string> {
-    const result = new Set<string>();
-    const depMap = new Map<string, string[]>();
-    
-    // Build dependency map
-    this.buildDependencyMap(collection.items, depMap);
-    
-    // Resolve dependencies recursively
-    for (const requestId of matchingIds) {
-      this.resolveDependencies(requestId, depMap, result);
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Build map of request/folder ID -> dependencies
-   */
-  private static buildDependencyMap(
-    items: CollectionItem[],
-    depMap: Map<string, string[]>
-  ): void {
-    for (const item of items) {
-      if (item.type === 'request') {
-        depMap.set(item.id, item.dependsOn ?? []);
-      } else {
-        // Folders can also have dependencies
-        const folder = item;
-        const folderDeps = folder.dependsOn;
-        if (folderDeps !== undefined && folderDeps.length > 0) {
-          depMap.set(folder.id, folderDeps);
-        }
-        
-        // Recurse to children
-        this.buildDependencyMap(folder.items, depMap);
-      }
-    }
-  }
-  
-  /**
-   * Recursively resolve dependencies for a request/folder
-   */
-  private static resolveDependencies(
-    itemId: string,
-    depMap: Map<string, string[]>,
-    result: Set<string>
-  ): void {
-    result.add(itemId);
-    
-    const deps = depMap.get(itemId) ?? [];
-    for (const depId of deps) {
-      if (!result.has(depId)) {
-        this.resolveDependencies(depId, depMap, result);
-      }
-    }
-  }
-}

package/src/ScriptEngine.ts

@@ -1,219 +0,0 @@
-import vm from 'vm';
-import { expect } from 'chai';
-import _ from 'lodash';
-import type { ExecutionContext, ScriptResult, TestResult } from '@apiquest/types';
-import { ScriptType } from '@apiquest/types';
-import { Logger } from './Logger.js';
-import { createQuestAPI } from './QuestAPI.js';
-import { isNullOrWhitespace } from './utils.js';
-
-interface ConsoleAPI {
-  log(...args: unknown[]): void;
-  info(...args: unknown[]): void;
-  warn(...args: unknown[]): void;
-  error(...args: unknown[]): void;
-}
-
-export class ScriptEngine {
-  private tests: TestResult[] = [];
-  private consoleOutput: string[] = [];
-  private logger: Logger;
-
-  constructor(baseLogger?: Logger) {
-    this.logger = baseLogger?.createLogger('ScriptEngine') ?? new Logger('ScriptEngine');
-  }
-
-  /**
-   * Execute a script in VM context with quest API
-   */
-  async execute(
-    script: string,
-    context: ExecutionContext,
-    scriptType: ScriptType,
-    emitAssertion: (test: TestResult) => void
-  ): Promise<ScriptResult> {
-    if (isNullOrWhitespace(script)) {
-      this.logger.trace('Empty script, skipping execution');
-      return {
-        success: true,
-        tests: [],
-        consoleOutput: []
-      };
-    }
-
-    const scriptPreview = script.length > 100 ? script.substring(0, 100) + '...' : script;
-    this.logger.debug(`Executing ${scriptType} script (${script.length} chars)`);
-    this.logger.trace(`Script preview: ${scriptPreview}`);
-
-    this.tests = [];
-    this.consoleOutput = [];
-
-    try {
-      this.logger.trace('Creating quest API sandbox');
-      const questAPI = createQuestAPI(context, scriptType, this.tests, emitAssertion);
-
-      const sandbox = {
-        quest: questAPI,
-        expect,
-        _,
-        console: this.createConsoleAPI(),
-        require: this.createRequire(),
-        setTimeout,
-        setInterval,
-        clearTimeout,
-        clearInterval,
-        Promise,
-        Buffer,
-        AbortController,
-        AbortSignal,
-        signal: context.abortSignal
-      };
-
-      const vmContext = vm.createContext(sandbox);
-      this.logger.trace('VM context created');
-
-      // Wrap script in async function to support top-level await
-      const wrappedScript = `
-        (async () => {
-          ${script}
-        })()
-      `;
-
-      // Execute script and get the promise
-      const startTime = Date.now();
-      const result = vm.runInContext(wrappedScript, vmContext, {
-        timeout: 30000,
-        displayErrors: true
-      }) as unknown;
-
-      // If result is a promise, wait for it
-      if (result !== null && result !== undefined && typeof (result as { then?: unknown }).then === 'function') {
-        await (result as Promise<void>);
-      }
-
-      // Wait for any other pending promises
-      await new Promise(resolve => setImmediate(resolve));
-
-      const duration = Date.now() - startTime;
-      this.logger.debug(`Script executed successfully in ${duration}ms`);
-      this.logger.trace(`Tests collected: ${this.tests.length}, Console output: ${this.consoleOutput.length} lines`);
-
-      return {
-        success: true,
-        tests: this.tests,
-        consoleOutput: this.consoleOutput
-      };
-    } catch (error: unknown) {
-      const errorMsg = (error as { message?: string }).message ?? String(error);
-      const errorStack = (error as { stack?: string }).stack;
-      const errorName = (error as { name?: string }).name;
-      
-      // Check if this was an abort
-      if (errorName === 'AbortError' || errorMsg.includes('abort') || errorMsg.includes('Abort')) {
-        this.logger.debug('Script execution interrupted by abort signal');
-        return {
-          success: false,
-          tests: this.tests,
-          error: 'Script aborted',
-          consoleOutput: this.consoleOutput
-        };
-      }
-      
-      this.logger.error(`Script execution failed: ${errorMsg}`);
-      if (errorStack !== undefined) {
-        this.logger.trace(`Error stack: ${errorStack}`);
-      }
-      return {
-        success: false,
-        tests: this.tests,
-        error: errorMsg,
-        consoleOutput: this.consoleOutput
-      };
-    }
-  }
-
-  /**
-   * Create console API that captures output
-   */
-  private createConsoleAPI(): ConsoleAPI {
-    const self = this;
-    
-    const safeStringify = (value: unknown): string => {
-      if (typeof value === 'string') return value;
-      if (value === null || value === undefined) return String(value);
-      if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
-      if (typeof value === 'symbol') return value.toString();
-      if (typeof value === 'function') return '[Function]';
-
-      try {
-        const seen = new WeakSet<object>();
-        return JSON.stringify(
-          value,
-          (_key, val: unknown) => {
-            if (typeof val === 'bigint') {
-              return val.toString();
-            }
-            if (typeof val === 'function') {
-              return '[Function]';
-            }
-            if (typeof val === 'symbol') {
-              return val.toString();
-            }
-            if (typeof val === 'object' && val !== null) {
-              if (seen.has(val)) {
-                return '[Circular]';
-              }
-              seen.add(val);
-            }
-            return val as string | number | boolean | null;
-          },
-          2
-        );
-      } catch {
-        return String(value);
-      }
-    };
-
-    return {
-      log(...args: unknown[]) {
-        const message = args.map(safeStringify).join(' ');
-        self.consoleOutput.push(message);
-        console.log(message);
-      },
-      info(...args: unknown[]) {
-        const message = args.map(safeStringify).join(' ');
-        self.consoleOutput.push(`[INFO] ${message}`);
-        console.info(message);
-      },
-      warn(...args: unknown[]) {
-        const message = args.map(safeStringify).join(' ');
-        self.consoleOutput.push(`[WARN] ${message}`);
-        console.warn(message);
-      },
-      error(...args: unknown[]) {
-        const message = args.map(safeStringify).join(' ');
-        self.consoleOutput.push(`[ERROR] ${message}`);
-        console.error(message);
-      }
-    };
-  }
-
-  /**
-   * Create minimal require function
-   */
-  private createRequire() {
-    return (moduleName: string) => {
-      const allowedModules: Record<string, unknown> = {
-        'chai': require('chai') as unknown,
-        'lodash': require('lodash') as unknown,
-        'moment': require('moment') as unknown
-      };
-
-      if (moduleName in allowedModules) {
-        return allowedModules[moduleName];
-      }
-
-      throw new Error(`Module '${moduleName}' is not allowed in scripts`);
-    };
-  }
-}