@http-forge/core 0.1.0

package/README.md

@@ -0,0 +1,500 @@
+# @http-forge/core
+
+**Lightweight, VS Code-independent HTTP API testing engine** - The execution core of HTTP Forge.
+
+[![npm version](https://img.shields.io/npm/v/@http-forge/core.svg)](https://www.npmjs.com/package/@http-forge/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 📦 What is @http-forge/core?
+
+`@http-forge/core` is a standalone, dependency-injection-based HTTP execution engine that powers HTTP Forge. It provides a clean API for:
+
+- 🚀 Executing HTTP requests with full HTTP Forge collection support
+- 🔄 Running pre-request and post-response scripts
+- 🌍 Managing environments and variables
+- 🍪 Automatic cookie handling
+- 📊 Test assertions and validations
+- 🔌 Extensible via interceptors and custom implementations
+
+**Perfect for:**
+- Building custom API testing tools
+- Integrating HTTP Forge into CI/CD pipelines
+- Creating CLI tools for API testing
+- Headless API testing automation
+
+## 🎯 Installation
+
+```bash
+npm install @http-forge/core
+```
+
+Or using the tarball:
+```bash
+npm install ./http-forge-core-0.1.0.tgz
+```
+
+## ⚡ Quick Start
+
+### Basic Usage
+
+```typescript
+import { ForgeContainer } from '@http-forge/core';
+
+// Create a container with default settings
+const forge = new ForgeContainer();
+
+// Load a collection
+const collection = await forge.loadCollection('./my-api.forge.json');
+
+// Execute a request
+const result = await forge.execute(collection.items[0], collection);
+
+console.log(result.response.status);        // 200
+console.log(result.response.body);          // Response data
+console.log(result.postResponseResult?.assertions);  // Test results
+```
+
+### With Environment Variables
+
+```typescript
+const forge = new ForgeContainer();
+
+// Set environment variables
+forge.setEnvironment({
+    baseUrl: 'https://api.example.com',
+    apiKey: 'your-api-key',
+    timeout: '5000'
+});
+
+// Variables are automatically interpolated in requests
+// URL: {{baseUrl}}/users -> https://api.example.com/users
+const result = await forge.execute(request, collection);
+```
+
+### With Custom Configuration
+
+```typescript
+const forge = new ForgeContainer({
+    // Use native Node.js http/https instead of fetch
+    useNativeHttp: true,
+    
+    // Enable automatic cookie management
+    enableCookies: true,
+    
+    // Set request timeout
+    requestTimeout: 10000,
+    
+    // Enable request history
+    enableHistory: true,
+    maxHistoryEntries: 50,
+    
+    // Storage format
+    storageFormat: 'folder'  // or 'file'
+});
+```
+
+## 📚 Core Concepts
+
+### ForgeContainer
+
+The main entry point - a dependency injection container that wires up all components.
+
+```typescript
+const forge = new ForgeContainer(options);
+
+// Load collections
+const collection = await forge.loadCollection(path);
+const folderCollection = await forge.loadFolderCollection(path);
+
+// Execute requests
+const result = await forge.execute(request, collection, options);
+
+// Manage environments
+forge.setEnvironment(variables);
+forge.setActiveEnvironment(name);
+const resolved = forge.getResolvedEnvironment();
+
+// Access services
+const executor = forge.getRequestExecutor();
+const loader = forge.getCollectionLoader();
+```
+
+### Request Execution
+
+Execute requests with full control over the execution pipeline:
+
+```typescript
+const result = await forge.execute(request, collection, {
+    environment: 'production',
+    overrides: {
+        url: 'https://override.com/api',
+        headers: { 'X-Custom': 'value' }
+    },
+    skipPreRequest: false,
+    skipPostResponse: false,
+    timeout: 5000
+});
+
+// Access results
+console.log(result.response);           // HTTP response
+console.log(result.preRequestResult);   // Pre-request script output
+console.log(result.postResponseResult); // Test results
+```
+
+### Script Execution
+
+Run pre-request and post-response scripts:
+
+**Pre-request script:**
+```javascript
+// Set variables before request
+forge.env.set('timestamp', Date.now());
+forge.env.set('requestId', forge.uuid());
+
+// Modify request
+forge.request.headers['X-Request-ID'] = forge.env.get('requestId');
+```
+
+**Post-response script:**
+```javascript
+// Run tests
+forge.expect(forge.response.status).toBe(200);
+forge.expect(forge.response.body.success).toBeTruthy();
+
+// Extract data from response
+const token = forge.response.body.token;
+forge.env.set('authToken', token);
+```
+
+### Environment Management
+
+```typescript
+// Define multiple environments
+forge.setEnvironmentConfig({
+    dev: { baseUrl: 'https://dev.api.com', apiKey: 'dev-key' },
+    staging: { baseUrl: 'https://staging.api.com', apiKey: 'staging-key' },
+    prod: { baseUrl: 'https://api.com', apiKey: 'prod-key' }
+});
+
+// Switch environments
+forge.setActiveEnvironment('prod');
+
+// Get resolved variables (with inheritance and overrides)
+const vars = forge.getResolvedEnvironment('prod');
+```
+
+## 🔧 Advanced Features
+
+### Custom HTTP Client
+
+Implement your own HTTP client:
+
+```typescript
+import { IHttpClient, HttpRequest, HttpResponse } from '@http-forge/core';
+
+class CustomHttpClient implements IHttpClient {
+    async send(request: HttpRequest): Promise<HttpResponse> {
+        // Your custom HTTP logic
+        return {
+            status: 200,
+            statusText: 'OK',
+            headers: {},
+            body: {},
+            duration: 100,
+            size: 1024
+        };
+    }
+}
+
+const forge = new ForgeContainer({
+    httpClient: new CustomHttpClient()
+});
+```
+
+### Request/Response Interceptors
+
+Add custom interceptors to modify requests and responses:
+
+```typescript
+import { IRequestInterceptor, IResponseInterceptor } from '@http-forge/core';
+
+// Request interceptor
+class AuthInterceptor implements IRequestInterceptor {
+    async intercept(request: HttpRequest): Promise<HttpRequest> {
+        request.headers['Authorization'] = `Bearer ${getToken()}`;
+        return request;
+    }
+}
+
+// Response interceptor
+class LoggingInterceptor implements IResponseInterceptor {
+    async intercept(response: HttpResponse, request: HttpRequest): Promise<HttpResponse> {
+        console.log(`${request.method} ${request.url} -> ${response.status}`);
+        return response;
+    }
+}
+
+const forge = new ForgeContainer({
+    requestInterceptors: [new AuthInterceptor()],
+    responseInterceptors: [new LoggingInterceptor()]
+});
+```
+
+### Cookie Management
+
+Automatic cookie handling across requests:
+
+```typescript
+const forge = new ForgeContainer({
+    enableCookies: true
+});
+
+// Cookies are automatically stored and sent
+const loginResult = await forge.execute(loginRequest, collection);
+// Session cookie from login is automatically included in next request
+const dataResult = await forge.execute(dataRequest, collection);
+```
+
+### Request History
+
+Track all executed requests:
+
+```typescript
+const forge = new ForgeContainer({
+    enableHistory: true,
+    maxHistoryEntries: 100
+});
+
+// Execute requests
+await forge.execute(request1, collection);
+await forge.execute(request2, collection);
+
+// Access history
+const history = forge.getRequestHistory();
+const entries = history.getAll();         // All requests
+const byId = history.getByRequestId(id);  // Specific request history
+```
+
+## 📖 API Reference
+
+### ForgeContainer
+
+**Constructor Options:**
+```typescript
+interface ForgeContainerOptions {
+    forgeRoot?: string;              // Path to http-forge folder
+    storageFormat?: 'file' | 'folder'; // Collection storage format
+    
+    // HTTP Settings
+    useNativeHttp?: boolean;         // Use native http/https
+    httpClient?: IHttpClient;        // Custom HTTP client
+    httpSettings?: RequestSettings;  // Default HTTP settings
+    requestTimeout?: number;         // Request timeout (ms)
+    
+    // Cookie Settings
+    enableCookies?: boolean;         // Enable cookie jar
+    cookieJar?: ICookieJar;         // Custom cookie jar
+    
+    // Interceptors
+    requestInterceptors?: IRequestInterceptor[];
+    responseInterceptors?: IResponseInterceptor[];
+    errorInterceptors?: IErrorInterceptor[];
+    
+    // Script Settings
+    scriptRunner?: IScriptRunner;    // Custom script runner
+    scriptTimeout?: number;          // Script timeout (ms)
+    
+    // History
+    enableHistory?: boolean;         // Enable request history
+    maxHistoryEntries?: number;      // Max history size
+}
+```
+
+**Methods:**
+```typescript
+// Collection loading
+loadCollection(path: string): Promise<UnifiedCollection>
+loadFolderCollection(path: string): Promise<UnifiedCollection>
+
+// Request execution
+execute(
+    request: UnifiedRequest,
+    collection: UnifiedCollection,
+    options?: ExecuteOptions
+): Promise<ExecuteResult>
+
+// Environment management
+setEnvironment(variables: Record<string, string>): void
+setEnvironmentConfig(config: EnvironmentConfig): void
+setActiveEnvironment(name: string): void
+getResolvedEnvironment(name?: string): Record<string, string>
+
+// Service access
+getRequestExecutor(): RequestExecutor
+getCollectionLoader(): ICollectionLoader
+getEnvironmentResolver(): EnvironmentResolver
+getRequestHistory(): IRequestHistory
+```
+
+### ExecuteResult
+
+```typescript
+interface ExecuteResult {
+    response: HttpResponse;          // HTTP response
+    preRequestResult?: ScriptResult; // Pre-request script output
+    postResponseResult?: ScriptResult; // Test results
+    requestId: string;               // Unique request ID
+    timestamp: number;               // Execution timestamp
+}
+```
+
+### HttpResponse
+
+```typescript
+interface HttpResponse {
+    status: number;                  // HTTP status code
+    statusText: string;              // Status text
+    headers: Record<string, string>; // Response headers
+    body: any;                       // Parsed response body
+    cookies?: Cookie[];              // Response cookies
+    duration: number;                // Request duration (ms)
+    size: number;                    // Response size (bytes)
+    redirected?: boolean;            // Whether redirected
+}
+```
+
+## 🛠️ Use Cases
+
+### CLI Tool
+
+```typescript
+#!/usr/bin/env node
+import { ForgeContainer } from '@http-forge/core';
+
+async function runTests(collectionPath: string) {
+    const forge = new ForgeContainer();
+    const collection = await forge.loadCollection(collectionPath);
+    
+    for (const request of collection.items) {
+        const result = await forge.execute(request, collection);
+        const tests = result.postResponseResult?.assertions || [];
+        
+        console.log(`\n${request.name}: ${result.response.status}`);
+        tests.forEach(test => {
+            console.log(`  ${test.passed ? '✓' : '✗'} ${test.name}`);
+        });
+    }
+}
+
+runTests(process.argv[2]);
+```
+
+### CI/CD Integration
+
+```typescript
+import { ForgeContainer } from '@http-forge/core';
+
+async function ciTest() {
+    const forge = new ForgeContainer({
+        enableCookies: true,
+        requestTimeout: 30000
+    });
+    
+    forge.setEnvironment({
+        baseUrl: process.env.API_URL,
+        apiKey: process.env.API_KEY
+    });
+    
+    const collection = await forge.loadCollection('./api-tests.forge.json');
+    
+    let failedTests = 0;
+    for (const request of collection.items) {
+        const result = await forge.execute(request, collection);
+        const failed = result.postResponseResult?.assertions?.filter(t => !t.passed) || [];
+        failedTests += failed.length;
+    }
+    
+    process.exit(failedTests > 0 ? 1 : 0);
+}
+```
+
+### Custom Testing Framework
+
+```typescript
+import { ForgeContainer } from '@http-forge/core';
+
+class ApiTestRunner {
+    private forge: ForgeContainer;
+    
+    constructor() {
+        this.forge = new ForgeContainer({
+            enableCookies: true,
+            enableHistory: true
+        });
+    }
+    
+    async runSuite(suites: TestSuite[]) {
+        for (const suite of suites) {
+            await this.runTests(suite);
+        }
+    }
+    
+    async runTests(suite: TestSuite) {
+        const collection = await this.forge.loadCollection(suite.collection);
+        
+        for (const request of collection.items) {
+            const result = await this.forge.execute(request, collection);
+            suite.results.push(result);
+        }
+    }
+}
+```
+
+## 📦 Storage Formats
+
+### File Format (Single JSON)
+```
+my-api.forge.json
+```
+
+### Folder Format (Directory Structure)
+```
+my-api/
+  collection.json
+  requests/
+    login/
+      request.json
+    users/
+      get-users/
+        request.json
+      create-user/
+        request.json
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT © Henry Huang
+
+## 🔗 Links
+
+- [HTTP Forge Extension](https://marketplace.visualstudio.com/items?itemName=your-publisher.http-forge)
+- [GitHub Repository](https://github.com/hsl1230/http-forge)
+- [Issues](https://github.com/hsl1230/http-forge/issues)
+
+## 📝 Changelog
+
+### 0.1.0 (Initial Release)
+
+- ✅ Core request execution engine
+- ✅ Environment and variable management
+- ✅ Pre-request and post-response scripts
+- ✅ Cookie jar support
+- ✅ Request/response interceptors
+- ✅ Request history tracking
+- ✅ File and folder collection formats
+- ✅ Full TypeScript support
+- ✅ Comprehensive test coverage

package/dist/container.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Forge Container - Dependency Injection Container
+ *
+ * Single Responsibility: Wire up all components with proper dependencies
+ * Factory Pattern: Creates configured instances of services
+ */
+import { IDataFileParser, IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IRequestPreprocessor, IResponseInterceptor } from './implementations';
+import { ICollectionLoader, ICookieJar, IFileSystem, IHttpClient, IRequestHistory, IScriptRunner, IVariableInterpolator } from './interfaces';
+import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './interfaces/types';
+import { EnvironmentConfig, EnvironmentResolver, ForgeEnv, ParserRegistry, RequestExecutor, ScriptPipeline } from './services';
+/**
+ * Container configuration options
+ */
+/**
+ * Storage format for collections
+ */
+export type StorageFormat = 'file' | 'folder';
+export interface ForgeContainerOptions {
+    /** Path to http-forge folder (enables custom modules from modules/ folder) */
+    forgeRoot?: string;
+    /** Storage format: 'file' for single JSON files, 'folder' for directory structure (default: 'folder') */
+    storageFormat?: StorageFormat;
+    /** Use native http/https instead of fetch (recommended for full control) */
+    useNativeHttp?: boolean;
+    /** Custom HTTP client implementation (overrides useNativeHttp) */
+    httpClient?: IHttpClient;
+    /** Default HTTP request settings */
+    httpSettings?: Partial<RequestSettings>;
+    /** HTTP request timeout (ms) - shorthand for httpSettings.timeout */
+    requestTimeout?: number;
+    /** Enable cookie jar for automatic cookie management */
+    enableCookies?: boolean;
+    /** Custom cookie jar implementation */
+    cookieJar?: ICookieJar;
+    /** Request interceptors to register */
+    requestInterceptors?: IRequestInterceptor[];
+    /** Response interceptors to register */
+    responseInterceptors?: IResponseInterceptor[];
+    /** Error interceptors to register */
+    errorInterceptors?: IErrorInterceptor[];
+    /** Custom interceptor chain (overrides individual interceptors) */
+    interceptorChain?: IInterceptorChain;
+    /** Custom script runner implementation */
+    scriptRunner?: IScriptRunner;
+    /** Script execution timeout (ms) */
+    scriptTimeout?: number;
+    /** Custom file system implementation */
+    fileSystem?: IFileSystem;
+    /** Custom variable interpolator implementation */
+    interpolator?: IVariableInterpolator;
+    /** Custom request preprocessor implementation */
+    preprocessor?: IRequestPreprocessor;
+    /** Custom data file parser implementation */
+    dataFileParser?: IDataFileParser;
+    /** Enable request history recording */
+    enableHistory?: boolean;
+    /** Maximum history entries per request (default: 100) */
+    maxHistoryEntries?: number;
+    /** Custom request history implementation */
+    requestHistory?: IRequestHistory;
+    /** Environment configuration */
+    environmentConfig?: EnvironmentConfig;
+}
+/**
+ * Forge Container - Main entry point for HTTP Forge Core
+ *
+ * Usage:
+ * ```typescript
+ * const forge = new ForgeContainer();
+ * const collection = await forge.loadCollection('./api.forge.json');
+ * const result = await forge.execute(collection.items[0], collection);
+ * ```
+ */
+export declare class ForgeContainer {
+    readonly httpClient: IHttpClient;
+    readonly fileSystem: IFileSystem;
+    readonly scriptRunner: IScriptRunner;
+    readonly interpolator: IVariableInterpolator;
+    readonly cookieJar: ICookieJar;
+    readonly interceptorChain: IInterceptorChain;
+    readonly preprocessor: IRequestPreprocessor;
+    readonly dataFileParser: IDataFileParser;
+    readonly requestHistory: IRequestHistory | null;
+    readonly parserRegistry: ParserRegistry;
+    readonly collectionLoader: ICollectionLoader;
+    readonly environmentStore: EnvironmentResolver;
+    readonly forgeEnv: ForgeEnv;
+    readonly scriptPipeline: ScriptPipeline;
+    readonly requestExecutor: RequestExecutor;
+    private readonly options;
+    constructor(options?: ForgeContainerOptions);
+    /**
+     * Create interceptor chain from options
+     */
+    private createInterceptorChain;
+    /**
+     * Load a collection from file (only works with file storage format)
+     * @deprecated Use loadAllCollections() for folder format
+     */
+    loadCollection(filePath: string): Promise<UnifiedCollection>;
+    /**
+     * Load all collections from the configured storage
+     * Works with both file and folder storage formats
+     */
+    loadAllCollections(): Promise<UnifiedCollection[]>;
+    /**
+     * Execute a request with full pipeline
+     */
+    execute(request: UnifiedRequest, collection: UnifiedCollection, options?: any): Promise<import("./services").ExecuteResult>;
+    /**
+     * Execute a simple HTTP request
+     */
+    executeSimple(request: HttpRequest, options?: any): Promise<HttpResponse>;
+    /**
+     * Register a custom collection parser
+     */
+    registerParser(format: string, parser: any): void;
+    /**
+     * Set environment configuration
+     */
+    setEnvironmentConfig(config: EnvironmentConfig): void;
+    /**
+     * Create a new container with custom options
+     */
+    static create(options?: ForgeContainerOptions): ForgeContainer;
+    /**
+     * Create a container by auto-loading environments from forgeRoot
+     *
+     * Reads `{forgeRoot}/environments/environments.json` and creates
+     * a container with the environment configuration pre-loaded.
+     *
+     * @param forgeRoot - Path to http-forge folder (default: './http-forge')
+     * @param options - Additional container options
+     *
+     * @example
+     * ```typescript
+     * // Auto-load environments from ./http-forge/environments/environments.json
+     * const forge = ForgeContainer.fromForgeRoot('./http-forge');
+     *
+     * // Switch environment
+     * forge.forgeEnv.setActiveEnvironment('sit');
+     * ```
+     */
+    static fromForgeRoot(forgeRoot?: string, options?: Omit<ForgeContainerOptions, 'forgeRoot' | 'environmentConfig'>): ForgeContainer;
+}
+//# sourceMappingURL=container.d.ts.map

package/dist/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"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"}