@http-forge/core 0.2.14 → 0.2.15

package/dist/application/use-cases/execute-request.use-case.d.ts

@@ -1,46 +0,0 @@
-/**
- * Execute Request Use Case - Main business workflow
- *
- * Orchestrates:
- * 1. Load request from repository
- * 2. Prepare execution environment
- * 3. Call domain services for planning
- * 4. Execute HTTP request via infrastructure
- * 5. Handle scripts and variable updates
- * 6. Publish events
- */
-import { IRequestRepository } from '../../ports/repositories/request-repository.interface';
-import { IEnvironmentRepository } from '../../ports/repositories/environment-repository.interface';
-import { IHttpExecutor } from '../../ports/executors/http-executor.interface';
-import { IScriptExecutor } from '../../ports/executors/script-executor.interface';
-import { IDomainEventPublisher } from '../../domain/services/domain-events';
-import { ILogger } from '../../ports/external/logger.interface';
-import { ExecuteRequestInput } from '../dto/request-dtos';
-import { ExecuteRequestOutput } from '../dto/response-dtos';
-/**
- * Options for request execution (backward compat alias)
- */
-export type ExecuteRequestOptions = ExecuteRequestInput;
-/**
- * Use Case: Execute a request
- *
- * This is the main business workflow
- */
-export declare class ExecuteRequestUseCase {
-    private requestRepository;
-    private environmentRepository;
-    private httpExecutor;
-    private scriptExecutor;
-    private eventPublisher;
-    private logger;
-    private planner;
-    constructor(requestRepository: IRequestRepository, environmentRepository: IEnvironmentRepository, httpExecutor: IHttpExecutor, scriptExecutor: IScriptExecutor, eventPublisher: IDomainEventPublisher, logger: ILogger);
-    /**
-     * Execute a request from a collection
-     */
-    execute(options: ExecuteRequestInput): Promise<ExecuteRequestOutput>;
-    /**
-     * Determine overall execution status
-     */
-    private determineStatus;
-}

package/dist/application/use-cases/export-collection.use-case.d.ts

@@ -1,22 +0,0 @@
-/**
- * Export Collection Use Case
- */
-import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
-import { IFileSystem } from '../../ports/external/file-system.interface';
-import { ILogger } from '../../ports/external/logger.interface';
-import { IDomainEventPublisher } from '../../domain/services/domain-events';
-import { ExportCollectionInput } from '../dto/request-dtos';
-import { ExportCollectionOutput } from '../dto/response-dtos';
-export type { ExportCollectionInput } from '../dto/request-dtos';
-export declare class ExportCollectionUseCase {
-    private collectionRepository;
-    private fileSystem;
-    private eventPublisher;
-    private logger;
-    constructor(collectionRepository: ICollectionRepository, fileSystem: IFileSystem, eventPublisher: IDomainEventPublisher, logger: ILogger);
-    execute(input: ExportCollectionInput): Promise<ExportCollectionOutput>;
-    private toPostman;
-    private toOpenAPI;
-    private convertItems;
-    private extractPaths;
-}

package/dist/application/use-cases/get-collection.use-case.d.ts

@@ -1,13 +0,0 @@
-/**
- * Get Collection Use Case
- */
-import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
-import { ILogger } from '../../ports/external/logger.interface';
-import { GetCollectionInput } from '../dto/request-dtos';
-import { GetCollectionOutput } from '../dto/response-dtos';
-export declare class GetCollectionUseCase {
-    private collectionRepository;
-    private logger;
-    constructor(collectionRepository: ICollectionRepository, logger: ILogger);
-    execute(input: GetCollectionInput): Promise<GetCollectionOutput>;
-}

package/dist/application/use-cases/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * Application Use Cases
- */
-export * from './execute-request.use-case';
-export * from './load-collection.use-case';
-export * from './save-collection.use-case';
-export * from './create-request.use-case';
-export * from './update-request.use-case';
-export * from './delete-request.use-case';
-export * from './list-requests.use-case';
-export * from './get-collection.use-case';
-export * from './export-collection.use-case';

package/dist/application/use-cases/list-requests.use-case.d.ts

@@ -1,14 +0,0 @@
-/**
- * List Requests Use Case
- */
-import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
-import { ILogger } from '../../ports/external/logger.interface';
-import { ListRequestsInput } from '../dto/request-dtos';
-import { ListRequestsOutput } from '../dto/response-dtos';
-export declare class ListRequestsUseCase {
-    private collectionRepository;
-    private logger;
-    constructor(collectionRepository: ICollectionRepository, logger: ILogger);
-    execute(input: ListRequestsInput): Promise<ListRequestsOutput>;
-    private collectRequests;
-}

package/dist/application/use-cases/load-collection.use-case.d.ts

@@ -1,30 +0,0 @@
-/**
- * Load Collection Use Case
- *
- * Loads a collection from file and parses it
- * Returns FULL collection with ALL metadata preserved (headers, query, scripts, etc.)
- */
-import { IDomainEventPublisher } from '../../domain/services/domain-events';
-import { IFileSystem } from '../../ports/external/file-system.interface';
-import { ILogger } from '../../ports/external/logger.interface';
-import { ICollectionParser } from '../../ports/parsers/collection-parser.interface';
-import { LoadCollectionInput } from '../dto/request-dtos';
-import { LoadCollectionOutput } from '../dto/response-dtos';
-/**
- * Use Case: Load collection from file
- */
-export declare class LoadCollectionUseCase {
-    private fileSystem;
-    private collectionParser;
-    private eventPublisher;
-    private logger;
-    constructor(fileSystem: IFileSystem, collectionParser: ICollectionParser, eventPublisher: IDomainEventPublisher, logger: ILogger);
-    /**
-     * Load collection from file path
-     */
-    execute(input: LoadCollectionInput): Promise<LoadCollectionOutput>;
-    /**
-     * Count total requests recursively
-     */
-    private countRequests;
-}

package/dist/application/use-cases/save-collection.use-case.d.ts

@@ -1,25 +0,0 @@
-/**
- * Save Collection Use Case
- *
- * Saves a collection to file
- */
-import { IFileSystem } from '../../ports/external/file-system.interface';
-import { ILogger } from '../../ports/external/logger.interface';
-import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
-import { IDomainEventPublisher } from '../../domain/services/domain-events';
-import { SaveCollectionInput } from '../dto/request-dtos';
-import { SaveCollectionOutput } from '../dto/response-dtos';
-/**
- * Use Case: Save collection to file
- */
-export declare class SaveCollectionUseCase {
-    private fileSystem;
-    private collectionRepository;
-    private eventPublisher;
-    private logger;
-    constructor(fileSystem: IFileSystem, collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
-    /**
-     * Save collection to file
-     */
-    execute(input: SaveCollectionInput): Promise<SaveCollectionOutput>;
-}

package/dist/application/use-cases/update-request.use-case.d.ts

@@ -1,17 +0,0 @@
-/**
- * Update Request Use Case
- * Supports updating all request fields including enabled/disabled headers and schemas
- */
-import { IDomainEventPublisher } from '../../domain/services/domain-events';
-import { ILogger } from '../../ports/external/logger.interface';
-import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
-import { UpdateRequestInput } from '../dto/request-dtos';
-import { UpdateRequestOutput } from '../dto/response-dtos';
-export type { UpdateRequestInput } from '../dto/request-dtos';
-export declare class UpdateRequestUseCase {
-    private collectionRepository;
-    private eventPublisher;
-    private logger;
-    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
-    execute(input: UpdateRequestInput): Promise<UpdateRequestOutput>;
-}

package/dist/domain/errors/domain-errors.d.ts

@@ -1,52 +0,0 @@
-/**
- * Domain Errors - Business-specific exceptions
- *
- * Use these instead of generic Error for domain-level problems
- */
-/**
- * Base domain error
- */
-export declare class DomainError extends Error {
-    readonly code: string;
-    readonly message: string;
-    readonly details?: Record<string, any> | undefined;
-    constructor(code: string, message: string, details?: Record<string, any> | undefined);
-}
-/**
- * Collection not found
- */
-export declare class CollectionNotFoundError extends DomainError {
-    constructor(collectionId: string);
-}
-/**
- * Request not found
- */
-export declare class RequestNotFoundError extends DomainError {
-    constructor(requestId: string);
-}
-/**
- * Invalid request - validation failed
- */
-export declare class InvalidRequestError extends DomainError {
-    constructor(message: string);
-    constructor(requestId: string, reason: string);
-}
-/**
- * Execution failed - HTTP or script error
- */
-export declare class ExecutionError extends DomainError {
-    readonly originalError?: Error | undefined;
-    constructor(requestId: string, reason: string, originalError?: Error | undefined);
-}
-/**
- * Script error - pre/post script failed
- */
-export declare class ScriptExecutionError extends DomainError {
-    constructor(requestId: string, stage: 'pre' | 'post', reason: string);
-}
-/**
- * Variable interpolation failed
- */
-export declare class VariableResolutionError extends DomainError {
-    constructor(variableName: string, reason: string);
-}

package/dist/domain/errors/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Domain Errors - Business exceptions
- */
-export * from './domain-errors';

package/dist/domain/index.d.ts

@@ -1,24 +0,0 @@
-/**
- * Domain Layer - Business logic (Clean Architecture)
- *
- * Contains:
- * - Domain models (pure data structures)
- * - Domain services (pure business logic)
- * - Domain errors (business exceptions)
- * - Domain events (event publishing)
- *
- * Constraints:
- * - ZERO external dependencies
- * - NO platform-specific code
- * - NO persistence concerns
- * - Fully testable without mocks
- *
- * Usage:
- * - Imported by application layer
- * - Used for business rule validation
- * - Should be framework-agnostic
- */
-export * from './models';
-export * from './services';
-export * from './errors';
-export * from './value-objects';

package/dist/domain/models/execution.d.ts

@@ -1,88 +0,0 @@
-/**
- * Execution Domain Models - Core execution data structures
- *
- * These are pure domain models independent of storage or UI concerns
- */
-import { HttpRequest, HttpResponse } from '../../types/types';
-/**
- * Execution context - captures state during request execution
- */
-export interface IExecutionContext {
-    requestId: string;
-    collectionId: string;
-    variables: Record<string, any>;
-    environment: Record<string, any>;
-    cookies: Record<string, string>;
-    metadata?: {
-        userId?: string;
-        timestamp?: Date;
-        [key: string]: any;
-    };
-}
-/**
- * Execution plan - describes how to execute a request
- */
-export interface IExecutionPlan {
-    requestId: string;
-    request: HttpRequest;
-    preScripts?: string[];
-    postScripts?: string[];
-    scripts?: {
-        preRequest?: string;
-        postResponse?: string;
-    };
-}
-/**
- * Execution result - outcome of request execution
- */
-export interface IExecutionResult {
-    /** Request ID */
-    requestId: string;
-    /** HTTP response */
-    response: HttpResponse;
-    /** Execution time (ms) */
-    duration: number;
-    /** Pre-request script result */
-    preScriptResult?: {
-        success: boolean;
-        output: any;
-        errors: string[];
-    };
-    /** Post-response script result */
-    postScriptResult?: {
-        success: boolean;
-        output: any;
-        errors: string[];
-        assertions?: AssertionResult[];
-    };
-    /** Variable changes during execution */
-    variableChanges?: Record<string, any>;
-    /** Execution status */
-    status: 'success' | 'failed' | 'partial';
-    /** Error message if execution failed */
-    error?: string;
-}
-/**
- * Test assertion result
- */
-export interface AssertionResult {
-    name: string;
-    passed: boolean;
-    expected: any;
-    actual: any;
-    message?: string;
-}
-/**
- * Execution metrics
- */
-export interface IExecutionMetrics {
-    requestId: string;
-    duration: number;
-    httpStatus: number;
-    success: boolean;
-    timestamp: Date;
-    size?: {
-        requestBytes?: number;
-        responseBytes?: number;
-    };
-}

package/dist/domain/models/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Domain Models - Core business data structures
- */
-export * from './execution';

package/dist/domain/services/domain-events.d.ts

@@ -1,60 +0,0 @@
-/**
- * Domain Events - Events published by domain to application layer
- *
- * Domain events decouple domain logic from side effects
- */
-import { IExecutionResult } from '../models/execution';
-/**
- * Base domain event
- */
-export declare abstract class DomainEvent {
-    readonly aggregateId: string;
-    readonly eventType: string;
-    readonly occurredAt: Date;
-    constructor(aggregateId: string, eventType: string);
-}
-/**
- * RequestExecuted - Published when a request is successfully executed
- */
-export declare class RequestExecutedEvent extends DomainEvent {
-    readonly collectionId: string;
-    readonly result: IExecutionResult;
-    constructor(requestId: string, collectionId: string, result: IExecutionResult);
-}
-/**
- * RequestExecutionFailed - Published when request execution fails
- */
-export declare class RequestExecutionFailedEvent extends DomainEvent {
-    readonly collectionId: string;
-    readonly error: Error;
-    readonly stage: 'preparation' | 'execution' | 'script';
-    constructor(requestId: string, collectionId: string, error: Error, stage: 'preparation' | 'execution' | 'script');
-}
-/**
- * VariableUpdated - Published when execution changes variables
- */
-export declare class VariableUpdatedEvent extends DomainEvent {
-    readonly variables: Record<string, any>;
-    readonly changes: Record<string, any>;
-    constructor(variables: Record<string, any>, changes: Record<string, any>);
-}
-/**
- * CookieUpdated - Published when HTTP response sets cookies
- */
-export declare class CookieUpdatedEvent extends DomainEvent {
-    readonly cookies: Record<string, string>;
-    constructor(cookies: Record<string, string>);
-}
-/**
- * Domain event publisher abstraction
- */
-export interface IDomainEventPublisher {
-    /**
-     * Publish domain event
-     */
-    publish(event: DomainEvent): Promise<void>;
-    /**
-     * Subscribe to events
-     */
-    subscribe(eventType: string, handler: (event: DomainEvent) => Promise<void>): void;
-}

package/dist/domain/services/execution-planner.domain-service.d.ts

@@ -1,40 +0,0 @@
-/**
- * Execution Planner Domain Service - Pure business logic for execution planning
- *
- * No external dependencies - only domain models and exceptions
- * All logic is deterministic and testable without mocks
- */
-import { UnifiedRequest } from '../../types/types';
-import { IExecutionContext, IExecutionPlan } from '../models/execution';
-/**
- * Domain service for planning HTTP request execution
- * Encapsulates rules for:
- * - Request validation
- * - Script preparation
- * - Variable interpolation
- */
-export declare class ExecutionPlannerDomainService {
-    /**
-     * Validate request before execution
-     */
-    validateRequest(request: UnifiedRequest): void;
-    /**
-     * Create execution plan from request and context
-     *
-     * Pure logic - no side effects
-     */
-    createExecutionPlan(request: UnifiedRequest, context: IExecutionContext): IExecutionPlan;
-    /**
-     * Check if request requires script execution
-     */
-    hasScripts(request: UnifiedRequest): boolean;
-    /**
-     * Check if request requires variable interpolation
-     */
-    needsVariableInterpolation(request: UnifiedRequest): boolean;
-    /**
-     * Build execution context from request and environment
-     */
-    buildExecutionContext(requestId: string, collectionId: string, variables: Record<string, any>, environment: Record<string, any>, cookies?: Record<string, string>): IExecutionContext;
-    private kvArrayToRecord;
-}

package/dist/domain/services/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Domain Services - Pure business logic
- *
- * Services contain only domain rules, no infrastructure concerns
- * Zero external dependencies - fully testable without mocks
- */
-export * from './execution-planner.domain-service';
-export * from './schema-inference.domain-service';
-export * from './domain-events';

package/dist/domain/services/schema-inference.domain-service.d.ts

@@ -1,54 +0,0 @@
-/**
- * Schema Inference Domain Service - Pure business logic for schema analysis
- *
- * Merges information from multiple sources to infer response schema
- */
-/**
- * Response schema representation
- */
-export interface ResponseSchema {
-    type?: string;
-    properties?: Record<string, unknown>;
-    required?: string[];
-    description?: string;
-    example?: unknown;
-}
-/**
- * Script hints extracted from post-response script
- */
-export interface ScriptHints {
-    propertyAccess: string[];
-    assertions: string[];
-    dataExtracted: string[];
-}
-/**
- * Schema validation result
- */
-export interface ValidationResult {
-    valid: boolean;
-    errors: string[];
-    warnings: string[];
-}
-/**
- * Domain service for schema inference
- * Pure logic for merging and validating schemas
- */
-export declare class SchemaInferenceDomainService {
-    /**
-     * Merge multiple schemas into a final schema
-     * Priority: user-edited > inferred from history > script hints
-     */
-    mergeResponseSchemas(userEdited: ResponseSchema | null, inferredFromHistory: ResponseSchema | null, scriptHints: ScriptHints | null): ResponseSchema;
-    /**
-     * Validate schema is well-formed
-     */
-    validateSchema(schema: ResponseSchema): ValidationResult;
-    /**
-     * Extract property hints from script accesses
-     */
-    private buildPropertiesFromHints;
-    /**
-     * Merge two schemas using set union logic
-     */
-    private mergeSchemas;
-}

package/dist/domain/value-objects/entity-id.d.ts

@@ -1,26 +0,0 @@
-/**
- * EntityId Value Object
- *
- * Base class for typed entity identifiers (RequestId, CollectionId).
- * Prevents accidentally passing a collection ID where a request ID is expected.
- */
-export declare abstract class EntityId {
-    readonly value: string;
-    constructor(value: string);
-    equals(other: EntityId): boolean;
-    toString(): string;
-}
-/**
- * RequestId — uniquely identifies a request within a collection
- */
-export declare class RequestId extends EntityId {
-    static create(id: string): RequestId;
-    static generate(): RequestId;
-}
-/**
- * CollectionId — uniquely identifies a collection
- */
-export declare class CollectionId extends EntityId {
-    static create(id: string): CollectionId;
-    static generate(): CollectionId;
-}

package/dist/domain/value-objects/http-method.d.ts

@@ -1,30 +0,0 @@
-/**
- * HttpMethod Value Object
- *
- * Ensures only valid HTTP methods are used throughout the domain.
- * Immutable — validated at construction time.
- */
-declare const VALID_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "TRACE", "CONNECT"];
-export type HttpMethodValue = typeof VALID_METHODS[number];
-export declare class HttpMethod {
-    readonly value: HttpMethodValue;
-    private constructor();
-    /**
-     * Create an HttpMethod from a string.
-     * Normalizes to uppercase and validates.
-     */
-    static create(method: string): HttpMethod;
-    /**
-     * Create without validation (for trusted internal data).
-     */
-    static fromTrusted(method: HttpMethodValue): HttpMethod;
-    equals(other: HttpMethod): boolean;
-    toString(): string;
-    /** Whether this method typically has a request body */
-    get hasBody(): boolean;
-    /** Whether this method is considered safe (no side effects) */
-    get isSafe(): boolean;
-    /** Whether this method is idempotent */
-    get isIdempotent(): boolean;
-}
-export {};

package/dist/domain/value-objects/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Domain Value Objects
- *
- * Immutable, validated building blocks for the domain model.
- * These enforce business invariants at construction time.
- */
-export { HttpMethod, type HttpMethodValue } from './http-method';
-export { RequestUrl } from './request-url';
-export { EntityId, RequestId, CollectionId } from './entity-id';

package/dist/domain/value-objects/request-url.d.ts

@@ -1,28 +0,0 @@
-/**
- * RequestUrl Value Object
- *
- * Validates and normalizes request URLs.
- * Supports both absolute URLs and URL templates with variables (e.g. {{baseUrl}}/users).
- */
-export declare class RequestUrl {
-    readonly value: string;
-    private constructor();
-    /**
-     * Create a RequestUrl from a string.
-     * Allows variable templates like {{baseUrl}}/path.
-     */
-    static create(url: string): RequestUrl;
-    /**
-     * Create without validation (for trusted internal data).
-     */
-    static fromTrusted(url: string): RequestUrl;
-    /** Whether the URL contains template variables */
-    get hasVariables(): boolean;
-    /** Extract variable names from the URL template */
-    get variableNames(): string[];
-    /** Get the protocol if present */
-    get protocol(): string | undefined;
-    equals(other: RequestUrl): boolean;
-    toString(): string;
-    private static isValidUrl;
-}

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

@@ -1,5 +0,0 @@
-/**
- * External Adapters
- */
-export * from './node-file-system.adapter';
-export * from './logger.adapter';

package/dist/infrastructure/adapters/logger.adapter.d.ts

@@ -1,25 +0,0 @@
-/**
- * Console Logger Adapter - ILogger implementation
- */
-import { ILogger, LogLevel } from '../../ports/external/logger.interface';
-/**
- * Simple console-based logger implementation
- */
-export declare class ConsoleLoggerAdapter implements ILogger {
-    private minLevel;
-    constructor(minLevel?: LogLevel);
-    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;
-    private canLog;
-}
-/**
- * Silent logger - no output
- */
-export declare class SilentLoggerAdapter implements ILogger {
-    debug(): void;
-    info(): void;
-    warn(): void;
-    error(): void;
-}