@http-forge/core 0.1.0 → 0.2.0

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 { Collection, CollectionItem, CollectionRequestItem, CreateRequestOptions, ICollectionService } from './collection-service-interfaces';
+import { IFileWatcherFactory } from '../types/platform';
+import { IConfigService } from '../config';
+/**
+ * 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 { Collection, CollectionItem, RequestScripts } from './collection-service-interfaces';
+import type { CollectionRequest } from '../types/types';
+/**
+ * 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,256 @@
+/**
+ * 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/folder-collection-store.d.ts

@@ -0,0 +1,168 @@
+/**
+ * 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);
+    /**
+     * 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 searchForItemPath;
+    private findItemById;
+    private deleteItemFromTree;
+}

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;
+}