@flowdrop/flowdrop 1.0.0 → 1.1.0

package/dist/services/apiVariableService.js

@@ -5,9 +5,9 @@
  *
  * @module services/apiVariableService
  */
-import { getEndpointConfig } from './api.js';
-import { logger } from '../utils/logger.js';
-import { DEFAULT_CACHE_TTL_MS } from '../config/constants.js';
+import { getEndpointConfig } from "./api.js";
+import { logger } from "../utils/logger.js";
+import { DEFAULT_CACHE_TTL_MS } from "../config/constants.js";
 /**
  * Variable schema cache with TTL support
  * Key format: `variables:{workflowId}:{nodeId}`
@@ -48,7 +48,7 @@ export function resolveEndpointUrl(template, context) {
  * @returns A unique cache key string
  */
 function generateVariableCacheKey(workflowId, nodeId) {
-    return `variables:${workflowId || 'unknown'}:${nodeId}`;
+    return `variables:${workflowId || "unknown"}:${nodeId}`;
 }
 /**
  * Checks if a cached variable schema is still valid (not expired).
@@ -71,7 +71,7 @@ function isCacheValid(entry, ttl = DEFAULT_VARIABLE_CACHE_TTL) {
 function resolveBodyTemplates(body, context) {
     const resolved = {};
     for (const [key, value] of Object.entries(body)) {
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             // Resolve template variables in string values
             let resolvedValue = value;
             if (context.workflowId) {
@@ -80,7 +80,9 @@ function resolveBodyTemplates(body, context) {
             resolvedValue = resolvedValue.replace(/\{nodeId\}/g, encodeURIComponent(context.nodeId));
             resolved[key] = resolvedValue;
         }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        else if (typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
             // Recursively resolve nested objects
             resolved[key] = resolveBodyTemplates(value, context);
         }
@@ -129,27 +131,27 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             return {
                 success: true,
                 schema: cached.schema,
-                fromCache: true
+                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('/')) {
+    if (url.startsWith("/")) {
         const currentConfig = getEndpointConfig();
         if (currentConfig?.baseUrl) {
-            const baseUrl = currentConfig.baseUrl.replace(/\/$/, '');
+            const baseUrl = currentConfig.baseUrl.replace(/\/$/, "");
             url = `${baseUrl}${url}`;
         }
     }
     // Prepare request options
-    const method = endpoint.method ?? 'GET';
+    const method = endpoint.method ?? "GET";
     const timeout = endpoint.timeout ?? 30000;
     const headers = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-        ...endpoint.headers
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...endpoint.headers,
     };
     // Add auth headers from AuthProvider if available
     if (authProvider) {
@@ -158,19 +160,22 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             Object.assign(headers, authHeaders);
         }
         catch (error) {
-            logger.warn('Failed to get auth headers:', error);
+            logger.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}`;
+        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 === "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) {
+        else if (currentConfig.auth.type === "custom" &&
+            currentConfig.auth.headers) {
             Object.assign(headers, currentConfig.auth.headers);
         }
     }
@@ -178,10 +183,10 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
     const fetchOptions = {
         method,
         headers,
-        signal: AbortSignal.timeout(timeout)
+        signal: AbortSignal.timeout(timeout),
     };
     // Add body for non-GET requests
-    if (method !== 'GET' && endpoint.body) {
+    if (method !== "GET" && endpoint.body) {
         const resolvedBody = resolveBodyTemplates(endpoint.body, context);
         fetchOptions.body = JSON.stringify(resolvedBody);
     }
@@ -192,7 +197,7 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             return {
                 success: true,
                 schema: { variables: {} },
-                fromCache: false
+                fromCache: false,
             };
         }
         if (!response.ok) {
@@ -207,13 +212,13 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
                 }
                 return {
                     success: false,
-                    error: 'Authentication failed'
+                    error: "Authentication failed",
                 };
             }
             const errorText = await response.text();
             return {
                 success: false,
-                error: `HTTP ${response.status}: ${errorText || response.statusText}`
+                error: `HTTP ${response.status}: ${errorText || response.statusText}`,
             };
         }
         const data = await response.json();
@@ -223,15 +228,17 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
         // 3. Wrapped in { schema: { variables: {...} } }
         // 4. Wrapped in { success: true, data: { variables: {...} } }
         let schema;
-        if (data.variables && typeof data.variables === 'object') {
+        if (data.variables && typeof data.variables === "object") {
             // Direct VariableSchema
             schema = data;
         }
-        else if (data.data?.variables && typeof data.data.variables === 'object') {
+        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') {
+        else if (data.schema?.variables &&
+            typeof data.schema.variables === "object") {
             // Wrapped in { schema: ... }
             schema = data.schema;
         }
@@ -242,7 +249,7 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
         if (!schema) {
             return {
                 success: false,
-                error: 'Invalid variable schema format received from endpoint'
+                error: "Invalid variable schema format received from endpoint",
             };
         }
         // Cache the schema (if caching is enabled)
@@ -250,32 +257,32 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             variableCache.set(cacheKey, {
                 schema,
                 cachedAt: Date.now(),
-                cacheKey
+                cacheKey,
             });
         }
         return {
             success: true,
             schema,
-            fromCache: false
+            fromCache: false,
         };
     }
     catch (error) {
         // Handle specific error types
         if (error instanceof Error) {
-            if (error.name === 'AbortError' || error.name === 'TimeoutError') {
+            if (error.name === "AbortError" || error.name === "TimeoutError") {
                 return {
                     success: false,
-                    error: `Request timed out after ${timeout}ms`
+                    error: `Request timed out after ${timeout}ms`,
                 };
             }
             return {
                 success: false,
-                error: error.message
+                error: error.message,
             };
         }
         return {
             success: false,
-            error: 'Unknown error occurred while fetching variable schema'
+            error: "Unknown error occurred while fetching variable schema",
         };
     }
 }

package/dist/services/autoSaveService.js

@@ -6,9 +6,9 @@
  *
  * @module services/autoSaveService
  */
-import { getBehaviorSettings, onSettingsChange } from '../stores/settingsStore.svelte.js';
-import { isDirty } from '../stores/workflowStore.svelte.js';
-import { logger } from '../utils/logger.js';
+import { getBehaviorSettings, onSettingsChange, } from "../stores/settingsStore.svelte.js";
+import { isDirty } from "../stores/workflowStore.svelte.js";
+import { logger } from "../utils/logger.js";
 /**
  * Initialize auto-save functionality based on user settings
  *
@@ -45,7 +45,7 @@ export function initAutoSave(options) {
         intervalId: null,
         isSaving: false,
         settingsUnsubscriber: null,
-        dirtyUnsubscriber: null
+        dirtyUnsubscriber: null,
     };
     /**
      * Perform auto-save if conditions are met
@@ -62,7 +62,7 @@ export function initAutoSave(options) {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Auto-save failed:', err);
+            logger.error("Auto-save failed:", err);
             onError?.(err);
         }
         finally {
@@ -88,7 +88,7 @@ export function initAutoSave(options) {
     }
     // Listen for settings changes to react to auto-save toggle/interval changes
     state.settingsUnsubscriber = onSettingsChange((event) => {
-        if (event.category === 'behavior') {
+        if (event.category === "behavior") {
             updateAutoSaveInterval();
         }
     });
@@ -147,7 +147,7 @@ export class AutoSaveManager {
             return; // Already started
         }
         this.settingsUnsubscriber = onSettingsChange((event) => {
-            if (event.category === 'behavior') {
+            if (event.category === "behavior") {
                 this.updateInterval();
             }
         });
@@ -217,7 +217,7 @@ export class AutoSaveManager {
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            logger.error('Auto-save failed:', err);
+            logger.error("Auto-save failed:", err);
             this.onError?.(err);
         }
         finally {

package/dist/services/categoriesApi.d.ts

@@ -2,8 +2,8 @@
  * Categories API Service
  * Handles fetching category definitions from the backend
  */
-import type { CategoryDefinition } from '../types/index.js';
-import type { EndpointConfig } from '../config/endpoints.js';
+import type { CategoryDefinition } from "../types/index.js";
+import type { EndpointConfig } from "../config/endpoints.js";
 /**
  * Fetch category definitions from API
  */

package/dist/services/categoriesApi.js

@@ -2,9 +2,9 @@
  * Categories API Service
  * Handles fetching category definitions from the backend
  */
-import { buildEndpointUrl } from '../config/endpoints.js';
-import { DEFAULT_CATEGORIES } from '../config/defaultCategories.js';
-import { logger } from '../utils/logger.js';
+import { buildEndpointUrl } from "../config/endpoints.js";
+import { DEFAULT_CATEGORIES } from "../config/defaultCategories.js";
+import { logger } from "../utils/logger.js";
 /**
  * Fetch category definitions from API
  */
@@ -12,7 +12,7 @@ export async function fetchCategories(endpointConfig) {
     try {
         const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.categories);
         const response = await fetch(url, {
-            headers: { 'Content-Type': 'application/json' }
+            headers: { "Content-Type": "application/json" },
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -20,13 +20,13 @@ export async function fetchCategories(endpointConfig) {
         const data = await response.json();
         const categories = data.data ?? data;
         if (!categories || !Array.isArray(categories)) {
-            logger.warn('Invalid categories received from API, using default');
+            logger.warn("Invalid categories received from API, using default");
             return DEFAULT_CATEGORIES;
         }
         return categories;
     }
     catch (error) {
-        logger.error('Error fetching categories:', error);
+        logger.error("Error fetching categories:", error);
         return DEFAULT_CATEGORIES;
     }
 }
@@ -38,10 +38,10 @@ export function validateCategories(categories) {
         return false;
     }
     for (const category of categories) {
-        if (!category.name || typeof category.name !== 'string') {
+        if (!category.name || typeof category.name !== "string") {
             return false;
         }
-        if (!category.label || typeof category.label !== 'string') {
+        if (!category.label || typeof category.label !== "string") {
             return false;
         }
     }

package/dist/services/draftStorage.d.ts

@@ -6,7 +6,7 @@
  *
  * @module services/draftStorage
  */
-import type { Workflow } from '../types/index.js';
+import type { Workflow } from "../types/index.js";
 /**
  * Draft metadata stored alongside the workflow
  */

package/dist/services/draftStorage.js

@@ -6,11 +6,11 @@
  *
  * @module services/draftStorage
  */
-import { logger } from '../utils/logger.js';
+import { logger } from "../utils/logger.js";
 /**
  * Default storage key prefix
  */
-const STORAGE_KEY_PREFIX = 'flowdrop:draft';
+const STORAGE_KEY_PREFIX = "flowdrop:draft";
 /**
  * Generate a storage key for a workflow
  *
@@ -44,15 +44,15 @@ export function saveDraft(workflow, storageKey) {
             metadata: {
                 savedAt: new Date().toISOString(),
                 workflowId: workflow.id,
-                workflowName: workflow.name
-            }
+                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);
+        logger.warn("Failed to save draft to localStorage:", error);
         return false;
     }
 }
@@ -71,13 +71,13 @@ export function loadDraft(storageKey) {
         const draft = JSON.parse(stored);
         // Validate the draft structure
         if (!draft.workflow || !draft.metadata) {
-            logger.warn('Invalid draft structure in localStorage');
+            logger.warn("Invalid draft structure in localStorage");
             return null;
         }
         return draft;
     }
     catch (error) {
-        logger.warn('Failed to load draft from localStorage:', error);
+        logger.warn("Failed to load draft from localStorage:", error);
         return null;
     }
 }
@@ -91,7 +91,7 @@ export function deleteDraft(storageKey) {
         localStorage.removeItem(storageKey);
     }
     catch (error) {
-        logger.warn('Failed to delete draft from localStorage:', error);
+        logger.warn("Failed to delete draft from localStorage:", error);
     }
 }
 /**
@@ -272,15 +272,15 @@ export class DraftAutoSaveManager {
             nodes: workflow.nodes.map((n) => ({
                 id: n.id,
                 position: n.position,
-                data: n.data
+                data: n.data,
             })),
             edges: workflow.edges.map((e) => ({
                 id: e.id,
                 source: e.source,
                 target: e.target,
                 sourceHandle: e.sourceHandle,
-                targetHandle: e.targetHandle
-            }))
+                targetHandle: e.targetHandle,
+            })),
         };
         return JSON.stringify(toHash);
     }

package/dist/services/dynamicSchemaService.d.ts

@@ -5,7 +5,7 @@
  *
  * @module services/dynamicSchemaService
  */
-import type { ConfigSchema, DynamicSchemaEndpoint, ExternalEditLink, ConfigEditOptions, WorkflowNode } from '../types/index.js';
+import type { ConfigSchema, DynamicSchemaEndpoint, ExternalEditLink, ConfigEditOptions, WorkflowNode } from "../types/index.js";
 /**
  * Result of a dynamic schema fetch operation
  */

package/dist/services/dynamicSchemaService.js

@@ -5,8 +5,8 @@
  *
  * @module services/dynamicSchemaService
  */
-import { getEndpointConfig } from './api.js';
-import { DEFAULT_CACHE_TTL_MS } from '../config/constants.js';
+import { getEndpointConfig } from "./api.js";
+import { DEFAULT_CACHE_TTL_MS } from "../config/constants.js";
 /**
  * Schema cache with TTL support
  * Key format: `{nodeTypeId}:{instanceId}` or `{nodeTypeId}` for type-level caching
@@ -30,13 +30,13 @@ const DEFAULT_CACHE_TTL = DEFAULT_CACHE_TTL_MS;
  * ```
  */
 function resolveVariablePath(context, path) {
-    const parts = path.split('.');
+    const parts = path.split(".");
     let current = context;
     for (const part of parts) {
         if (current === null || current === undefined) {
             return undefined;
         }
-        if (typeof current === 'object' && part in current) {
+        if (typeof current === "object" && part in current) {
             current = current[part];
         }
         else {
@@ -77,7 +77,7 @@ function resolveTemplate(template, parameterMapping, context) {
         const value = resolveVariablePath(context, contextPath);
         if (value !== undefined) {
             // Use global regex to replace all occurrences
-            const regex = new RegExp(`\\{${variableName}\\}`, 'g');
+            const regex = new RegExp(`\\{${variableName}\\}`, "g");
             resolved = resolved.replace(regex, encodeURIComponent(value));
         }
     }
@@ -145,7 +145,7 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
         metadata: node.data.metadata,
         config: node.data.config,
         extensions: node.data.extensions,
-        workflowId
+        workflowId,
     };
     // Generate cache key
     const cacheKey = generateCacheKey(endpoint, context);
@@ -156,39 +156,41 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
             return {
                 success: true,
                 schema: cached.schema,
-                fromCache: true
+                fromCache: true,
             };
         }
     }
     // Resolve the URL with template variables
     let url = resolveTemplate(endpoint.url, endpoint.parameterMapping, context);
     // If URL is relative, try to prepend base URL from endpoint config
-    if (url.startsWith('/')) {
+    if (url.startsWith("/")) {
         const currentConfig = getEndpointConfig();
         if (currentConfig?.baseUrl) {
             // Remove trailing slash from base URL and leading slash from relative URL
-            const baseUrl = currentConfig.baseUrl.replace(/\/$/, '');
+            const baseUrl = currentConfig.baseUrl.replace(/\/$/, "");
             url = `${baseUrl}${url}`;
         }
     }
     // Prepare request options
-    const method = endpoint.method ?? 'GET';
+    const method = endpoint.method ?? "GET";
     const timeout = endpoint.timeout ?? 10000;
     const headers = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-        ...endpoint.headers
+        Accept: "application/json",
+        "Content-Type": "application/json",
+        ...endpoint.headers,
     };
     // Add auth headers from endpoint config if available
     const currentConfig = getEndpointConfig();
     if (currentConfig?.auth) {
-        if (currentConfig.auth.type === 'bearer' && currentConfig.auth.token) {
-            headers['Authorization'] = `Bearer ${currentConfig.auth.token}`;
+        if (currentConfig.auth.type === "bearer" && currentConfig.auth.token) {
+            headers["Authorization"] = `Bearer ${currentConfig.auth.token}`;
         }
-        else if (currentConfig.auth.type === 'api_key' && currentConfig.auth.apiKey) {
-            headers['X-API-Key'] = currentConfig.auth.apiKey;
+        else if (currentConfig.auth.type === "api_key" &&
+            currentConfig.auth.apiKey) {
+            headers["X-API-Key"] = currentConfig.auth.apiKey;
         }
-        else if (currentConfig.auth.type === 'custom' && currentConfig.auth.headers) {
+        else if (currentConfig.auth.type === "custom" &&
+            currentConfig.auth.headers) {
             Object.assign(headers, currentConfig.auth.headers);
         }
     }
@@ -196,14 +198,14 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
     const fetchOptions = {
         method,
         headers,
-        signal: AbortSignal.timeout(timeout)
+        signal: AbortSignal.timeout(timeout),
     };
     // Add body for non-GET requests
-    if (method !== 'GET' && endpoint.body) {
+    if (method !== "GET" && endpoint.body) {
         // Resolve any template variables in the body
         const resolvedBody = {};
         for (const [key, value] of Object.entries(endpoint.body)) {
-            if (typeof value === 'string') {
+            if (typeof value === "string") {
                 resolvedBody[key] = resolveTemplate(value, endpoint.parameterMapping, context);
             }
             else {
@@ -218,7 +220,7 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
             const errorText = await response.text();
             return {
                 success: false,
-                error: `HTTP ${response.status}: ${errorText || response.statusText}`
+                error: `HTTP ${response.status}: ${errorText || response.statusText}`,
             };
         }
         const data = await response.json();
@@ -227,26 +229,26 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
         // 2. Wrapped in { data: ConfigSchema } or { schema: ConfigSchema }
         // 3. Wrapped in { success: true, data: ConfigSchema }
         let schema;
-        if (data.type === 'object' && data.properties) {
+        if (data.type === "object" && data.properties) {
             // Direct ConfigSchema
             schema = data;
         }
-        else if (data.data?.type === 'object' && data.data?.properties) {
+        else if (data.data?.type === "object" && data.data?.properties) {
             // Wrapped in { data: ... }
             schema = data.data;
         }
-        else if (data.schema?.type === 'object' && data.schema?.properties) {
+        else if (data.schema?.type === "object" && data.schema?.properties) {
             // Wrapped in { schema: ... }
             schema = data.schema;
         }
-        else if (data.success && data.data?.type === 'object') {
+        else if (data.success && data.data?.type === "object") {
             // Wrapped in { success: true, data: ... }
             schema = data.data;
         }
         if (!schema) {
             return {
                 success: false,
-                error: 'Invalid schema format received from endpoint'
+                error: "Invalid schema format received from endpoint",
             };
         }
         // Cache the schema (if caching is enabled)
@@ -254,32 +256,32 @@ export async function fetchDynamicSchema(endpoint, node, workflowId) {
             schemaCache.set(cacheKey, {
                 schema,
                 cachedAt: Date.now(),
-                cacheKey
+                cacheKey,
             });
         }
         return {
             success: true,
             schema,
-            fromCache: false
+            fromCache: false,
         };
     }
     catch (error) {
         // Handle specific error types
         if (error instanceof Error) {
-            if (error.name === 'AbortError' || error.name === 'TimeoutError') {
+            if (error.name === "AbortError" || error.name === "TimeoutError") {
                 return {
                     success: false,
-                    error: `Request timed out after ${timeout}ms`
+                    error: `Request timed out after ${timeout}ms`,
                 };
             }
             return {
                 success: false,
-                error: error.message
+                error: error.message,
             };
         }
         return {
             success: false,
-            error: 'Unknown error occurred while fetching schema'
+            error: "Unknown error occurred while fetching schema",
         };
     }
 }
@@ -311,13 +313,13 @@ export function resolveExternalEditUrl(link, node, workflowId, callbackUrl) {
         metadata: node.data.metadata,
         config: node.data.config,
         extensions: node.data.extensions,
-        workflowId
+        workflowId,
     };
     // Resolve the URL with template variables
     let url = resolveTemplate(link.url, link.parameterMapping, context);
     // Append callback URL if configured
     if (callbackUrl && link.callbackUrlParam) {
-        const separator = url.includes('?') ? '&' : '?';
+        const separator = url.includes("?") ? "&" : "?";
         url = `${url}${separator}${link.callbackUrlParam}=${encodeURIComponent(callbackUrl)}`;
     }
     return url;
@@ -351,16 +353,16 @@ export function getEffectiveConfigEditOptions(node) {
         externalEditLink: (instanceConfig.externalEditLink ?? typeConfig.externalEditLink)
             ? {
                 ...(typeConfig.externalEditLink ?? {}),
-                ...(instanceConfig.externalEditLink ?? {})
+                ...(instanceConfig.externalEditLink ?? {}),
             }
             : undefined,
         // Deep merge dynamic schema
         dynamicSchema: (instanceConfig.dynamicSchema ?? typeConfig.dynamicSchema)
             ? {
                 ...(typeConfig.dynamicSchema ?? {}),
-                ...(instanceConfig.dynamicSchema ?? {})
+                ...(instanceConfig.dynamicSchema ?? {}),
             }
-            : undefined
+            : undefined,
     };
 }
 /**
@@ -393,7 +395,7 @@ export function invalidateSchemaCache(node, endpoint) {
         type: node.type,
         metadata: node.data.metadata,
         config: node.data.config,
-        extensions: node.data.extensions
+        extensions: node.data.extensions,
     };
     const cacheKey = generateCacheKey(endpoint, context);
     schemaCache.delete(cacheKey);