@http-forge/core 0.2.1 → 0.2.3

package/dist/ports/external/http-client.interface.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HTTP Client Port - Abstract HTTP operations
+ * Enables switching between fetch, Node.js fetch, Node.js http, etc.
+ *
+ * Implementations: NodeHttpClient, FetchHttpClient
+ */
+export interface IHttpClient {
+    /**
+     * Execute HTTP request
+     */
+    execute(request: IHttpClientRequest): Promise<IHttpClientResponse>;
+}
+export interface IHttpClientRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string | Buffer;
+    timeout?: number;
+}
+export interface IHttpClientResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string | string[]>;
+    body: Buffer | string;
+}

package/dist/ports/external/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * External Ports - Platform and infrastructure abstractions
+ * Enables dependency injection and platform independence
+ */
+export * from './file-system.interface';
+export * from './http-client.interface';
+export * from './logger.interface';

package/dist/ports/external/logger.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logger Port - Abstract logging operations
+ *
+ * Implementations: ConsoleLogger, SilentLogger, CustomLogger
+ */
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export interface ILogger {
+    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;
+}

package/dist/ports/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ports Layer - Abstract interfaces (Hexagonal Architecture)
+ *
+ * Defines contracts for:
+ * - Data access (Repositories)
+ * - Execution (HTTP, Scripts)
+ * - Storage (History, Cache)
+ * - External systems (FileSystem, HTTP Client, Logger)
+ * - Parsing (Collection formats)
+ *
+ * Implementations are in the infrastructure layer
+ */
+export * from './external';
+export * from './repositories';
+export * from './executors';
+export * from './storage';
+export * from './parsers';

package/dist/ports/parsers/collection-parser.interface.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Collection Parser Port - Abstract collection parsing
+ *
+ * Implementations: HttpForgeParser, PostmanParser, OpenAPIParser
+ */
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Collection Parser - Parses different collection formats
+ */
+export interface ICollectionParser {
+    /**
+     * Check if this parser can handle the content
+     */
+    canHandle(content: string, format?: string): boolean;
+    /**
+     * Parse collection from content
+     */
+    parse(content: string): Promise<UnifiedCollection>;
+    /**
+     * Supported formats (e.g., 'http-forge', 'postman', 'openapi')
+     */
+    readonly supportedFormats: string[];
+}

package/dist/ports/parsers/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parser Ports - Parsing abstraction
+ */
+export * from './collection-parser.interface';

package/dist/ports/repositories/collection-repository.interface.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Collection Repository Port - Abstract collection data access
+ * Enables switching between file-based, in-memory, cloud storage, etc.
+ *
+ * Implementations: FileSystemCollectionRepository, InMemoryCollectionRepository
+ */
+import { UnifiedCollection } from '../../types/types';
+/**
+ * Repository for managing collections
+ */
+export interface ICollectionRepository {
+    /**
+     * Find collection by ID
+     */
+    findById(id: string): Promise<UnifiedCollection | null>;
+    /**
+     * Find all collections
+     */
+    findAll(): Promise<UnifiedCollection[]>;
+    /**
+     * Save or update collection
+     */
+    save(id: string, collection: UnifiedCollection): Promise<void>;
+    /**
+     * Delete collection by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if collection exists
+     */
+    exists(id: string): Promise<boolean>;
+}

package/dist/ports/repositories/environment-repository.interface.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Environment Repository Port - Abstract environment data access
+ *
+ * Implementations: FileSystemEnvironmentRepository
+ */
+import { Environment } from '../../infrastructure/environment/environment-resolver';
+/**
+ * Repository for managing environments
+ */
+export interface IEnvironmentRepository {
+    /**
+     * Find environment by ID/name
+     */
+    findById(id: string): Promise<Environment | null>;
+    /**
+     * Find active environment
+     */
+    findActive(): Promise<Environment | null>;
+    /**
+     * Find all environments
+     */
+    findAll(): Promise<Environment[]>;
+    /**
+     * Save or update environment
+     */
+    save(environment: Environment): Promise<void>;
+    /**
+     * Delete environment by ID
+     */
+    delete(id: string): Promise<void>;
+}

package/dist/ports/repositories/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Repository Ports - Data access abstraction
+ */
+export * from './request-repository.interface';
+export * from './collection-repository.interface';
+export * from './environment-repository.interface';

package/dist/ports/repositories/request-repository.interface.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Request Repository Port - Abstract request data access
+ * Enables switching between file-based, in-memory, cloud storage, etc.
+ *
+ * Implementations: FileSystemRequestRepository, InMemoryRequestRepository
+ */
+import { UnifiedRequest } from '../../types/types';
+/**
+ * Repository for managing individual requests
+ */
+export interface IRequestRepository {
+    /**
+     * Find request by ID
+     */
+    findById(id: string): Promise<UnifiedRequest | null>;
+    /**
+     * Find all requests in a collection
+     */
+    findAll(collectionId: string): Promise<UnifiedRequest[]>;
+    /**
+     * Save or update request
+     */
+    save(request: UnifiedRequest): Promise<void>;
+    /**
+     * Delete request by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Check if request exists
+     */
+    exists(id: string): Promise<boolean>;
+}

package/dist/ports/storage/cache-store.interface.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Cache Store Port - Abstract caching
+ *
+ * Implementations: GraphQLSchemaCacheStore, MemoryCacheStore
+ */
+/**
+ * Generic cache store
+ */
+export interface ICacheStore<T> {
+    /**
+     * Get value from cache
+     */
+    get(key: string): Promise<T | null>;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Clear all cache
+     */
+    clear(): Promise<void>;
+}

package/dist/ports/storage/history-loader.interface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * History Loader Port - Abstract history loading
+ *
+ * Implementations: FileSystemHistoryLoader, InMemoryHistoryLoader
+ */
+import { HttpResponse } from '../../types/types';
+/**
+ * History entry metadata
+ */
+export interface IHistoryEntry {
+    id: string;
+    requestId: string;
+    collectionId: string;
+    timestamp: Date;
+    status: number;
+    duration: number;
+}
+/**
+ * History Loader - Loads request execution history
+ */
+export interface IHistoryLoader {
+    /**
+     * Load history entries for a request
+     */
+    loadHistory(collectionId: string, requestId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IHistoryEntry[]>;
+    /**
+     * Load full response from history
+     */
+    loadFullResponse(collectionId: string, requestId: string, entryId: string): Promise<HttpResponse | null>;
+    /**
+     * Save history entry
+     */
+    saveEntry(collectionId: string, requestId: string, response: HttpResponse, duration: number): Promise<IHistoryEntry>;
+}

package/dist/ports/storage/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Storage Ports - Storage and caching abstraction
+ */
+export * from './history-loader.interface';
+export * from './cache-store.interface';

package/dist/{collection/collection-service-interfaces.d.ts → types/collection.d.ts}

@@ -1,10 +1,10 @@
 /**
- * Collection Service Interface
+ * Collection Types
  *
- * Interface Segregation: Separated into focused sub-interfaces
- * Dependency Inversion: Consumers depend on this abstraction
+ * Migrated from src/collection/ for better organization
+ * These types define the contracts for collection management
  */
-import { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings } from '../types/types';
+import { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings } from './types';
 export type { CollectionRequest, KeyValueEntry, RequestAuth, RequestScripts, RequestSettings };
 /**
  * Request item in a collection - CollectionRequest with type discriminator
@@ -117,3 +117,18 @@ export interface ICollectionImportExport {
 export interface ICollectionService extends ICollectionReader, ICollectionWriter, IRequestManager, IFolderManager, ICollectionVariableManager, ICollectionImportExport {
     dispose(): void;
 }
+/**
+ * Collection loader interface
+ */
+export interface ICollectionLoader {
+    load(filePath: string, options?: any): Promise<import('./types').UnifiedCollection> | import('./types').UnifiedCollection | undefined;
+    loadAll(): Promise<import('./types').UnifiedCollection[]> | import('./types').UnifiedCollection[];
+}
+/**
+ * Collection parser interface (infrastructure-level)
+ * Different from ports/parsers/ICollectionParser
+ */
+export interface ICollectionParser {
+    canParse(content: string): boolean;
+    parse(content: string, filePath?: string): import('./types').UnifiedCollection;
+}

package/dist/types/environment-config.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Environment Configuration Types
+ *
+ * Migrated from src/environment/ for better organization
+ * These types define the contracts for environment management
+ */
+/**
+ * Environment configuration structure
+ */
+export interface EnvironmentConfig {
+    description?: string;
+    requiresConfirmation?: boolean;
+    variables?: Record<string, string>;
+}
+/**
+ * Shared configuration file structure
+ */
+export interface SharedConfig {
+    environments: Record<string, EnvironmentConfig>;
+    globalVariables?: Record<string, string>;
+    defaultHeaders?: Record<string, string>;
+}
+/**
+ * Local configuration file structure
+ */
+export interface LocalConfig {
+    credentials?: Record<string, {
+        variables?: Record<string, string>;
+    }>;
+    variables?: Record<string, string>;
+}
+/**
+ * Resolved environment with all inherited values
+ */
+export interface ResolvedEnvironment {
+    name: string;
+    description?: string;
+    requiresConfirmation?: boolean;
+    headers: Record<string, string>;
+    variables: Record<string, string>;
+}
+/**
+ * Representation of an imported environment (from Postman)
+ */
+export interface ImportedEnvironment {
+    name: string;
+    variables: Record<string, string>;
+    description?: string;
+}
+/**
+ * Import operations for environments
+ */
+export interface IEnvironmentImporter {
+    importPostmanEnvironmentFile(filePath: string): ImportedEnvironment | null;
+}
+/**
+ * Read operations for environment configuration
+ */
+export interface IEnvironmentConfigReader {
+    getWorkspaceFolder(): string;
+    getRootPath(): string;
+    getEnvironmentNames(): string[];
+    getSelectedEnvironment(): string;
+    getSharedConfig(): SharedConfig | null;
+    getSharedConfigPath(): string;
+    getLocalConfig(): LocalConfig | null;
+    getLocalConfigPath(): string;
+    getEnvironmentConfigPath(envName: string): string;
+    getEnvLocalPath(envName: string): string;
+    getResolvedEnvironment(envName: string): ResolvedEnvironment | null;
+}
+/**
+ * Write operations for environment configuration
+ */
+export interface IEnvironmentConfigWriter {
+    saveSharedConfig(config: SharedConfig): void;
+    saveLocalConfig(config: LocalConfig): void;
+}
+/**
+ * Environment selection operations
+ */
+export interface IEnvironmentSelector {
+    setSelectedEnvironment(envName: string): Promise<void>;
+}
+/**
+ * Variable resolution operations
+ */
+export interface IVariableResolver {
+    resolveVariables(text: string, envName?: string): string;
+    resolveVariablesWithExtra(text: string, extraVariables: Record<string, string>, envName?: string): string;
+    resolveVariablesInObject<T extends Record<string, any>>(obj: T, envName?: string): T;
+    resolveVariablesInObjectWithExtra<T extends Record<string, any>>(obj: T, extraVariables: Record<string, string>, envName?: string): T;
+}
+/**
+ * Variable management operations (for scripts)
+ */
+export interface IVariableManager {
+    setEnvironmentVariable(key: string, value: unknown): void;
+    deleteEnvironmentVariable(key: string): void;
+    clearEnvironmentVariables(): void;
+    getEnvironmentVariableLocals(): Record<string, string>;
+    setGlobalVariable(key: string, value: unknown): void;
+    getGlobalVariable(key: string): string | undefined;
+    deleteGlobalVariable(key: string): void;
+    clearGlobalVariables(): void;
+    setSessionVariable(key: string, value: unknown): void;
+    deleteSessionVariable(key: string): Promise<void>;
+    clearSessionVariables(): Promise<void>;
+    getSessionVariables(): Record<string, string>;
+    getGlobalVariables(): Record<string, string>;
+}
+/**
+ * Full environment configuration service interface
+ */
+export interface IEnvironmentConfigService extends IEnvironmentConfigReader, IEnvironmentConfigWriter, IEnvironmentSelector, IVariableResolver, IVariableManager {
+    loadConfigs(): void;
+    exportEnvironmentsToFolder(outDir: string, mergeGlobals?: boolean): void;
+}
+/**
+ * Interface for storing and retrieving environment variables
+ */
+export interface IEnvironmentStore {
+    get(key: string): string | undefined;
+    set(key: string, value: string): void;
+    getAll(): Record<string, string>;
+    getActive(): string | undefined;
+    setActive(name: string): void;
+    getVariables(environmentName?: string): Record<string, string>;
+}
+/**
+ * Interface for interpolating variables in strings
+ * Handles {{variable}} syntax replacement
+ */
+export interface IVariableInterpolator {
+    interpolate(input: string, variables: Record<string, string>): string;
+    extractVariables(input: string): string[];
+    interpolateObject<T>(obj: T, variables: Record<string, string>): T;
+}
+/**
+ * ForgeEnv type for environment representation
+ * @see src/infrastructure/environment/forge-env.ts for the canonical definition
+ */
+export type { IForgeEnv } from '../infrastructure/environment/forge-env';

package/dist/types/types.d.ts

@@ -4,7 +4,7 @@
  * Core data types used throughout the framework.
  * Simplified design for maximum compatibility.
  */
-import { ParsedCookie } from '../cookie/interfaces';
+import { ParsedCookie } from '../infrastructure/cookie/interfaces';
 export type { ParsedCookie };
 /**
  * Unified Collection - the common format all parsers produce
@@ -24,6 +24,8 @@ export interface UnifiedCollection {
         filePath: string;
         version?: string;
     };
+    /** Metadata (parser info, load timestamps, etc.) */
+    meta?: Record<string, any>;
 }
 /**
  * Unified Folder within a collection
@@ -39,6 +41,7 @@ export interface UnifiedFolder {
 }
 /**
  * Unified Request - normalized request format
+ * Supports full feature set from CollectionRequest with metadata preservation
  */
 export interface UnifiedRequest {
     type: 'request';
@@ -47,16 +50,26 @@ export interface UnifiedRequest {
     description?: string;
     method: string;
     url: string;
-    /** Headers as simple key-value pairs */
-    headers: Record<string, string>;
-    /** Query parameters as simple key-value pairs */
-    query: Record<string, string>;
-    /** Path parameters */
-    params?: Record<string, string>;
+    /** Headers with per-header enabled/disabled flag and OpenAPI metadata */
+    headers: KeyValueEntry[];
+    /** Query parameters with per-item enabled/disabled flag and OpenAPI metadata */
+    query: KeyValueEntry[];
+    /** Path parameters with OpenAPI metadata */
+    params?: Record<string, string | PathParamEntry>;
     body?: RequestBody;
+    /** Content-Type override for request body */
+    bodyContentType?: string;
     auth?: CollectionAuth;
     settings?: RequestSettings;
     scripts?: CollectionScripts;
+    /** Mark request as disabled (not editable via UI) */
+    disabled?: boolean;
+    /** Mark request as deprecated */
+    deprecated?: boolean;
+    /** Response schema for validation */
+    responseSchema?: ResponseSchemaDefinition;
+    /** Body schema for validation */
+    bodySchema?: BodySchemaDefinition;
 }
 /**
  * Collection-level scripts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@http-forge/core",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Headless HTTP testing engine with Postman collection support, dynamic variables, and script-based automation.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/dist/collection/interfaces.d.ts

@@ -1,32 +0,0 @@
-/**
- * Collection Domain Interfaces
- *
- * Re-exports from collection-service-interfaces.ts and collection-store.ts,
- * plus inline interfaces for ICollectionLoader and ICollectionParser.
- */
-import { UnifiedCollection } from '../types/types';
-export * from './collection-service-interfaces';
-export * from './collection-store';
-/**
- * Interface for loading collections from storage.
- *
- * Implementations:
- * - CollectionLoader: Loads single-file collections (.forge.json)
- * - FolderCollectionLoader: Loads folder-based collections
- */
-export interface ICollectionLoader {
-    loadAll(): Promise<UnifiedCollection[]> | UnifiedCollection[];
-}
-/**
- * Interface for parsing collection files into unified format.
- *
- * Implementations:
- * - HttpForgeParser: Parses .forge.json files
- * - PostmanParser: Parses .postman_collection.json (future)
- * - InsomniaParser: Parses Insomnia exports (future)
- */
-export interface ICollectionParser {
-    readonly format: string;
-    canParse(content: string): boolean;
-    parse(content: string, filePath: string): UnifiedCollection;
-}

package/dist/parsers/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Collection Parsers
- *
- * Export all parser implementations
- */
-export { HttpForgeParser } from './http-forge-parser';