@flowdrop/flowdrop 1.0.0

package/dist/services/draftStorage.js

@@ -0,0 +1,299 @@
+/**
+ * Draft Storage Service for FlowDrop
+ *
+ * Handles saving and loading workflow drafts to/from localStorage.
+ * Provides interval-based auto-save functionality.
+ *
+ * @module services/draftStorage
+ */
+import { logger } from '../utils/logger.js';
+/**
+ * Default storage key prefix
+ */
+const STORAGE_KEY_PREFIX = 'flowdrop:draft';
+/**
+ * Generate a storage key for a workflow
+ *
+ * If a custom key is provided, use it directly.
+ * Otherwise, generate based on workflow ID or use "new" for unsaved workflows.
+ *
+ * @param workflowId - The workflow ID (optional)
+ * @param customKey - Custom storage key provided by enterprise (optional)
+ * @returns The storage key to use
+ */
+export function getDraftStorageKey(workflowId, customKey) {
+    if (customKey) {
+        return customKey;
+    }
+    if (workflowId) {
+        return `${STORAGE_KEY_PREFIX}:${workflowId}`;
+    }
+    return `${STORAGE_KEY_PREFIX}:new`;
+}
+/**
+ * Save a workflow draft to localStorage
+ *
+ * @param workflow - The workflow to save
+ * @param storageKey - The storage key to use
+ * @returns true if saved successfully, false otherwise
+ */
+export function saveDraft(workflow, storageKey) {
+    try {
+        const draft = {
+            workflow,
+            metadata: {
+                savedAt: new Date().toISOString(),
+                workflowId: workflow.id,
+                workflowName: workflow.name
+            }
+        };
+        localStorage.setItem(storageKey, JSON.stringify(draft));
+        return true;
+    }
+    catch (error) {
+        // localStorage might be full or disabled
+        logger.warn('Failed to save draft to localStorage:', error);
+        return false;
+    }
+}
+/**
+ * Load a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to load from
+ * @returns The stored draft, or null if not found
+ */
+export function loadDraft(storageKey) {
+    try {
+        const stored = localStorage.getItem(storageKey);
+        if (!stored) {
+            return null;
+        }
+        const draft = JSON.parse(stored);
+        // Validate the draft structure
+        if (!draft.workflow || !draft.metadata) {
+            logger.warn('Invalid draft structure in localStorage');
+            return null;
+        }
+        return draft;
+    }
+    catch (error) {
+        logger.warn('Failed to load draft from localStorage:', error);
+        return null;
+    }
+}
+/**
+ * Delete a workflow draft from localStorage
+ *
+ * @param storageKey - The storage key to delete
+ */
+export function deleteDraft(storageKey) {
+    try {
+        localStorage.removeItem(storageKey);
+    }
+    catch (error) {
+        logger.warn('Failed to delete draft from localStorage:', error);
+    }
+}
+/**
+ * Check if a draft exists for a given storage key
+ *
+ * @param storageKey - The storage key to check
+ * @returns true if a draft exists
+ */
+export function hasDraft(storageKey) {
+    try {
+        return localStorage.getItem(storageKey) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get draft metadata without loading the full workflow
+ *
+ * Useful for displaying draft information without parsing the entire workflow.
+ *
+ * @param storageKey - The storage key to check
+ * @returns Draft metadata, or null if not found
+ */
+export function getDraftMetadata(storageKey) {
+    const draft = loadDraft(storageKey);
+    return draft?.metadata ?? null;
+}
+/**
+ * Draft auto-save manager
+ *
+ * Handles interval-based auto-saving of workflow drafts.
+ * Should be instantiated per FlowDrop instance.
+ */
+export class DraftAutoSaveManager {
+    /** Interval timer ID */
+    intervalId = null;
+    /** Storage key for drafts */
+    storageKey;
+    /** Auto-save interval in milliseconds */
+    interval;
+    /** Whether auto-save is enabled */
+    enabled;
+    /** Function to get current workflow */
+    getWorkflow;
+    /** Function to check if workflow is dirty */
+    isDirty;
+    /** Last saved workflow hash (for change detection) */
+    lastSavedHash = null;
+    /**
+     * Create a new DraftAutoSaveManager
+     *
+     * @param options - Configuration options
+     */
+    constructor(options) {
+        this.storageKey = options.storageKey;
+        this.interval = options.interval;
+        this.enabled = options.enabled;
+        this.getWorkflow = options.getWorkflow;
+        this.isDirty = options.isDirty;
+    }
+    /**
+     * Start auto-save interval
+     *
+     * Will save drafts at the configured interval if there are unsaved changes.
+     */
+    start() {
+        if (!this.enabled || this.intervalId) {
+            return;
+        }
+        this.intervalId = setInterval(() => {
+            this.saveIfDirty();
+        }, this.interval);
+    }
+    /**
+     * Stop auto-save interval
+     */
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    /**
+     * Save draft if there are unsaved changes
+     *
+     * @returns true if a draft was saved
+     */
+    saveIfDirty() {
+        if (!this.enabled) {
+            return false;
+        }
+        const workflow = this.getWorkflow();
+        if (!workflow) {
+            return false;
+        }
+        // Only save if dirty
+        if (!this.isDirty()) {
+            return false;
+        }
+        // Check if workflow has actually changed since last save
+        const currentHash = this.hashWorkflow(workflow);
+        if (currentHash === this.lastSavedHash) {
+            return false;
+        }
+        const saved = saveDraft(workflow, this.storageKey);
+        if (saved) {
+            this.lastSavedHash = currentHash;
+        }
+        return saved;
+    }
+    /**
+     * Force save the current workflow as a draft
+     *
+     * Saves regardless of dirty state.
+     *
+     * @returns true if saved successfully
+     */
+    forceSave() {
+        const workflow = this.getWorkflow();
+        if (!workflow) {
+            return false;
+        }
+        const saved = saveDraft(workflow, this.storageKey);
+        if (saved) {
+            this.lastSavedHash = this.hashWorkflow(workflow);
+        }
+        return saved;
+    }
+    /**
+     * Clear the draft from storage
+     */
+    clearDraft() {
+        deleteDraft(this.storageKey);
+        this.lastSavedHash = null;
+    }
+    /**
+     * Mark the current state as saved
+     *
+     * Updates the hash so the next saveIfDirty won't save unless there are new changes.
+     */
+    markAsSaved() {
+        const workflow = this.getWorkflow();
+        if (workflow) {
+            this.lastSavedHash = this.hashWorkflow(workflow);
+        }
+    }
+    /**
+     * Update the storage key
+     *
+     * Useful when the workflow ID changes (e.g., after first save).
+     *
+     * @param newKey - The new storage key
+     */
+    updateStorageKey(newKey) {
+        // If there's an existing draft with the old key, migrate it
+        const existingDraft = loadDraft(this.storageKey);
+        if (existingDraft && this.storageKey !== newKey) {
+            deleteDraft(this.storageKey);
+            saveDraft(existingDraft.workflow, newKey);
+        }
+        this.storageKey = newKey;
+    }
+    /**
+     * Simple hash function for change detection
+     *
+     * Not cryptographically secure, just for detecting changes.
+     *
+     * @param workflow - The workflow to hash
+     * @returns A simple hash string
+     */
+    hashWorkflow(workflow) {
+        // Use a simple stringification for change detection
+        // We only need nodes, edges, name, and description for change detection
+        const toHash = {
+            name: workflow.name,
+            description: workflow.description,
+            nodes: workflow.nodes.map((n) => ({
+                id: n.id,
+                position: n.position,
+                data: n.data
+            })),
+            edges: workflow.edges.map((e) => ({
+                id: e.id,
+                source: e.source,
+                target: e.target,
+                sourceHandle: e.sourceHandle,
+                targetHandle: e.targetHandle
+            }))
+        };
+        return JSON.stringify(toHash);
+    }
+    /**
+     * Check if auto-save is currently running
+     */
+    isRunning() {
+        return this.intervalId !== null;
+    }
+    /**
+     * Get the current storage key
+     */
+    getStorageKey() {
+        return this.storageKey;
+    }
+}

package/dist/services/dynamicSchemaService.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Dynamic Schema Service
+ * Handles fetching configuration schemas from REST endpoints at runtime.
+ * Used for nodes where the config schema cannot be determined at workflow load time.
+ *
+ * @module services/dynamicSchemaService
+ */
+import type { ConfigSchema, DynamicSchemaEndpoint, ExternalEditLink, ConfigEditOptions, WorkflowNode } from '../types/index.js';
+/**
+ * Result of a dynamic schema fetch operation
+ */
+export interface DynamicSchemaResult {
+    /** Whether the fetch was successful */
+    success: boolean;
+    /** The fetched config schema (if successful) */
+    schema?: ConfigSchema;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether the schema was loaded from cache */
+    fromCache?: boolean;
+}
+/**
+ * Fetches a dynamic configuration schema from a REST endpoint.
+ *
+ * @param endpoint - The dynamic schema endpoint configuration
+ * @param node - The workflow node instance
+ * @param workflowId - Optional workflow ID for context
+ * @returns A promise that resolves to the schema result
+ *
+ * @example
+ * ```typescript
+ * const endpoint: DynamicSchemaEndpoint = {
+ *   url: "/api/nodes/{nodeTypeId}/schema",
+ *   method: "GET",
+ *   parameterMapping: { nodeTypeId: "metadata.id" }
+ * };
+ *
+ * const result = await fetchDynamicSchema(endpoint, node);
+ * if (result.success && result.schema) {
+ *   // Use the fetched schema
+ * }
+ * ```
+ */
+export declare function fetchDynamicSchema(endpoint: DynamicSchemaEndpoint, node: WorkflowNode, workflowId?: string): Promise<DynamicSchemaResult>;
+/**
+ * Resolves an external edit link URL with template variables.
+ *
+ * @param link - The external edit link configuration
+ * @param node - The workflow node instance
+ * @param workflowId - Optional workflow ID for context
+ * @param callbackUrl - Optional callback URL to append
+ * @returns The resolved URL string
+ *
+ * @example
+ * ```typescript
+ * const link: ExternalEditLink = {
+ *   url: "https://admin.example.com/nodes/{nodeTypeId}/edit/{instanceId}",
+ *   parameterMapping: { nodeTypeId: "metadata.id", instanceId: "id" }
+ * };
+ *
+ * const url = resolveExternalEditUrl(link, node, workflowId);
+ * // Returns "https://admin.example.com/nodes/llm-node/edit/node-1"
+ * ```
+ */
+export declare function resolveExternalEditUrl(link: ExternalEditLink, node: WorkflowNode, workflowId?: string, callbackUrl?: string): string;
+/**
+ * Gets the effective config edit options for a node.
+ * Merges node type defaults with instance-level overrides.
+ *
+ * @param node - The workflow node instance
+ * @returns The merged config edit options, or undefined if not configured
+ */
+export declare function getEffectiveConfigEditOptions(node: WorkflowNode): ConfigEditOptions | undefined;
+/**
+ * Clears the schema cache.
+ * Can optionally clear only entries matching a specific pattern.
+ *
+ * @param pattern - Optional pattern to match cache keys (e.g., node type ID)
+ */
+export declare function clearSchemaCache(pattern?: string): void;
+/**
+ * Invalidates a specific schema cache entry for a node.
+ *
+ * @param node - The workflow node to invalidate cache for
+ * @param endpoint - The dynamic schema endpoint configuration
+ */
+export declare function invalidateSchemaCache(node: WorkflowNode, endpoint: DynamicSchemaEndpoint): void;
+/**
+ * Checks if a node has config edit options configured.
+ *
+ * @param node - The workflow node to check
+ * @returns True if the node has config edit options configured
+ */
+export declare function hasConfigEditOptions(node: WorkflowNode): boolean;
+/**
+ * Determines if external edit should be shown for a node.
+ *
+ * @param node - The workflow node to check
+ * @returns True if external edit link should be shown
+ */
+export declare function shouldShowExternalEdit(node: WorkflowNode): boolean;
+/**
+ * Determines if dynamic schema should be used for a node.
+ *
+ * @param node - The workflow node to check
+ * @returns True if dynamic schema should be fetched
+ */
+export declare function shouldUseDynamicSchema(node: WorkflowNode): boolean;