@flowdrop/flowdrop 1.0.0

package/dist/types/auth.d.ts

@@ -0,0 +1,263 @@
+/**
+ * Authentication Provider Types for FlowDrop
+ *
+ * Provides interfaces and implementations for authentication in FlowDrop.
+ * AuthProvider is passed at mount time and cannot be changed without remounting.
+ *
+ * @module types/auth
+ */
+/**
+ * Authentication provider interface
+ *
+ * Defines the contract for authentication providers that can be passed to FlowDrop.
+ * Implementations handle token retrieval, authentication state, and error handling.
+ *
+ * @example
+ * ```typescript
+ * const authProvider: AuthProvider = {
+ *   getAuthHeaders: async () => ({ Authorization: "Bearer token123" }),
+ *   isAuthenticated: () => true
+ * };
+ * ```
+ */
+export interface AuthProvider {
+    /**
+     * Get current authentication headers
+     *
+     * Called before every API request to retrieve current auth headers.
+     * Should return fresh headers each time (e.g., after token refresh).
+     *
+     * @returns Promise resolving to a record of header name-value pairs
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Check if currently authenticated
+     *
+     * Used to determine if API requests should be attempted.
+     * Should return synchronously for performance.
+     *
+     * @returns true if authenticated, false otherwise
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Called when API returns 401 Unauthorized
+     *
+     * Allows the provider to attempt token refresh or re-authentication.
+     * If this returns true, the failed request will be retried with new headers.
+     *
+     * @returns Promise resolving to true if auth was refreshed and request should retry
+     */
+    onUnauthorized?(): Promise<boolean>;
+    /**
+     * Called when API returns 403 Forbidden
+     *
+     * Allows the provider to handle permission errors (e.g., show error UI).
+     * Unlike 401, this typically means the user is authenticated but lacks permission.
+     */
+    onForbidden?(): Promise<void>;
+}
+/**
+ * Configuration for static authentication
+ *
+ * Used to configure StaticAuthProvider with different auth types.
+ */
+export interface StaticAuthConfig {
+    /** Authentication type */
+    type: 'none' | 'bearer' | 'api_key' | 'custom';
+    /** Bearer token (used when type is "bearer") */
+    token?: string;
+    /** API key (used when type is "api_key") */
+    apiKey?: string;
+    /** Custom headers (used when type is "custom") */
+    headers?: Record<string, string>;
+}
+/**
+ * Static authentication provider
+ *
+ * Provides authentication using static credentials configured at instantiation.
+ * Suitable for simple use cases where tokens don't change during the session.
+ * Also used internally for backward compatibility with existing endpointConfig.auth.
+ *
+ * @example
+ * ```typescript
+ * // Bearer token authentication
+ * const authProvider = new StaticAuthProvider({
+ *   type: "bearer",
+ *   token: "your-jwt-token"
+ * });
+ *
+ * // API key authentication
+ * const authProvider = new StaticAuthProvider({
+ *   type: "api_key",
+ *   apiKey: "your-api-key"
+ * });
+ *
+ * // Custom headers
+ * const authProvider = new StaticAuthProvider({
+ *   type: "custom",
+ *   headers: {
+ *     "X-Custom-Auth": "value",
+ *     "X-Tenant-ID": "tenant123"
+ *   }
+ * });
+ * ```
+ */
+export declare class StaticAuthProvider implements AuthProvider {
+    /** Cached authentication headers */
+    private headers;
+    /**
+     * Create a new StaticAuthProvider
+     *
+     * @param config - Static authentication configuration
+     */
+    constructor(config: StaticAuthConfig);
+    /**
+     * Get authentication headers
+     *
+     * Returns the statically configured headers.
+     *
+     * @returns Promise resolving to authentication headers
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Check if authenticated
+     *
+     * Returns true if any auth headers are configured.
+     *
+     * @returns true if headers are configured
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Handle unauthorized response
+     *
+     * Static provider cannot refresh tokens, so always returns false.
+     *
+     * @returns Promise resolving to false (cannot refresh)
+     */
+    onUnauthorized(): Promise<boolean>;
+    /**
+     * Handle forbidden response
+     *
+     * Static provider has no special handling for 403.
+     */
+    onForbidden(): Promise<void>;
+}
+/**
+ * Configuration for callback-based authentication
+ *
+ * Used to configure CallbackAuthProvider with dynamic token retrieval.
+ */
+export interface CallbackAuthConfig {
+    /**
+     * Function to get the current access token
+     *
+     * Called before each API request to get a fresh token.
+     * Should return null if not authenticated.
+     */
+    getToken: () => Promise<string | null>;
+    /**
+     * Optional callback when 401 Unauthorized is received
+     *
+     * Can be used to trigger token refresh.
+     *
+     * @returns Promise resolving to true if token was refreshed successfully
+     */
+    onUnauthorized?: () => Promise<boolean>;
+    /**
+     * Optional callback when 403 Forbidden is received
+     *
+     * Can be used to show permission error UI.
+     */
+    onForbidden?: () => Promise<void>;
+}
+/**
+ * Callback-based authentication provider
+ *
+ * Provides authentication using callback functions for dynamic token retrieval.
+ * Ideal for enterprise integrations where the parent application manages auth.
+ *
+ * @example
+ * ```typescript
+ * const authProvider = new CallbackAuthProvider({
+ *   getToken: async () => {
+ *     return authService.getAccessToken();
+ *   },
+ *   onUnauthorized: async () => {
+ *     const refreshed = await authService.refreshToken();
+ *     return refreshed;
+ *   },
+ *   onForbidden: async () => {
+ *     showError("You don't have permission to access this resource");
+ *   }
+ * });
+ * ```
+ */
+export declare class CallbackAuthProvider implements AuthProvider {
+    /** Function to get the current token */
+    private getToken;
+    /** Optional unauthorized callback */
+    private onUnauthorizedCallback?;
+    /** Optional forbidden callback */
+    private onForbiddenCallback?;
+    /**
+     * Create a new CallbackAuthProvider
+     *
+     * @param config - Callback authentication configuration
+     */
+    constructor(config: CallbackAuthConfig);
+    /**
+     * Get authentication headers
+     *
+     * Calls the getToken callback to retrieve the current token.
+     *
+     * @returns Promise resolving to authentication headers
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Check if authenticated
+     *
+     * For callback-based auth, we assume authenticated if getToken exists.
+     * The actual token validity is checked when making requests.
+     *
+     * @returns true (assumes authenticated, actual check happens on request)
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Handle unauthorized response
+     *
+     * Calls the onUnauthorized callback if provided.
+     *
+     * @returns Promise resolving to true if auth was refreshed
+     */
+    onUnauthorized(): Promise<boolean>;
+    /**
+     * Handle forbidden response
+     *
+     * Calls the onForbidden callback if provided.
+     */
+    onForbidden(): Promise<void>;
+}
+/**
+ * No-op authentication provider
+ *
+ * Used when no authentication is required.
+ * Provides empty headers and always returns not authenticated.
+ */
+export declare class NoAuthProvider implements AuthProvider {
+    /**
+     * Get authentication headers
+     *
+     * Returns empty headers (no auth).
+     *
+     * @returns Promise resolving to empty object
+     */
+    getAuthHeaders(): Promise<Record<string, string>>;
+    /**
+     * Check if authenticated
+     *
+     * Always returns false (no auth configured).
+     *
+     * @returns false
+     */
+    isAuthenticated(): boolean;
+}

package/dist/types/auth.js

@@ -0,0 +1,229 @@
+/**
+ * Authentication Provider Types for FlowDrop
+ *
+ * Provides interfaces and implementations for authentication in FlowDrop.
+ * AuthProvider is passed at mount time and cannot be changed without remounting.
+ *
+ * @module types/auth
+ */
+/**
+ * Static authentication provider
+ *
+ * Provides authentication using static credentials configured at instantiation.
+ * Suitable for simple use cases where tokens don't change during the session.
+ * Also used internally for backward compatibility with existing endpointConfig.auth.
+ *
+ * @example
+ * ```typescript
+ * // Bearer token authentication
+ * const authProvider = new StaticAuthProvider({
+ *   type: "bearer",
+ *   token: "your-jwt-token"
+ * });
+ *
+ * // API key authentication
+ * const authProvider = new StaticAuthProvider({
+ *   type: "api_key",
+ *   apiKey: "your-api-key"
+ * });
+ *
+ * // Custom headers
+ * const authProvider = new StaticAuthProvider({
+ *   type: "custom",
+ *   headers: {
+ *     "X-Custom-Auth": "value",
+ *     "X-Tenant-ID": "tenant123"
+ *   }
+ * });
+ * ```
+ */
+export class StaticAuthProvider {
+    /** Cached authentication headers */
+    headers;
+    /**
+     * Create a new StaticAuthProvider
+     *
+     * @param config - Static authentication configuration
+     */
+    constructor(config) {
+        this.headers = {};
+        switch (config.type) {
+            case 'bearer':
+                if (config.token) {
+                    this.headers['Authorization'] = `Bearer ${config.token}`;
+                }
+                break;
+            case 'api_key':
+                if (config.apiKey) {
+                    this.headers['X-API-Key'] = config.apiKey;
+                }
+                break;
+            case 'custom':
+                if (config.headers) {
+                    this.headers = { ...config.headers };
+                }
+                break;
+            case 'none':
+            default:
+                // No headers needed
+                break;
+        }
+    }
+    /**
+     * Get authentication headers
+     *
+     * Returns the statically configured headers.
+     *
+     * @returns Promise resolving to authentication headers
+     */
+    async getAuthHeaders() {
+        return this.headers;
+    }
+    /**
+     * Check if authenticated
+     *
+     * Returns true if any auth headers are configured.
+     *
+     * @returns true if headers are configured
+     */
+    isAuthenticated() {
+        return Object.keys(this.headers).length > 0;
+    }
+    /**
+     * Handle unauthorized response
+     *
+     * Static provider cannot refresh tokens, so always returns false.
+     *
+     * @returns Promise resolving to false (cannot refresh)
+     */
+    async onUnauthorized() {
+        // Static provider cannot refresh tokens
+        return false;
+    }
+    /**
+     * Handle forbidden response
+     *
+     * Static provider has no special handling for 403.
+     */
+    async onForbidden() {
+        // No special handling for static provider
+    }
+}
+/**
+ * Callback-based authentication provider
+ *
+ * Provides authentication using callback functions for dynamic token retrieval.
+ * Ideal for enterprise integrations where the parent application manages auth.
+ *
+ * @example
+ * ```typescript
+ * const authProvider = new CallbackAuthProvider({
+ *   getToken: async () => {
+ *     return authService.getAccessToken();
+ *   },
+ *   onUnauthorized: async () => {
+ *     const refreshed = await authService.refreshToken();
+ *     return refreshed;
+ *   },
+ *   onForbidden: async () => {
+ *     showError("You don't have permission to access this resource");
+ *   }
+ * });
+ * ```
+ */
+export class CallbackAuthProvider {
+    /** Function to get the current token */
+    getToken;
+    /** Optional unauthorized callback */
+    onUnauthorizedCallback;
+    /** Optional forbidden callback */
+    onForbiddenCallback;
+    /**
+     * Create a new CallbackAuthProvider
+     *
+     * @param config - Callback authentication configuration
+     */
+    constructor(config) {
+        this.getToken = config.getToken;
+        this.onUnauthorizedCallback = config.onUnauthorized;
+        this.onForbiddenCallback = config.onForbidden;
+    }
+    /**
+     * Get authentication headers
+     *
+     * Calls the getToken callback to retrieve the current token.
+     *
+     * @returns Promise resolving to authentication headers
+     */
+    async getAuthHeaders() {
+        const token = await this.getToken();
+        if (token) {
+            return { Authorization: `Bearer ${token}` };
+        }
+        return {};
+    }
+    /**
+     * Check if authenticated
+     *
+     * For callback-based auth, we assume authenticated if getToken exists.
+     * The actual token validity is checked when making requests.
+     *
+     * @returns true (assumes authenticated, actual check happens on request)
+     */
+    isAuthenticated() {
+        // For callback-based auth, we assume authenticated if getToken exists
+        // The actual token validity is checked when making requests
+        return true;
+    }
+    /**
+     * Handle unauthorized response
+     *
+     * Calls the onUnauthorized callback if provided.
+     *
+     * @returns Promise resolving to true if auth was refreshed
+     */
+    async onUnauthorized() {
+        if (this.onUnauthorizedCallback) {
+            return this.onUnauthorizedCallback();
+        }
+        return false;
+    }
+    /**
+     * Handle forbidden response
+     *
+     * Calls the onForbidden callback if provided.
+     */
+    async onForbidden() {
+        if (this.onForbiddenCallback) {
+            await this.onForbiddenCallback();
+        }
+    }
+}
+/**
+ * No-op authentication provider
+ *
+ * Used when no authentication is required.
+ * Provides empty headers and always returns not authenticated.
+ */
+export class NoAuthProvider {
+    /**
+     * Get authentication headers
+     *
+     * Returns empty headers (no auth).
+     *
+     * @returns Promise resolving to empty object
+     */
+    async getAuthHeaders() {
+        return {};
+    }
+    /**
+     * Check if authenticated
+     *
+     * Always returns false (no auth configured).
+     *
+     * @returns false
+     */
+    isAuthenticated() {
+        return false;
+    }
+}

package/dist/types/config.d.ts

@@ -0,0 +1,151 @@
+/**
+ * FlowDrop Editor Configuration Types
+ *
+ * This module contains configuration-specific types for the workflow editor.
+ * For core workflow types (WorkflowNode, WorkflowEdge, etc.), see ./index.ts
+ */
+import type { EndpointConfig } from '../config/endpoints.js';
+import type { PortConfig, NodeMetadata } from './index.js';
+/**
+ * Re-export core types from index.ts for convenience
+ * This allows consumers to import from either location
+ */
+export type { WorkflowNode, WorkflowEdge, NodePort, ExecutionResult, NodeMetadata } from './index.js';
+export interface WorkflowEditorConfig {
+    /** API configuration with endpoints */
+    api: APIConfig;
+    /** Available node types loaded from API (uses NodeMetadata from index.ts) */
+    nodeTypes?: NodeMetadata[];
+    /** Port configuration system */
+    ports: PortConfig;
+    /** Theme configuration */
+    theme: 'light' | 'dark' | 'auto';
+    /** Editor features configuration */
+    features: EditorFeatures;
+    /** UI customization options */
+    ui: UIConfig;
+    /** Execution configuration */
+    execution: ExecutionConfig;
+    /** Storage configuration */
+    storage: StorageConfig;
+}
+export interface EditorFeatures {
+    /** Enable drag and drop functionality */
+    dragAndDrop: boolean;
+    /** Enable node editing */
+    nodeEditing: boolean;
+    /** Enable workflow execution */
+    execution: boolean;
+    /** Enable workflow saving */
+    saveWorkflow: boolean;
+    /** Enable workflow loading */
+    loadWorkflow: boolean;
+    /** Enable undo/redo */
+    undoRedo: boolean;
+    /** Enable node search */
+    nodeSearch: boolean;
+    /** Enable node categories */
+    nodeCategories: boolean;
+    /** Enable node validation */
+    nodeValidation: boolean;
+    /** Enable real-time collaboration */
+    collaboration: boolean;
+    /** Enable workflow templates */
+    templates: boolean;
+    /** Enable workflow import/export */
+    importExport: boolean;
+}
+export interface UIConfig {
+    /** Show node sidebar */
+    showSidebar: boolean;
+    /** Show toolbar */
+    showToolbar: boolean;
+    /** Show minimap */
+    showMinimap: boolean;
+    /** Show grid */
+    showGrid: boolean;
+    /** Grid size */
+    gridSize: number;
+    /** Node spacing */
+    nodeSpacing: number;
+    /** Canvas padding */
+    canvasPadding: number;
+    /** Navbar height in pixels (configurable at runtime) */
+    navbarHeight: number;
+    /** Zoom limits */
+    zoom: {
+        min: number;
+        max: number;
+        default: number;
+    };
+    /** Node colors */
+    colors: {
+        primary: string;
+        secondary: string;
+        accent: string;
+        background: string;
+        text: string;
+    };
+    /** Custom CSS classes */
+    cssClasses: {
+        container?: string;
+        sidebar?: string;
+        toolbar?: string;
+        canvas?: string;
+        node?: string;
+    };
+}
+export interface APIConfig {
+    /** Endpoint configuration */
+    endpoints: EndpointConfig;
+    /** API timeout in milliseconds */
+    timeout: number;
+    /** Retry configuration */
+    retry: {
+        enabled: boolean;
+        maxAttempts: number;
+        delay: number;
+    };
+    /** Authentication configuration */
+    auth: {
+        type: 'none' | 'bearer' | 'api_key' | 'custom';
+        token?: string;
+        apiKey?: string;
+        headers?: Record<string, string>;
+    };
+    /** Custom headers */
+    headers: Record<string, string>;
+}
+export interface ExecutionConfig {
+    /** Enable real-time execution updates */
+    realTimeUpdates: boolean;
+    /** Execution timeout in seconds */
+    timeout: number;
+    /** Maximum concurrent executions */
+    maxConcurrent: number;
+    /** Show execution progress */
+    showProgress: boolean;
+    /** Auto-save execution state */
+    autoSaveState: boolean;
+    /** Execution result caching */
+    caching: {
+        enabled: boolean;
+        ttl: number;
+    };
+}
+export interface StorageConfig {
+    /** Storage type */
+    type: 'api' | 'local' | 'session' | 'custom';
+    /** Auto-save interval in milliseconds */
+    autoSaveInterval: number;
+    /** Maximum undo steps */
+    maxUndoSteps: number;
+    /** Storage key prefix */
+    keyPrefix: string;
+    /** Custom storage implementation */
+    customStorage?: {
+        save: (key: string, data: unknown) => Promise<void>;
+        load: (key: string) => Promise<unknown>;
+        delete: (key: string) => Promise<void>;
+    };
+}

package/dist/types/config.js

@@ -0,0 +1,7 @@
+/**
+ * FlowDrop Editor Configuration Types
+ *
+ * This module contains configuration-specific types for the workflow editor.
+ * For core workflow types (WorkflowNode, WorkflowEdge, etc.), see ./index.ts
+ */
+export {};