@nocturnium/svelte-ide 1.0.0-rc.1

package/dist/services/optimistic.js

@@ -0,0 +1,367 @@
+/**
+ * Optimistic Update Service
+ *
+ * Provides utilities for optimistic UI updates with automatic rollback on failure.
+ * Implements a queue-based system for managing pending operations.
+ */
+// ============================================================================
+// Operation Queue
+// ============================================================================
+const operationQueue = new Map();
+const rollbackFunctions = new Map();
+// ============================================================================
+// Core Functions
+// ============================================================================
+/**
+ * Execute an optimistic update with automatic rollback on failure
+ *
+ * @example
+ * ```typescript
+ * const result = await optimisticUpdate({
+ *   type: 'file_save',
+ *   payload: { path: '/src/main.ts', content: '...' },
+ *   apply: () => {
+ *     // Apply change locally immediately
+ *     updateLocalFile(path, content);
+ *   },
+ *   rollback: () => {
+ *     // Revert to previous state
+ *     updateLocalFile(path, previousContent);
+ *   },
+ *   commit: async () => {
+ *     // Persist to server
+ *     return await vfsClient.writeFile(workspaceId, path, content);
+ *   }
+ * });
+ * ```
+ */
+export async function optimisticUpdate(options) {
+    const { type, payload, apply, rollback, commit, config = {} } = options;
+    const { maxRetries = 3, retryDelay = 1000, onCommit, onRollback, onRetry } = config;
+    const operation = {
+        id: crypto.randomUUID(),
+        type,
+        payload,
+        timestamp: Date.now(),
+        status: 'pending',
+        retryCount: 0,
+        maxRetries
+    };
+    // Store operation and rollback
+    operationQueue.set(operation.id, operation);
+    rollbackFunctions.set(operation.id, rollback);
+    // Apply optimistically
+    try {
+        apply();
+    }
+    catch (applyError) {
+        // If apply fails, don't even try to commit
+        operation.status = 'failed';
+        operationQueue.delete(operation.id);
+        rollbackFunctions.delete(operation.id);
+        return {
+            success: false,
+            error: applyError instanceof Error ? applyError : new Error(String(applyError)),
+            operation: operation
+        };
+    }
+    // Try to commit with retries
+    let lastError;
+    while (operation.retryCount <= maxRetries) {
+        try {
+            const result = await commit();
+            operation.status = 'committed';
+            operationQueue.delete(operation.id);
+            rollbackFunctions.delete(operation.id);
+            onCommit?.(operation);
+            return {
+                success: true,
+                data: result,
+                operation: operation
+            };
+        }
+        catch (commitError) {
+            lastError = commitError instanceof Error ? commitError : new Error(String(commitError));
+            operation.retryCount++;
+            if (operation.retryCount <= maxRetries) {
+                onRetry?.(operation, operation.retryCount);
+                await delay(retryDelay * operation.retryCount); // Exponential backoff
+            }
+        }
+    }
+    // All retries failed - rollback
+    operation.status = 'failed';
+    try {
+        await rollback();
+        operation.status = 'rolledback';
+        onRollback?.(operation, lastError);
+    }
+    catch (rollbackError) {
+        console.error('Rollback failed:', rollbackError);
+    }
+    operationQueue.delete(operation.id);
+    rollbackFunctions.delete(operation.id);
+    return {
+        success: false,
+        error: lastError,
+        operation: operation
+    };
+}
+/**
+ * Create an optimistic state manager for a specific resource
+ */
+export function createOptimisticState(initialValue) {
+    let currentValue = initialValue;
+    let pendingValue = null;
+    let isPending = false;
+    return {
+        get value() {
+            return pendingValue ?? currentValue;
+        },
+        get isPending() {
+            return isPending;
+        },
+        get confirmedValue() {
+            return currentValue;
+        },
+        /**
+         * Apply an optimistic update
+         */
+        async update(newValue, commit, config) {
+            const previousValue = currentValue;
+            pendingValue = newValue;
+            isPending = true;
+            const result = await optimisticUpdate({
+                type: 'state_update',
+                payload: newValue,
+                apply: () => {
+                    // Already set pendingValue above
+                },
+                rollback: () => {
+                    pendingValue = null;
+                    isPending = false;
+                },
+                commit: async () => {
+                    const confirmed = await commit();
+                    currentValue = confirmed;
+                    pendingValue = null;
+                    isPending = false;
+                    return confirmed;
+                },
+                config
+            });
+            if (!result.success) {
+                pendingValue = null;
+                isPending = false;
+                currentValue = previousValue;
+            }
+            return result;
+        },
+        /**
+         * Confirm a pending value (e.g., from server response)
+         */
+        confirm(value) {
+            currentValue = value;
+            pendingValue = null;
+            isPending = false;
+        },
+        /**
+         * Reset to initial value
+         */
+        reset() {
+            currentValue = initialValue;
+            pendingValue = null;
+            isPending = false;
+        }
+    };
+}
+/**
+ * Batch multiple optimistic operations
+ */
+export async function batchOptimisticUpdates(operations, config) {
+    const results = [];
+    let failedCount = 0;
+    // Apply all optimistically first
+    const appliedOps = [];
+    for (const op of operations) {
+        try {
+            op.apply();
+            appliedOps.push({ op, rollback: op.rollback });
+        }
+        catch {
+            // If any apply fails, rollback all previous
+            for (const applied of appliedOps.reverse()) {
+                try {
+                    await applied.rollback();
+                }
+                catch (rollbackError) {
+                    console.error('Batch rollback failed:', rollbackError);
+                }
+            }
+            return {
+                success: false,
+                results: [],
+                failedCount: operations.length
+            };
+        }
+    }
+    // Commit all
+    for (const { op, rollback } of appliedOps) {
+        const result = await optimisticUpdate({
+            ...op,
+            apply: () => { }, // Already applied
+            rollback,
+            config
+        });
+        results.push(result);
+        if (!result.success)
+            failedCount++;
+    }
+    return {
+        success: failedCount === 0,
+        results,
+        failedCount
+    };
+}
+// ============================================================================
+// Queue Management
+// ============================================================================
+/**
+ * Get all pending operations
+ */
+export function getPendingOperations() {
+    return Array.from(operationQueue.values()).filter((op) => op.status === 'pending');
+}
+/**
+ * Get operation by ID
+ */
+export function getOperation(id) {
+    return operationQueue.get(id);
+}
+/**
+ * Cancel a pending operation
+ */
+export async function cancelOperation(id) {
+    const operation = operationQueue.get(id);
+    if (!operation || operation.status !== 'pending') {
+        return false;
+    }
+    const rollback = rollbackFunctions.get(id);
+    if (rollback) {
+        try {
+            await rollback();
+            operation.status = 'rolledback';
+        }
+        catch (error) {
+            console.error('Cancel rollback failed:', error);
+            return false;
+        }
+    }
+    operationQueue.delete(id);
+    rollbackFunctions.delete(id);
+    return true;
+}
+/**
+ * Cancel all pending operations
+ */
+export async function cancelAllOperations() {
+    const pending = getPendingOperations();
+    for (const op of pending) {
+        await cancelOperation(op.id);
+    }
+}
+/**
+ * Check if an error indicates a conflict
+ */
+export function isConflictError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes('version') || message.includes('conflict') || message.includes('stale')) {
+        return {
+            type: 'version',
+            timestamp: Date.now()
+        };
+    }
+    if (message.includes('lock') || message.includes('locked')) {
+        return {
+            type: 'lock',
+            timestamp: Date.now()
+        };
+    }
+    if (message.includes('concurrent') || message.includes('modified')) {
+        return {
+            type: 'concurrent',
+            timestamp: Date.now()
+        };
+    }
+    return null;
+}
+/**
+ * Parse conflict details from error
+ */
+export function parseConflictDetails(error) {
+    // This would parse structured error responses from the server
+    // For now, return null as a placeholder
+    try {
+        const data = JSON.parse(error.message);
+        return {
+            localContent: data.localContent,
+            serverContent: data.serverContent,
+            baseContent: data.baseContent
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// Utilities
+// ============================================================================
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Create a debounced optimistic updater
+ */
+export function createDebouncedOptimistic(commitFn, delayMs = 500) {
+    let timeoutId = null;
+    let pendingValue = null;
+    let pendingResolve = null;
+    return {
+        update(value, apply, rollback) {
+            // Apply immediately
+            apply();
+            pendingValue = value;
+            // Clear previous timeout
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+            return new Promise((resolve) => {
+                pendingResolve = resolve;
+                timeoutId = setTimeout(async () => {
+                    if (pendingValue === null)
+                        return;
+                    const result = await optimisticUpdate({
+                        type: 'debounced_update',
+                        payload: pendingValue,
+                        apply: () => { }, // Already applied
+                        rollback,
+                        commit: () => commitFn(pendingValue)
+                    });
+                    pendingValue = null;
+                    timeoutId = null;
+                    pendingResolve?.(result);
+                    pendingResolve = null;
+                }, delayMs);
+            });
+        },
+        flush() {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        },
+        get isPending() {
+            return pendingValue !== null;
+        }
+    };
+}

package/dist/services/vfs-client.d.ts

@@ -0,0 +1,81 @@
+/**
+ * VFS Client Service
+ * Handles all HTTP interactions with a virtual filesystem (VFS) backend
+ */
+import { type VFSFile, type VFSFileInfo, type VFSDirectory, type VFSWorkspace, type VFSTransaction, type VFSTransactionResult, type VFSOperation, type VFSFileLock, type VFSLockAcquisitionOptions, type VFSClientConfig } from '../types';
+export declare function configure(newConfig: Partial<VFSClientConfig>): void;
+export declare function getConfig(): VFSClientConfig;
+export declare function getWorkspace(workspaceId: string): Promise<VFSWorkspace>;
+export declare function updateWorkspace(workspaceId: string, updates: Partial<VFSWorkspace>): Promise<VFSWorkspace>;
+export declare function listWorkspaces(): Promise<VFSWorkspace[]>;
+export declare function readFile(workspaceId: string, path: string): Promise<VFSFile>;
+export declare function writeFile(workspaceId: string, path: string, content: string, version?: number): Promise<VFSFileInfo>;
+export declare function deleteFile(workspaceId: string, path: string, version?: number): Promise<void>;
+export declare function renameFile(workspaceId: string, oldPath: string, newPath: string, version?: number): Promise<VFSFileInfo>;
+export declare function getFileInfo(workspaceId: string, path: string): Promise<VFSFileInfo>;
+export declare function copyFile(workspaceId: string, sourcePath: string, destPath: string): Promise<VFSFileInfo>;
+export declare function readDirectory(workspaceId: string, path: string): Promise<VFSDirectory>;
+export declare function createDirectory(workspaceId: string, path: string): Promise<VFSFileInfo>;
+export declare function deleteDirectory(workspaceId: string, path: string, recursive?: boolean): Promise<void>;
+export declare function quickWriteFile(workspaceId: string, path: string, content: string): Promise<VFSFileInfo>;
+export declare function quickDeleteFile(workspaceId: string, path: string): Promise<void>;
+export declare function beginTransaction(workspaceId: string): Promise<string>;
+export declare function commitTransaction(transactionId: string, operations: VFSOperation[]): Promise<VFSTransactionResult>;
+export declare function rollbackTransaction(transactionId: string): Promise<void>;
+export declare function getTransaction(transactionId: string): Promise<VFSTransaction>;
+/**
+ * Execute multiple operations in a transaction
+ * Auto-commits on success, auto-rollbacks on failure
+ */
+export declare function executeTransaction(workspaceId: string, operations: VFSOperation[]): Promise<VFSTransactionResult>;
+export declare function acquireLock(workspaceId: string, path: string, holder: string, options?: VFSLockAcquisitionOptions): Promise<VFSFileLock>;
+export declare function releaseLock(workspaceId: string, path: string, holder: string): Promise<void>;
+export declare function refreshLock(workspaceId: string, path: string, holder: string): Promise<VFSFileLock>;
+export declare function getLockInfo(workspaceId: string, path: string): Promise<VFSFileLock | null>;
+export declare function listLocks(workspaceId: string): Promise<VFSFileLock[]>;
+export declare function forceReleaseLock(workspaceId: string, path: string, adminId: string): Promise<void>;
+/**
+ * Execute a function with a file lock
+ * Automatically acquires, executes, and releases
+ */
+export declare function withLock<T>(workspaceId: string, path: string, holder: string, fn: () => Promise<T>, options?: VFSLockAcquisitionOptions): Promise<T>;
+/**
+ * Batch file operations with automatic locking and transaction
+ */
+export declare function batchUpdate(workspaceId: string, holder: string, updates: Array<{
+    path: string;
+    content: string;
+    version?: number;
+}>): Promise<VFSTransactionResult>;
+/**
+ * Read file with automatic version tracking
+ */
+export declare function readFileWithVersion(workspaceId: string, path: string): Promise<{
+    content: string;
+    version: number;
+}>;
+/**
+ * Write file with version conflict detection
+ */
+export declare function safeWriteFile(workspaceId: string, path: string, content: string, expectedVersion: number): Promise<VFSFileInfo>;
+export interface VFSSearchOptions {
+    pattern: string;
+    caseSensitive?: boolean;
+    regex?: boolean;
+    includeHidden?: boolean;
+    maxResults?: number;
+    filePatterns?: string[];
+}
+export interface VFSSearchResult {
+    path: string;
+    line: number;
+    column: number;
+    content: string;
+    matchStart: number;
+    matchEnd: number;
+}
+export declare function searchFiles(workspaceId: string, options: VFSSearchOptions): Promise<VFSSearchResult[]>;
+export declare function healthCheck(): Promise<{
+    status: 'ok' | 'error';
+    latency: number;
+}>;