@http-forge/core 0.1.0 → 0.2.0

package/dist/openapi/example-generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Example Generator
+ *
+ * Generates example values from JSON Schema definitions.
+ * Handles allOf (flatten + merge), oneOf/anyOf (first variant),
+ * discriminator injection, enum, formats, readOnly omission.
+ */
+import { JSONSchema7 } from '../types/types';
+export declare class ExampleGenerator {
+    /**
+     * Generate an example value from a JSON Schema.
+     */
+    generate(schema: JSONSchema7, options?: {
+        omitReadOnly?: boolean;
+        components?: Record<string, JSONSchema7>;
+    }): any;
+    private generateString;
+    private generateInteger;
+    private generateNumber;
+    private generateArray;
+    private generateObject;
+    private generateFromAllOf;
+    private generateFromOneOfAnyOf;
+    private guessDiscriminatorValue;
+    private resolveLocalRef;
+}

package/dist/openapi/history-analyzer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * History Analyzer
+ *
+ * Reads FullResponse files from history and shared-history directories
+ * to build response schemas by inferring from actual response data.
+ */
+import { IRequestHistoryService } from '../history/request-history-service-interfaces';
+import { ResponseSchemaDefinition } from '../types/types';
+import { SchemaInferrer } from './schema-inferrer';
+export declare class HistoryAnalyzer {
+    private historyService;
+    private inferrer;
+    constructor(historyService: IRequestHistoryService, inferrer: SchemaInferrer);
+    /**
+     * Analyze all available history for a request.
+     * Groups responses by status code, infers schema per group.
+     */
+    analyze(collectionId: string, requestId: string, options?: {
+        environment?: string;
+        maxSamples?: number;
+    }): Promise<ResponseSchemaDefinition>;
+    private buildResponseDefinition;
+    private inferBodySchema;
+    private extractContentType;
+    private isJsonContentType;
+    private findConsistentHeaders;
+    private inferHeaderSchema;
+    private tryParseJson;
+}

package/dist/openapi/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OpenAPI Services
+ *
+ * Complete OpenAPI 3.0 import/export functionality with schema inference.
+ */
+export { ExampleGenerator } from './example-generator';
+export { HistoryAnalyzer } from './history-analyzer';
+export { RefResolver } from './ref-resolver';
+export { SchemaInferrer } from './schema-inferrer';
+export { ScriptAnalyzer } from './script-analyzer';
+export type { ScriptAnalysisResult } from './script-analyzer';
+export { SchemaInferenceService } from './schema-inference-service';
+export { OpenApiExporter } from './openapi-exporter';
+export type { OpenApiExportOptions } from './openapi-exporter';
+export { OpenApiImporter } from './openapi-importer';
+export type { OpenApiImportOptions } from './openapi-importer';

package/dist/openapi/interfaces.d.ts

@@ -0,0 +1,42 @@
+/**
+ * OpenAPI Service Interfaces
+ *
+ * DI abstractions for OpenAPI-related services.
+ * The concrete implementations live in services/openapi/.
+ */
+import type { OpenApiExportOptions } from './openapi-exporter';
+import type { OpenApiImportOptions } from './openapi-importer';
+import type { Collection } from '../collection/collection-service-interfaces';
+import type { BodySchemaDefinition, JSONSchema7, KeyValueEntry, ResponseSchemaDefinition } from '../types/types';
+/**
+ * Schema inference service interface
+ */
+export interface ISchemaInferenceService {
+    infer(collectionId: string, requestId: string, existingSchema?: ResponseSchemaDefinition, options?: {
+        environment?: string;
+        postResponseScript?: string;
+    }): Promise<ResponseSchemaDefinition>;
+    inferBodySchema(bodyContent: any, bodyType?: string, bodyFormat?: string, formDataEntries?: KeyValueEntry[], existingSchema?: BodySchemaDefinition): Promise<BodySchemaDefinition | undefined>;
+}
+/**
+ * OpenAPI exporter service interface
+ */
+export interface IOpenApiExporter {
+    export(collectionId: string, options: OpenApiExportOptions): Promise<string>;
+}
+/**
+ * OpenAPI importer service interface
+ */
+export interface IOpenApiImporter {
+    import(filePath: string, options?: OpenApiImportOptions): Promise<{
+        collection: Collection;
+        environmentCreated?: string;
+    }>;
+}
+/**
+ * Schema inferrer interface (low-level)
+ */
+export interface ISchemaInferrer {
+    inferFromValue(value: any): JSONSchema7;
+    mergeSchemas(a: JSONSchema7, b: JSONSchema7): JSONSchema7;
+}

package/dist/openapi/openapi-exporter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * OpenAPI 3.0 Exporter
+ *
+ * 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 { SchemaInferenceService } from './schema-inference-service';
+export interface OpenApiExportOptions {
+    format: 'json' | 'yaml';
+    /** Environment name(s) to use for server URL resolution */
+    environments?: string[];
+    /** Include inferred response schemas from history */
+    inferFromHistory?: boolean;
+    /** OpenAPI info metadata overrides */
+    info?: {
+        title?: string;
+        version?: string;
+        description?: string;
+    };
+}
+export declare class OpenApiExporter {
+    private collectionService;
+    private envConfigService;
+    private inferenceService;
+    private inferrer;
+    constructor(collectionService: ICollectionService, envConfigService: IEnvironmentConfigService, inferenceService: SchemaInferenceService);
+    /**
+     * Export a collection as an OpenAPI 3.0.3 document.
+     */
+    export(collectionId: string, options: OpenApiExportOptions): Promise<string>;
+    private buildInfo;
+    private buildServers;
+    private processItems;
+    private processRequest;
+    private normalizeUrl;
+    private generateOperationId;
+    private collectOperationIds;
+    private toCamelCase;
+    private buildParameters;
+    private buildKeyValueParam;
+    /**
+     * Parse a Cookie header value into individual in:cookie parameters.
+     */
+    private parseCookieHeader;
+    /**
+     * Infer a type from a string value (for path/query params without explicit type).
+     */
+    private inferTypeFromValue;
+    /**
+     * Coerce a string value to the appropriate JS type for the 'example' field.
+     */
+    private coerceExample;
+    private buildRequestBody;
+    private getContentType;
+    private tryParseBodyContent;
+    private buildFormDataSchemaFromBody;
+    private buildResponses;
+    private buildOperationSecurity;
+    private mapAuthToSecurityScheme;
+    private parseScopes;
+    /**
+     * When multiple operations share structurally identical schemas,
+     * promote them to components/schemas and replace with $ref.
+     */
+    private deduplicateComponents;
+    private trackSchema;
+    private replaceInlineSchema;
+    private sanitizeComponentName;
+    private cleanSummary;
+    private hasDeprecatedPrefix;
+}

package/dist/openapi/openapi-importer.d.ts

@@ -0,0 +1,72 @@
+/**
+ * OpenAPI 3.0 Importer
+ *
+ * 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';
+export interface OpenApiImportOptions {
+    /** Base environment name to create with server URL */
+    environmentName?: string;
+    /** Collection name override */
+    collectionName?: string;
+}
+export declare class OpenApiImporter {
+    private collectionService;
+    private envConfigService;
+    private exampleGenerator;
+    private refResolver;
+    constructor(collectionService: ICollectionService, envConfigService: IEnvironmentConfigService);
+    /**
+     * Import an OpenAPI spec file and create an HTTP Forge collection.
+     */
+    import(filePath: string, options?: OpenApiImportOptions): Promise<{
+        collection: Collection;
+        environmentCreated?: string;
+    }>;
+    private processOperation;
+    /**
+     * Convert OpenAPI path parameters from {param} to :param syntax.
+     */
+    private convertPathParams;
+    private processParameters;
+    /**
+     * Generate an example value string for a parameter from its schema.
+     */
+    private generateExampleForParam;
+    private processRequestBody;
+    /**
+     * Select the primary content type from available options.
+     */
+    private selectPrimaryContentType;
+    /**
+     * Map an OpenAPI content type to HTTP Forge body type/format.
+     */
+    private mapContentTypeToBodyType;
+    /**
+     * Generate body content from an OpenAPI media type object.
+     */
+    private generateBodyContent;
+    /**
+     * Build form data entries from an object schema.
+     */
+    private buildFormDataEntries;
+    /**
+     * Build body.schema.json from the requestBody.
+     */
+    private buildBodySchema;
+    private processResponses;
+    private mapSecurityToAuth;
+    private createEnvironmentFromServers;
+    /**
+     * Extract component schemas referenced by a given schema.
+     * Walks $ref pointers and collects the referenced definitions.
+     */
+    private extractUsedComponents;
+    /**
+     * Extract the component name from a $ref pointer.
+     * "#/components/schemas/User" → "User"
+     */
+    private extractRefName;
+}

package/dist/openapi/ref-resolver.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Ref Resolver
+ *
+ * Wrapper around @apidevtools/json-schema-ref-parser for resolving
+ * $ref pointers in OpenAPI specifications before import processing.
+ *
+ * Handles:
+ * - Internal $ref (same document)
+ * - External file $ref
+ * - External URL $ref
+ * - Circular $ref (break cycle with { type: "object" } placeholder)
+ */
+export declare class RefResolver {
+    /**
+     * Resolve all $ref pointers in an OpenAPI document.
+     * Returns a fully dereferenced (inline) copy of the spec.
+     */
+    resolve(spec: any): Promise<any>;
+    /**
+     * Bundle all $ref pointers — resolves external refs but keeps
+     * internal $ref pointers intact.
+     */
+    bundle(spec: any): Promise<any>;
+    /**
+     * Parse and resolve an OpenAPI file from disk.
+     */
+    resolveFile(filePath: string): Promise<any>;
+}

package/dist/openapi/schema-inference-service.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Schema Inference Service
+ *
+ * Orchestrates all inference sources (history, scripts, user edits)
+ * to produce unified response and body schemas.
+ *
+ * Merge priority (highest → lowest):
+ * 1. User-edited schema — never overwritten, only augmented
+ * 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 { HistoryAnalyzer } from './history-analyzer';
+import { SchemaInferrer } from './schema-inferrer';
+import { ScriptAnalyzer } from './script-analyzer';
+export declare class SchemaInferenceService {
+    private historyAnalyzer;
+    private scriptAnalyzer;
+    private inferrer;
+    constructor(historyAnalyzer: HistoryAnalyzer, scriptAnalyzer: ScriptAnalyzer, inferrer: SchemaInferrer);
+    /**
+     * Infer a complete response schema for a request by combining
+     * history data, script analysis, and any existing schema.
+     */
+    infer(collectionId: string, requestId: string, existingSchema?: ResponseSchemaDefinition, options?: {
+        environment?: string;
+        postResponseScript?: string;
+    }): Promise<ResponseSchemaDefinition>;
+    /**
+     * Infer a body schema from the request's body content.
+     */
+    inferBodySchema(bodyContent: any, bodyType?: string, bodyFormat?: string, formDataEntries?: KeyValueEntry[], existingSchema?: BodySchemaDefinition): Promise<BodySchemaDefinition | undefined>;
+    private buildFormDataSchema;
+    private mergeResponseSchemas;
+    private applyScriptHints;
+    private augmentSchemaWithHints;
+    private ensureFieldPath;
+    private mergeResponseDefinitions;
+    private mergeBodySchemaWithExisting;
+}

package/dist/openapi/schema-inferrer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Schema Inferrer
+ *
+ * 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';
+export declare class SchemaInferrer {
+    /**
+     * Infer a JSON Schema from a sample value.
+     * Recursively walks objects and arrays.
+     * Uses OAS 3.0 nullable semantics (nullable: true instead of type array).
+     */
+    inferFromValue(value: any): JSONSchema7;
+    /**
+     * Merge two schemas — broadens types, unions properties.
+     * Used when aggregating multiple response samples.
+     */
+    mergeSchemas(a: JSONSchema7, b: JSONSchema7): JSONSchema7;
+    private inferStringFormat;
+    private inferStringSchema;
+    private inferArraySchema;
+    private inferObjectSchema;
+    private mergeObjectSchemas;
+    private mergeArraySchemas;
+}

package/dist/openapi/script-analyzer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Script Analyzer
+ *
+ * Static analysis of post-response scripts to extract response field expectations.
+ * Uses regex-based pattern matching (not full AST) since post-response scripts
+ * are typically simple assertion chains.
+ */
+/**
+ * Result of analyzing a post-response script.
+ */
+export interface ScriptAnalysisResult {
+    /** Dot-separated field paths: ["data.users[].id", "data.users[].name"] */
+    fieldPaths: string[];
+    /** Type hints from assertions: { "data.count": "number", "data.active": "boolean" } */
+    typeHints: Record<string, string>;
+    /** Value hints from equality assertions: { "data.status": "ok" } */
+    valueHints: Record<string, any>;
+    /** Expected status codes from pm.response.to.have.status(N) */
+    expectedStatuses: number[];
+}
+export declare class ScriptAnalyzer {
+    /**
+     * Parse a post-response script to discover expected response fields
+     * and their types from assertion patterns.
+     */
+    analyze(scriptSource: string): ScriptAnalysisResult;
+    /**
+     * Strip single-line and multi-line comments from source code.
+     */
+    private stripComments;
+    private extractFieldPaths;
+    private extractTypeAssertions;
+    private extractEqualityAssertions;
+    private extractBooleanAssertions;
+    private extractLengthAssertions;
+    private extractStatusAssertions;
+    private normalizeFieldPath;
+    private isCommonMethodCall;
+    private mapAssertionType;
+    private parseAssertionValue;
+}

package/dist/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 '../interfaces';
-import { UnifiedCollection } from '../interfaces/types';
+import { ICollectionParser } from '../collection/interfaces';
+import { UnifiedCollection } from '../types/types';
 /**
  * Parser for HTTP Forge native collection format
  */
@@ -32,4 +32,3 @@ export declare class HttpForgeParser implements ICollectionParser {
      */
     private convertRequest;
 }
-//# sourceMappingURL=http-forge-parser.d.ts.map

package/dist/parsers/index.d.ts

@@ -4,4 +4,3 @@
  * Export all parser implementations
  */
 export { HttpForgeParser } from './http-forge-parser';
-//# sourceMappingURL=index.d.ts.map

package/dist/{implementations → platform}/data-file-parser.d.ts

@@ -68,4 +68,3 @@ export declare class DataFileParser implements IDataFileParser {
      */
     private parseCsvLine;
 }
-//# sourceMappingURL=data-file-parser.d.ts.map

package/dist/{implementations → 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 '../interfaces';
+import { IFileSystem } from '../types/platform';
 /**
  * Node.js implementation of IFileSystem.
  * Uses Node.js fs/promises for all operations.
@@ -49,4 +49,3 @@ export declare class NodeFileSystem implements IFileSystem {
      */
     private matchPattern;
 }
-//# sourceMappingURL=node-file-system.d.ts.map

package/dist/script/interfaces.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Script Execution Interfaces
+ *
+ * Defines abstractions for the session-based script execution architecture.
+ * Matches the VS Code extension's interfaces for consistency.
+ *
+ * Dependency Inversion: Define abstractions for request execution components
+ * Interface Segregation: Each interface has a focused purpose
+ */
+import { Cookie } from '../cookie/interfaces';
+import { PreparedRequest, RequestAuth, RequestBody, RequestScripts, RequestSettings, ScriptInfo, TestAssertion } from '../types/types';
+export type { Cookie, ScriptInfo };
+/**
+ * Cookie Jar Interface
+ * Single Responsibility: Manage cookies for HTTP requests
+ */
+export interface ICookieJar {
+    get(name: string, domain?: string): Cookie | undefined;
+    getCookiesForDomain(domain: string): Cookie[];
+    getAll(domain?: string): Cookie[];
+    has(name: string, domain?: string): boolean;
+    set(cookie: Cookie): void;
+    delete(name: string, domain?: string, path?: string): boolean;
+    setCookiesFromResponse(url: string, headers: Record<string, string | string[]>): void;
+    getCookieHeader(url: string): string | undefined;
+    clear(): void;
+    flush?(): Promise<void>;
+}
+/**
+ * Request context for test scripts
+ */
+export interface RequestContext {
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: RequestBody | null;
+    bodyContentType?: string;
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    settings?: RequestSettings;
+    scripts?: RequestScripts;
+    auth?: RequestAuth;
+}
+/**
+ * Response context for test scripts
+ */
+export interface ResponseContext {
+    executedRequest: PreparedRequest;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: any;
+    cookies?: Record<string, string>;
+    responseTime?: number;
+    responseSize?: number;
+}
+/**
+ * Common script execution context (shared between pre-request and test scripts)
+ */
+export interface CommonScriptContext {
+    variables: Record<string, string>;
+    collectionVariables?: Record<string, string>;
+    globals?: Record<string, string>;
+    sessionVariables?: Record<string, string>;
+    environmentVariables?: Record<string, string>;
+    environmentName?: string;
+    sendRequest?: (options: any) => Promise<any>;
+    info?: ScriptInfo;
+    iteration?: number;
+    iterationCount?: number;
+    onSessionChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
+    onEnvironmentChange?: (action: 'set' | 'unset' | 'clear', key?: string, value?: string) => void;
+}
+/**
+ * Script execution context for pre-request scripts
+ */
+export interface PreRequestScriptContext extends CommonScriptContext {
+    request: RequestContext;
+    cookieJar?: ICookieJar;
+}
+/**
+ * Script execution result for pre-request scripts
+ */
+export interface PreRequestScriptResult {
+    success: boolean;
+    error?: string;
+    modifiedRequest?: {
+        url?: string;
+        method?: string;
+        headers?: Record<string, string>;
+        body?: RequestBody | null;
+        params?: Record<string, string>;
+        query?: Record<string, string>;
+    };
+    modifiedVariables?: Record<string, string>;
+    modifiedCollectionVariables?: Record<string, string>;
+    modifiedGlobals?: Record<string, string>;
+    modifiedSessionVariables?: Record<string, string>;
+    modifiedEnvironmentVariables?: Record<string, string>;
+    consoleOutput?: string[];
+}
+/**
+ * Script execution result for post-response scripts
+ */
+export interface PostResponseScriptResult {
+    testResults: TestAssertion[];
+    consoleOutput?: string[];
+    modifiedEnvironmentVariables?: Record<string, string>;
+    modifiedSessionVariables?: Record<string, string>;
+}
+/**
+ * Test script execution context
+ */
+export interface TestScriptContext extends CommonScriptContext {
+    request: RequestContext;
+    response: ResponseContext;
+}
+/**
+ * Script Executor Interface
+ * Single Responsibility: Create request execution sessions
+ * Open/Closed: Can be extended with new execution strategies
+ */
+export interface IScriptExecutor {
+    /**
+     * Create a request execution session that shares VM context between pre-request and post-response
+     * This enables JavaScript variables declared in pre-request to be accessible in post-response
+     * (Postman-compatible behavior)
+     */
+    createRequestSession(context: PreRequestScriptContext): IRequestScriptSession;
+}
+/**
+ * Request Script Session Interface
+ * Represents a shared VM context for a single request's pre-request and post-response scripts
+ * JavaScript variables declared in pre-request will be accessible in post-response
+ */
+export interface IRequestScriptSession {
+    /**
+     * Execute pre-request scripts in the shared session
+     */
+    executePreRequest(script: string | string[]): Promise<PreRequestScriptResult>;
+    /**
+     * Update the session with response data and execute post-response scripts
+     */
+    executePostResponse(script: string | string[], responseContext: ResponseContext): Promise<PostResponseScriptResult>;
+    /**
+     * Clean up the session (optional - for resource management)
+     */
+    dispose?(): void;
+}