chat-flow-ardymalihi 1.0.2 → 3.0.2

package/dist/src/adapters/repository/SupabaseRepository.js

@@ -0,0 +1,774 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabaseRepository = void 0;
+const supabase_js_1 = require("@supabase/supabase-js");
+const lru_cache_1 = require("lru-cache");
+const ConversationSession_1 = require("../../core/entities/ConversationSession");
+const encryption_helpers_1 = require("../../utils/encryption-helpers");
+const DEFAULT_CACHE_TTL_SECONDS = 120; // 2 minutes
+class SupabaseRepository {
+    constructor(config) {
+        this.supabase = (0, supabase_js_1.createClient)(config.supabaseUrl, config.supabaseKey);
+        this.CACHE_TTL_MS = (config.cacheTtlSeconds || DEFAULT_CACHE_TTL_SECONDS) * 1000;
+        this.cache = new lru_cache_1.LRUCache({
+            max: 500, // Max 500 items in memory
+            ttl: this.CACHE_TTL_MS,
+            allowStale: false,
+        });
+        console.log(`[SupabaseRepository] Initialized with Cache TTL: ${this.CACHE_TTL_MS / 1000} s`);
+    }
+    getCacheKey(type, id) {
+        return `${type}:${id} `;
+    }
+    // ============================================================================
+    // Session Management (Write Heavy - Limited Caching)
+    // ============================================================================
+    async saveSession(session) {
+        const snapshot = session.toSnapshot();
+        const { error } = await this.supabase
+            .from('chat_flow_sessions')
+            .upsert({
+            session_id: session.sessionId,
+            user_id: session.userId || null, // null for global if uuid
+            config_id: session.configId,
+            data: (0, encryption_helpers_1.encryptJSON)(snapshot), // Store full snapshot in JSONB
+            status: session.status,
+            updated_at: new Date().toISOString()
+        }, { onConflict: 'session_id' });
+        if (error) {
+            console.error('[Supabase] Failed to save session:', error);
+            throw new Error(`Failed to save session: ${error.message} `);
+        }
+    }
+    async findSessionById(sessionId) {
+        const { data, error } = await this.supabase
+            .from('chat_flow_sessions')
+            .select('data')
+            .eq('session_id', sessionId)
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116')
+                return null; // Not found code
+            console.error('[Supabase] Failed to find session:', error);
+            return null;
+        }
+        if (!data || !data.data)
+            return null;
+        try {
+            const decryptedData = (0, encryption_helpers_1.decryptJSON)(data.data);
+            return ConversationSession_1.ConversationSession.reconstitute(decryptedData);
+        }
+        catch (err) {
+            console.error(`Failed to reconstitute session ${sessionId} `, err);
+            return null;
+        }
+    }
+    async getAllSessions(userId, limit = 50, offset = 0) {
+        // Get Total
+        const countRes = await this.supabase
+            .from('chat_flow_sessions')
+            .select('*', { count: 'exact', head: true })
+            .eq('user_id', userId);
+        const total = countRes.count || 0;
+        // Get Data
+        const { data, error } = await this.supabase
+            .from('chat_flow_sessions')
+            .select('data')
+            .eq('user_id', userId)
+            .order('updated_at', { ascending: false })
+            .range(offset, offset + limit - 1);
+        if (error) {
+            console.error('[Supabase] Failed to list sessions:', error);
+            return { sessions: [], total: 0 };
+        }
+        const sessions = (data || [])
+            .map((row) => {
+            try {
+                return ConversationSession_1.ConversationSession.reconstitute(row.data);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((s) => s !== null);
+        return { sessions, total };
+    }
+    // ============================================================================
+    // User & Config Management (Read Heavy - Unbounded Time Caching)
+    // ============================================================================
+    async findUserById(id) {
+        const cacheKey = this.getCacheKey('user', id);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase.auth.admin.getUserById(id);
+        if (error || !data || !data.user) {
+            console.error('[SupabaseRepository] findUserById failed:', error);
+            return null;
+        }
+        const u = data.user;
+        const user = {
+            id: u.id,
+            name: u.user_metadata?.name || u.user_metadata?.full_name || 'Unknown',
+            apiKey: u.user_metadata?.api_key || '',
+            metadata: u.user_metadata || {}
+        };
+        this.cache.set(cacheKey, user);
+        return user;
+    }
+    async saveConversationConfig(config) {
+        const { error } = await this.supabase
+            .from('chat_flow_configs')
+            .upsert({
+            id: config.id,
+            user_id: config.userId,
+            system_prompt: config.systemPrompt,
+            voice_config: config.voiceConfig,
+            allowed_intents: config.allowedIntents,
+            allowed_origins: config.allowedOrigins,
+            metadata: config.metadata,
+            ui_config: config.uiConfig,
+            blacklisted_words: config.blacklistedWords,
+            exit_phrases: config.exitPhrases,
+            multi_lingual_mode: config.multiLingualMode,
+            default_language: config.defaultLanguage,
+            supported_languages: config.supportedLanguages,
+            language_voice_mapping: config.languageVoiceMapping,
+            webhook: config.webhook
+        });
+        if (error)
+            throw new Error(error.message);
+        this.cache.delete(this.getCacheKey('config', config.id));
+        this.cache.delete(this.getCacheKey('configs', config.userId));
+    }
+    async findConversationConfig(userId, configId) {
+        // If configId provided, fetch precise
+        if (configId) {
+            const cacheKey = this.getCacheKey('config', configId);
+            if (this.cache.has(cacheKey))
+                return this.cache.get(cacheKey);
+            const { data, error } = await this.supabase
+                .from('chat_flow_configs')
+                .select('*')
+                .eq('id', configId)
+                .eq('user_id', userId)
+                .single();
+            if (error || !data)
+                return null;
+            const config = this.mapConfig(data);
+            this.cache.set(cacheKey, config);
+            return config;
+        }
+        // Use getAll to find first if no ID
+        const all = await this.getAllConversationConfigs(userId);
+        return all.length > 0 ? all[0] : null;
+    }
+    async getAllConversationConfigs(userId) {
+        const cacheKey = this.getCacheKey('configs', userId);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase
+            .from('chat_flow_configs')
+            .select('*')
+            .eq('user_id', userId);
+        if (error)
+            return [];
+        const configs = data.map(this.mapConfig);
+        this.cache.set(cacheKey, configs);
+        return configs;
+    }
+    mapConfig(data) {
+        return {
+            id: data.id,
+            userId: data.user_id,
+            systemPrompt: data.system_prompt,
+            voiceConfig: data.voice_config,
+            allowedIntents: data.allowed_intents,
+            allowedOrigins: data.allowed_origins,
+            metadata: data.metadata,
+            uiConfig: data.ui_config,
+            blacklistedWords: data.blacklisted_words,
+            exitPhrases: data.exit_phrases,
+            multiLingualMode: data.multi_lingual_mode,
+            defaultLanguage: data.default_language,
+            supportedLanguages: data.supported_languages,
+            languageVoiceMapping: data.language_voice_mapping,
+            webhook: data.webhook
+        };
+    }
+    // ============================================================================
+    // Intent Management
+    // ============================================================================
+    async saveIntent(intent) {
+        const userId = intent.userId;
+        const { error } = await this.supabase
+            .from('chat_flow_intents')
+            .upsert({
+            name: intent.name,
+            user_id: userId,
+            description: intent.description,
+            required_fields: intent.required_fields,
+            optional_fields: intent.optional_fields,
+            processing_messages: intent.processingMessages,
+            skip_workflow: intent.skipWorkflow
+        }, { onConflict: 'name, user_id' }); // Assuming composite key
+        if (error)
+            throw new Error(error.message);
+        if (userId) {
+            this.cache.delete(this.getCacheKey('intents', userId));
+            this.cache.delete(this.getCacheKey('intent', `${userId}:${intent.name} `));
+        }
+    }
+    async upsertIntents(intents) {
+        // Not atomic in Supabase client for unrelated rows easily, loop is fine
+        for (const intent of intents) {
+            await this.saveIntent(intent);
+        }
+    }
+    async findIntentByName(name, userId) {
+        if (!userId)
+            return null;
+        const cacheKey = this.getCacheKey('intent', `${userId}:${name} `);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data } = await this.supabase
+            .from('chat_flow_intents')
+            .select('*')
+            .eq('name', name)
+            .eq('user_id', userId)
+            .single();
+        if (data) {
+            const intent = this.mapIntent(data);
+            this.cache.set(cacheKey, intent);
+            return intent;
+        }
+        return null;
+    }
+    async getAllIntents(userId) {
+        if (!userId)
+            return [];
+        const cacheKey = this.getCacheKey('intents', userId);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase
+            .from('chat_flow_intents')
+            .select('*')
+            .eq('user_id', userId);
+        if (error)
+            return [];
+        const intents = data.map(d => this.mapIntent(d));
+        this.cache.set(cacheKey, intents);
+        return intents;
+    }
+    async deleteIntent(name, userId) {
+        if (!userId)
+            return;
+        await this.supabase
+            .from('chat_flow_intents')
+            .delete()
+            .eq('name', name)
+            .eq('user_id', userId);
+        this.cache.delete(this.getCacheKey('intents', userId));
+        this.cache.delete(this.getCacheKey('intent', `${userId}:${name} `));
+    }
+    mapIntent(data) {
+        return {
+            id: data.id,
+            userId: data.user_id,
+            name: data.name,
+            description: data.description,
+            required_fields: data.required_fields || [],
+            optional_fields: data.optional_fields || [],
+            processingMessages: data.processing_messages,
+            skipWorkflow: data.skip_workflow
+        };
+    }
+    // ============================================================================
+    // Workflow Management
+    // ============================================================================
+    async saveWorkflow(workflow) {
+        const userId = workflow.userId;
+        const payload = {
+            user_id: userId,
+            name: workflow.name,
+            description: workflow.description,
+            event_type: workflow.event_type,
+            definition: (0, encryption_helpers_1.encryptJSON)(workflow.definition),
+            configs: (0, encryption_helpers_1.encryptJSON)(workflow.configs),
+            is_active: workflow.is_active,
+            updated_at: new Date().toISOString(),
+            viewport: workflow.viewport,
+            priority: workflow.priority || 100
+        };
+        // If ID is provided (update or seed), include it
+        if (workflow.id) {
+            payload.id = workflow.id;
+        }
+        // Use UPSERT: This handles both "Update Existing" and "Insert New with specified ID"
+        // This fixes the issue where seeding with a UUID failed because UPDATE found 0 rows.
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflows')
+            .upsert(payload, { onConflict: 'id' })
+            .select('id')
+            .single();
+        if (error) {
+            console.error('[Supabase] Save workflow failed:', error);
+            throw new Error(error.message);
+        }
+        const resultId = data.id;
+        // Separate handling for Cron Configs (Separate Table)
+        // Strategy: Delete existing config for this workflow and insert new if present
+        if (workflow.workflow_cron_configs) {
+            await this.supabase
+                .from('chat_flow_workflow_cron_configs')
+                .delete()
+                .eq('workflow_id', resultId);
+            const cronEntries = Array.isArray(workflow.workflow_cron_configs)
+                ? workflow.workflow_cron_configs
+                : [workflow.workflow_cron_configs];
+            // Filter out empty/invalid configs
+            const validCronEntries = cronEntries.filter(c => c && c.cron_schedule);
+            if (validCronEntries.length > 0) {
+                const cronPayloads = validCronEntries.map(c => ({
+                    workflow_id: resultId,
+                    user_id: userId,
+                    cron_schedule: c.cron_schedule,
+                    next_run_at: c.next_run_at || new Date().toISOString()
+                }));
+                const { error: cronError } = await this.supabase
+                    .from('chat_flow_workflow_cron_configs')
+                    .insert(cronPayloads);
+                if (cronError)
+                    console.error('[Supabase] Failed to save cron configs:', cronError);
+            }
+        }
+        if (userId) {
+            // Invalidate Caches
+            this.cache.delete(this.getCacheKey('workflow', `${userId}:${resultId} `));
+            this.cache.delete(this.getCacheKey('workflows', userId));
+            // Also invalidate event-specific cache. 
+            // Note: Cache key logic in getActiveWorkflowsForEvent is `workflows:${userId}:${eventType}`
+            // But getCacheKey('workflows:event', ...) isn't standard.
+            // Let's manually reconstruct the key used in getActiveWorkflowsForEvent:
+            this.cache.delete(this.getCacheKey('workflows', `${userId}:${workflow.event_type}`));
+        }
+        return resultId;
+    }
+    async findWorkflowById(id, userId) {
+        if (!userId)
+            return null;
+        const cacheKey = this.getCacheKey('workflow', `${userId}:${id} `);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflows')
+            .select(`
+    *,
+    workflow_cron_configs: chat_flow_workflow_cron_configs(*)
+        `) // Join cron configs
+            .eq('id', id)
+            .eq('user_id', userId)
+            .single();
+        if (error || !data)
+            return null;
+        const workflow = this.mapWorkflow(data);
+        this.cache.set(cacheKey, workflow);
+        return workflow;
+    }
+    async getAllWorkflows(userId) {
+        if (!userId)
+            return [];
+        const cacheKey = this.getCacheKey('workflows', userId);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflows')
+            .select(`
+        *,
+        workflow_cron_configs: chat_flow_workflow_cron_configs(*)
+            `)
+            .eq('user_id', userId);
+        if (error)
+            return [];
+        const workflows = data.map(this.mapWorkflow);
+        this.cache.set(cacheKey, workflows);
+        return workflows;
+    }
+    async getActiveWorkflowsForEvent(userId, eventType) {
+        if (!userId)
+            return [];
+        const cacheKey = this.getCacheKey('workflows:event', `${userId}:${eventType} `);
+        if (this.cache.has(cacheKey))
+            return this.cache.get(cacheKey);
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflows')
+            .select(`
+    *,
+    workflow_cron_configs: chat_flow_workflow_cron_configs(*)
+            `)
+            .eq('user_id', userId)
+            .eq('event_type', eventType)
+            .eq('is_active', true);
+        if (error) {
+            console.error('[Supabase] Failed to fetch active workflows:', error);
+            return [];
+        }
+        const workflows = data.map(this.mapWorkflow);
+        this.cache.set(cacheKey, workflows);
+        return workflows;
+    }
+    async deleteWorkflow(id, userId) {
+        if (!userId)
+            return;
+        await this.supabase
+            .from('chat_flow_workflows')
+            .delete()
+            .eq('id', id)
+            .eq('user_id', userId);
+        this.cache.delete(this.getCacheKey('workflow', `${userId}:${id} `));
+        this.cache.delete(this.getCacheKey('workflows', userId));
+        this.cache.clear();
+    }
+    mapWorkflow(data) {
+        const cronConfig = data.workflow_cron_configs; // Now an object or array from join
+        return {
+            id: data.id.toString(),
+            userId: data.user_id,
+            name: data.name,
+            description: data.description,
+            event_type: data.event_type,
+            definition: (0, encryption_helpers_1.decryptJSON)(data.definition),
+            configs: (0, encryption_helpers_1.decryptJSON)(data.configs),
+            is_active: data.is_active,
+            created_at: data.created_at,
+            updated_at: data.updated_at,
+            viewport: data.viewport,
+            priority: data.priority,
+            workflow_cron_configs: Array.isArray(cronConfig) ? cronConfig[0] : cronConfig // Supabase joins return array usually
+        };
+    }
+    // ============================================================================
+    // Workflow Execution (Write Heavy - No Cache)
+    // ============================================================================
+    async createWorkflowExecution(execution) {
+        const userId = execution.userId;
+        if (!userId) {
+            throw new Error('createWorkflowExecution: userId is required');
+        }
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .insert({
+            user_id: userId,
+            workflow_id: execution.workflow_id,
+            event_type: execution.event_type,
+            event_payload: (0, encryption_helpers_1.encryptJSON)(execution.event_payload),
+            status: execution.status || 'pending',
+            started_at: execution.started_at || new Date().toISOString(),
+            priority: execution.priority || 0,
+        })
+            .select('id')
+            .single();
+        if (error)
+            throw new Error(error.message);
+        const newExecution = {
+            ...execution,
+            id: data.id.toString(), // Get generated ID
+            userId: userId,
+            workflow_id: execution.workflow_id || '',
+            event_type: execution.event_type || '',
+            event_payload: execution.event_payload || {},
+            status: execution.status || 'pending',
+            started_at: execution.started_at || new Date().toISOString(),
+            completed_at: null,
+            error_message: null,
+            last_failed_step_id: null,
+            step_logs: [],
+            priority: execution.priority || 0
+        };
+        return newExecution;
+    }
+    async updateWorkflowExecution(executionId, updates) {
+        const { error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .update({
+            status: updates.status,
+            completed_at: updates.completed_at,
+            error_message: updates.error_message,
+            last_failed_step_id: updates.last_failed_step_id,
+            output_result: updates.outputResult
+        })
+            .eq('id', executionId);
+        if (error)
+            console.error('[Supabase] Update execution failed', error);
+    }
+    async getWorkflowExecutionById(executionId) {
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .select('*')
+            .eq('id', executionId)
+            .single();
+        if (error || !data)
+            return null;
+        return {
+            id: data.id.toString(),
+            userId: data.user_id,
+            workflow_id: data.workflow_id,
+            event_type: data.event_type,
+            event_payload: (0, encryption_helpers_1.decryptJSON)(data.event_payload),
+            status: data.status,
+            started_at: data.started_at,
+            completed_at: data.completed_at,
+            error_message: data.error_message,
+            last_failed_step_id: data.last_failed_step_id,
+            priority: data.priority,
+            outputResult: data.output_result, // Map
+        };
+    }
+    async getWorkflowExecutionWithLogs(executionId) {
+        // Join query would be better, but simple sequential fetch for now to match interface
+        const execution = await this.getWorkflowExecutionById(executionId);
+        if (!execution)
+            throw new Error('Execution not found');
+        const logs = await this.getWorkflowExecutionLogs(executionId);
+        const workflow = await this.findWorkflowById(execution.workflow_id, execution.userId);
+        return {
+            ...execution,
+            workflow_action_logs: logs,
+            workflow: workflow
+        };
+    }
+    async getPendingWorkflowExecutions(limit) {
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .select('*')
+            .eq('status', 'pending')
+            .order('priority', { ascending: true }) // Higher priority = lower number usually? Or higher? Assuming lower is better/first.
+            // Wait, priority 0 is default. Let's assume standard queue.
+            .order('started_at', { ascending: true })
+            .limit(limit);
+        if (error)
+            return [];
+        return data.map((d) => ({
+            id: d.id.toString(),
+            userId: d.user_id,
+            workflow_id: d.workflow_id,
+            event_type: d.event_type,
+            event_payload: (0, encryption_helpers_1.decryptJSON)(d.event_payload),
+            status: d.status,
+            started_at: d.started_at,
+            completed_at: d.completed_at,
+            error_message: d.error_message,
+            priority: d.priority,
+        }));
+    }
+    async getActiveWorkflowExecutionCount(workflowId) {
+        const { count, error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .select('*', { count: 'exact', head: true })
+            .eq('workflow_id', workflowId)
+            .eq('status', 'processing'); // or pending?
+        if (error)
+            return 0;
+        return count || 0;
+    }
+    async markWorkflowExecutionFailed(executionId, error) {
+        await this.updateWorkflowExecution(executionId, {
+            status: 'failed',
+            error_message: error,
+            completed_at: new Date().toISOString()
+        });
+    }
+    async logWorkflowAction(logEntry) {
+        let resultId = logEntry.id;
+        if (resultId) {
+            // Update existing log
+            const { error } = await this.supabase
+                .from('chat_flow_action_logs')
+                .update({
+                status: logEntry.status,
+                output: (0, encryption_helpers_1.encryptJSON)(logEntry.output),
+                error_message: logEntry.error_message,
+                completed_at: logEntry.completed_at
+            })
+                .eq('id', resultId);
+            if (error) {
+                console.error('[Supabase] Log action update failed', error);
+            }
+        }
+        else {
+            // Insert new log
+            const { data, error } = await this.supabase
+                .from('chat_flow_action_logs')
+                .insert({
+                user_id: logEntry.userId || 'global',
+                execution_id: logEntry.execution_id,
+                workflow_id: logEntry.workflow_id,
+                step_id: logEntry.step_id,
+                action_type: logEntry.action_type,
+                input: (0, encryption_helpers_1.encryptJSON)(logEntry.input),
+                output: (0, encryption_helpers_1.encryptJSON)(logEntry.output),
+                status: logEntry.status,
+                error_message: logEntry.error_message,
+                started_at: logEntry.started_at || new Date().toISOString(),
+                completed_at: logEntry.completed_at
+            })
+                .select('id')
+                .single();
+            if (error) {
+                console.error('[Supabase] Log action insert failed', error);
+            }
+            else {
+                resultId = data.id.toString();
+            }
+        }
+        // Return the log entry with ID (merged)
+        return {
+            ...logEntry,
+            id: resultId?.toString(),
+        };
+    }
+    async getWorkflowExecutionLogs(executionId) {
+        const { data, error } = await this.supabase
+            .from('chat_flow_action_logs')
+            .select('*')
+            .eq('execution_id', executionId)
+            .order('started_at', { ascending: true });
+        if (error)
+            return [];
+        return data.map((d) => ({
+            id: d.id.toString(),
+            userId: d.user_id, // Map
+            execution_id: d.execution_id,
+            workflow_id: d.workflow_id,
+            step_id: d.step_id,
+            action_type: d.action_type,
+            input: (0, encryption_helpers_1.decryptJSON)(d.input),
+            output: (0, encryption_helpers_1.decryptJSON)(d.output),
+            status: d.status,
+            error_message: d.error_message,
+            started_at: d.started_at,
+            completed_at: d.completed_at
+        }));
+    }
+    // ============================================================================
+    // Webhook Events
+    // ============================================================================
+    async storeWebhookEvent(event) {
+        // ID generation in Postgres usually serial, but interface expects number return.
+        // We will insert and return 'id'.
+        const { data, error } = await this.supabase
+            .from('chat_flow_webhook_events')
+            .insert({
+            type: event.type,
+            payload: (0, encryption_helpers_1.encryptJSON)(event.payload),
+            source: event.source,
+            // user_id: event.userId, // Schema checks: 'user_id' in webhook_events?
+            // provided schema: user_id uuid
+            user_id: event.userId, // Map
+            status: event.status || 'pending',
+            created_at: event.created_at || new Date().toISOString()
+        })
+            .select('id')
+            .single();
+        if (error)
+            throw new Error(error.message);
+        return data.id;
+    }
+    async getWebhookEvent(id) {
+        const { data, error } = await this.supabase
+            .from('chat_flow_webhook_events')
+            .select('*')
+            .eq('id', id)
+            .single();
+        if (error || !data)
+            return null;
+        return {
+            id: data.id,
+            created_at: data.created_at,
+            type: data.type,
+            payload: (0, encryption_helpers_1.decryptJSON)(data.payload),
+            source: data.source,
+            userId: data.user_id, // Map
+            status: data.status,
+            error_message: data.error_message
+        };
+    }
+    async updateWebhookEventStatus(id, updates) {
+        await this.supabase
+            .from('chat_flow_webhook_events')
+            .update({
+            status: updates.status,
+            error_message: updates.error_message
+        })
+            .eq('id', id);
+    }
+    // ============================================================================
+    // Scheduler
+    // ============================================================================
+    async getDueScheduledWorkflows(now) {
+        // This requires a more complex query joining cron configs or storing next_run in a separate column/table
+        // For simplicity, assuming 'workflows' table has a 'next_run_at' derived column or we join.
+        // Let's assume a simplified 'scheduled_tasks' table or similar if strictly following relational.
+        // OR we query workflows where workflow_cron_configs->0->next_run_at < now.
+        // JSONB query:
+        // workflow_cron_configs is array or object.
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflows')
+            .select('*')
+            .not('workflow_cron_configs', 'is', null);
+        if (error)
+            return [];
+        // Manual filtering in JS for flexibility since JSONB queries can be tricky without specific indexes
+        return data.map(this.mapWorkflow).filter(w => {
+            const configs = Array.isArray(w.workflow_cron_configs) ? w.workflow_cron_configs : [w.workflow_cron_configs];
+            return configs.some((c) => c && c.next_run_at && new Date(c.next_run_at) <= now);
+        });
+    }
+    async updateWorkflowSchedule(workflowId, nextRun) {
+        // Fetch, update JSON, Save.
+        // This is inefficient but functional for low volume.
+        // Ideally we expose updateWorkflowConfig specific method.
+        const { data } = await this.supabase.from('chat_flow_workflows').select('workflow_cron_configs').eq('id', workflowId).single();
+        if (data && data.workflow_cron_configs) {
+            let configs = data.workflow_cron_configs;
+            if (Array.isArray(configs)) {
+                configs[0].next_run_at = nextRun.toISOString();
+            }
+            else {
+                configs.next_run_at = nextRun.toISOString();
+            }
+            await this.supabase.from('chat_flow_workflows').update({ workflow_cron_configs: configs }).eq('id', workflowId);
+        }
+    }
+    async getAllExecutions(userId, limit = 50, offset = 0) {
+        const countRes = await this.supabase.from('chat_flow_workflow_executions').select('*', { count: 'exact', head: true }).eq('user_id', userId);
+        const total = countRes.count || 0;
+        const { data, error } = await this.supabase
+            .from('chat_flow_workflow_executions')
+            .select('*')
+            .eq('user_id', userId)
+            .order('started_at', { ascending: false })
+            .range(offset, offset + limit - 1);
+        if (error)
+            return { executions: [], total: 0 };
+        const executions = data.map((d) => ({
+            id: d.id.toString(),
+            userId: d.user_id,
+            workflow_id: d.workflow_id,
+            event_type: d.event_type,
+            event_payload: (0, encryption_helpers_1.decryptJSON)(d.event_payload),
+            status: d.status,
+            started_at: d.started_at,
+            completed_at: d.completed_at,
+            error_message: d.error_message,
+            priority: d.priority,
+            outputResult: d.output_result // Added missing field
+        }));
+        return { executions, total };
+    }
+    async disconnect() {
+        // Supabase client handles connection pool, usually no explicit disconnect needed for stateless HTTP
+        // But if using realtime subscription, we would unsubscribe here.
+    }
+}
+exports.SupabaseRepository = SupabaseRepository;
+//# sourceMappingURL=SupabaseRepository.js.map