@http-forge/core 0.2.1 → 0.2.2

package/dist/{openapi → infrastructure/openapi}/openapi-exporter.d.ts

@@ -4,8 +4,8 @@
  * Generates a valid OpenAPI 3.0.3 document from an HTTP Forge collection.
  * Implements all mapping rules per the solution document §4.3.2.
  */
-import { ICollectionService } from '../collection/interfaces';
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { ICollectionService } from '../../types/collection';
+import { IEnvironmentConfigService } from '../../types/environment-config';
 import { SchemaInferenceService } from './schema-inference-service';
 export interface OpenApiExportOptions {
     format: 'json' | 'yaml';

package/dist/{openapi → infrastructure/openapi}/openapi-importer.d.ts

@@ -4,8 +4,8 @@
  * Parses an OpenAPI 3.0 spec and creates a fully hydrated HTTP Forge collection.
  * Implements all mapping rules per the solution document §4.4.2.
  */
-import { Collection, ICollectionService } from '../collection/interfaces';
-import { IEnvironmentConfigService } from '../environment/interfaces';
+import { Collection, ICollectionService } from '../../types/collection';
+import { IEnvironmentConfigService } from '../../types/environment-config';
 export interface OpenApiImportOptions {
     /** Base environment name to create with server URL */
     environmentName?: string;

package/dist/{openapi → infrastructure/openapi}/schema-inference-service.d.ts

@@ -9,7 +9,7 @@
  * 2. History data — real response bodies provide the most accurate schemas
  * 3. Script hints — field paths and types from post-response scripts
  */
-import { BodySchemaDefinition, KeyValueEntry, ResponseSchemaDefinition } from '../types/types';
+import { BodySchemaDefinition, KeyValueEntry, ResponseSchemaDefinition } from '../../types/types';
 import { HistoryAnalyzer } from './history-analyzer';
 import { SchemaInferrer } from './schema-inferrer';
 import { ScriptAnalyzer } from './script-analyzer';

package/dist/{openapi → infrastructure/openapi}/schema-inferrer.d.ts

@@ -4,7 +4,7 @@
  * Core utility that generates JSON Schema (OAS 3.0 compatible) from sample JSON values.
  * Supports recursive inference, format detection, schema merging, and nullable semantics.
  */
-import { JSONSchema7 } from '../types/types';
+import { JSONSchema7 } from '../../types/types';
 export declare class SchemaInferrer {
     /**
      * Infer a JSON Schema from a sample value.

package/dist/infrastructure/parsers/collection-parser.adapter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * HTTP Forge Collection Parser Adapter - Implements ICollectionParser
+ *
+ * Wraps existing HttpForgeParser to conform to the port interface
+ */
+import { ICollectionParser } from '../../ports/parsers/collection-parser.interface';
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Adapter that implements ICollectionParser for HTTP Forge format
+ */
+export declare class HttpForgeCollectionParserAdapter implements ICollectionParser {
+    private parser;
+    get supportedFormats(): string[];
+    canHandle(content: string, format?: string): boolean;
+    parse(content: string): Promise<UnifiedCollection>;
+}
+/**
+ * Collection Parser Registry - Manages multiple parsers
+ *
+ * Implements ICollectionParser by delegating to registered parsers
+ */
+export declare class CollectionParserRegistry implements ICollectionParser {
+    private parsers;
+    constructor(initialParsers?: ICollectionParser[]);
+    /**
+     * Register a parser
+     */
+    register(parser: ICollectionParser): void;
+    get supportedFormats(): string[];
+    canHandle(content: string, format?: string): boolean;
+    parse(content: string, format?: string): Promise<UnifiedCollection>;
+}

package/dist/{parsers → infrastructure/parsers}/http-forge-parser.d.ts

@@ -4,8 +4,8 @@
  * Single Responsibility: Parse HTTP Forge collection format (.forge.json)
  * Dependency Inversion: Implements ICollectionParser interface
  */
-import { ICollectionParser } from '../collection/interfaces';
-import { UnifiedCollection } from '../types/types';
+import { ICollectionParser } from '../../types/collection';
+import { UnifiedCollection } from '../../types/types';
 /**
  * Parser for HTTP Forge native collection format
  */

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

@@ -0,0 +1,7 @@
+/**
+ * Parser Infrastructure Implementations
+ *
+ * Collection format parsers for different formats
+ */
+export * from './collection-parser.adapter';
+export { HttpForgeParser } from './http-forge-parser';

package/dist/infrastructure/persistence/file-system-history-loader.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File System History Loader Implementation
+ *
+ * Implements IHistoryLoader using file-based storage
+ * Compatible with existing RequestHistoryService
+ */
+import { IHistoryLoader, IHistoryEntry } from '../../ports/storage/history-loader.interface';
+import { HttpResponse } from '../../types/types';
+import { IFileSystem } from '../../ports/external/file-system.interface';
+/**
+ * File system implementation of IHistoryLoader
+ * Stores execution history in timestamped files
+ */
+export declare class FileSystemHistoryLoader implements IHistoryLoader {
+    private fileSystem;
+    private basePath;
+    private readonly historyDir;
+    private readonly manifestFile;
+    private readonly responseExt;
+    constructor(fileSystem: IFileSystem, basePath: string);
+    loadHistory(collectionId: string, requestId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IHistoryEntry[]>;
+    loadFullResponse(collectionId: string, requestId: string, entryId: string): Promise<HttpResponse | null>;
+    saveEntry(collectionId: string, requestId: string, response: HttpResponse, duration: number): Promise<IHistoryEntry>;
+    /**
+     * Generate unique entry ID
+     */
+    private generateEntryId;
+}

package/dist/infrastructure/persistence/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Persistence Infrastructure Implementations
+ *
+ * Includes history storage, caching, and other persistence concerns
+ */
+export * from './file-system-history-loader';

package/dist/{platform → infrastructure/platform}/node-file-system.d.ts

@@ -4,7 +4,7 @@
  * Single Responsibility: File operations using Node.js fs module
  * Dependency Inversion: Implements IFileSystem interface
  */
-import { IFileSystem } from '../types/platform';
+import { IFileSystem } from '../../types/platform';
 /**
  * Node.js implementation of IFileSystem.
  * Uses Node.js fs/promises for all operations.

package/dist/infrastructure/repositories/file-system/fs-collection-repository.d.ts

@@ -0,0 +1,72 @@
+/**
+ * File System Collection Repository
+ *
+ * Implements ICollectionRepository using the FolderCollectionStore.
+ *
+ * Delegates to FolderCollectionStore for all disk operations,
+ * converting between UnifiedCollection (repository contract) and
+ * Collection (internal format).
+ *
+ * This ensures a single source of truth for folder-based storage
+ * while supporting both the legacy CollectionService and new use-case architecture.
+ */
+import { ICollectionRepository } from '../../../ports/repositories/collection-repository.interface';
+import { UnifiedCollection } from '../../../types/types';
+/**
+ * File system collection repository implementation using FolderCollectionStore
+ */
+export declare class FileSystemCollectionRepository implements ICollectionRepository {
+    private store;
+    constructor(basePath: string);
+    /**
+     * 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
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if collection exists
+     */
+    exists(id: string): Promise<boolean>;
+    /**
+     * Convert internal Collection to UnifiedCollection
+     */
+    private toUnifiedCollection;
+    /**
+     * Convert UnifiedCollection to internal Collection
+     */
+    private toCollection;
+    /**
+     * Normalize auth object to remove oauth2 type if present
+     * Converts RequestAuth to CollectionAuth by removing oauth2-specific fields
+     */
+    private normalizeAuth;
+    /**
+     * Recursively convert items from internal format to unified
+     * PRESERVES: enabled flags, metadata on headers/query, all request fields
+     */
+    private itemsToUnified;
+    /**
+     * Recursively convert items from unified format to internal
+     * PRESERVES: enabled flags, metadata, all request fields
+     */
+    private itemsFromUnified;
+    /**
+     * Convert variables Record to unified format
+     */
+    private recordToUnified;
+    /**
+     * Convert variables from unified format to Record
+     */
+    private unifiedToRecord;
+}

package/dist/infrastructure/repositories/file-system/fs-environment-file-loader.adapter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * File System Environment File Loader Adapter
+ *
+ * Loads environment configuration files from disk
+ * Wraps the legacy environment-file-loader functionality
+ */
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+import { ILogger } from '../../../ports/external/logger.interface';
+export interface EnvironmentFileConfig {
+    name: string;
+    variables: Record<string, string>;
+    [key: string]: any;
+}
+export interface EnvironmentLoadResult {
+    environments: Record<string, EnvironmentFileConfig>;
+    globalVariables?: Record<string, string>;
+}
+/**
+ * Adapter: Load environment files from file system
+ */
+export declare class FileSystemEnvironmentFileLoaderAdapter {
+    private fileSystem;
+    private logger;
+    constructor(fileSystem: IFileSystem, logger: ILogger);
+    /**
+     * Load single environment file
+     */
+    loadEnvironmentFile(filePath: string): Promise<EnvironmentFileConfig>;
+    /**
+     * Load all environment files from directory
+     */
+    loadEnvironmentDirectory(dirPath: string): Promise<EnvironmentLoadResult>;
+    /**
+     * Write environment file
+     */
+    saveEnvironmentFile(filePath: string, config: EnvironmentFileConfig): Promise<void>;
+    /**
+     * Delete environment file
+     */
+    deleteEnvironmentFile(filePath: string): Promise<void>;
+}

package/dist/infrastructure/repositories/file-system/fs-environment-repository.d.ts

@@ -0,0 +1,34 @@
+/**
+ * File System Environment Repository Implementation
+ *
+ * Implements IEnvironmentRepository using folder-based storage
+ * Compatible with existing EnvironmentResolver and environment-file-loader
+ */
+import { IEnvironmentRepository } from '../../../ports/repositories/environment-repository.interface';
+import { Environment } from '../../environment/environment-resolver';
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+/**
+ * File system implementation of IEnvironmentRepository
+ * Stores environments in a dedicated directory
+ */
+export declare class FileSystemEnvironmentRepository implements IEnvironmentRepository {
+    private fileSystem;
+    private basePath;
+    private readonly environmentsDir;
+    private readonly environmentExt;
+    private activeEnvironmentId;
+    constructor(fileSystem: IFileSystem, basePath: string);
+    findById(id: string): Promise<Environment | null>;
+    findActive(): Promise<Environment | null>;
+    findAll(): Promise<Environment[]>;
+    save(environment: Environment): Promise<void>;
+    delete(id: string): Promise<void>;
+    /**
+     * Set environment as active
+     */
+    setActive(id: string): void;
+    /**
+     * Build file path for environment
+     */
+    private buildEnvironmentPath;
+}

package/dist/infrastructure/repositories/file-system/fs-request-repository.d.ts

@@ -0,0 +1,31 @@
+/**
+ * File System Request Repository Implementation
+ *
+ * Implements IRequestRepository using folder-based storage
+ * Compatible with existing FolderCollectionStore and folder-io
+ */
+import { IRequestRepository } from '../../../ports/repositories/request-repository.interface';
+import { UnifiedRequest } from '../../../types/types';
+import { IFileSystem } from '../../../ports/external/file-system.interface';
+/**
+ * File system implementation of IRequestRepository
+ * Stores requests as .json files in collection directories
+ */
+export declare class FileSystemRequestRepository implements IRequestRepository {
+    private fileSystem;
+    private collectionsBasePath;
+    private readonly requestsDir;
+    private readonly requestExt;
+    constructor(fileSystem: IFileSystem, collectionsBasePath: string);
+    findById(id: string): Promise<UnifiedRequest | null>;
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    save(request: UnifiedRequest): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    /**
+     * Build file path for a request
+     * Assumes request ID contains collection ID in some form
+     * or that we have configuration for this
+     */
+    private buildRequestPath;
+}

package/dist/infrastructure/repositories/file-system/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * File System Repository Implementations
+ */
+export * from './fs-request-repository';
+export * from './fs-environment-repository';
+export * from './fs-collection-repository';
+export * from './fs-environment-file-loader.adapter';

package/dist/infrastructure/repositories/in-memory/in-memory-collection-repository.d.ts

@@ -0,0 +1,18 @@
+/**
+ * In-Memory Collection Repository
+ *
+ * Useful for testing and development
+ */
+import { ICollectionRepository } from '../../../ports/repositories/collection-repository.interface';
+import { UnifiedCollection } from '../../../types/types';
+/**
+ * In-memory collection repository implementation
+ */
+export declare class InMemoryCollectionRepository implements ICollectionRepository {
+    private collections;
+    findById(id: string): Promise<UnifiedCollection | null>;
+    findAll(filter?: any): Promise<UnifiedCollection[]>;
+    save(id: string, collection: UnifiedCollection): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+}

package/dist/infrastructure/repositories/in-memory/in-memory-environment-repository.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-Memory Environment Repository Implementation
+ */
+import { Environment } from '../../environment/environment-resolver';
+import { IEnvironmentRepository } from '../../../ports/repositories/environment-repository.interface';
+/**
+ * In-memory implementation of IEnvironmentRepository
+ */
+export declare class InMemoryEnvironmentRepository implements IEnvironmentRepository {
+    private environments;
+    private activeId;
+    findById(id: string): Promise<Environment | null>;
+    findActive(): Promise<Environment | null>;
+    findAll(): Promise<Environment[]>;
+    save(environment: Environment): Promise<void>;
+    delete(id: string): Promise<void>;
+    /**
+     * Set active environment
+     */
+    setActive(id: string): void;
+    /**
+     * Clear all environments
+     */
+    clear(): void;
+}

package/dist/infrastructure/repositories/in-memory/in-memory-request-repository.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-Memory Request Repository Implementation
+ */
+import { UnifiedRequest } from '../../../types/types';
+import { IRequestRepository } from '../../../ports/repositories/request-repository.interface';
+/**
+ * In-memory implementation of IRequestRepository
+ * Useful for testing and as a fallback
+ */
+export declare class InMemoryRequestRepository implements IRequestRepository {
+    private requests;
+    findById(id: string): Promise<UnifiedRequest | null>;
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    save(request: UnifiedRequest): Promise<void>;
+    delete(id: string): Promise<void>;
+    exists(id: string): Promise<boolean>;
+    /**
+     * Clear all requests (useful for testing)
+     */
+    clear(): void;
+    /**
+     * Pre-populate requests (useful for testing)
+     */
+    addRequests(...requests: UnifiedRequest[]): void;
+}

package/dist/infrastructure/repositories/in-memory/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * In-Memory Repository Implementations
+ * Useful for testing and as fallbacks
+ */
+export * from './in-memory-request-repository';
+export * from './in-memory-environment-repository';
+export * from './in-memory-collection-repository';

package/dist/infrastructure/script/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Script Infrastructure Adapters and Implementations
+ */
+export * from './vm-script-executor.adapter';

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

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
  */

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

@@ -8,7 +8,7 @@
  * - On-demand result loading
  */
 import { IConfigService } from '../config';
-import { ExecutionResult } from '../types/types';
+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;
+}