@http-forge/core 0.2.1 → 0.2.2

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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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

@@ -0,0 +1,17 @@
+/**
+ * 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/container.d.ts

@@ -1,21 +1,38 @@
 /**
  * Forge Container - Dependency Injection Container
  *
+ * ⚠️ @deprecated 此类用于向后兼容
+ * 新代码应使用 infrastructure/di/complete-bootstrap 中的 bootstrapComplete() 函数
+ *
+ * 向后兼容层:
+ * 此文件继续提供原有的 ForgeContainer 接口
+ * 内部实现现已迁移至三层架构 (Domain/Application/Infrastructure)
+ *
+ * 迁移指南:
+ * 旧代码:
+ *   const container = new ForgeContainer(config);
+ *
+ * 新代码:
+ *   import { ServiceContainer } from '@http-forge/core/di';
+ *   import { bootstrapComplete } from '@http-forge/core/infrastructure/di';
+ *
+ *   const container = new ServiceContainer();
+ *   bootstrapComplete(container, { useFileSystem: true });
+ *
  * Single Responsibility: Wire up all components with proper dependencies
  * Factory Pattern: Creates configured instances of services
  */
-import { ICollectionLoader } from './collection/interfaces';
-import { ParserRegistry } from './collection/parser-registry';
-import { ICookieService } from './cookie/interfaces';
-import { EnvironmentResolver, EnvironmentStoreConfig } from './environment/environment-resolver';
-import { ForgeEnv } from './environment/forge-env';
-import { IVariableInterpolator } from './environment/interfaces';
-import { RequestExecutor } from './execution/request-executor';
-import { IRequestHistory } from './history/history-interfaces';
-import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './http/interceptor-chain';
-import { IRequestPreprocessor } from './http/request-preprocessor';
-import { IDataFileParser } from './platform/data-file-parser';
-import { IScriptExecutor } from './script/interfaces';
+import { ParserRegistry } from './infrastructure/collection/parser-registry';
+import { ICookieService } from './infrastructure/cookie/interfaces';
+import { EnvironmentResolver, EnvironmentStoreConfig } from './infrastructure/environment/environment-resolver';
+import { ForgeEnv } from './infrastructure/environment/forge-env';
+import { IVariableInterpolator } from './types/environment-config';
+import { RequestExecutor } from './infrastructure/execution/request-executor';
+import { IRequestHistory } from './infrastructure/history/history-interfaces';
+import { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor } from './infrastructure/http/interceptor-chain';
+import { IRequestPreprocessor } from './infrastructure/http/request-preprocessor';
+import { IDataFileParser } from './infrastructure/platform/data-file-parser';
+import { IScriptExecutor } from './infrastructure/script/interfaces';
 import { IFileSystem, IHttpClient } from './types/platform';
 import { HttpRequest, HttpResponse, RequestSettings, UnifiedCollection, UnifiedRequest } from './types/types';
 /**
@@ -92,7 +109,7 @@ export declare class ForgeContainer {
     readonly dataFileParser: IDataFileParser;
     readonly requestHistory: IRequestHistory | null;
     readonly parserRegistry: ParserRegistry;
-    readonly collectionLoader: ICollectionLoader;
+    readonly collectionLoader: import('./types/collection').ICollectionLoader;
     readonly environmentStore: EnvironmentResolver;
     readonly forgeEnv: ForgeEnv;
     readonly requestExecutor: RequestExecutor;

package/dist/di/index.d.ts

@@ -1,8 +1,16 @@
 /**
  * Dependency Injection
  *
+ * ⚠️ @deprecated 此模块用于向后兼容
+ * 新代码应使用 infrastructure/di/complete-bootstrap 中的功能
+ *
  * Provides a generic, platform-agnostic DI container and service bootstrap.
  * Host environments (VS Code, CLI, etc.) only need to supply PlatformAdapters.
+ *
+ * 迁移指南:
+ * - 旧的 ServiceContainer 已被新的架构集成
+ * - 使用 bootstrapComplete() 替代 registerCoreServices()
+ * - 详见 ARCHITECTURE_IMPLEMENTATION.md
  */
 export { registerCoreServices } from './core-bootstrap';
 export type { PlatformAdapters } from './platform-adapters';

package/dist/di/platform-adapters.d.ts

@@ -8,7 +8,10 @@
  * without depending on any specific platform.
  */
 import type { IConsoleService } from '../types/console-service';
-import type { IApplicationInfo, IExternalBrowserService, IFileWatcherFactory, IKeyValueStore, INotificationService, ISecretStore } from '../types/platform';
+import type { IApplicationInfo, IExternalBrowserService, IFileSystem, IFileWatcherFactory, IHttpClient, IKeyValueStore, INotificationService, ISecretStore } from '../types/platform';
+import type { IHttpExecutor } from '../ports/executors/http-executor.interface';
+import type { IScriptExecutor } from '../ports/executors/script-executor.interface';
+import type { ILogger } from '../ports/external/logger.interface';
 /**
  * Platform adapters required by core service bootstrap.
  *
@@ -50,4 +53,14 @@ export interface PlatformAdapters {
     applicationInfo?: IApplicationInfo;
     /** Structured logging service. Optional — a no-op console is used if absent. */
     consoleService?: IConsoleService;
+    /** File system adapter */
+    fileSystem?: IFileSystem;
+    /** Logger adapter */
+    logger?: ILogger;
+    /** HTTP client adapter */
+    httpClient?: IHttpClient;
+    /** HTTP executor adapter */
+    httpExecutor?: IHttpExecutor;
+    /** Script executor adapter */
+    scriptExecutor?: IScriptExecutor;
 }

package/dist/di/service-container.d.ts

@@ -9,21 +9,21 @@
  * - Single Responsibility: Container only manages service lifecycle
  * - Open/Closed: New services registered without modifying existing code
  */
-import type { IAsyncCookieService } from '../cookie/interfaces';
-import type { IRequestPreparer } from '../execution/request-preparer-interfaces';
-import type { IRequestHistoryService } from '../history/request-history-service-interfaces';
-import type { IHttpRequestService } from '../http/interfaces';
-import type { IScriptExecutor } from '../script/interfaces';
+import type { IAsyncCookieService } from '../infrastructure/cookie/interfaces';
+import type { IRequestPreparer } from '../infrastructure/execution/request-preparer-interfaces';
+import type { IRequestHistoryService } from '../infrastructure/history/request-history-service-interfaces';
+import type { IHttpRequestService } from '../infrastructure/http/interfaces';
+import type { IScriptExecutor } from '../infrastructure/script/interfaces';
 import type { IConsoleService } from '../types/console-service';
 import type { IHttpClient } from '../types/platform';
 import type { ServiceIdentifier } from './service-identifiers';
-import type { IOAuth2TokenManager } from '../auth/interfaces';
-import type { ICollectionService } from '../collection/collection-service-interfaces';
-import type { IConfigService } from '../config';
-import type { IEnvironmentConfigService } from '../environment/interfaces';
-import type { IGraphQLSchemaService } from '../graphql/graphql-schema-service';
-import type { IDataFileParser } from '../platform/data-file-parser';
-import type { ICookieJar } from '../script/interfaces';
+import type { IOAuth2TokenManager } from '../infrastructure/auth/interfaces';
+import type { ICollectionService } from '../types/collection';
+import type { IConfigService } from '../infrastructure/config';
+import type { IEnvironmentConfigService } from '../types/environment-config';
+import type { IGraphQLSchemaService } from '../infrastructure/graphql/graphql-schema-service';
+import type { IDataFileParser } from '../infrastructure/platform/data-file-parser';
+import type { ICookieJar } from '../infrastructure/script/interfaces';
 /**
  * Factory function type for creating services
  */

package/dist/di/service-identifiers.d.ts

@@ -31,4 +31,4 @@ export declare const ServiceIdentifiers: {
     readonly OpenApiExporter: symbol;
     readonly OpenApiImporter: symbol;
 };
-export type ServiceIdentifier = typeof ServiceIdentifiers[keyof typeof ServiceIdentifiers];
+export type ServiceIdentifier = typeof ServiceIdentifiers[keyof typeof ServiceIdentifiers] | string;

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

@@ -0,0 +1,52 @@
+/**
+ * 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

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

package/dist/domain/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,88 @@
+/**
+ * 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

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

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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,40 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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';