@http-forge/core 0.2.0 → 0.2.2

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
@@ -575,4 +588,11 @@ export interface ExecutionResult {
     modifiedCollectionVariables?: Record<string, string>;
     modifiedSessionVariables?: Record<string, string>;
     error?: string;
+    /** Postman-compatible: pm.execution.setNextRequest() value. null = stop runner. */
+    nextRequest?: string | null;
+    /** Postman-compatible: pm.visualizer.set(template, data) output */
+    visualizerData?: {
+        template: string;
+        data?: any;
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@http-forge/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Headless HTTP testing engine with Postman collection support, dynamic variables, and script-based automation.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -48,7 +48,7 @@
     "directory": "packages/core"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.3",

package/dist/collection/folder-collection-loader.d.ts

@@ -1,256 +0,0 @@
-/**
- * Folder Collection Loader
- *
- * Loads collections from directory structure (folder format)
- * Each collection is a folder containing:
- * - collection.json (metadata)
- * - scripts/ (pre-request.js, post-response.js)
- * - {folder-slug}/ (subfolders with folder.json)
- * - {request-slug}/ (request folders with request.json)
- *
- * This is a port of the VS Code extension's FolderCollectionLoader
- */
-import type { CollectionScripts, RequestBody, UnifiedCollection, UnifiedFolder, UnifiedRequest } from '../types/types';
-import type { ICollectionLoader } from './interfaces';
-/**
- * Collection metadata structure
- */
-interface CollectionMetadata {
-    id: string;
-    name: string;
-    description?: string;
-    version?: string;
-    variables?: Record<string, string>;
-    auth?: any;
-    order?: string[];
-}
-/**
- * Scripts structure
- */
-interface Scripts {
-    preRequest?: string;
-    postResponse?: string;
-}
-/**
- * Collection item (folder or request)
- */
-type CollectionItem = UnifiedFolder | UnifiedRequest;
-/**
- * Folder Collection Loader
- *
- * Loads collections from folder structure:
- * collections/
- *   {collection-slug}/
- *     collection.json
- *     scripts/
- *       pre-request.js
- *       post-response.js
- *     {folder-slug}/
- *       folder.json
- *       scripts/
- *       {request-slug}/
- *         request.json
- *         scripts/
- *     {request-slug}/
- *       request.json
- *       scripts/
- */
-export declare class FolderCollectionLoader implements ICollectionLoader {
-    protected collectionsDir: string;
-    protected cache: Map<string, UnifiedCollection>;
-    protected slugToIdMap: Map<string, string>;
-    protected idToSlugMap: Map<string, string>;
-    constructor(collectionsDir: string);
-    /**
-     * Ensure collections directory exists
-     */
-    protected ensureDirectory(): void;
-    /**
-     * Load all collections from disk
-     */
-    loadAll(): UnifiedCollection[];
-    /**
-     * Get collection slug from ID
-     */
-    getSlugById(id: string): string | undefined;
-    /**
-     * Get collection ID from slug
-     */
-    getIdBySlug(slug: string): string | undefined;
-    /**
-     * Load a collection from a folder
-     */
-    protected loadCollectionFromFolder(slug: string): UnifiedCollection | undefined;
-    /**
-     * Load items from a directory
-     * @param dirPath - Directory path to load items from
-     * @param parentId - Parent ID for tracking
-     * @param order - Optional order array (slugs) to sort items
-     */
-    protected loadItemsFromDir(dirPath: string, parentId: string, order?: string[]): CollectionItem[];
-    /**
-     * Load a folder from directory
-     */
-    protected loadFolderFromDir(folderPath: string, slug: string): UnifiedFolder | undefined;
-    /**
-     * Load a request from directory
-     */
-    protected loadRequestFromDir(requestPath: string, slug: string): UnifiedRequest | undefined;
-    /**
-     * Convert array of { key, value, enabled } to Record<string, string>
-     * Also handles Record format (pass-through)
-     * Only includes enabled items (or all if enabled is undefined)
-     */
-    protected arrayToRecord(arr?: Array<{
-        key: string;
-        value: string;
-        enabled?: boolean;
-    }> | Record<string, string>): Record<string, string>;
-    /**
-     * Load scripts from a scripts directory
-     */
-    protected loadScriptsFromDir(scriptsPath: string): Scripts | undefined;
-    /**
-     * Load body from external file if present
-     * Supports: body.json, body.xml, body.txt, body.html, body.js, body.graphql
-     */
-    protected loadBodyFromDir(requestPath: string): RequestBody | undefined;
-    /**
-     * Load a JSON schema file if it exists.
-     * Returns the parsed object or undefined.
-     */
-    protected loadSchemaFile(filePath: string): any | undefined;
-    /**
-     * Load a single collection by ID.
-     * Checks the in-memory cache first, then falls back to slug-map → loadAll().
-     */
-    load(id: string): UnifiedCollection | undefined;
-    /**
-     * Create a new empty collection and persist it to disk.
-     */
-    create(name: string, id?: string): Promise<UnifiedCollection>;
-    /**
-     * Save (create or update) an entire collection to disk.
-     */
-    save(collection: UnifiedCollection): Promise<void>;
-    /**
-     * Delete a collection by ID (removes directory from disk).
-     */
-    delete(id: string): Promise<boolean>;
-    /**
-     * Check if a collection exists on disk.
-     */
-    exists(id: string): boolean;
-    /**
-     * Get the filesystem path for a collection.
-     */
-    getCollectionPath(id: string): string;
-    /**
-     * Update collection-level metadata (name, description, variables, etc.)
-     * without rewriting every item.
-     */
-    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
-    /**
-     * Save (create or update) a single item within a collection.
-     * @param collectionId - The owning collection
-     * @param item - Folder or request to save
-     * @param parentId - Optional parent folder (omit for root-level)
-     */
-    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
-    /**
-     * Update a single item's metadata in-place.
-     */
-    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
-    /**
-     * Delete a single item (and its directory) from a collection.
-     */
-    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
-    /**
-     * Move an item to a different parent within the same collection.
-     * @param newParentId - Target folder ID, or `undefined` for collection root
-     */
-    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
-    /**
-     * Reorder items within a parent (folder or collection root).
-     * Writes an `order` array into the parent's metadata file.
-     */
-    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
-    /**
-     * Save scripts for a specific item (collection, folder, or request).
-     */
-    saveScripts(collectionId: string, itemId: string, scripts: CollectionScripts): Promise<void>;
-    /**
-     * Load scripts for a specific item by ID.
-     */
-    loadScripts(collectionId: string, itemId: string): CollectionScripts | undefined;
-    /**
-     * Persist a list of items to a parent directory.
-     */
-    protected saveItemsToDir(parentPath: string, items: CollectionItem[]): Promise<void>;
-    /**
-     * Persist a folder's metadata, scripts, and nested items.
-     */
-    protected saveFolderToDir(folderPath: string, folder: UnifiedFolder): Promise<void>;
-    /**
-     * Persist a request's metadata, body files, schema files, and scripts.
-     */
-    protected saveRequestToDir(requestPath: string, request: UnifiedRequest): Promise<void>;
-    /**
-     * Write scripts to a scripts/ directory.
-     */
-    protected saveScriptsToDir(scriptsPath: string, scripts: CollectionScripts): Promise<void>;
-    /**
-     * Separate body content into metadata-inline vs. external-file parts.
-     */
-    protected prepareBodyForSave(body: RequestBody | undefined): {
-        bodyForMetadata: any;
-        externalBodyFile?: {
-            filename: string;
-            content: string;
-        };
-    };
-    /**
-     * Remove stale body files that don't match the current format.
-     */
-    protected cleanupOldBodyFiles(requestPath: string, currentBodyFile?: string): Promise<void>;
-    /**
-     * Save OpenAPI schema files (response.schema.json, body.schema.json).
-     */
-    protected saveSchemaFiles(requestPath: string, request: UnifiedRequest): Promise<void>;
-    /**
-     * Convert Record<string, string> to the array format used in metadata files.
-     */
-    protected recordToArray(record?: Record<string, string>): Array<{
-        key: string;
-        value: string;
-        enabled: boolean;
-    }> | undefined;
-    /**
-     * Resolve a filesystem path for an item within a collection.
-     */
-    protected findItemPath(collectionId: string, itemId: string): string | undefined;
-    /**
-     * Recursively search for a directory named `targetSlug` under `basePath`.
-     */
-    protected searchForItemPath(basePath: string, targetSlug: string): string | undefined;
-    /**
-     * Find an item by ID in the in-memory tree (recursive).
-     */
-    protected findItemById(items: CollectionItem[], id: string): CollectionItem | undefined;
-    /**
-     * Remove an item from the in-memory tree by ID (mutates the array).
-     */
-    protected deleteItemFromTree(items: CollectionItem[], id: string): boolean;
-    /**
-     * Re-sort items to match an ordered list of IDs.
-     * Items not in `orderedIds` are appended at the end.
-     */
-    protected sortItemsByOrder(items: CollectionItem[], orderedIds: string[]): CollectionItem[];
-}
-/**
- * Generate a slug from a name
- * Handles HTTP method prefixes, version indicators (T7, 1.5), path parameters,
- * and deduplication with counter suffixes.
- */
-export declare function generateSlug(name: string, existingSlugs?: string[]): string;
-export {};

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';

package/dist/{collection → infrastructure/collection}/collection-loader-factory.d.ts

@@ -3,8 +3,8 @@
  *
  * Factory Pattern: Creates appropriate loader based on configuration
  */
-import { ICollectionStore } from './collection-store';
 import { IConfigService } from '../config';
+import { ICollectionStore } from './collection-store';
 /**
  * Factory for creating collection loaders
  */

package/dist/{cookie → infrastructure/cookie}/in-memory-cookie-jar.d.ts

@@ -8,8 +8,8 @@
  * For persistent cookie handling (across requests in a session), use
  * PersistentCookieJar which wraps an ICookieService backend.
  */
-import type { Cookie } from './interfaces';
 import type { ICookieJar } from '../script/interfaces';
+import type { Cookie } from './interfaces';
 export declare class InMemoryCookieJar implements ICookieJar {
     private cookies;
     /**

package/dist/{cookie → infrastructure/cookie}/persistent-cookie-jar.d.ts

@@ -9,8 +9,8 @@
  *
  * Extracted from extension's request-execution/PersistentCookieJar.ts.
  */
-import { Cookie, IAsyncCookieService, ICookieService } from './interfaces';
 import { ICookieJar } from '../script/interfaces';
+import { Cookie, IAsyncCookieService, ICookieService } from './interfaces';
 export declare class PersistentCookieJar implements ICookieJar {
     private cookieService;
     /** Local cache that reflects script modifications */

package/dist/{script → infrastructure/script}/script-executor.d.ts

@@ -8,8 +8,8 @@
  * This is the main entry point for script execution.
  * It configures the VM sandbox and delegates session management to RequestScriptSession.
  */
-import { IRequestScriptSession, IScriptExecutor, PreRequestScriptContext } from './interfaces';
 import { IHttpRequestService } from '../http/interfaces';
+import { IRequestScriptSession, IScriptExecutor, PreRequestScriptContext } from './interfaces';
 /**
  * Script Executor Implementation
  *