@http-forge/core 0.2.1 → 0.2.3

package/dist/application/dto/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Application DTOs
+ *
+ * Data Transfer Objects decouple use-case inputs/outputs
+ * from domain internals and infrastructure types.
+ */
+export type { CreateRequestInput, UpdateRequestInput, DeleteRequestInput, ListRequestsInput, GetCollectionInput, ExecuteRequestInput, LoadCollectionInput, SaveCollectionInput, ExportCollectionInput, GetRequestSchemaInput, ExportFormat, } from './request-dtos';
+export type { RequestSummaryDto, RequestDetailDto, CollectionSummaryDto, CollectionDetailDto, CollectionItemDto, ScriptResultDto, AssertionResultDto, ExecuteRequestOutput, RequestSchemaOutput, CreateRequestOutput, UpdateRequestOutput, DeleteRequestOutput, SaveCollectionOutput, ExportCollectionOutput, LoadCollectionOutput, ListRequestsOutput, GetCollectionOutput, } from './response-dtos';

package/dist/application/dto/request-dtos.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Application DTOs — Request Input Types
+ *
+ * Standardized input objects for all use-cases.
+ * These decouple the public API from internal domain types.
+ */
+import { BodySchemaDefinition, KeyValueEntry, PathParamEntry, RequestBody, RequestScripts, RequestSettings, ResponseSchemaDefinition } from '../../types/types';
+export interface CreateRequestInput {
+    collectionId: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    /** Headers with enabled/disabled flag */
+    headers?: KeyValueEntry[];
+    /** Query parameters with enabled/disabled flag */
+    query?: KeyValueEntry[];
+    /** Path parameters */
+    params?: Record<string, string | PathParamEntry>;
+    /** Request body - supports raw, form-data, url-encoded, graphql, binary, or none */
+    body?: RequestBody;
+    /** Content-Type override */
+    bodyContentType?: string;
+    /** Request-level settings */
+    settings?: RequestSettings;
+    /** Request scripts (pre/post) */
+    scripts?: RequestScripts;
+    /** Authentication config (basic, bearer, apikey - no oauth2 at collection level) */
+    auth?: any;
+    /** Mark as disabled */
+    disabled?: boolean;
+    /** Mark as deprecated */
+    deprecated?: boolean;
+    /** Response schema */
+    responseSchema?: ResponseSchemaDefinition;
+    /** Body schema */
+    bodySchema?: BodySchemaDefinition;
+}
+export interface UpdateRequestInput {
+    collectionId: string;
+    requestId: string;
+    name?: string;
+    method?: string;
+    url?: string;
+    description?: string;
+    /** Headers with enabled/disabled flag */
+    headers?: KeyValueEntry[];
+    /** Query parameters with enabled/disabled flag */
+    query?: KeyValueEntry[];
+    /** Path parameters */
+    params?: Record<string, string | PathParamEntry>;
+    /** Request body - supports raw, form-data, url-encoded, graphql, binary, or none */
+    body?: RequestBody;
+    /** Content-Type override */
+    bodyContentType?: string;
+    /** Request-level settings */
+    settings?: RequestSettings;
+    /** Request scripts (pre/post) */
+    scripts?: RequestScripts;
+    /** Authentication config (basic, bearer, apikey - no oauth2 at collection level) */
+    auth?: any;
+    /** Mark as disabled */
+    disabled?: boolean;
+    /** Mark as deprecated */
+    deprecated?: boolean;
+    /** Response schema */
+    responseSchema?: ResponseSchemaDefinition;
+    /** Body schema */
+    bodySchema?: BodySchemaDefinition;
+}
+export interface DeleteRequestInput {
+    collectionId: string;
+    requestId: string;
+}
+export interface ListRequestsInput {
+    collectionId: string;
+}
+export interface GetCollectionInput {
+    collectionId: string;
+}
+export interface ExecuteRequestInput {
+    collectionId: string;
+    requestId: string;
+    overrides?: {
+        variables?: Record<string, any>;
+        environment?: Record<string, any>;
+    };
+}
+export interface LoadCollectionInput {
+    filePath: string;
+}
+export interface SaveCollectionInput {
+    filePath: string;
+    collectionId: string;
+}
+export type ExportFormat = 'postman' | 'openapi';
+export interface ExportCollectionInput {
+    collectionId: string;
+    format: ExportFormat;
+    outputPath: string;
+}
+export interface GetRequestSchemaInput {
+    collectionId: string;
+    requestId: string;
+}

package/dist/application/dto/response-dtos.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Application DTOs — Response Output Types
+ *
+ * Standardized output objects for all use-cases.
+ * These shield consumers from internal domain model changes.
+ */
+import { BodySchemaDefinition, KeyValueEntry, RequestBody, RequestScripts, RequestSettings, ResponseSchemaDefinition } from '../../types/types';
+export interface RequestSummaryDto {
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    disabled?: boolean;
+    deprecated?: boolean;
+}
+export interface RequestDetailDto {
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    /** Headers with per-header enabled/disabled flag */
+    headers: KeyValueEntry[];
+    /** Query parameters with per-item enabled/disabled flag */
+    query: KeyValueEntry[];
+    body?: RequestBody;
+    bodyContentType?: string;
+    auth?: any;
+    settings?: RequestSettings;
+    scripts?: RequestScripts;
+    disabled?: boolean;
+    deprecated?: boolean;
+    responseSchema?: ResponseSchemaDefinition;
+    bodySchema?: BodySchemaDefinition;
+    hasPreScript: boolean;
+    hasPostScript: boolean;
+}
+export interface CollectionSummaryDto {
+    id: string;
+    name: string;
+    description?: string;
+    requestCount: number;
+    folderCount: number;
+}
+export interface CollectionItemDto {
+    id: string;
+    name: string;
+    type: 'request' | 'folder';
+    method?: string;
+    url?: string;
+    childCount?: number;
+}
+export interface CollectionDetailDto {
+    id: string;
+    name: string;
+    description?: string;
+    items: CollectionItemDto[];
+    requestCount: number;
+    folderCount: number;
+    meta?: Record<string, any>;
+}
+/**
+ * Full Collection Detail with all nested request/folder metadata
+ * Used by LoadCollectionUseCase to return COMPLETE data (not filtered)
+ */
+export interface CollectionFullDetailDto {
+    id: string;
+    name: string;
+    description?: string;
+    /** Full nested structure with all request/folder metadata preserved */
+    items: (CollectionFullItemDto)[];
+    variables?: Record<string, string>;
+    auth?: any;
+    scripts?: RequestScripts;
+    meta?: Record<string, any>;
+}
+/**
+ * Full collection item (request or folder) with ALL metadata
+ */
+export type CollectionFullItemDto = CollectionFullRequestDto | CollectionFullFolderDto;
+/**
+ * Full request DTO with all fields preserved (headers, query, body, scripts, etc.)
+ */
+export interface CollectionFullRequestDto {
+    type: 'request';
+    id: string;
+    name: string;
+    method: string;
+    url: string;
+    description?: string;
+    headers: KeyValueEntry[];
+    query: KeyValueEntry[];
+    body?: RequestBody;
+    bodyContentType?: string;
+    auth?: any;
+    settings?: RequestSettings;
+    scripts?: RequestScripts;
+    disabled?: boolean;
+    deprecated?: boolean;
+    responseSchema?: ResponseSchemaDefinition;
+    bodySchema?: BodySchemaDefinition;
+}
+/**
+ * Full folder DTO with nested items preserved
+ */
+export interface CollectionFullFolderDto {
+    type: 'folder';
+    id: string;
+    name: string;
+    description?: string;
+    auth?: any;
+    scripts?: RequestScripts;
+    items: (CollectionFullItemDto)[];
+}
+export interface ScriptResultDto {
+    success: boolean;
+    output?: any;
+    errors: string[];
+}
+export interface AssertionResultDto {
+    name: string;
+    passed: boolean;
+    expected?: any;
+    actual?: any;
+    message?: string;
+}
+export interface ExecuteRequestOutput {
+    requestId: string;
+    status: 'success' | 'failed' | 'partial';
+    duration: number;
+    response: {
+        status: number;
+        statusText: string;
+        headers: Record<string, string | string[]>;
+        bodySize?: number;
+    };
+    preScriptResult?: ScriptResultDto;
+    postScriptResult?: ScriptResultDto & {
+        assertions?: AssertionResultDto[];
+    };
+    variableChanges?: Record<string, any>;
+    error?: string;
+}
+export interface RequestSchemaOutput {
+    requestId: string;
+    schema: any;
+    sources: ('user' | 'history' | 'script')[];
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface CreateRequestOutput {
+    request: RequestDetailDto;
+}
+export interface UpdateRequestOutput {
+    request: RequestDetailDto;
+}
+export interface DeleteRequestOutput {
+    requestId: string;
+    collectionId: string;
+    deletedAt: string;
+}
+export interface SaveCollectionOutput {
+    filePath: string;
+    collectionName: string;
+    savedAt: string;
+}
+export interface ExportCollectionOutput {
+    collectionId: string;
+    format: string;
+    outputPath: string;
+    exportedAt: string;
+}
+export interface LoadCollectionOutput {
+    /** Full collection with ALL nested metadata preserved */
+    collection: CollectionFullDetailDto;
+    loadedFrom: string;
+}
+export interface ListRequestsOutput {
+    collectionId: string;
+    requests: RequestSummaryDto[];
+    total: number;
+}
+export interface GetCollectionOutput {
+    collection: CollectionDetailDto;
+}

package/dist/application/events/application-events.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Application Events
+ *
+ * Higher-level events published by use-cases to notify the outer system
+ * (e.g. VS Code extension, CLI) about completed operations.
+ *
+ * These are distinct from domain events:
+ * - Domain events: model business invariants (RequestExecutedEvent, VariableUpdatedEvent)
+ * - Application events: notify about user actions (RequestCreatedEvent, CollectionExportedEvent)
+ */
+import { DomainEvent } from '../../domain/services/domain-events';
+export declare class RequestCreatedEvent extends DomainEvent {
+    readonly collectionId: string;
+    readonly name: string;
+    readonly method: string;
+    readonly url: string;
+    constructor(requestId: string, collectionId: string, name: string, method: string, url: string);
+}
+export declare class RequestUpdatedEvent extends DomainEvent {
+    readonly collectionId: string;
+    readonly changes: string[];
+    constructor(requestId: string, collectionId: string, changes: string[]);
+}
+export declare class RequestDeletedEvent extends DomainEvent {
+    readonly collectionId: string;
+    constructor(requestId: string, collectionId: string);
+}
+export declare class CollectionLoadedEvent extends DomainEvent {
+    readonly name: string;
+    readonly source: string;
+    readonly requestCount: number;
+    constructor(collectionId: string, name: string, source: string, // file path or identifier
+    requestCount: number);
+}
+export declare class CollectionSavedEvent extends DomainEvent {
+    readonly name: string;
+    readonly filePath: string;
+    constructor(collectionId: string, name: string, filePath: string);
+}
+export declare class CollectionExportedEvent extends DomainEvent {
+    readonly format: string;
+    readonly outputPath: string;
+    constructor(collectionId: string, format: string, outputPath: string);
+}
+export declare const ApplicationEventTypes: {
+    readonly REQUEST_CREATED: "REQUEST_CREATED";
+    readonly REQUEST_UPDATED: "REQUEST_UPDATED";
+    readonly REQUEST_DELETED: "REQUEST_DELETED";
+    readonly COLLECTION_LOADED: "COLLECTION_LOADED";
+    readonly COLLECTION_SAVED: "COLLECTION_SAVED";
+    readonly COLLECTION_EXPORTED: "COLLECTION_EXPORTED";
+};
+export type ApplicationEventType = typeof ApplicationEventTypes[keyof typeof ApplicationEventTypes];

package/dist/application/events/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Application Events
+ *
+ * Events published by use-cases to notify about completed user actions.
+ */
+export { RequestCreatedEvent, RequestUpdatedEvent, RequestDeletedEvent, CollectionLoadedEvent, CollectionSavedEvent, CollectionExportedEvent, ApplicationEventTypes, type ApplicationEventType, } from './application-events';

package/dist/application/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Application Layer - Use Cases and Queries
+ *
+ * Contains:
+ * - Use Cases (commands that modify state)
+ * - Queries (read-only operations)
+ * - Data Transfer Objects (DTOs)
+ * - Application Events
+ * - Mappers (domain ↔ DTO conversion)
+ *
+ * Constraints:
+ * - Depends on Domain and Ports layers
+ * - Orchestrates between Domain and Infrastructure
+ * - Never directly depends on Infrastructure implementations
+ *
+ * Usage:
+ * - Called by controllers/handlers
+ * - Uses repositories and executors from ports
+ * - Publishes domain events
+ */
+export * from './use-cases';
+export * from './queries';
+export * from './dto';
+export * from './events';
+export * from './mappers';

package/dist/application/mappers/collection-mapper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * CollectionMapper
+ *
+ * Maps between UnifiedCollection (domain/infrastructure type) and
+ * application-layer DTOs (CollectionDetailDto, CollectionSummaryDto, CollectionFullDetailDto).
+ *
+ * Provides two mapping strategies:
+ * - toDetail() / toSummary() - Filtered summaries for list/UI views
+ * - toFullDetail() - Complete metadata for full collection operations (load, edit)
+ */
+import { UnifiedCollection } from '../../types/types';
+import { CollectionDetailDto, CollectionFullDetailDto, CollectionSummaryDto } from '../dto/response-dtos';
+export declare class CollectionMapper {
+    /**
+     * Map domain collection to a summary DTO
+     */
+    static toSummary(collection: UnifiedCollection): CollectionSummaryDto;
+    /**
+     * Map domain collection to a full detail DTO
+     */
+    static toDetail(collection: UnifiedCollection): CollectionDetailDto;
+    /**
+     * Map domain collection to a full detail DTO (preserves ALL metadata)
+     * Used by LoadCollectionUseCase to return complete collection with all fields
+     */
+    static toFullDetail(collection: UnifiedCollection): CollectionFullDetailDto;
+    /**
+     * Map top-level items to full detail items (preserves ALL metadata per request/folder)
+     */
+    private static toFullItems;
+    /**
+     * Map top-level items to flat CollectionItemDto list
+     */
+    private static mapItems;
+    /**
+     * Recursively count requests and folders
+     */
+    private static countItems;
+}

package/dist/application/mappers/execution-result-mapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * ExecutionResultMapper
+ *
+ * Maps between IExecutionResult (domain model) and
+ * ExecuteRequestOutput (application DTO).
+ */
+import { IExecutionResult } from '../../domain/models/execution';
+import { ExecuteRequestOutput } from '../dto/response-dtos';
+export declare class ExecutionResultMapper {
+    /**
+     * Map domain execution result to application-layer output DTO
+     */
+    static toOutput(result: IExecutionResult): ExecuteRequestOutput;
+    private static mapScriptResult;
+    private static mapAssertion;
+}

package/dist/application/mappers/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Application Mappers
+ *
+ * Convert between domain types and application DTOs.
+ * Mappers formalize the boundary between layers.
+ */
+export { RequestMapper } from './request-mapper';
+export { CollectionMapper } from './collection-mapper';
+export { ExecutionResultMapper } from './execution-result-mapper';

package/dist/application/mappers/request-mapper.d.ts

@@ -0,0 +1,29 @@
+/**
+ * RequestMapper
+ *
+ * Maps between UnifiedRequest (domain/infrastructure type) and
+ * application-layer DTOs (RequestDetailDto, RequestSummaryDto).
+ *
+ * Preserves all metadata including enabled/disabled flags and schemas.
+ */
+import { UnifiedRequest } from '../../types/types';
+import { RequestDetailDto, RequestSummaryDto } from '../dto/response-dtos';
+export declare class RequestMapper {
+    /**
+     * Map domain request to a lightweight summary DTO
+     */
+    static toSummary(request: UnifiedRequest): RequestSummaryDto;
+    /**
+     * Map domain request to a full detail DTO
+     * PRESERVES all metadata including enabled/disabled headers and schemas
+     */
+    static toDetail(request: UnifiedRequest): RequestDetailDto;
+    /**
+     * Map multiple requests to summaries
+     */
+    static toSummaryList(requests: UnifiedRequest[]): RequestSummaryDto[];
+    /**
+     * Map multiple requests to details
+     */
+    static toDetailList(requests: UnifiedRequest[]): RequestDetailDto[];
+}

package/dist/application/queries/get-request-schema.query.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Get Request Schema Query
+ *
+ * Retrieves inferred response schema for a request
+ * Merges information from: user definition, history, script hints
+ */
+import { IRequestRepository } from '../../ports/repositories/request-repository.interface';
+import { IHistoryLoader } from '../../ports/storage/history-loader.interface';
+import { ResponseSchema } from '../../domain/services/schema-inference.domain-service';
+import { ILogger } from '../../ports/external/logger.interface';
+/**
+ * Query: Get request response schema
+ */
+export declare class GetRequestSchemaQuery {
+    private requestRepository;
+    private historyLoader;
+    private logger;
+    private schemaInference;
+    constructor(requestRepository: IRequestRepository, historyLoader: IHistoryLoader, logger: ILogger);
+    /**
+     * Get combined response schema for a request
+     */
+    execute(collectionId: string, requestId: string): Promise<ResponseSchema>;
+    /**
+     * Infer schema from historical responses
+     */
+    private inferFromHistory;
+    /**
+     * Extract property hints from post-response script
+     */
+    private extractScriptHints;
+}

package/dist/application/queries/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Application Queries
+ *
+ * Read-only operations
+ */
+export * from './get-request-schema.query';

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

@@ -0,0 +1,23 @@
+/**
+ * Create Request Use Case
+ *
+ * Creates a new HTTP request in a collection
+ * Supports full request metadata including enabled/disabled headers, schemas, etc.
+ */
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { ILogger } from '../../ports/external/logger.interface';
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { CreateRequestInput } from '../dto/request-dtos';
+import { CreateRequestOutput } from '../dto/response-dtos';
+export type { CreateRequestInput } from '../dto/request-dtos';
+/**
+ * Use Case: Create a new request in collection
+ */
+export declare class CreateRequestUseCase {
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: CreateRequestInput): Promise<CreateRequestOutput>;
+    private generateId;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Delete Request Use Case
+ */
+import { ICollectionRepository } from '../../ports/repositories/collection-repository.interface';
+import { ILogger } from '../../ports/external/logger.interface';
+import { IDomainEventPublisher } from '../../domain/services/domain-events';
+import { DeleteRequestInput } from '../dto/request-dtos';
+import { DeleteRequestOutput } from '../dto/response-dtos';
+export declare class DeleteRequestUseCase {
+    private collectionRepository;
+    private eventPublisher;
+    private logger;
+    constructor(collectionRepository: ICollectionRepository, eventPublisher: IDomainEventPublisher, logger: ILogger);
+    execute(input: DeleteRequestInput): Promise<DeleteRequestOutput>;
+}

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

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

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

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

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