@http-forge/core 0.2.0 → 0.2.1

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

@@ -0,0 +1,53 @@
+/**
+ * Platform Adapters
+ *
+ * Interface for platform-specific implementations that must be
+ * provided by the host environment (VS Code, CLI, etc.).
+ *
+ * The core bootstrap uses these adapters to wire up services
+ * without depending on any specific platform.
+ */
+import type { IConsoleService } from '../types/console-service';
+import type { IApplicationInfo, IExternalBrowserService, IFileWatcherFactory, IKeyValueStore, INotificationService, ISecretStore } from '../types/platform';
+/**
+ * Platform adapters required by core service bootstrap.
+ *
+ * The host environment (VS Code extension, CLI tool, etc.) creates
+ * concrete implementations and passes them to `registerCoreServices()`.
+ *
+ * @example VS Code extension:
+ * ```typescript
+ * const adapters: PlatformAdapters = {
+ *   workspaceFolder: '/path/to/workspace',
+ *   fileWatcherFactory: new VscodeFileWatcherFactory(),
+ *   notificationService: new VscodeNotificationService(),
+ *   workspaceStore: new VscodeKeyValueStore(context.workspaceState),
+ *   globalStore: new VscodeKeyValueStore(context.globalState),
+ *   secretStore: vscodeSecretStoreAdapter,
+ *   browserService: vscodeBrowserAdapter,
+ *   applicationInfo: { name: 'HttpForge', version: '1.0.0' },
+ *   consoleService: new ConsoleService('HTTP Forge'),
+ * };
+ * registerCoreServices(container, adapters);
+ * ```
+ */
+export interface PlatformAdapters {
+    /** Workspace root folder path */
+    workspaceFolder: string;
+    /** File watcher factory — watches for file changes (ConfigService, CollectionService) */
+    fileWatcherFactory: IFileWatcherFactory;
+    /** Notification service — shows info/warning/error messages (ConfigService) */
+    notificationService: INotificationService;
+    /** Per-workspace key-value store (EnvironmentConfigService) */
+    workspaceStore: IKeyValueStore;
+    /** Global key-value store (CookieService) */
+    globalStore: IKeyValueStore;
+    /** Secret storage for tokens (OAuth2TokenManager). Optional — OAuth2 disabled if absent. */
+    secretStore?: ISecretStore;
+    /** External browser service for OAuth2 flows. Optional — OAuth2 disabled if absent. */
+    browserService?: IExternalBrowserService;
+    /** Application name/version for User-Agent header (RequestPreparer) */
+    applicationInfo?: IApplicationInfo;
+    /** Structured logging service. Optional — a no-op console is used if absent. */
+    consoleService?: IConsoleService;
+}

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

@@ -0,0 +1,97 @@
+/**
+ * Service Container
+ *
+ * Generic dependency injection container.
+ * Platform-agnostic — no VS Code dependencies.
+ *
+ * Principles:
+ * - Dependency Inversion: Services accessed through interfaces
+ * - 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 { 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';
+/**
+ * Factory function type for creating services
+ */
+type ServiceFactory<T> = (container: ServiceContainer) => T;
+/**
+ * Service Container implementation
+ * Provides dependency injection capabilities
+ */
+export declare class ServiceContainer {
+    private static _instance;
+    private services;
+    private primitives;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static get instance(): ServiceContainer;
+    /**
+     * Reset the container (useful for testing)
+     */
+    static reset(): void;
+    /**
+     * Register a primitive value (like workspace folder path)
+     */
+    registerValue<T>(identifier: ServiceIdentifier, value: T): this;
+    /**
+     * Register a service factory as a singleton
+     * The service will be created on first resolution and reused
+     */
+    registerSingleton<T>(identifier: ServiceIdentifier, factory: ServiceFactory<T>): this;
+    /**
+     * Register a service factory as transient
+     * A new instance will be created on each resolution
+     */
+    registerTransient<T>(identifier: ServiceIdentifier, factory: ServiceFactory<T>): this;
+    /**
+     * Register an already instantiated service
+     */
+    registerInstance<T>(identifier: ServiceIdentifier, instance: T): this;
+    /**
+     * Resolve a service by its identifier
+     */
+    resolve<T>(identifier: ServiceIdentifier): T;
+    /**
+     * Check if a service is registered
+     */
+    has(identifier: ServiceIdentifier): boolean;
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+    get config(): IConfigService;
+    get console(): IConsoleService;
+    get environmentConfig(): IEnvironmentConfigService;
+    get collection(): ICollectionService;
+    get httpRequest(): IHttpRequestService;
+    get httpClient(): IHttpClient;
+    get cookie(): IAsyncCookieService;
+    get requestHistory(): IRequestHistoryService;
+    get dataFileParser(): IDataFileParser;
+    get scriptExecutor(): IScriptExecutor;
+    get requestPreparer(): IRequestPreparer;
+    get persistentCookieJar(): ICookieJar;
+    get oauth2TokenManager(): IOAuth2TokenManager;
+    get graphqlSchemaService(): IGraphQLSchemaService;
+}
+/**
+ * Convenience function to get the service container instance
+ */
+export declare function getServiceContainer(): ServiceContainer;
+export {};

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

@@ -0,0 +1,34 @@
+/**
+ * Service Identifiers
+ *
+ * Symbol-based identifiers for type-safe service resolution.
+ * Used by ServiceContainer for dependency injection.
+ */
+export declare const ServiceIdentifiers: {
+    readonly Config: symbol;
+    readonly Console: symbol;
+    readonly EnvironmentConfig: symbol;
+    readonly Collection: symbol;
+    readonly HttpRequest: symbol;
+    readonly HttpClient: symbol;
+    readonly Cookie: symbol;
+    readonly RequestHistory: symbol;
+    readonly UrlBuilder: symbol;
+    readonly RequestPreprocessor: symbol;
+    readonly RequestPreparer: symbol;
+    readonly InterceptorChain: symbol;
+    readonly ScriptExecutor: symbol;
+    readonly DataFileParser: symbol;
+    readonly CollectionRequestExecutor: symbol;
+    readonly WorkspaceFolder: symbol;
+    readonly PersistentCookieJar: symbol;
+    readonly OAuth2TokenManager: symbol;
+    readonly GraphQLSchemaService: symbol;
+    readonly SchemaInferrer: symbol;
+    readonly HistoryAnalyzer: symbol;
+    readonly ScriptAnalyzer: symbol;
+    readonly SchemaInferenceService: symbol;
+    readonly OpenApiExporter: symbol;
+    readonly OpenApiImporter: symbol;
+};
+export type ServiceIdentifier = typeof ServiceIdentifiers[keyof typeof ServiceIdentifiers];

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

@@ -4,9 +4,9 @@
  * Platform-agnostic — uses IKeyValueStore for persistence instead of
  * VS Code's workspaceState/globalState.
  */
-import { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from './interfaces';
-import { IKeyValueStore } from '../types/platform';
 import { IConfigService } from '../config';
+import { IKeyValueStore } from '../types/platform';
+import { IEnvironmentConfigService, ImportedEnvironment, LocalConfig, ResolvedEnvironment, SharedConfig } from './interfaces';
 export declare class EnvironmentConfigService implements IEnvironmentConfigService {
     private workspaceFolder;
     private workspaceStore;
@@ -69,9 +69,12 @@ export declare class EnvironmentConfigService implements IEnvironmentConfigServi
     importPostmanEnvironmentFile(filePath: string): ImportedEnvironment;
     saveEnvLocalConfig(envName: string, variables: Record<string, string>): void;
     getEnvLocalPath(envName: string): string;
-    private isSystemEnvironmentFile;
     private getEnvLocalConfigPath;
     private loadFolderConfigs;
+    /**
+     * Create a VariableResolver pre-loaded with environment + session variables.
+     */
+    private createResolver;
     private saveFolderSharedConfig;
     reload(): void;
     getAllEnvironments(): Array<{

package/dist/environment/environment-file-loader.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Environment File Loader
+ *
+ * Shared logic for reading the multi-file environment folder format:
+ *   _global.json           — global variables + default headers
+ *   {env}.json             — per-environment variables
+ *   _global.local.json     — local variable overrides (gitignored)
+ *   {env}.local.json       — per-environment local overrides (gitignored)
+ *
+ * Used by both EnvironmentConfigService (extension) and
+ * ForgeContainer.fromForgeRoot (standalone).
+ */
+export interface EnvironmentFolderData {
+    /** Variables available in all environments */
+    globalVariables: Record<string, string>;
+    /** Default headers sent with every request */
+    defaultHeaders: Record<string, string>;
+    /** Per-environment configs keyed by environment name */
+    environments: Record<string, EnvironmentEntry>;
+    /** Local global variable overrides from _global.local.json */
+    localVariables: Record<string, string>;
+    /** Per-environment local variable overrides from {env}.local.json */
+    localCredentials: Record<string, {
+        variables: Record<string, string>;
+    }>;
+}
+export interface EnvironmentEntry {
+    description?: string;
+    requiresConfirmation?: boolean;
+    variables: Record<string, string>;
+}
+/**
+ * Determine whether a filename is a system/meta file (not an environment file).
+ */
+export declare function isSystemEnvironmentFile(fileName: string): boolean;
+/**
+ * Load environment configuration from a multi-file folder.
+ *
+ * @param envDir - Absolute path to the environments folder
+ * @returns Parsed environment data (or empty defaults when the folder is missing)
+ */
+export declare function loadEnvironmentsFromFolder(envDir: string): EnvironmentFolderData;

package/dist/environment/forge-env.d.ts

@@ -30,8 +30,8 @@
  * env.get('token');  // 'abc'
  * ```
  */
-import { IEnvironmentStore, IVariableInterpolator } from './interfaces';
 import { EnvironmentResolver } from './environment-resolver';
+import { IEnvironmentStore, IVariableInterpolator } from './interfaces';
 /**
  * ForgeEnv interface - the public API for environment management
  */

package/dist/execution/collection-request-executor.d.ts

@@ -10,11 +10,11 @@
  * Extracted from extension's request-execution/collection-request-executor.ts.
  * Platform-independent — no vscode dependency.
  */
-import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../types/types';
-import { ICookieJar, IScriptExecutor } from '../script/interfaces';
 import { IEnvironmentConfigService } from '../environment/interfaces';
-import { ConsoleOutputCallback, ICollectionRequestExecutor } from './collection-request-executor-interfaces';
 import { IHttpRequestService } from '../http/interfaces';
+import { ICookieJar, IScriptExecutor } from '../script/interfaces';
+import { ExecutionRequest, ExecutionResult, PreparedRequest, RequestScripts } from '../types/types';
+import { ConsoleOutputCallback, ICollectionRequestExecutor } from './collection-request-executor-interfaces';
 import { IRequestPreparer } from './request-preparer-interfaces';
 /**
  * Enhanced implementation with Postman parity.

package/dist/execution/request-executor.d.ts

@@ -4,11 +4,11 @@
  * Single Responsibility: Orchestrate the complete request execution flow
  * Facade Pattern: Provides simplified interface to complex subsystem
  */
-import { IHttpClient } from '../types/platform';
-import { IScriptExecutor } from '../script/interfaces';
+import { IForgeEnv } from '../environment/forge-env';
 import { IRequestPreprocessor } from '../http/request-preprocessor';
+import { IScriptExecutor } from '../script/interfaces';
+import { IHttpClient } from '../types/platform';
 import { HttpRequest, HttpResponse, RequestOverrides, ScriptResult, UnifiedCollection, UnifiedRequest } from '../types/types';
-import { IForgeEnv } from '../environment/forge-env';
 /**
  * Options for request execution
  */

package/dist/execution/request-preparer.d.ts

@@ -9,12 +9,12 @@
  *
  * Used by both Request Tester (manual) and Collection Runner (batch).
  */
-import { IRequestPreprocessor } from '../http/request-preprocessor';
-import { ExecutionRequest, PreparedRequest } from '../types/types';
+import { IOAuth2TokenManager } from '../auth/interfaces';
 import { IEnvironmentConfigService, ResolvedEnvironment } from '../environment/interfaces';
 import { IHttpRequestService } from '../http/interfaces';
-import { IOAuth2TokenManager } from '../auth/interfaces';
+import { IRequestPreprocessor } from '../http/request-preprocessor';
 import { IApplicationInfo } from '../types/platform';
+import { ExecutionRequest, PreparedRequest } from '../types/types';
 import { IRequestPreparer } from './request-preparer-interfaces';
 /**
  * RequestPreparer implementation

package/dist/history/request-history.d.ts

@@ -7,8 +7,8 @@
  * Based on VS Code plugin's RequestHistoryService logic,
  * but adapted for storage-agnostic design.
  */
-import { FullResponse, HistoryEntry, IRequestHistory } from './history-interfaces';
 import { HttpRequest, HttpResponse } from '../types/types';
+import { FullResponse, HistoryEntry, IRequestHistory } from './history-interfaces';
 /**
  * In-memory request history storage
  *

package/dist/http/http-request-service.d.ts

@@ -15,9 +15,9 @@
  * - Open/Closed: Extended through interceptor chain
  * - Dependency Inversion: Depends on IHttpClient, IUrlBuilder, IInterceptorChain, IRequestPreprocessor
  */
-import { IInterceptorChain } from './interceptor-chain';
-import { HttpRequestOptions, HttpResponse } from '../types/types';
 import type { IHttpClient } from '../types/platform';
+import { HttpRequestOptions, HttpResponse } from '../types/types';
+import { IInterceptorChain } from './interceptor-chain';
 import { IHttpRequestService } from './interfaces';
 import { IUrlBuilder } from './url-builder';
 export declare class HttpRequestService implements IHttpRequestService {

package/dist/import-export/import-postman-environment.d.ts

@@ -6,8 +6,8 @@
  *
  * Pure function — no platform dependencies.
  */
-import { IFileSystem } from '../types/platform';
 import { ImportedEnvironment } from '../environment/interfaces';
+import { IFileSystem } from '../types/platform';
 export type { ImportedEnvironment } from '../environment/interfaces';
 /**
  * Parse Postman environment JSON content.

package/dist/index.d.ts

@@ -18,72 +18,78 @@
  */
 export { ForgeContainer } from './container';
 export type { ForgeContainerOptions, StorageFormat } from './container';
-export * from './types/types';
-export * from './types/platform';
+export { ServiceContainer, ServiceIdentifiers, getServiceContainer, registerCoreServices } from './di';
+export type { PlatformAdapters, ServiceIdentifier } from './di';
 export * from './types/console-service';
-export * from './cookie/interfaces';
+export * from './types/platform';
+export * from './types/types';
 export { CookieJar } from './cookie/cookie-jar';
+export { CookieService } from './cookie/cookie-service';
 export { CookieUtils } from './cookie/cookie-utils';
 export { InMemoryCookieJar } from './cookie/in-memory-cookie-jar';
+export * from './cookie/interfaces';
 export { PersistentCookieJar } from './cookie/persistent-cookie-jar';
-export { CookieService } from './cookie/cookie-service';
-export type { IHttpRequestService } from './http/interfaces';
 export { FetchHttpClient } from './http/fetch-http-client';
-export { DEFAULT_REQUEST_SETTINGS, NodeHttpClient } from './http/native-http-client';
+export { HttpRequestService } from './http/http-request-service';
 export { InterceptorChain, LoggingRequestInterceptor, RetryErrorInterceptor, TimingResponseInterceptor } from './http/interceptor-chain';
-export type { IErrorInterceptor, IInterceptorChain, InterceptorContext, IRequestInterceptor, IResponseInterceptor } from './http/interceptor-chain';
+export type { IErrorInterceptor, IInterceptorChain, IRequestInterceptor, IResponseInterceptor, InterceptorContext } from './http/interceptor-chain';
+export type { IHttpRequestService } from './http/interfaces';
 export { mergeRequestSettings } from './http/merge-request-settings';
+export { DEFAULT_REQUEST_SETTINGS, NodeHttpClient } from './http/native-http-client';
 export { RequestPreprocessor } from './http/request-preprocessor';
 export type { IRequestPreprocessor } from './http/request-preprocessor';
-export { HttpRequestService } from './http/http-request-service';
 export { UrlBuilder } from './http/url-builder';
 export type { IUrlBuilder } from './http/url-builder';
 export * from './script/interfaces';
-export { ScriptExecutor } from './script/script-executor';
+export { ModuleLoader, createLodashShim, createModuleLoader, createMomentShim } from './script/module-loader';
+export type { ModuleLoaderOptions } from './script/module-loader';
 export { RequestScriptSession } from './script/request-script-session';
 export type { SessionDependencies } from './script/request-script-session';
+export { ScriptExecutor } from './script/script-executor';
 export { createExpectChain, createResponseObject } from './script/script-factories';
 export type { ExpectChain, ResponseAssertions, ScriptResponse } from './script/script-factories';
 export { concatenateScripts, createScriptConsole, createTestFunction, formatConsoleOutput, hasChanged, normalizeHeaders } from './script/script-utils';
 export type { ConsoleMessage } from './script/script-utils';
-export { ModuleLoader, createLodashShim, createModuleLoader, createMomentShim } from './script/module-loader';
-export type { ModuleLoaderOptions } from './script/module-loader';
-export * from './collection/interfaces';
 export { CollectionLoader } from './collection/collection-loader';
 export type { LoadOptions } from './collection/collection-loader';
 export { CollectionLoaderFactory } from './collection/collection-loader-factory';
 export { CollectionService } from './collection/collection-service';
-export { FolderCollectionLoader, generateSlug } from './collection/folder-collection-loader';
+export { FolderCollectionLoader } from './collection/folder-collection-loader';
 export { FolderCollectionStore } from './collection/folder-collection-store';
+export * from './collection/folder-io';
+export { generateSlug } from './collection/folder-io';
+export * from './collection/interfaces';
 export { JsonCollectionLoader } from './collection/json-collection-loader';
 export { ParserRegistry } from './collection/parser-registry';
-export * from './environment/interfaces';
 export { EnvironmentConfigService } from './environment/environment-config-service';
+export { isSystemEnvironmentFile, loadEnvironmentsFromFolder } from './environment/environment-file-loader';
+export type { EnvironmentEntry, EnvironmentFolderData } from './environment/environment-file-loader';
 export { EnvironmentResolver } from './environment/environment-resolver';
 export type { Environment, EnvironmentStoreConfig } from './environment/environment-resolver';
 export { ForgeEnv } from './environment/forge-env';
 export type { IForgeEnv } from './environment/forge-env';
+export * from './environment/interfaces';
 export { VariableInterpolator, VariableResolver, createVariableResolver } from './environment/variable-interpolator';
 export type { VariableResolverConfig } from './environment/variable-interpolator';
-export * from './execution/collection-request-executor-interfaces';
-export * from './execution/request-preparer-interfaces';
 export { CollectionRequestExecutor } from './execution/collection-request-executor';
+export * from './execution/collection-request-executor-interfaces';
 export { RequestExecutor } from './execution/request-executor';
 export type { ExecuteOptions, ExecuteResult } from './execution/request-executor';
 export { RequestPreparer } from './execution/request-preparer';
+export * from './execution/request-preparer-interfaces';
 export * from './history/history-interfaces';
-export type { IRequestHistoryService, IResponseStorage } from './history/request-history-service-interfaces';
 export { RequestHistoryStore } from './history/request-history';
 export { RequestHistoryService } from './history/request-history-service';
+export type { IRequestHistoryService, IResponseStorage } from './history/request-history-service-interfaces';
 export * from './auth/interfaces';
 export { OAuth2TokenManager } from './auth/oauth2-token-manager';
 export { getCompletions, parseQueryContext } from './graphql/graphql-completion-provider';
 export type { CompletionItem, ContextType, QueryContext } from './graphql/graphql-completion-provider';
 export { GraphQLSchemaService } from './graphql/graphql-schema-service';
 export type { GraphQLDirective, GraphQLField, GraphQLOperation, GraphQLSchema, GraphQLType, IGraphQLSchemaService } from './graphql/graphql-schema-service';
-export * from './openapi/interfaces';
 export { ExampleGenerator, HistoryAnalyzer, OpenApiExporter, OpenApiImporter, RefResolver, SchemaInferenceService, SchemaInferrer, ScriptAnalyzer } from './openapi';
 export type { OpenApiExportOptions, OpenApiImportOptions, ScriptAnalysisResult } from './openapi';
+export * from './openapi/interfaces';
 export { CONFIG_FILES, ConfigService, DEFAULT_CONFIG, ROOT_DIRECTORIES } from './config';
 export type { EnvironmentsConfig, HttpForgeConfig, IConfigService, ProxyConfig, RequestConfig, RestClientExportConfig, RunnerConfig, ScriptsConfig, StorageConfig } from './config';
 export { DEFAULT_SUITE_CONFIG } from './test-suite/interfaces';
@@ -100,9 +106,9 @@ export { HttpForgeParser } from './parsers';
 export { parsePostmanEnvironment, parsePostmanEnvironmentFile } from './import-export/import-postman-environment';
 export type { ImportedEnvironment } from './import-export/import-postman-environment';
 export { exportCollectionToRestClient, getRestClientExportFolder, writeEnvFile, writeFolderItems, writeScriptFile } from './import-export/rest-client-export';
-export { NodeFileSystem } from './platform/node-file-system';
 export { DataFileParser } from './platform/data-file-parser';
 export type { IDataFileParser } from './platform/data-file-parser';
+export { NodeFileSystem } from './platform/node-file-system';
 export { DYNAMIC_VARIABLES, augmentWithDynamicVars, resolveDynamicVariable, resolveDynamicVariablesInString } from './utils/dynamic-variables';
 export { evaluateExpression, isExpression } from './utils/expression-evaluator';
 export { applyFilterChain, parseFilterChain } from './utils/filter-engine';