@http-forge/core 0.1.0 → 0.2.1

package/dist/collection/collection-service.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Collection Service
+ *
+ * Service for managing HTTP Forge collections.
+ * Platform-agnostic — uses IFileWatcherFactory instead of VS Code APIs.
+ *
+ * Refactored to use:
+ * - ConfigService for configuration
+ * - CollectionLoader for storage abstraction (supports folder and json formats)
+ */
+import { IConfigService } from '../config';
+import { IFileWatcherFactory } from '../types/platform';
+import { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from './collection-service-interfaces';
+/**
+ * Service for managing HTTP Forge collections
+ */
+export declare class CollectionService implements ICollectionService {
+    private workspaceRoot;
+    private configService;
+    private fileWatcherFactory?;
+    private collectionsDir;
+    private collections;
+    private fileWatcher?;
+    private loader;
+    /**
+     * In-memory Local Values for collection variables (not persisted)
+     */
+    private localCollectionValues;
+    constructor(workspaceRoot: string, configService: IConfigService, fileWatcherFactory?: IFileWatcherFactory | undefined);
+    private ensureCollectionsDir;
+    private loadCollections;
+    private setupFileWatcher;
+    getAllCollections(): Collection[];
+    getCollection(id: string): Collection | undefined;
+    getCollectionById(id: string): Collection | undefined;
+    getCollectionByName(name: string): Collection | undefined;
+    saveCollection(collection: Collection): Promise<void>;
+    getCollectionVariables(collectionId: string): Record<string, string>;
+    getCollectionVariableLocals(collectionId: string): Record<string, string>;
+    setCollectionVariable(collectionId: string, key: string, value: unknown): void;
+    deleteCollectionVariable(collectionId: string, key: string): void;
+    clearCollectionVariables(collectionId: string): void;
+    deleteCollection(id: string): Promise<boolean>;
+    findRequest(collectionId: string, requestId: string): CollectionRequestItem | undefined;
+    findRequestByPath(collectionId: string, requestPath: string): CollectionItem | undefined;
+    updateRequest(collectionId: string, requestId: string, updates: Partial<CollectionRequestItem>): Promise<boolean>;
+    addRequest(collectionId: string, request: CollectionRequestItem, parentFolderId?: string): Promise<boolean>;
+    deleteRequest(collectionId: string, requestId: string): Promise<boolean>;
+    getAllRequests(collectionId: string): CollectionItem[];
+    private findItemRecursive;
+    private findItemByPath;
+    private updateItemRecursive;
+    private deleteItemRecursive;
+    private collectRequestsRecursive;
+    createCollection(name: string): Promise<Collection>;
+    renameCollection(id: string, newName: string): Promise<boolean>;
+    createFolder(options: {
+        name: string;
+        collectionId: string;
+        parentId?: string;
+    }): Promise<CollectionItem>;
+    deleteFolder(collectionId: string, folderId: string): Promise<boolean>;
+    renameFolder(collectionId: string, folderId: string, newName: string): Promise<boolean>;
+    createRequest(options: CreateRequestOptions): Promise<CollectionRequestItem>;
+    renameRequest(collectionId: string, requestId: string, newName: string): Promise<boolean>;
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    private findItemById;
+    private deleteItemById;
+    importCollection(filePath: string): Promise<Collection>;
+    private importPostmanCollection;
+    exportCollection(collectionId: string, filePath: string): Promise<void>;
+    exportCollectionAsRestClientFolder(collectionId: string, outDir: string): Promise<void>;
+    dispose(): void;
+}

package/dist/collection/collection-store.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Collection Store Interface
+ *
+ * Rich CRUD interface for collection storage operations.
+ * Strategy Pattern: Different stores for different storage formats
+ * - JsonCollectionLoader: Loads from single JSON files
+ * - FolderCollectionStore: Loads from directory structure
+ */
+import type { CollectionRequest } from '../types/types';
+import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+/**
+ * Rich interface for loading, saving, and managing collections
+ */
+export interface ICollectionStore {
+    /**
+     * Load all collections from storage
+     */
+    loadAll(): Collection[];
+    /**
+     * Load a single collection by ID
+     */
+    load(id: string): Collection | undefined;
+    /**
+     * Save an entire collection (use for bulk operations or JSON format)
+     */
+    save(collection: Collection): Promise<void>;
+    /**
+     * Delete a collection
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Check if a collection exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Get the path for a collection
+     */
+    getCollectionPath(id: string): string;
+    /**
+     * Create a new collection with default structure
+     */
+    create(name: string, id?: string): Promise<Collection>;
+    /**
+     * Update collection metadata only (name, description, variables, auth)
+     */
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    /**
+     * Save/update a single item (request or folder)
+     * For folder format: only writes the specific item's files
+     * For JSON format: falls back to save()
+     */
+    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
+    /**
+     * Delete a single item by ID
+     */
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    /**
+     * Update a single item's metadata (not scripts)
+     * For folder format: only updates request.json or folder.json
+     */
+    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
+    /**
+     * Move an item to a new parent
+     */
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    /**
+     * Reorder items within a parent (collection or folder)
+     * @param collectionId - The collection ID
+     * @param parentId - The parent folder ID (undefined for collection root)
+     * @param orderedItemIds - Array of item IDs in the desired order
+     */
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    /**
+     * Save scripts for a specific item
+     */
+    saveScripts(collectionId: string, itemId: string, scripts: RequestScripts): Promise<void>;
+    /**
+     * Load scripts for a specific item
+     */
+    loadScripts(collectionId: string, itemId: string): RequestScripts | undefined;
+}
+/**
+ * Metadata stored in collection.json for folder format
+ */
+export interface CollectionMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    variables?: Record<string, string>;
+    auth?: Collection['auth'];
+    /** Order of child items (folder slugs). If not specified, filesystem order is used. */
+    order?: string[];
+}
+/**
+ * Metadata stored in folder.json
+ */
+export interface FolderMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    auth?: Collection['auth'];
+    /** Order of child items (folder slugs). If not specified, filesystem order is used. */
+    order?: string[];
+}
+/**
+ * Metadata stored in request.json (scripts stored separately in scripts/ directory)
+ */
+export type RequestMetadata = Omit<CollectionRequest, 'scripts' | 'disabled' | 'bodyContentType'>;

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

@@ -0,0 +1,45 @@
+/**
+ * Folder Collection Loader
+ *
+ * Thin adapter around FolderCollectionStore that converts between the
+ * `Collection` / `CollectionItem` types (array-based headers/query with
+ * `enabled` flag) and the simpler `UnifiedCollection` / `UnifiedRequest`
+ * types (Record-based headers/query) used by ForgeContainer.
+ *
+ * All disk I/O is delegated to FolderCollectionStore — this class only
+ * performs type conversion on the way in and out.
+ */
+import type { CollectionScripts, UnifiedCollection, UnifiedFolder, UnifiedRequest } from '../types/types';
+import type { CollectionMetadata } from './collection-store';
+import type { ICollectionLoader } from './interfaces';
+export { generateSlug } from './folder-io';
+type UnifiedItem = UnifiedFolder | UnifiedRequest;
+/**
+ * Folder Collection Loader
+ *
+ * Implements `ICollectionLoader` and exposes CRUD using `UnifiedCollection` /
+ * `UnifiedRequest` types. All disk I/O is handled by the underlying
+ * `FolderCollectionStore`; this class converts types on the boundary.
+ */
+export declare class FolderCollectionLoader implements ICollectionLoader {
+    /** The underlying canonical store that handles all disk I/O */
+    private readonly store;
+    constructor(collectionsDir: string);
+    loadAll(): UnifiedCollection[];
+    getSlugById(id: string): string | undefined;
+    getIdBySlug(slug: string): string | undefined;
+    load(id: string): UnifiedCollection | undefined;
+    create(name: string, id?: string): Promise<UnifiedCollection>;
+    save(collection: UnifiedCollection): Promise<void>;
+    delete(id: string): Promise<boolean>;
+    exists(id: string): boolean;
+    getCollectionPath(id: string): string;
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    saveItem(collectionId: string, item: UnifiedItem, parentId?: string): Promise<void>;
+    updateItem(collectionId: string, itemId: string, updates: Partial<UnifiedItem>): Promise<boolean>;
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    saveScripts(collectionId: string, itemId: string, scripts: CollectionScripts): Promise<void>;
+    loadScripts(collectionId: string, itemId: string): CollectionScripts | undefined;
+}

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

@@ -0,0 +1,175 @@
+/**
+ * Folder Collection Store
+ *
+ * Loads and manages collections from directory structure using Collection types.
+ * Implements the rich ICollectionStore interface with full CRUD operations.
+ *
+ * Each collection is a folder containing:
+ * - collection.json (metadata)
+ * - scripts/ (pre-request.js, post-response.js)
+ * - {folder-slug}/ (subfolders)
+ * - {request-slug}/ (request folders)
+ *
+ * Ported from the VS Code extension's FolderCollectionLoader.
+ */
+import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { CollectionMetadata, ICollectionStore } from './collection-store';
+/**
+ * Loads and manages collections from folder structure using Collection types.
+ *
+ * Structure:
+ * collections/
+ *   {collection-slug}/
+ *     collection.json
+ *     scripts/
+ *       pre-request.js
+ *       post-response.js
+ *     {folder-slug}/
+ *       folder.json
+ *       scripts/
+ *       {request-slug}/
+ *         request.json
+ *         scripts/
+ */
+export declare class FolderCollectionStore implements ICollectionStore {
+    private collectionsDir;
+    private cache;
+    private slugToIdMap;
+    private idToSlugMap;
+    constructor(collectionsDir: string);
+    /**
+     * Get collection/item slug from ID
+     */
+    getSlugById(id: string): string | undefined;
+    /**
+     * Get collection/item ID from slug
+     */
+    getIdBySlug(slug: string): string | undefined;
+    /**
+     * Ensure collections directory exists
+     */
+    private ensureDirectory;
+    /**
+     * Load all collections from disk
+     */
+    loadAll(): Collection[];
+    /**
+     * Load a collection from a folder
+     */
+    private loadCollectionFromFolder;
+    /**
+     * Load items from a directory
+     */
+    private loadItemsFromDir;
+    /**
+     * Load a folder from directory
+     */
+    private loadFolderFromDir;
+    /**
+     * Load a request from directory
+     */
+    private loadRequestFromDir;
+    /**
+     * Load scripts from a scripts directory
+     */
+    private loadScriptsFromDir;
+    /**
+     * Load body from external file if present
+     */
+    private loadBodyFromDir;
+    /**
+     * Load a JSON schema file if it exists.
+     */
+    private loadSchemaFile;
+    /**
+     * Save OpenAPI schema files if present.
+     */
+    private saveSchemaFiles;
+    /**
+     * Load a single collection by ID
+     */
+    load(id: string): Collection | undefined;
+    /**
+     * Save a collection
+     */
+    save(collection: Collection): Promise<void>;
+    /**
+     * Save items to a directory
+     */
+    private saveItemsToDir;
+    /**
+     * Save a folder to directory
+     */
+    private saveFolderToDir;
+    /**
+     * Save a request to directory
+     */
+    private saveRequestToDir;
+    /**
+     * Prepare body for saving - determine what goes in metadata vs external file
+     */
+    private prepareBodyForSave;
+    /**
+     * Clean up old body files that don't match current format
+     */
+    private cleanupOldBodyFiles;
+    /**
+     * Save scripts to a directory
+     */
+    private saveScriptsToDir;
+    /**
+     * Delete a collection
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Check if a collection exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Get the path for a collection
+     */
+    getCollectionPath(id: string): string;
+    /**
+     * Create a new collection
+     */
+    create(name: string, id?: string): Promise<Collection>;
+    /**
+     * Save scripts for a specific item
+     */
+    saveScripts(collectionId: string, itemId: string, scripts: RequestScripts): Promise<void>;
+    /**
+     * Load scripts for a specific item
+     */
+    loadScripts(collectionId: string, itemId: string): RequestScripts | undefined;
+    /**
+     * Update collection metadata only
+     */
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    /**
+     * Save/update a single item
+     */
+    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
+    /**
+     * Delete a single item
+     */
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    /**
+     * Update a single item's metadata
+     */
+    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
+    /**
+     * Move an item to a new parent
+     */
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    /**
+     * Reorder items within a parent
+     */
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    /**
+     * Sort items array by ID order
+     */
+    private sortItemsByOrder;
+    private findItemPath;
+    private findItemById;
+    private deleteItemFromTree;
+}

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

@@ -0,0 +1,113 @@
+/**
+ * Folder Format I/O Primitives
+ *
+ * Shared file I/O operations for the folder-based collection storage format.
+ * Used by both FolderCollectionLoader (read-only, UnifiedCollection types)
+ * and FolderCollectionStore (full CRUD, Collection types).
+ *
+ * Eliminates ~200 lines of duplicated code between the two implementations.
+ */
+import type { RequestBody } from '../types/types';
+/** Script file names within a scripts/ directory */
+export declare const SCRIPT_FILES: {
+    preRequest: string;
+    postResponse: string;
+};
+/** Metadata file names that identify item types */
+export declare const METADATA_FILES: {
+    collection: string;
+    folder: string;
+    request: string;
+};
+/**
+ * Body file extensions mapped to body type/format.
+ * Files stored externally get syntax highlighting benefits.
+ * Other types (form-data, urlencoded, binary, none) stay in request.json.
+ */
+export declare const BODY_FILE_MAP: Record<string, {
+    type: 'raw' | 'graphql';
+    format?: 'json' | 'text' | 'xml' | 'html' | 'javascript';
+}>;
+/** Schema files stored alongside request.json for OpenAPI round-trip support */
+export declare const SCHEMA_FILES: {
+    responseSchema: string;
+    bodySchema: string;
+};
+/** Scripts directory name */
+export declare const SCRIPTS_DIR = "scripts";
+/**
+ * Scripts structure (shared shape between CollectionScripts and RequestScripts)
+ */
+export interface ScriptsData {
+    preRequest?: string;
+    postResponse?: string;
+}
+/**
+ * Read scripts from a scripts/ directory.
+ * Returns undefined if the directory doesn't exist or has no scripts.
+ */
+export declare function readScriptsFromDir(scriptsPath: string): ScriptsData | undefined;
+/**
+ * Write scripts to a scripts/ directory.
+ */
+export declare function writeScriptsToDir(scriptsPath: string, scripts: ScriptsData): Promise<void>;
+/**
+ * Load body from external file if present.
+ * Supports: body.json, body.xml, body.txt, body.html, body.js, body.graphql
+ */
+export declare function readBodyFromDir(requestPath: string): RequestBody | undefined;
+/**
+ * Separate body content into metadata-inline vs. external-file parts.
+ */
+export declare function prepareBodyForSave(body: any): {
+    bodyForMetadata: any;
+    externalBodyFile?: {
+        filename: string;
+        content: string;
+    };
+};
+/**
+ * Remove stale body files that don't match the current format.
+ */
+export declare function cleanupOldBodyFiles(requestPath: string, currentBodyFile?: string): Promise<void>;
+/**
+ * Load a JSON schema file if it exists.
+ * Returns the parsed object or undefined.
+ */
+export declare function readSchemaFile(filePath: string): any | undefined;
+/**
+ * Save OpenAPI schema files (response.schema.json, body.schema.json).
+ */
+export declare function writeSchemaFiles(requestPath: string, responseSchema?: any, bodySchema?: any): Promise<void>;
+/** Minimal interface for tree traversal — both UnifiedFolder/UnifiedRequest and CollectionItem satisfy this */
+interface TreeNode {
+    id: string;
+    type: string;
+    items?: TreeNode[];
+}
+/**
+ * Find an item by ID in a tree (recursive).
+ */
+export declare function findItemById<T extends TreeNode>(items: T[], id: string): T | undefined;
+/**
+ * Remove an item from a tree by ID (mutates the array).
+ */
+export declare function deleteItemFromTree<T extends TreeNode>(items: T[], id: string): boolean;
+/**
+ * Re-sort items to match an ordered list of IDs.
+ * Items not in orderedIds are appended at the end.
+ */
+export declare function sortItemsByOrder<T extends {
+    id: string;
+}>(items: T[], orderedIds: string[]): T[];
+/**
+ * Recursively search for a directory named targetSlug under basePath.
+ */
+export declare function searchForItemPath(basePath: string, targetSlug: string): string | undefined;
+/**
+ * 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

@@ -0,0 +1,32 @@
+/**
+ * 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/collection/json-collection-loader.d.ts

@@ -0,0 +1,95 @@
+/**
+ * JSON Collection Loader
+ *
+ * Loads collections from single JSON files (legacy format)
+ * Each collection is stored as a single .json file
+ *
+ * For JSON format, all item-level operations fall back to saving the entire collection
+ * since everything is in one file anyway.
+ */
+import type { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { CollectionMetadata, ICollectionStore } from './collection-store';
+/**
+ * Loads collections from JSON files
+ * Format: collections/{collection-id}.json
+ */
+export declare class JsonCollectionLoader implements ICollectionStore {
+    private collectionsDir;
+    private cache;
+    constructor(collectionsDir: string);
+    /**
+     * Ensure collections directory exists
+     */
+    private ensureDirectory;
+    /**
+     * Load all collections from disk
+     */
+    loadAll(): Collection[];
+    /**
+     * Load a single collection by ID
+     */
+    load(id: string): Collection | undefined;
+    /**
+     * Save a collection
+     */
+    save(collection: Collection): Promise<void>;
+    /**
+     * Delete a collection
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Check if a collection exists
+     */
+    exists(id: string): boolean;
+    /**
+     * Get the file path for a collection
+     */
+    getCollectionPath(id: string): string;
+    /**
+     * Create a new collection
+     */
+    create(name: string, id?: string): Promise<Collection>;
+    /**
+     * Save scripts for a specific item
+     * In JSON format, scripts are embedded in the collection JSON
+     */
+    saveScripts(collectionId: string, itemId: string, scripts: RequestScripts): Promise<void>;
+    /**
+     * Load scripts for a specific item
+     */
+    loadScripts(collectionId: string, itemId: string): RequestScripts | undefined;
+    /**
+     * Update collection metadata
+     */
+    updateCollectionMetadata(collectionId: string, updates: Partial<CollectionMetadata>): Promise<void>;
+    /**
+     * Save/update a single item
+     * For JSON format: saves entire collection
+     */
+    saveItem(collectionId: string, item: CollectionItem, parentId?: string): Promise<void>;
+    /**
+     * Delete a single item
+     */
+    deleteItem(collectionId: string, itemId: string): Promise<boolean>;
+    /**
+     * Update a single item
+     */
+    updateItem(collectionId: string, itemId: string, updates: Partial<CollectionItem>): Promise<boolean>;
+    /**
+     * Move an item to a new parent
+     */
+    moveItem(collectionId: string, itemId: string, newParentId?: string): Promise<boolean>;
+    /**
+     * Reorder items within a parent (collection or folder)
+     * For JSON format, just reorder the items array and save
+     */
+    reorderItems(collectionId: string, parentId: string | undefined, orderedItemIds: string[]): Promise<boolean>;
+    /**
+     * Find an item by ID in the collection tree
+     */
+    private findItemById;
+    /**
+     * Delete an item by ID from the collection tree
+     */
+    private deleteItemById;
+}

package/dist/{services → collection}/parser-registry.d.ts

@@ -4,7 +4,7 @@
  * Open/Closed Principle: New parsers can be added without modifying existing code
  * Single Responsibility: Manage collection parser registration and lookup
  */
-import { ICollectionParser } from '../interfaces';
+import { ICollectionParser } from './interfaces';
 /**
  * Registry for collection parsers
  * Allows registering parsers for different collection formats
@@ -46,4 +46,3 @@ export declare class ParserRegistry {
      */
     clear(): void;
 }
-//# sourceMappingURL=parser-registry.d.ts.map