@http-forge/core 0.1.0 → 0.2.1

package/dist/test-suite/result-storage.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Result Storage Interfaces for Test Suite
+ *
+ * SOLID Principles:
+ * - Interface Segregation: Separate interfaces for different concerns
+ * - Dependency Inversion: Define abstractions for storage operations
+ */
+import { ExecutionResult } from '../types/types';
+/**
+ * HTTP Method encoding for memory efficiency
+ * Using numbers instead of strings saves ~5 bytes per summary
+ */
+export declare const HTTP_METHOD_MAP: Record<string, number>;
+export declare const HTTP_METHOD_REVERSE: Record<number, string>;
+/**
+ * Compact Summary for memory efficiency (~150 bytes vs ~450 bytes)
+ * Sent to webview during run - contains only essential display data
+ */
+export interface ResultSummary {
+    /** Index within run (i) */
+    i: number;
+    /** Iteration 1-based (it) */
+    it: number;
+    /** Request name (n) */
+    n: string;
+    /** HTTP method code (m) - use HTTP_METHOD_REVERSE to decode */
+    m: number;
+    /** HTTP status code (s) */
+    s: number;
+    /** Duration in ms (d) */
+    d: number;
+    /** Passed (p) */
+    p: boolean;
+    /** Assertions passed count (ap) */
+    ap: number;
+    /** Assertions failed count (af) */
+    af: number;
+    /** Request ID (r) - used to rebuild filename */
+    r: string;
+    /** Error message if failed (e) - null if passed */
+    e: string | null;
+}
+/**
+ * Build result filename from summary components
+ */
+export declare function buildResultFileName(index: number, iteration: number, requestId: string): string;
+/**
+ * Helper to decode ResultSummary for display
+ */
+export declare function expandSummary(s: ResultSummary): {
+    index: number;
+    iteration: number;
+    name: string;
+    method: string;
+    status: number;
+    duration: number;
+    passed: boolean;
+    assertionsPassed: number;
+    assertionsFailed: number;
+    requestId: string;
+    resultFile: string;
+    error: string | null;
+};
+/**
+ * Per-request aggregated statistics
+ */
+export interface RequestStats {
+    /** Request name */
+    name: string;
+    /** Total executions */
+    count: number;
+    /** Passed executions */
+    passed: number;
+    /** Failed executions */
+    failed: number;
+    /** Total duration for averaging */
+    totalDuration: number;
+    /** Average duration */
+    avgDuration: number;
+    /** Minimum duration */
+    minDuration: number;
+    /** Maximum duration */
+    maxDuration: number;
+    /** 50th percentile */
+    p50?: number;
+    /** 90th percentile */
+    p90?: number;
+    /** 95th percentile */
+    p95?: number;
+    /** 99th percentile */
+    p99?: number;
+}
+/**
+ * Overall run statistics
+ */
+export interface RunStats {
+    /** Total requests executed */
+    totalRequests: number;
+    /** Passed requests */
+    passed: number;
+    /** Failed requests */
+    failed: number;
+    /** Skipped requests */
+    skipped: number;
+    /** Total duration */
+    totalDuration: number;
+    /** Average duration */
+    avgDuration: number;
+    /** Minimum duration */
+    minDuration: number;
+    /** Maximum duration */
+    maxDuration: number;
+}
+/**
+ * Run configuration stored in manifest
+ */
+export interface RunConfig {
+    /** Number of iterations */
+    iterations: number;
+    /** Delay between requests in ms */
+    delayBetweenRequests: number;
+    /** Whether to stop on error */
+    stopOnError: boolean;
+}
+/**
+ * Run manifest (metadata only - kept small)
+ */
+export interface RunManifest {
+    /** Schema version */
+    version: string;
+    /** Unique run ID */
+    runId: string;
+    /** Suite ID */
+    suiteId: string;
+    /** Suite name */
+    suiteName: string;
+    /** Environment used */
+    environment: string;
+    /** Run start time */
+    startTime: string;
+    /** Run end time */
+    endTime?: string;
+    /** Run status */
+    status: 'running' | 'completed' | 'aborted' | 'error';
+    /** Run configuration */
+    config: RunConfig;
+    /** Aggregated statistics */
+    stats: RunStats;
+    /** Per-request statistics */
+    requestStats: Record<string, RequestStats>;
+    /** Total index pages */
+    totalIndexPages: number;
+    /** Summaries per index page */
+    indexPageSize: number;
+}
+/**
+ * Full result details (loaded on demand from file)
+ */
+export interface FullResultDetails {
+    /** Result index */
+    index: number;
+    /** Iteration number */
+    iteration: number;
+    /** Request ID */
+    requestId: string;
+    /** Request name */
+    name: string;
+    /** HTTP method */
+    method: string;
+    /** Full URL */
+    url: string;
+    /** HTTP status code */
+    status: number;
+    /** HTTP status text */
+    statusText: string;
+    /** Duration in milliseconds */
+    duration: number;
+    /** Whether request passed */
+    passed: boolean;
+    /** Execution timestamp */
+    timestamp: number;
+    /** Request details */
+    request: {
+        headers: Record<string, string>;
+        body: any;
+    };
+    /** Response details */
+    response: {
+        headers: Record<string, string | string[]>;
+        body: any;
+    };
+    /** Test assertions */
+    assertions: Array<{
+        name: string;
+        passed: boolean;
+        message: string | null;
+    }>;
+    /** Error message */
+    error: string | null;
+}
+/**
+ * Index page containing summaries
+ */
+export interface IndexPage {
+    /** Page number (1-based) */
+    page: number;
+    /** Starting index */
+    startIndex: number;
+    /** Number of summaries in this page */
+    count: number;
+    /** Summaries */
+    summaries: ResultSummary[];
+}
+/**
+ * Recent error for UI display
+ */
+export interface RecentError {
+    /** Timestamp */
+    timestamp: number;
+    /** Iteration number */
+    iteration: number;
+    /** Request name */
+    requestName: string;
+    /** HTTP status */
+    status: number;
+    /** Error message */
+    error: string;
+    /** Result file reference */
+    resultFile: string;
+}
+/**
+ * Result Storage Service Interface
+ * Single Responsibility: Defines contract for result persistence
+ */
+export interface IResultStorageService {
+    /**
+     * Get the base path for result storage
+     */
+    getBasePath(): string;
+    /**
+     * Initialize a new run
+     */
+    initializeRun(suiteId: string, suiteName: string, environment: string, config: RunConfig): Promise<string>;
+    /**
+     * Save a request result
+     * Returns lightweight summary for UI
+     */
+    saveResult(iteration: number, result: ExecutionResult): Promise<ResultSummary>;
+    /**
+     * Finalize run
+     */
+    finalizeRun(status: 'completed' | 'aborted' | 'error'): Promise<void>;
+    /**
+     * Get current run stats
+     */
+    getCurrentStats(): {
+        stats: RunStats;
+        requestStats: Record<string, RequestStats>;
+        recentErrors: RecentError[];
+    } | null;
+    /**
+     * Get current run ID
+     */
+    getCurrentRunId(): string | null;
+    /**
+     * Get current suite ID
+     */
+    getCurrentSuiteId(): string | null;
+    /**
+     * Get full result details from file
+     */
+    getResultDetails(suiteId: string, runId: string, resultFile: string): Promise<FullResultDetails>;
+    /**
+     * Get index page
+     */
+    getIndexPage(suiteId: string, runId: string, page: number): Promise<IndexPage>;
+    /**
+     * Get run manifest
+     */
+    getManifest(suiteId: string, runId: string): Promise<RunManifest>;
+    /**
+     * List all runs for a suite
+     */
+    listRuns(suiteId: string): Promise<RunManifest[]>;
+    /**
+     * Delete a run
+     */
+    deleteRun(suiteId: string, runId: string): Promise<void>;
+    /**
+     * Clean up old runs based on retention policy
+     */
+    cleanupOldRuns(): Promise<{
+        deleted: number;
+        freed: number;
+    }>;
+}

package/dist/test-suite/statistics-service.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Statistics Service
+ *
+ * Real-time statistics calculation for Test Suite runs
+ * Calculates P50, P90, P95, P99 percentiles
+ */
+import { ErrorSummary, IStatisticsService, RequestStatistics, RunStatistics, RunSummary } from './interfaces';
+/**
+ * Service for calculating real-time run statistics
+ */
+export declare class StatisticsService implements IStatisticsService {
+    private summary;
+    private byRequest;
+    private overall;
+    private errors;
+    private startTime;
+    constructor();
+    /**
+     * Create empty summary
+     */
+    private createEmptySummary;
+    /**
+     * Start a new run
+     */
+    start(): void;
+    /**
+     * Reset statistics for a new run
+     */
+    reset(): void;
+    /**
+     * Mark run as complete
+     */
+    complete(): void;
+    /**
+     * Add a result and update statistics
+     */
+    addResult(requestName: string, duration: number, passed: boolean, skipped: boolean, error?: string): void;
+    /**
+     * Get current statistics
+     */
+    getStatistics(): RunStatistics;
+    /**
+     * Get serializable statistics (for sending to webview or CLI)
+     */
+    getSerializableStatistics(): {
+        summary: RunSummary;
+        byRequest: Array<RequestStatistics>;
+        overall: RequestStatistics;
+        errors: ErrorSummary[];
+    };
+}

package/dist/test-suite/test-suite-service.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Test Suite Service
+ *
+ * Manages CRUD operations for Test Suites.
+ * Platform-agnostic version (no VS Code dependency).
+ */
+import { ICollectionService } from '../collection/interfaces';
+import { IConfigService } from '../config';
+import { ITestSuiteService, SuiteRequest, TestSuite } from './interfaces';
+/**
+ * Callback invoked when the suites on disk change.
+ */
+export type SuitesChangedCallback = () => void;
+/**
+ * Service for managing Test Suites
+ */
+export declare class TestSuiteService implements ITestSuiteService {
+    private collectionService;
+    private configService;
+    readonly suitesDir: string;
+    protected suites: Map<string, TestSuite>;
+    /** Native file watcher (if watching is enabled) */
+    private fileWatcher;
+    /** Debounce timer for coalescing rapid change events */
+    private debounceTimer;
+    /** External listener notified after suites are reloaded */
+    private onSuitesChanged?;
+    constructor(collectionService: ICollectionService, configService: IConfigService, options?: {
+        watch?: boolean;
+        onSuitesChanged?: SuitesChangedCallback;
+    });
+    /**
+     * Ensure suites directory exists
+     */
+    private ensureSuitesDir;
+    /**
+     * Set up a file-system watcher on the suites directory.
+     * Uses Node.js `fs.watch` — no VS Code dependency.
+     * Changes are debounced so rapid edits trigger a single reload.
+     */
+    private setupFileWatcher;
+    /**
+     * Stop watching and release resources.
+     */
+    dispose(): void;
+    /**
+     * Load all suites from disk
+     */
+    loadSuites(): void;
+    /**
+     * Get all suites
+     */
+    getAllSuites(): Promise<TestSuite[]>;
+    /**
+     * Get a suite by ID
+     */
+    getSuite(id: string): Promise<TestSuite | undefined>;
+    /**
+     * Create a new suite
+     */
+    createSuite(name: string, requests?: SuiteRequest[]): Promise<TestSuite>;
+    /**
+     * Update an existing suite
+     */
+    updateSuite(suite: TestSuite): Promise<void>;
+    /**
+     * Delete a suite
+     */
+    deleteSuite(id: string): Promise<boolean>;
+    /**
+     * Create a temporary suite from a collection
+     */
+    createTempSuiteFromCollection(collectionId: string): Promise<TestSuite | undefined>;
+    /**
+     * Save a temporary suite as a permanent one
+     */
+    saveTempSuite(suite: TestSuite, name: string): Promise<TestSuite>;
+    /**
+     * Get all requests from all collections for the Add Request modal
+     */
+    getAllAvailableRequests(): Array<{
+        collectionId: string;
+        collectionName: string;
+        requestId: string;
+        name: string;
+        method: string;
+        folderPath: string;
+    }>;
+    /**
+     * Recursively extract requests from collection items
+     */
+    private extractRequestsFromCollection;
+    /**
+     * Save suite to disk
+     */
+    private saveSuiteToDisk;
+}

package/dist/test-suite/test-suite-store.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Test Suite Store
+ *
+ * Manages suite requests that can come from different collections.
+ * Resolves requests fresh from ICollectionService to ensure latest data.
+ *
+ * Single Responsibility: Maintain suite state and resolve requests from collections
+ * Dependency Inversion: Depends on ICollectionService abstraction
+ */
+import { CollectionRequest, ICollectionService, RequestScripts } from '../collection/interfaces';
+import { SuiteRequest, TestSuite } from './interfaces';
+/**
+ * Cached request entry with full context
+ */
+export interface SuiteRequestEntry {
+    /** The full request object from the source collection */
+    request: CollectionRequest;
+    /** Suite request metadata */
+    suiteRequest: SuiteRequest;
+    /** Collection scripts */
+    collectionScripts?: RequestScripts;
+    /** Folder scripts chain */
+    folderScriptsChain: RequestScripts[];
+}
+/**
+ * Interface for TestSuiteStore
+ */
+export interface ITestSuiteStore {
+    /**
+     * Set the test suite
+     */
+    setSuite(suite: TestSuite): void;
+    /**
+     * Get the current suite
+     */
+    getSuite(): TestSuite | undefined;
+    /**
+     * Get a request by ID with full context (collection scripts + folder scripts)
+     */
+    getRequestWithContext(collectionId: string, requestId: string): SuiteRequestEntry | undefined;
+    /**
+     * Get all suite requests with their resolved data
+     */
+    getAllSuiteRequests(): SuiteRequestEntry[];
+    /**
+     * Get resolved requests for webview display
+     */
+    getResolvedRequests(): Array<{
+        id: string;
+        collectionId: string;
+        requestId: string;
+        name: string;
+        method: string;
+        url: string;
+        collectionName: string;
+        folderPath: string;
+        enabled: boolean;
+    }>;
+    /**
+     * Get suite requests by selection state
+     * @param selectedIds IDs of selected requests in execution order
+     */
+    getSelectedRequests(selectedIds: string[]): SuiteRequestEntry[];
+    /**
+     * Add a request to the suite
+     */
+    addRequest(request: SuiteRequest): void;
+    /**
+     * Remove a request from the suite
+     */
+    removeRequest(requestId: string): void;
+    /**
+     * Reorder requests
+     */
+    reorderRequests(requestIds: string[]): void;
+}
+/**
+ * Implementation of TestSuiteStore
+ */
+export declare class TestSuiteStore implements ITestSuiteStore {
+    private readonly collectionService;
+    private suite;
+    constructor(collectionService: ICollectionService);
+    /**
+     * Set the suite
+     */
+    setSuite(suite: TestSuite): void;
+    /**
+     * Get the current suite
+     */
+    getSuite(): TestSuite | undefined;
+    /**
+     * Resolve a suite request to its full request data
+     */
+    private resolveRequest;
+    /**
+     * Find a request in a collection, including folder scripts
+     */
+    private findRequestInCollection;
+    /**
+     * Recursively search for a request
+     */
+    private searchItems;
+    /**
+     * Normalize request data
+     */
+    private normalizeRequest;
+    /**
+     * Normalize key-value array or object to standard format
+     * Handles both array format [{key, value}] and object format {key: value}
+     */
+    private normalizeKeyValues;
+    /**
+     * Get a request with full context
+     * Always resolves fresh from collection service to ensure latest data
+     */
+    getRequestWithContext(collectionId: string, requestId: string): SuiteRequestEntry | undefined;
+    /**
+     * Get all suite requests with resolved data
+     * Always resolves fresh from collection service to ensure latest data
+     */
+    getAllSuiteRequests(): SuiteRequestEntry[];
+    /**
+     * Get resolved requests for webview display
+     * Returns simplified format with display-relevant properties
+     */
+    getResolvedRequests(): Array<{
+        id: string;
+        collectionId: string;
+        requestId: string;
+        name: string;
+        method: string;
+        url: string;
+        collectionName: string;
+        folderPath: string;
+        enabled: boolean;
+    }>;
+    /**
+     * Get selected requests in order
+     * Always resolves fresh from collection service to ensure latest data
+     */
+    getSelectedRequests(selectedIds: string[]): SuiteRequestEntry[];
+    /**
+     * Add a request to the suite
+     */
+    addRequest(request: SuiteRequest): void;
+    /**
+     * Remove a request from the suite
+     */
+    removeRequest(requestId: string): void;
+    /**
+     * Reorder requests by request IDs (format: "collectionId:requestId")
+     */
+    reorderRequests(orderedKeys: string[]): void;
+}

package/dist/types/console-service.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Console Service Interface
+ *
+ * Platform-agnostic logging abstraction.
+ * VS Code extension implements this with an Output Channel.
+ * Standalone / CLI can implement with stdout or a file logger.
+ */
+/**
+ * Log levels for console output
+ */
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Log entry with metadata
+ */
+export interface LogEntry {
+    timestamp: Date;
+    level: LogLevel;
+    message: string;
+    source?: string;
+    context?: Record<string, unknown>;
+}
+/**
+ * Console service interface for unified logging
+ */
+export interface IConsoleService {
+    log(level: LogLevel, message: string, source?: string): void;
+    trace(message: string, source?: string): void;
+    debug(message: string, source?: string): void;
+    info(message: string, source?: string): void;
+    warn(message: string, source?: string): void;
+    error(message: string, source?: string): void;
+    logBatch(entries: Array<{
+        level: LogLevel;
+        message: string;
+    }>, source?: string): void;
+    logRawLines(lines: string[], source?: string): void;
+    show(preserveFocus?: boolean): void;
+    clear(): void;
+    dispose(): void;
+}