@d34dman/flowdrop 0.0.47 → 0.0.49

package/dist/services/apiVariableService.js

@@ -0,0 +1,338 @@
+/**
+ * API Variable Service
+ * Handles fetching template variable schemas from REST endpoints at runtime.
+ * Enables dynamic variable suggestions from backend APIs for template editors.
+ *
+ * @module services/apiVariableService
+ */
+import { getEndpointConfig } from './api.js';
+/**
+ * Variable schema cache with TTL support
+ * Key format: `variables:{workflowId}:{nodeId}`
+ */
+const variableCache = new Map();
+/**
+ * Default cache TTL in milliseconds (5 minutes)
+ */
+export const DEFAULT_VARIABLE_CACHE_TTL = 5 * 60 * 1000;
+/**
+ * Replaces {workflowId} and {nodeId} placeholders in URL template.
+ *
+ * @param template - The URL template string
+ * @param context - The variable context with workflowId and nodeId
+ * @returns The resolved URL with placeholders replaced
+ *
+ * @example
+ * ```typescript
+ * const url = "/api/variables/{workflowId}/{nodeId}";
+ * const context = { workflowId: "wf-123", nodeId: "node-456" };
+ * resolveEndpointUrl(url, context);
+ * // Returns "/api/variables/wf-123/node-456"
+ * ```
+ */
+export function resolveEndpointUrl(template, context) {
+    let resolved = template;
+    // Replace {workflowId}
+    if (context.workflowId) {
+        resolved = resolved.replace(/\{workflowId\}/g, encodeURIComponent(context.workflowId));
+    }
+    // Replace {nodeId}
+    resolved = resolved.replace(/\{nodeId\}/g, encodeURIComponent(context.nodeId));
+    return resolved;
+}
+/**
+ * Generates a cache key for a variable schema based on the context.
+ *
+ * @param workflowId - The workflow ID (optional)
+ * @param nodeId - The node instance ID
+ * @returns A unique cache key string
+ */
+function generateVariableCacheKey(workflowId, nodeId) {
+    return `variables:${workflowId || 'unknown'}:${nodeId}`;
+}
+/**
+ * Checks if a cached variable schema is still valid (not expired).
+ *
+ * @param entry - The cache entry to check
+ * @param ttl - Time-to-live in milliseconds
+ * @returns True if the cache entry is still valid
+ */
+function isCacheValid(entry, ttl = DEFAULT_VARIABLE_CACHE_TTL) {
+    return Date.now() - entry.cachedAt < ttl;
+}
+/**
+ * Resolves template variables in request body.
+ * Recursively processes nested objects and arrays.
+ *
+ * @param body - The request body object
+ * @param context - The variable context
+ * @returns The body with template variables resolved
+ */
+function resolveBodyTemplates(body, context) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (typeof value === 'string') {
+            // Resolve template variables in string values
+            let resolvedValue = value;
+            if (context.workflowId) {
+                resolvedValue = resolvedValue.replace(/\{workflowId\}/g, encodeURIComponent(context.workflowId));
+            }
+            resolvedValue = resolvedValue.replace(/\{nodeId\}/g, encodeURIComponent(context.nodeId));
+            resolved[key] = resolvedValue;
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            // Recursively resolve nested objects
+            resolved[key] = resolveBodyTemplates(value, context);
+        }
+        else {
+            // Pass through other values as-is
+            resolved[key] = value;
+        }
+    }
+    return resolved;
+}
+/**
+ * Fetches variable schema from a backend API endpoint.
+ *
+ * @param workflowId - The workflow ID (optional)
+ * @param nodeId - The node instance ID
+ * @param config - The API variables configuration
+ * @param authProvider - Optional auth provider for auth headers
+ * @returns A promise that resolves to the variable schema result
+ *
+ * @example
+ * ```typescript
+ * const config: ApiVariablesConfig = {
+ *   endpoint: {
+ *     url: "/api/variables/{workflowId}/{nodeId}",
+ *     method: "GET"
+ *   },
+ *   cacheTtl: 300000
+ * };
+ *
+ * const result = await fetchVariableSchema("wf-123", "node-456", config);
+ * if (result.success && result.schema) {
+ *   // Use the fetched variable schema
+ * }
+ * ```
+ */
+export async function fetchVariableSchema(workflowId, nodeId, config, authProvider) {
+    const endpoint = config.endpoint;
+    const context = { workflowId, nodeId };
+    // Generate cache key
+    const cacheKey = generateVariableCacheKey(workflowId, nodeId);
+    // Check cache first (if caching is enabled)
+    if (endpoint.cacheEnabled !== false) {
+        const cached = variableCache.get(cacheKey);
+        const ttl = config.cacheTtl ?? DEFAULT_VARIABLE_CACHE_TTL;
+        if (cached && isCacheValid(cached, ttl)) {
+            return {
+                success: true,
+                schema: cached.schema,
+                fromCache: true
+            };
+        }
+    }
+    // Resolve the URL with template variables
+    let url = resolveEndpointUrl(endpoint.url, context);
+    // If URL is relative, prepend base URL from endpoint config
+    if (url.startsWith('/')) {
+        const currentConfig = getEndpointConfig();
+        if (currentConfig?.baseUrl) {
+            const baseUrl = currentConfig.baseUrl.replace(/\/$/, '');
+            url = `${baseUrl}${url}`;
+        }
+    }
+    // Prepare request options
+    const method = endpoint.method ?? 'GET';
+    const timeout = endpoint.timeout ?? 30000;
+    const headers = {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        ...endpoint.headers
+    };
+    // Add auth headers from AuthProvider if available
+    if (authProvider) {
+        try {
+            const authHeaders = await authProvider.getAuthHeaders();
+            Object.assign(headers, authHeaders);
+        }
+        catch (error) {
+            console.warn('Failed to get auth headers:', error);
+        }
+    }
+    // Add auth headers from endpoint config as fallback
+    const currentConfig = getEndpointConfig();
+    if (currentConfig?.auth) {
+        if (currentConfig.auth.type === 'bearer' && currentConfig.auth.token) {
+            headers['Authorization'] = headers['Authorization'] ?? `Bearer ${currentConfig.auth.token}`;
+        }
+        else if (currentConfig.auth.type === 'api_key' && currentConfig.auth.apiKey) {
+            headers['X-API-Key'] = headers['X-API-Key'] ?? currentConfig.auth.apiKey;
+        }
+        else if (currentConfig.auth.type === 'custom' && currentConfig.auth.headers) {
+            Object.assign(headers, currentConfig.auth.headers);
+        }
+    }
+    // Prepare fetch options
+    const fetchOptions = {
+        method,
+        headers,
+        signal: AbortSignal.timeout(timeout)
+    };
+    // Add body for non-GET requests
+    if (method !== 'GET' && endpoint.body) {
+        const resolvedBody = resolveBodyTemplates(endpoint.body, context);
+        fetchOptions.body = JSON.stringify(resolvedBody);
+    }
+    try {
+        const response = await fetch(url, fetchOptions);
+        // Handle 404 as "no variables available"
+        if (response.status === 404) {
+            return {
+                success: true,
+                schema: { variables: {} },
+                fromCache: false
+            };
+        }
+        if (!response.ok) {
+            // Handle authentication errors
+            if (response.status === 401 || response.status === 403) {
+                if (authProvider?.onUnauthorized) {
+                    const refreshed = await authProvider.onUnauthorized();
+                    if (refreshed) {
+                        // Retry with refreshed auth
+                        return fetchVariableSchema(workflowId, nodeId, config, authProvider);
+                    }
+                }
+                return {
+                    success: false,
+                    error: 'Authentication failed'
+                };
+            }
+            const errorText = await response.text();
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${errorText || response.statusText}`
+            };
+        }
+        const data = await response.json();
+        // The response could be:
+        // 1. Direct VariableSchema: { variables: {...} }
+        // 2. Wrapped in { data: { variables: {...} } }
+        // 3. Wrapped in { schema: { variables: {...} } }
+        // 4. Wrapped in { success: true, data: { variables: {...} } }
+        let schema;
+        if (data.variables && typeof data.variables === 'object') {
+            // Direct VariableSchema
+            schema = data;
+        }
+        else if (data.data?.variables && typeof data.data.variables === 'object') {
+            // Wrapped in { data: ... }
+            schema = data.data;
+        }
+        else if (data.schema?.variables && typeof data.schema.variables === 'object') {
+            // Wrapped in { schema: ... }
+            schema = data.schema;
+        }
+        else if (data.success && data.data?.variables) {
+            // Wrapped in { success: true, data: ... }
+            schema = data.data;
+        }
+        if (!schema) {
+            return {
+                success: false,
+                error: 'Invalid variable schema format received from endpoint'
+            };
+        }
+        // Cache the schema (if caching is enabled)
+        if (endpoint.cacheEnabled !== false) {
+            variableCache.set(cacheKey, {
+                schema,
+                cachedAt: Date.now(),
+                cacheKey
+            });
+        }
+        return {
+            success: true,
+            schema,
+            fromCache: false
+        };
+    }
+    catch (error) {
+        // Handle specific error types
+        if (error instanceof Error) {
+            if (error.name === 'AbortError' || error.name === 'TimeoutError') {
+                return {
+                    success: false,
+                    error: `Request timed out after ${timeout}ms`
+                };
+            }
+            return {
+                success: false,
+                error: error.message
+            };
+        }
+        return {
+            success: false,
+            error: 'Unknown error occurred while fetching variable schema'
+        };
+    }
+}
+/**
+ * Clears the variable schema cache.
+ * Can optionally clear only entries matching a specific pattern.
+ *
+ * @param pattern - Optional pattern to match cache keys (e.g., workflow ID or node ID)
+ *
+ * @example
+ * ```typescript
+ * // Clear all cache
+ * clearVariableCache();
+ *
+ * // Clear cache for a specific workflow
+ * clearVariableCache("wf-123");
+ *
+ * // Clear cache for a specific node
+ * clearVariableCache("node-456");
+ * ```
+ */
+export function clearVariableCache(pattern) {
+    if (!pattern) {
+        variableCache.clear();
+        return;
+    }
+    // Clear matching entries
+    for (const key of variableCache.keys()) {
+        if (key.includes(pattern)) {
+            variableCache.delete(key);
+        }
+    }
+}
+/**
+ * Invalidates a specific variable cache entry.
+ *
+ * @param workflowId - The workflow ID (optional)
+ * @param nodeId - The node instance ID
+ */
+export function invalidateVariableCache(workflowId, nodeId) {
+    const cacheKey = generateVariableCacheKey(workflowId, nodeId);
+    variableCache.delete(cacheKey);
+}
+/**
+ * Gets the current cache size (number of entries).
+ *
+ * @returns The number of cached variable schemas
+ */
+export function getVariableCacheSize() {
+    return variableCache.size;
+}
+/**
+ * Gets all cache keys currently stored.
+ * Useful for debugging and monitoring.
+ *
+ * @returns Array of cache keys
+ */
+export function getVariableCacheKeys() {
+    return Array.from(variableCache.keys());
+}

package/dist/services/globalSave.js

@@ -62,6 +62,12 @@ async function ensureApiConfiguration() {
  * Uses the current workflow from the global store
  */
 export async function globalSaveWorkflow() {
+    // Flush any pending form changes by blurring the active element.
+    // This ensures focusout handlers (like ConfigForm's handleFormBlur)
+    // sync local state to the global store before we read it.
+    if (typeof document !== 'undefined' && document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+    }
     let loadingToast;
     try {
         // Show loading toast

package/dist/services/variableService.d.ts

@@ -5,7 +5,7 @@
  *
  * @module services/variableService
  */
-import type { WorkflowNode, WorkflowEdge, VariableSchema, TemplateVariable } from "../types/index.js";
+import type { WorkflowNode, WorkflowEdge, VariableSchema, TemplateVariable, TemplateVariablesConfig, AuthProvider } from '../types/index.js';
 /**
  * Options for deriving available variables.
  */
@@ -46,14 +46,6 @@ export interface GetAvailableVariablesOptions {
  * ```
  */
 export declare function getAvailableVariables(node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], options?: GetAvailableVariablesOptions): VariableSchema;
-/**
- * Converts simple variable hints (string array) to a VariableSchema.
- * Used for backward compatibility with the old variableHints format.
- *
- * @param hints - Array of variable names
- * @returns A VariableSchema with basic string variables
- */
-export declare function hintsToVariableSchema(hints: string[]): VariableSchema;
 /**
  * Gets the child variables for a given path in the variable schema.
  * Used for drilling down into nested objects and arrays.
@@ -98,3 +90,52 @@ export declare function isArrayVariable(schema: VariableSchema, path: string): b
  * @returns True if the variable has children that can be drilled into
  */
 export declare function hasChildren(schema: VariableSchema, path: string): boolean;
+/**
+ * Merges two variable schemas together.
+ * Variables from the primary schema take precedence over the secondary schema.
+ *
+ * @param primary - The primary variable schema (takes precedence)
+ * @param secondary - The secondary variable schema
+ * @returns A merged VariableSchema
+ *
+ * @example
+ * ```typescript
+ * const apiSchema = { variables: { apiKey: {...}, endpoint: {...} } };
+ * const staticSchema = { variables: { env: {...}, config: {...} } };
+ * const merged = mergeVariableSchemas(apiSchema, staticSchema);
+ * // Result: { variables: { apiKey, endpoint, env, config } }
+ * ```
+ */
+export declare function mergeVariableSchemas(primary: VariableSchema, secondary: VariableSchema): VariableSchema;
+/**
+ * Gets variable schema using the appropriate mode (API, schema-based, or hybrid).
+ * This is the main orchestration function that determines how to fetch variables
+ * based on the configuration.
+ *
+ * @param node - The current node being configured
+ * @param nodes - All nodes in the workflow
+ * @param edges - All edges in the workflow
+ * @param config - Template variables configuration
+ * @param workflowId - Optional workflow ID for API context
+ * @param authProvider - Optional auth provider for API requests
+ * @returns A promise that resolves to the variable schema
+ *
+ * @example
+ * ```typescript
+ * // Schema-based mode (existing behavior)
+ * const config = { ports: ["data"], schema: {...} };
+ * const schema = await getVariableSchema(node, nodes, edges, config);
+ *
+ * // API mode
+ * const config = { api: { endpoint: { url: "/api/variables/{workflowId}/{nodeId}" } } };
+ * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
+ *
+ * // Hybrid mode (API + static schema)
+ * const config = {
+ *   schema: {...},
+ *   api: { endpoint: {...}, mergeWithSchema: true }
+ * };
+ * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
+ * ```
+ */
+export declare function getVariableSchema(node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], config: TemplateVariablesConfig, workflowId?: string, authProvider?: AuthProvider): Promise<VariableSchema>;

package/dist/services/variableService.js

@@ -13,22 +13,22 @@
  */
 function toTemplateVariableType(schemaType) {
     switch (schemaType) {
-        case "string":
-            return "string";
-        case "number":
-            return "number";
-        case "integer":
-            return "integer";
-        case "boolean":
-            return "boolean";
-        case "array":
-            return "array";
-        case "object":
-            return "object";
-        case "float":
-            return "float";
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'integer':
+            return 'integer';
+        case 'boolean':
+            return 'boolean';
+        case 'array':
+            return 'array';
+        case 'object':
+            return 'object';
+        case 'float':
+            return 'float';
         default:
-            return "mixed";
+            return 'mixed';
     }
 }
 /**
@@ -51,15 +51,15 @@ function propertyToTemplateVariable(name, property, sourcePort, sourceNode) {
         sourceNode
     };
     // Handle nested object properties
-    if (property.type === "object" && property.properties) {
+    if (property.type === 'object' && property.properties) {
         variable.properties = {};
         for (const [propName, propValue] of Object.entries(property.properties)) {
             variable.properties[propName] = propertyToTemplateVariable(propName, propValue, sourcePort, sourceNode);
         }
     }
     // Handle array items
-    if (property.type === "array" && property.items) {
-        variable.items = propertyToTemplateVariable("item", property.items, sourcePort, sourceNode);
+    if (property.type === 'array' && property.items) {
+        variable.items = propertyToTemplateVariable('item', property.items, sourcePort, sourceNode);
     }
     return variable;
 }
@@ -78,7 +78,7 @@ function portToTemplateVariable(port, sourceNode) {
             name: port.id,
             label: port.name,
             description: port.description,
-            type: "object",
+            type: 'object',
             sourcePort: port.id,
             sourceNode,
             properties: {}
@@ -186,12 +186,12 @@ export function getAvailableVariables(node, nodes, edges, options) {
     for (const connection of connections) {
         const { sourceNode, sourcePort, targetPort } = connection;
         // Skip trigger ports - they don't carry data
-        if (sourcePort?.dataType === "trigger")
+        if (sourcePort?.dataType === 'trigger')
             continue;
-        if (targetPort?.dataType === "trigger")
+        if (targetPort?.dataType === 'trigger')
             continue;
         // Get the target port ID for filtering
-        const targetPortId = targetPort?.id ?? sourcePort?.id ?? "data";
+        const targetPortId = targetPort?.id ?? sourcePort?.id ?? 'data';
         // Filter by target port IDs if specified
         if (targetPortIds !== undefined) {
             if (!targetPortIds.includes(targetPortId))
@@ -212,7 +212,7 @@ export function getAvailableVariables(node, nodes, edges, options) {
         }
         else {
             // No schema or includePortName is true - use port name as the variable
-            const variableName = includePortName ? targetPortId : (targetPortId);
+            const variableName = includePortName ? targetPortId : targetPortId;
             // Skip if we already have a variable with this name
             if (variables[variableName])
                 continue;
@@ -224,23 +224,6 @@ export function getAvailableVariables(node, nodes, edges, options) {
     }
     return { variables };
 }
-/**
- * Converts simple variable hints (string array) to a VariableSchema.
- * Used for backward compatibility with the old variableHints format.
- *
- * @param hints - Array of variable names
- * @returns A VariableSchema with basic string variables
- */
-export function hintsToVariableSchema(hints) {
-    const variables = {};
-    for (const hint of hints) {
-        variables[hint] = {
-            name: hint,
-            type: "mixed"
-        };
-    }
-    return { variables };
-}
 /**
  * Gets the child variables for a given path in the variable schema.
  * Used for drilling down into nested objects and arrays.
@@ -261,7 +244,7 @@ export function hintsToVariableSchema(hints) {
  * ```
  */
 export function getChildVariables(schema, path) {
-    const parts = path.split(".");
+    const parts = path.split('.');
     let current;
     // Navigate to the target variable
     for (let i = 0; i < parts.length; i++) {
@@ -312,7 +295,7 @@ export function getArrayIndexSuggestions(maxIndex = 2) {
         suggestions.push(`${i}]`);
     }
     // Add wildcard for "all items"
-    suggestions.push("*]");
+    suggestions.push('*]');
     return suggestions;
 }
 /**
@@ -323,7 +306,7 @@ export function getArrayIndexSuggestions(maxIndex = 2) {
  * @returns True if the variable is an array type
  */
 export function isArrayVariable(schema, path) {
-    const parts = path.split(".");
+    const parts = path.split('.');
     let current;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
@@ -352,7 +335,7 @@ export function isArrayVariable(schema, path) {
             return false;
         }
     }
-    return current?.type === "array";
+    return current?.type === 'array';
 }
 /**
  * Checks if a variable at the given path has child properties.
@@ -365,3 +348,115 @@ export function hasChildren(schema, path) {
     const children = getChildVariables(schema, path);
     return children.length > 0;
 }
+/**
+ * Merges two variable schemas together.
+ * Variables from the primary schema take precedence over the secondary schema.
+ *
+ * @param primary - The primary variable schema (takes precedence)
+ * @param secondary - The secondary variable schema
+ * @returns A merged VariableSchema
+ *
+ * @example
+ * ```typescript
+ * const apiSchema = { variables: { apiKey: {...}, endpoint: {...} } };
+ * const staticSchema = { variables: { env: {...}, config: {...} } };
+ * const merged = mergeVariableSchemas(apiSchema, staticSchema);
+ * // Result: { variables: { apiKey, endpoint, env, config } }
+ * ```
+ */
+export function mergeVariableSchemas(primary, secondary) {
+    // Create a shallow copy of secondary variables
+    const mergedVariables = { ...secondary.variables };
+    // Overlay primary variables (they take precedence)
+    for (const [key, value] of Object.entries(primary.variables)) {
+        mergedVariables[key] = value;
+    }
+    return { variables: mergedVariables };
+}
+/**
+ * Gets variable schema using the appropriate mode (API, schema-based, or hybrid).
+ * This is the main orchestration function that determines how to fetch variables
+ * based on the configuration.
+ *
+ * @param node - The current node being configured
+ * @param nodes - All nodes in the workflow
+ * @param edges - All edges in the workflow
+ * @param config - Template variables configuration
+ * @param workflowId - Optional workflow ID for API context
+ * @param authProvider - Optional auth provider for API requests
+ * @returns A promise that resolves to the variable schema
+ *
+ * @example
+ * ```typescript
+ * // Schema-based mode (existing behavior)
+ * const config = { ports: ["data"], schema: {...} };
+ * const schema = await getVariableSchema(node, nodes, edges, config);
+ *
+ * // API mode
+ * const config = { api: { endpoint: { url: "/api/variables/{workflowId}/{nodeId}" } } };
+ * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
+ *
+ * // Hybrid mode (API + static schema)
+ * const config = {
+ *   schema: {...},
+ *   api: { endpoint: {...}, mergeWithSchema: true }
+ * };
+ * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
+ * ```
+ */
+export async function getVariableSchema(node, nodes, edges, config, workflowId, authProvider) {
+    let resultSchema = { variables: {} };
+    // Try API mode first (if configured)
+    if (config.api) {
+        try {
+            // Import API variable service dynamically to avoid circular dependencies
+            const { fetchVariableSchema } = await import('./apiVariableService.js');
+            const apiResult = await fetchVariableSchema(workflowId, node.id, config.api, authProvider);
+            if (apiResult.success && apiResult.schema) {
+                resultSchema = apiResult.schema;
+                // Merge with static schema if configured
+                if (config.api.mergeWithSchema !== false && config.schema) {
+                    resultSchema = mergeVariableSchemas(resultSchema, config.schema);
+                }
+                // Merge with port-derived variables if configured
+                if (config.api.mergeWithPorts) {
+                    const portSchema = getAvailableVariables(node, nodes, edges, {
+                        targetPortIds: config.ports,
+                        includePortName: config.includePortName
+                    });
+                    resultSchema = mergeVariableSchemas(resultSchema, portSchema);
+                }
+                return resultSchema;
+            }
+            else if (!config.api.fallbackOnError) {
+                // API failed and fallback is disabled - return empty schema
+                console.error('Failed to fetch variables from API:', apiResult.error);
+                return { variables: {} };
+            }
+            // If fallback is enabled (default), continue to schema-based mode below
+        }
+        catch (error) {
+            console.error('Error fetching variables from API:', error);
+            // If fallback is disabled, return empty schema
+            if (config.api.fallbackOnError === false) {
+                return { variables: {} };
+            }
+            // Otherwise, continue to schema-based mode below
+        }
+    }
+    // Schema-based mode (existing behavior)
+    // This is the fallback when API mode is not configured or fails
+    // Start with port-derived variables (if ports are configured or no API mode)
+    if (config.ports !== undefined || !config.api) {
+        const portSchema = getAvailableVariables(node, nodes, edges, {
+            targetPortIds: config.ports,
+            includePortName: config.includePortName
+        });
+        resultSchema = portSchema;
+    }
+    // Merge with static schema (if configured)
+    if (config.schema) {
+        resultSchema = mergeVariableSchemas(config.schema, resultSchema);
+    }
+    return resultSchema;
+}