@http-forge/core 0.2.0 → 0.2.2

package/dist/{script → infrastructure/script}/interfaces.d.ts

@@ -8,7 +8,7 @@
  * Interface Segregation: Each interface has a focused purpose
  */
 import { Cookie } from '../cookie/interfaces';
-import { PreparedRequest, RequestAuth, RequestBody, RequestScripts, RequestSettings, ScriptInfo, TestAssertion } from '../types/types';
+import { PreparedRequest, RequestAuth, RequestBody, RequestScripts, RequestSettings, ScriptInfo, TestAssertion } from '../../types/types';
 export type { Cookie, ScriptInfo };
 /**
  * Cookie Jar Interface
@@ -68,6 +68,7 @@ export interface CommonScriptContext {
     info?: ScriptInfo;
     iteration?: number;
     iterationCount?: number;
+    iterationData?: Record<string, any>;
     onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
     onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
 }
@@ -98,6 +99,10 @@ export interface PreRequestScriptResult {
     modifiedSessionVariables?: Record<string, string>;
     modifiedEnvironmentVariables?: Record<string, string>;
     consoleOutput?: string[];
+    /** Postman-compatible: pm.execution.setNextRequest() value. null = stop runner. */
+    nextRequest?: string | null;
+    /** Postman-compatible: pm.execution.skipRequest() was called */
+    skipRequest?: boolean;
 }
 /**
  * Script execution result for post-response scripts
@@ -107,6 +112,13 @@ export interface PostResponseScriptResult {
     consoleOutput?: string[];
     modifiedEnvironmentVariables?: Record<string, string>;
     modifiedSessionVariables?: Record<string, string>;
+    /** Postman-compatible: pm.execution.setNextRequest() value. null = stop runner. */
+    nextRequest?: string | null;
+    /** Postman-compatible: pm.visualizer.set(template, data) output */
+    visualizerData?: {
+        template: string;
+        data?: any;
+    };
 }
 /**
  * Test script execution context

package/dist/{script → infrastructure/script}/request-script-session.d.ts

@@ -36,6 +36,9 @@ export declare class RequestScriptSession implements IRequestScriptSession {
     private _globals;
     private _sessionVariables;
     private _environmentVariables;
+    private _nextRequest;
+    private _skipRequest;
+    private _visualizerData;
     constructor(deps: SessionDependencies, initialContext: PreRequestScriptContext);
     /**
      * Initialize the shared VM context

package/dist/{script → infrastructure/script}/script-factories.d.ts

@@ -28,6 +28,7 @@ export interface ScriptResponse {
 }
 /**
  * Response assertion helpers (Postman-style)
+ * Note: be.ok/error/etc. are getters that execute assertions on property access
  */
 export interface ResponseAssertions {
     have: {
@@ -37,10 +38,11 @@ export interface ResponseAssertions {
         jsonBody(expectedJson?: any): void;
     };
     be: {
-        ok(): void;
-        error(): void;
-        clientError(): void;
-        serverError(): void;
+        readonly ok: any;
+        readonly success: any;
+        readonly error: any;
+        readonly clientError: any;
+        readonly serverError: any;
     };
 }
 /**
@@ -54,14 +56,17 @@ export declare function createResponseObject(response: ResponseContext): ScriptR
 export interface ExpectChain {
     _value: any;
     _negated: boolean;
+    _deep: boolean;
     not: ExpectChain;
     to: ExpectChain;
     be: ExpectChain;
     have: ExpectChain;
+    deep: ExpectChain;
     equal(expected: any): ExpectChain;
     eql(expected: any): ExpectChain;
     property(name: string, value?: any): ExpectChain;
     ok: ExpectChain;
+    exist: ExpectChain;
     include(value: any): ExpectChain;
     oneOf(values: any[]): ExpectChain;
     match(pattern: RegExp): ExpectChain;
@@ -70,12 +75,18 @@ export interface ExpectChain {
     greaterThan(num: number): ExpectChain;
     lessThan(num: number): ExpectChain;
     within(start: number, end: number): ExpectChain;
+    a(type: string): ExpectChain;
+    an(type: string): ExpectChain;
     true: ExpectChain;
     false: ExpectChain;
     null: ExpectChain;
     undefined: ExpectChain;
     empty: ExpectChain;
     length(len: number): ExpectChain;
+    lengthOf(len: number): ExpectChain;
+    members(arr: any[]): ExpectChain;
+    keys(...args: any[]): ExpectChain;
+    string(substr: string): ExpectChain;
 }
 /**
  * Create Chai-style expect chain for assertions

package/dist/{script → infrastructure/script}/script-utils.d.ts

@@ -4,7 +4,7 @@
  * Single Responsibility: Pure utility functions for script execution
  * These are stateless helper functions with no side effects
  */
-import { TestAssertion } from '../types/types';
+import { TestAssertion } from '../../types/types';
 /**
  * Console message structure for script output
  */
@@ -32,8 +32,9 @@ export declare function formatConsoleOutput(messages: ConsoleMessage[]): string[
 export declare function createScriptConsole(messages: ConsoleMessage[]): Console;
 /**
  * Create a test function that records assertions
+ * Supports both sync and async test functions (Postman-compatible)
  */
-export declare function createTestFunction(assertions: TestAssertion[]): (name: string, fn: () => void) => void;
+export declare function createTestFunction(assertions: TestAssertion[]): any;
 /**
  * Normalize HTTP headers to Record<string, string>
  * Converts multi-value headers (string[]) to comma-separated strings

package/dist/infrastructure/script/vm-script-executor.adapter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * VM Script Executor Adapter - Implements IScriptExecutor (port)
+ *
+ * Wraps existing ScriptExecutor to conform to the new port interface.
+ * The legacy ScriptExecutor uses `createRequestSession()` pattern;
+ * this adapter translates to the simpler `executePreRequest` / `executePostResponse` port API.
+ */
+import { IScriptExecutor as IScriptExecutorPort, IScriptSession, IScriptResult } from '../../ports/executors/script-executor.interface';
+import { HttpResponse } from '../../types/types';
+import { ScriptExecutor } from './script-executor';
+/**
+ * Adapter that implements ports/IScriptExecutor using the legacy ScriptExecutor
+ */
+export declare class VmScriptExecutorAdapter implements IScriptExecutorPort {
+    private scriptExecutor;
+    constructor(scriptExecutor: ScriptExecutor);
+    executePreRequest(session: IScriptSession, script: string): Promise<IScriptResult>;
+    executePostResponse(session: IScriptSession, script: string, response: HttpResponse): Promise<IScriptResult>;
+}

package/dist/{test-suite → infrastructure/test-suite}/result-storage-service.d.ts

@@ -7,8 +7,8 @@
  * - Aggregated stats in memory (constant size)
  * - On-demand result loading
  */
-import { ExecutionResult } from '../types/types';
 import { IConfigService } from '../config';
+import { ExecutionResult } from '../../types/types';
 import { FullResultDetails, IndexPage, IResultStorageService, RecentError, RequestStats, ResultSummary, RunConfig, RunManifest, RunStats } from './result-storage';
 /**
  * File-based Result Storage Service for Test Suite

package/dist/{test-suite → infrastructure/test-suite}/result-storage.d.ts

@@ -5,7 +5,7 @@
  * - Interface Segregation: Separate interfaces for different concerns
  * - Dependency Inversion: Define abstractions for storage operations
  */
-import { ExecutionResult } from '../types/types';
+import { ExecutionResult } from '../../types/types';
 /**
  * HTTP Method encoding for memory efficiency
  * Using numbers instead of strings saves ~5 bytes per summary

package/dist/{test-suite → infrastructure/test-suite}/test-suite-service.d.ts

@@ -4,7 +4,7 @@
  * Manages CRUD operations for Test Suites.
  * Platform-agnostic version (no VS Code dependency).
  */
-import { ICollectionService } from '../collection/interfaces';
+import { ICollectionService } from '../../types/collection';
 import { IConfigService } from '../config';
 import { ITestSuiteService, SuiteRequest, TestSuite } from './interfaces';
 /**

package/dist/{test-suite → infrastructure/test-suite}/test-suite-store.d.ts

@@ -7,7 +7,7 @@
  * Single Responsibility: Maintain suite state and resolve requests from collections
  * Dependency Inversion: Depends on ICollectionService abstraction
  */
-import { CollectionRequest, ICollectionService, RequestScripts } from '../collection/interfaces';
+import { CollectionRequest, ICollectionService, RequestScripts } from '../../types/collection';
 import { SuiteRequest, TestSuite } from './interfaces';
 /**
  * Cached request entry with full context

package/dist/ports/executors/http-executor.interface.d.ts

@@ -0,0 +1,34 @@
+/**
+ * HTTP Executor Port - Abstract HTTP execution
+ * Hides HTTP client details and interceptors
+ *
+ * Implementations: NodeHttpExecutor, FetchHttpExecutor
+ */
+import { HttpRequest, HttpResponse } from '../../types/types';
+/**
+ * Execution plan that describes how to prepare and execute an HTTP request
+ */
+export interface IExecutionPlan {
+    request: HttpRequest;
+    preScripts?: string[];
+    postScripts?: string[];
+}
+/**
+ * HTTP Executor - Handles HTTP request execution with interceptors and middleware
+ */
+export interface IHttpExecutor {
+    /**
+     * Prepare request for execution
+     * - Apply interceptors
+     * - Add cookies
+     * - Resolve variables
+     */
+    prepare(plan: IExecutionPlan): Promise<HttpRequest>;
+    /**
+     * Execute prepared HTTP request
+     * - Send over network
+     * - Apply response interceptors
+     * - Save cookies
+     */
+    execute(prepared: HttpRequest): Promise<HttpResponse>;
+}

package/dist/ports/executors/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Executor Ports - Execution abstraction
+ */
+export * from './http-executor.interface';
+export * from './script-executor.interface';

package/dist/ports/executors/script-executor.interface.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Script Executor Port - Abstract script execution
+ * Hides VM and runtime details
+ *
+ * Implementations: VmScriptExecutor, NodeScriptExecutor
+ */
+import { HttpResponse } from '../../types/types';
+/**
+ * Script execution session - tracks state during execution
+ */
+export interface IScriptSession {
+    variables: Record<string, any>;
+    environment: Record<string, any>;
+    cookies: Record<string, string>;
+    [key: string]: any;
+}
+/**
+ * Result of script execution
+ */
+export interface IScriptResult {
+    success: boolean;
+    output: any;
+    errors: string[];
+    logs: string[];
+    variableChanges: Record<string, any>;
+}
+/**
+ * Script Executor - Handles pre-request and post-response scripts
+ */
+export interface IScriptExecutor {
+    /**
+     * Execute pre-request script
+     * - Modifies request before sending
+     * - Can set variables, headers, etc.
+     */
+    executePreRequest(session: IScriptSession, script: string): Promise<IScriptResult>;
+    /**
+     * Execute post-response script
+     * - Processes response after receiving
+     * - Can validate, test, extract data
+     */
+    executePostResponse(session: IScriptSession, script: string, response: HttpResponse): Promise<IScriptResult>;
+}

package/dist/ports/external/file-system.interface.d.ts

@@ -0,0 +1,44 @@
+/**
+ * File System Port - Abstract file system operations
+ * Enables platform-agnostic code (Node.js, browser, etc.)
+ *
+ * Implementation: NodeFileSystem
+ */
+export interface IFileSystem {
+    /**
+     * Check if a path exists (file or directory)
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Read file contents as UTF-8 string
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Write file contents
+     */
+    writeFile(path: string, content: string): Promise<void>;
+    /**
+     * List directory contents
+     */
+    readDir(path: string): Promise<string[]>;
+    /**
+     * Create directory (recursively)
+     */
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Delete file or empty directory
+     */
+    delete(path: string): Promise<void>;
+    /**
+     * Get file metadata
+     */
+    stat(path: string): Promise<FileStat>;
+}
+export interface FileStat {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    size: number;
+    mtimeMs?: number;
+}

package/dist/ports/external/http-client.interface.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HTTP Client Port - Abstract HTTP operations
+ * Enables switching between fetch, Node.js fetch, Node.js http, etc.
+ *
+ * Implementations: NodeHttpClient, FetchHttpClient
+ */
+export interface IHttpClient {
+    /**
+     * Execute HTTP request
+     */
+    execute(request: IHttpClientRequest): Promise<IHttpClientResponse>;
+}
+export interface IHttpClientRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string | Buffer;
+    timeout?: number;
+}
+export interface IHttpClientResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string | string[]>;
+    body: Buffer | string;
+}

package/dist/ports/external/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * External Ports - Platform and infrastructure abstractions
+ * Enables dependency injection and platform independence
+ */
+export * from './file-system.interface';
+export * from './http-client.interface';
+export * from './logger.interface';

package/dist/ports/external/logger.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logger Port - Abstract logging operations
+ *
+ * Implementations: ConsoleLogger, SilentLogger, CustomLogger
+ */
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export interface ILogger {
+    debug(message: string, context?: Record<string, any>): void;
+    info(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    error(message: string, error?: Error | Record<string, any>): void;
+}

package/dist/ports/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ports Layer - Abstract interfaces (Hexagonal Architecture)
+ *
+ * Defines contracts for:
+ * - Data access (Repositories)
+ * - Execution (HTTP, Scripts)
+ * - Storage (History, Cache)
+ * - External systems (FileSystem, HTTP Client, Logger)
+ * - Parsing (Collection formats)
+ *
+ * Implementations are in the infrastructure layer
+ */
+export * from './external';
+export * from './repositories';
+export * from './executors';
+export * from './storage';
+export * from './parsers';

package/dist/ports/parsers/collection-parser.interface.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Collection Parser Port - Abstract collection parsing
+ *
+ * Implementations: HttpForgeParser, PostmanParser, OpenAPIParser
+ */
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Collection Parser - Parses different collection formats
+ */
+export interface ICollectionParser {
+    /**
+     * Check if this parser can handle the content
+     */
+    canHandle(content: string, format?: string): boolean;
+    /**
+     * Parse collection from content
+     */
+    parse(content: string): Promise<UnifiedCollection>;
+    /**
+     * Supported formats (e.g., 'http-forge', 'postman', 'openapi')
+     */
+    readonly supportedFormats: string[];
+}

package/dist/ports/parsers/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parser Ports - Parsing abstraction
+ */
+export * from './collection-parser.interface';

package/dist/ports/repositories/collection-repository.interface.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Collection Repository Port - Abstract collection data access
+ * Enables switching between file-based, in-memory, cloud storage, etc.
+ *
+ * Implementations: FileSystemCollectionRepository, InMemoryCollectionRepository
+ */
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Repository for managing collections
+ */
+export interface ICollectionRepository {
+    /**
+     * Find collection by ID
+     */
+    findById(id: string): Promise<UnifiedCollection | null>;
+    /**
+     * Find all collections
+     */
+    findAll(): Promise<UnifiedCollection[]>;
+    /**
+     * Save or update collection
+     */
+    save(id: string, collection: UnifiedCollection): Promise<void>;
+    /**
+     * Delete collection by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if collection exists
+     */
+    exists(id: string): Promise<boolean>;
+}

package/dist/ports/repositories/environment-repository.interface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Environment Repository Port - Abstract environment data access
+ *
+ * Implementations: FileSystemEnvironmentRepository
+ */
+import { Environment } from '../../infrastructure/environment/environment-resolver';
+/**
+ * Repository for managing environments
+ */
+export interface IEnvironmentRepository {
+    /**
+     * Find environment by ID/name
+     */
+    findById(id: string): Promise<Environment | null>;
+    /**
+     * Find active environment
+     */
+    findActive(): Promise<Environment | null>;
+    /**
+     * Find all environments
+     */
+    findAll(): Promise<Environment[]>;
+    /**
+     * Save or update environment
+     */
+    save(environment: Environment): Promise<void>;
+    /**
+     * Delete environment by ID
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/ports/repositories/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Repository Ports - Data access abstraction
+ */
+export * from './request-repository.interface';
+export * from './collection-repository.interface';
+export * from './environment-repository.interface';

package/dist/ports/repositories/request-repository.interface.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Request Repository Port - Abstract request data access
+ * Enables switching between file-based, in-memory, cloud storage, etc.
+ *
+ * Implementations: FileSystemRequestRepository, InMemoryRequestRepository
+ */
+import { UnifiedRequest } from '../../types/types';
+/**
+ * Repository for managing individual requests
+ */
+export interface IRequestRepository {
+    /**
+     * Find request by ID
+     */
+    findById(id: string): Promise<UnifiedRequest | null>;
+    /**
+     * Find all requests in a collection
+     */
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    /**
+     * Save or update request
+     */
+    save(request: UnifiedRequest): Promise<void>;
+    /**
+     * Delete request by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if request exists
+     */
+    exists(id: string): Promise<boolean>;
+}

package/dist/ports/storage/cache-store.interface.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cache Store Port - Abstract caching
+ *
+ * Implementations: GraphQLSchemaCacheStore, MemoryCacheStore
+ */
+/**
+ * Generic cache store
+ */
+export interface ICacheStore<T> {
+    /**
+     * Get value from cache
+     */
+    get(key: string): Promise<T | null>;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear all cache
+     */
+    clear(): Promise<void>;
+}

package/dist/ports/storage/history-loader.interface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * History Loader Port - Abstract history loading
+ *
+ * Implementations: FileSystemHistoryLoader, InMemoryHistoryLoader
+ */
+import { HttpResponse } from '../../types/types';
+/**
+ * History entry metadata
+ */
+export interface IHistoryEntry {
+    id: string;
+    requestId: string;
+    collectionId: string;
+    timestamp: Date;
+    status: number;
+    duration: number;
+}
+/**
+ * History Loader - Loads request execution history
+ */
+export interface IHistoryLoader {
+    /**
+     * Load history entries for a request
+     */
+    loadHistory(collectionId: string, requestId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IHistoryEntry[]>;
+    /**
+     * Load full response from history
+     */
+    loadFullResponse(collectionId: string, requestId: string, entryId: string): Promise<HttpResponse | null>;
+    /**
+     * Save history entry
+     */
+    saveEntry(collectionId: string, requestId: string, response: HttpResponse, duration: number): Promise<IHistoryEntry>;
+}

package/dist/ports/storage/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Storage Ports - Storage and caching abstraction
+ */
+export * from './history-loader.interface';
+export * from './cache-store.interface';

package/dist/{collection/collection-service-interfaces.d.ts → types/collection.d.ts}

@@ -1,10 +1,10 @@
 /**
- * Collection Service Interface
+ * Collection Types
  *
- * Interface Segregation: Separated into focused sub-interfaces
- * Dependency Inversion: Consumers depend on this abstraction
+ * Migrated from src/collection/ for better organization
+ * These types define the contracts for collection management
  */
-import { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings } from '../types/types';
+import { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings } from './types';
 export type { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings };
 /**
  * Request item in a collection - CollectionRequest with type discriminator
@@ -117,3 +117,18 @@ export interface ICollectionImportExport {
 export interface ICollectionService extends ICollectionReader, ICollectionWriter, IRequestManager, IFolderManager, ICollectionVariableManager, ICollectionImportExport {
     dispose(): void;
 }
+/**
+ * Collection loader interface
+ */
+export interface ICollectionLoader {
+    load(filePath: string, options?: any): Promise<import('./types').UnifiedCollection> | import('./types').UnifiedCollection | undefined;
+    loadAll(): Promise<import('./types').UnifiedCollection[]> | import('./types').UnifiedCollection[];
+}
+/**
+ * Collection parser interface (infrastructure-level)
+ * Different from ports/parsers/ICollectionParser
+ */
+export interface ICollectionParser {
+    canParse(content: string): boolean;
+    parse(content: string, filePath?: string): import('./types').UnifiedCollection;
+}