@octaviaflow/flow-rules 0.1.0

package/dist/catalog/general/query/config.js

@@ -0,0 +1,257 @@
+/**
+ * Build Query Configuration
+ *
+ * Configuration utilities and validation for the Build Query action
+ * Supports dual modes: Visual Builder (no-code) and SQL Editor (advanced)
+ */
+import { QueryMode, QueryType, } from './types';
+export const BuildQueryConfigDefaults = {
+    mode: QueryMode.Visual,
+    queryType: QueryType.Select,
+    timeout: 30000,
+    maxRows: 1000,
+    visualConfig: {
+        tables: [],
+        fields: [],
+        filters: undefined,
+        joins: [],
+        groupBy: [],
+        sort: [],
+        limit: 10,
+        offset: 0,
+    },
+    sqlConfig: {
+        sql: '',
+        parameters: {},
+    },
+};
+/**
+ * Validate Build Query configuration
+ */
+export const validateBuildQueryConfig = (config) => {
+    const errors = [];
+    const warnings = [];
+    if (!config.connectorId) {
+        errors.push({
+            field: 'connectorId',
+            message: 'Please select a connector',
+            severity: 'error',
+        });
+    }
+    if (!config.mode) {
+        errors.push({
+            field: 'mode',
+            message: 'Query mode is required',
+            severity: 'error',
+        });
+    }
+    if (!config.queryType) {
+        errors.push({
+            field: 'queryType',
+            message: 'Query type is required',
+            severity: 'error',
+        });
+    }
+    if (config.mode === QueryMode.Visual) {
+        const visualErrors = validateVisualQueryConfig(config.visualConfig);
+        errors.push(...visualErrors);
+    }
+    else if (config.mode === QueryMode.SQL) {
+        const sqlErrors = validateSQLQueryConfig(config.sqlConfig);
+        errors.push(...sqlErrors);
+    }
+    if (config.timeout !== undefined) {
+        if (config.timeout < 1000) {
+            errors.push({
+                field: 'timeout',
+                message: 'Timeout must be at least 1000ms',
+                severity: 'error',
+            });
+        }
+        else if (config.timeout > 300000) {
+            warnings.push({
+                field: 'timeout',
+                message: 'Timeout is very high (>5 minutes)',
+                severity: 'warning',
+            });
+        }
+    }
+    if (config.maxRows !== undefined) {
+        if (config.maxRows < 1) {
+            errors.push({
+                field: 'maxRows',
+                message: 'Max rows must be at least 1',
+                severity: 'error',
+            });
+        }
+        else if (config.maxRows > 10000) {
+            warnings.push({
+                field: 'maxRows',
+                message: 'Max rows is very high (>10,000). This may impact performance.',
+                severity: 'warning',
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+};
+/**
+ * Validate Visual Query configuration
+ */
+const validateVisualQueryConfig = (config) => {
+    const errors = [];
+    if (!config) {
+        errors.push({
+            field: 'visualConfig',
+            message: 'Visual query configuration is required',
+            severity: 'error',
+        });
+        return errors;
+    }
+    if (!config.tables || config.tables.length === 0) {
+        errors.push({
+            field: 'visualConfig.tables',
+            message: 'At least one table must be selected',
+            severity: 'error',
+        });
+    }
+    if (!config.fields || config.fields.length === 0) {
+        errors.push({
+            field: 'visualConfig.fields',
+            message: 'At least one field must be selected',
+            severity: 'error',
+        });
+    }
+    if (config.tables && config.tables.length > 1) {
+        if (!config.joins || config.joins.length === 0) {
+            errors.push({
+                field: 'visualConfig.joins',
+                message: 'Joins are required when selecting from multiple tables',
+                severity: 'error',
+            });
+        }
+    }
+    const hasAggregates = config.fields?.some(field => field.aggregate);
+    const hasNonAggregates = config.fields?.some(field => !field.aggregate);
+    if (hasAggregates && hasNonAggregates) {
+        if (!config.groupBy || config.groupBy.length === 0) {
+            errors.push({
+                field: 'visualConfig.groupBy',
+                message: 'Group by is required when mixing aggregate and non-aggregate fields',
+                severity: 'error',
+            });
+        }
+    }
+    return errors;
+};
+/**
+ * Validate SQL Query configuration
+ */
+const validateSQLQueryConfig = (config) => {
+    const errors = [];
+    if (!config) {
+        errors.push({
+            field: 'sqlConfig',
+            message: 'SQL query configuration is required',
+            severity: 'error',
+        });
+        return errors;
+    }
+    if (!config.sql || config.sql.trim().length === 0) {
+        errors.push({
+            field: 'sqlConfig.sql',
+            message: 'SQL query is required',
+            severity: 'error',
+        });
+    }
+    else {
+        const sql = config.sql.trim().toLowerCase();
+        const dangerousKeywords = ['drop', 'truncate', 'alter', 'create', 'grant', 'revoke'];
+        const hasDangerousKeyword = dangerousKeywords.some(keyword => sql.includes(keyword + ' '));
+        if (hasDangerousKeyword) {
+            errors.push({
+                field: 'sqlConfig.sql',
+                message: 'SQL query contains potentially dangerous operations (DROP, TRUNCATE, ALTER, etc.)',
+                severity: 'error',
+            });
+        }
+    }
+    return errors;
+};
+/**
+ * Merge user config with defaults
+ */
+export const mergeBuildQueryConfig = (userConfig) => {
+    const merged = {
+        connectorId: userConfig.connectorId || '',
+        mode: userConfig.mode || BuildQueryConfigDefaults.mode,
+        queryType: userConfig.queryType || BuildQueryConfigDefaults.queryType,
+        timeout: userConfig.timeout || BuildQueryConfigDefaults.timeout,
+        maxRows: userConfig.maxRows || BuildQueryConfigDefaults.maxRows,
+    };
+    if (merged.mode === QueryMode.Visual) {
+        merged.visualConfig = {
+            ...BuildQueryConfigDefaults.visualConfig,
+            ...userConfig.visualConfig,
+        };
+    }
+    else if (merged.mode === QueryMode.SQL) {
+        merged.sqlConfig = {
+            ...BuildQueryConfigDefaults.sqlConfig,
+            ...userConfig.sqlConfig,
+        };
+    }
+    return merged;
+};
+/**
+ * Get display label for configuration
+ */
+export const getBuildQueryLabel = (config) => {
+    if (config.mode === QueryMode.Visual && config.visualConfig) {
+        const tables = config.visualConfig.tables.join(', ');
+        const fieldCount = config.visualConfig.fields.length;
+        return `Query ${tables} (${fieldCount} fields)`;
+    }
+    else if (config.mode === QueryMode.SQL && config.sqlConfig) {
+        const preview = config.sqlConfig.sql.substring(0, 50);
+        return preview + (config.sqlConfig.sql.length > 50 ? '...' : '');
+    }
+    return 'Build Query';
+};
+/**
+ * Check if a connector is queryable (excludes storage-type connectors)
+ * Uses the isQueryable flag from connector metadata if available
+ */
+export function isQueryableConnector(connector) {
+    // If isQueryable flag is explicitly set, use it
+    if (connector.isQueryable !== undefined) {
+        return connector.isQueryable;
+    }
+    // Fallback: Exclude storage category
+    if (connector.category === 'storage') {
+        return false;
+    }
+    // Safety check: If type is undefined or null, default to not queryable
+    if (!connector.type) {
+        return false;
+    }
+    // Fallback: Check against known storage types
+    const storageTypes = [
+        'dropbox',
+        'google_drive',
+        'google-drive',
+        'onedrive',
+        'box',
+        'ftp',
+        'sftp',
+        's3',
+        'azure_blob',
+        'azure-blob',
+        'storage',
+    ];
+    return !storageTypes.includes(connector.type.toLowerCase());
+}
+;

package/dist/catalog/general/query/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build Query Action
+ *
+ * Execute queries against connected databases, APIs, CRMs with dual mode support:
+ * - Visual Builder: No-code/low-code query construction
+ * - SQL Editor: Advanced SQL query writing with syntax highlighting
+ */
+import { ActionDefinition } from '../../types';
+export declare const queryDefinition: ActionDefinition;
+export * from './types';
+export * from './config';

package/dist/catalog/general/query/index.js

@@ -0,0 +1,271 @@
+/**
+ * Build Query Action
+ *
+ * Execute queries against connected databases, APIs, CRMs with dual mode support:
+ * - Visual Builder: No-code/low-code query construction
+ * - SQL Editor: Advanced SQL query writing with syntax highlighting
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+import { QueryMode, QueryType } from './types';
+export const queryDefinition = {
+    id: 'query',
+    name: 'Query',
+    description: 'Execute queries against connected databases, APIs, and CRMs',
+    longDescription: 'Create powerful queries using either a visual no-code builder or advanced SQL editor. Supports databases (PostgreSQL, MySQL, MongoDB, etc.), APIs (REST, GraphQL), and CRMs (Salesforce, HubSpot). Query results can be used as input for downstream actions.',
+    category: ActionCategory.Database,
+    type: ActionType.Query,
+    tags: ['query', 'database', 'sql', 'visual-builder', 'no-code', 'api', 'crm', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'QueryQueue',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            {
+                key: 'connectorId',
+                label: 'Select Connector',
+                type: FieldType.Connection,
+                description: 'Choose a connected database, API, or CRM (storage connectors like Dropbox/Google Drive are not supported)',
+                validation: { required: true },
+                helpText: 'Only queryable connectors are shown. File storage connectors have separate actions.',
+            },
+            {
+                key: 'mode',
+                label: 'Query Mode',
+                type: FieldType.Select,
+                description: 'Choose between visual query builder or SQL editor',
+                options: [
+                    {
+                        label: 'Visual Builder (No-Code)',
+                        value: QueryMode.Visual,
+                        description: 'Build queries visually without writing code',
+                    },
+                    {
+                        label: 'SQL Editor (Advanced)',
+                        value: QueryMode.SQL,
+                        description: 'Write raw SQL queries with syntax highlighting',
+                    },
+                ],
+                defaultValue: QueryMode.Visual,
+                validation: { required: true },
+            },
+            {
+                key: 'queryType',
+                label: 'Query Type',
+                type: FieldType.Select,
+                // Read-only. The Query action reads; writes go through Transform.
+                // INSERT / UPDATE / DELETE / Custom were listed here but the config
+                // panel always compiles a SELECT (QueryConfigPanel pins queryType),
+                // so the catalogue no longer advertises them (DEV-349).
+                description: 'Type of query operation — the Query action reads data; use Transform to write',
+                options: [
+                    { label: 'SELECT (Read Data)', value: QueryType.Select },
+                ],
+                defaultValue: QueryType.Select,
+                validation: { required: true },
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.Visual,
+                        action: 'show',
+                    },
+                ],
+            },
+            // Visual Builder Fields
+            {
+                key: 'visualConfig.tables',
+                label: 'Select Tables',
+                type: FieldType.MultiSelect,
+                description: 'Choose one or more tables to query',
+                validation: { required: true },
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.Visual,
+                        action: 'show',
+                    },
+                ],
+                optionsSource: {
+                    type: 'dynamic',
+                    dependsOn: ['connectorId'],
+                },
+            },
+            {
+                key: 'visualConfig.fields',
+                label: 'Select Fields',
+                type: FieldType.Array,
+                description: 'Choose fields to include in the query result',
+                validation: { required: true },
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.Visual,
+                        action: 'show',
+                    },
+                ],
+            },
+            {
+                key: 'visualConfig.limit',
+                label: 'Limit',
+                type: FieldType.Number,
+                description: 'Maximum number of rows to return',
+                defaultValue: 10,
+                validation: { required: false, min: 1, max: 10000 },
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.Visual,
+                        action: 'show',
+                    },
+                ],
+            },
+            // SQL Editor Fields
+            {
+                key: 'sqlConfig.sql',
+                label: 'SQL Query',
+                type: FieldType.Code,
+                language: 'sql',
+                description: 'Write your SQL query here',
+                placeholder: 'SELECT * FROM users WHERE status = \'active\' LIMIT 100',
+                validation: { required: true },
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.SQL,
+                        action: 'show',
+                    },
+                ],
+            },
+            {
+                key: 'sqlConfig.parameters',
+                label: 'Query Parameters',
+                type: FieldType.JSON,
+                description: 'Parameters for parameterized queries (e.g., {"userId": 123})',
+                validation: { required: false },
+                advanced: true,
+                conditional: [
+                    {
+                        field: 'mode',
+                        operator: '==',
+                        value: QueryMode.SQL,
+                        action: 'show',
+                    },
+                ],
+            },
+            // Common Settings
+            {
+                key: 'timeout',
+                label: 'Query Timeout (ms)',
+                type: FieldType.Number,
+                description: 'Maximum time to wait for query execution',
+                defaultValue: 30000,
+                validation: { required: false, min: 1000, max: 300000 },
+                advanced: true,
+            },
+            {
+                key: 'maxRows',
+                label: 'Max Rows',
+                type: FieldType.Number,
+                description: 'Maximum number of rows to return',
+                defaultValue: 1000,
+                validation: { required: false, min: 1, max: 10000 },
+                advanced: true,
+            },
+        ],
+        groups: [
+            {
+                id: 'connection',
+                label: 'Connection',
+                description: 'Select the data source to query',
+                fields: ['connectorId'],
+            },
+            {
+                id: 'query_mode',
+                label: 'Query Configuration',
+                description: 'Configure how you want to build your query',
+                fields: ['mode', 'queryType'],
+            },
+            {
+                id: 'visual_builder',
+                label: 'Visual Query Builder',
+                description: 'Build your query visually without writing code',
+                fields: ['visualConfig.tables', 'visualConfig.fields', 'visualConfig.limit'],
+            },
+            {
+                id: 'sql_editor',
+                label: 'SQL Editor',
+                description: 'Write raw SQL queries',
+                fields: ['sqlConfig.sql', 'sqlConfig.parameters'],
+            },
+            {
+                id: 'settings',
+                label: 'Advanced Settings',
+                description: 'Configure query execution settings',
+                collapsed: true,
+                fields: ['timeout', 'maxRows'],
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'data',
+                type: FieldType.Array,
+                description: 'Query result data as an array of objects',
+                example: [{ id: 1, name: 'John Doe', email: 'john@example.com' }],
+            },
+            {
+                key: 'rowCount',
+                type: FieldType.Number,
+                description: 'Number of rows returned',
+                example: 1,
+            },
+            {
+                key: 'columns',
+                type: FieldType.Array,
+                description: 'Column names in the result set',
+                example: ['id', 'name', 'email'],
+            },
+            {
+                key: 'executionTime',
+                type: FieldType.Number,
+                description: 'Query execution time in milliseconds',
+                example: 45,
+            },
+            {
+                key: 'generatedSQL',
+                type: FieldType.String,
+                description: 'The SQL query that was executed (for visual builder mode)',
+                example: 'SELECT id, name, email FROM users WHERE status = \'active\' LIMIT 100',
+            },
+        ],
+        sampleOutput: {
+            data: [
+                { id: 1, name: 'John Doe', email: 'john@example.com', status: 'active' },
+                { id: 2, name: 'Jane Smith', email: 'jane@example.com', status: 'active' },
+            ],
+            rowCount: 2,
+            columns: ['id', 'name', 'email', 'status'],
+            executionTime: 45,
+            generatedSQL: 'SELECT id, name, email, status FROM users WHERE status = \'active\' LIMIT 100',
+        },
+    },
+    execution: {
+        timeout: 30000,
+        retryable: true,
+        requiresAuth: true,
+    },
+    testable: true,
+    version: '1.0.0',
+    createdAt: '2025-01-19T00:00:00Z',
+    updatedAt: '2025-01-19T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+};
+export * from './types';
+export * from './config';