@octaviaflow/flow-rules 0.1.0 → 0.2.0

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

@@ -1,257 +0,0 @@
-/**
- * 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.js

@@ -1,271 +0,0 @@
-/**
- * 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';

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

@@ -1,82 +0,0 @@
-/**
- * Build Query Action Types
- *
- * Type definitions for the Build Query action supporting both visual builder and SQL editor modes
- */
-// ============================================
-// QUERY MODES
-// ============================================
-export var QueryMode;
-(function (QueryMode) {
-    QueryMode["Visual"] = "visual";
-    QueryMode["SQL"] = "sql";
-})(QueryMode || (QueryMode = {}));
-export var QueryType;
-(function (QueryType) {
-    QueryType["Select"] = "select";
-    QueryType["Insert"] = "insert";
-    QueryType["Update"] = "update";
-    QueryType["Delete"] = "delete";
-    QueryType["Custom"] = "custom";
-})(QueryType || (QueryType = {}));
-// ============================================
-// VISUAL QUERY BUILDER TYPES
-// ============================================
-export var FilterOperator;
-(function (FilterOperator) {
-    FilterOperator["Equals"] = "equals";
-    FilterOperator["NotEquals"] = "not_equals";
-    FilterOperator["GreaterThan"] = "greater_than";
-    FilterOperator["LessThan"] = "less_than";
-    FilterOperator["GreaterThanOrEqual"] = "greater_than_or_equal";
-    FilterOperator["LessThanOrEqual"] = "less_than_or_equal";
-    FilterOperator["Contains"] = "contains";
-    FilterOperator["NotContains"] = "not_contains";
-    FilterOperator["StartsWith"] = "starts_with";
-    FilterOperator["EndsWith"] = "ends_with";
-    FilterOperator["In"] = "in";
-    FilterOperator["NotIn"] = "not_in";
-    FilterOperator["IsNull"] = "is_null";
-    FilterOperator["IsNotNull"] = "is_not_null";
-    FilterOperator["Between"] = "between";
-})(FilterOperator || (FilterOperator = {}));
-export var LogicalOperator;
-(function (LogicalOperator) {
-    LogicalOperator["And"] = "and";
-    LogicalOperator["Or"] = "or";
-})(LogicalOperator || (LogicalOperator = {}));
-export var SortDirection;
-(function (SortDirection) {
-    SortDirection["Ascending"] = "asc";
-    SortDirection["Descending"] = "desc";
-})(SortDirection || (SortDirection = {}));
-export var JoinType;
-(function (JoinType) {
-    JoinType["Inner"] = "inner";
-    JoinType["Left"] = "left";
-    JoinType["Right"] = "right";
-    JoinType["Full"] = "full";
-})(JoinType || (JoinType = {}));
-export var AggregateFunction;
-(function (AggregateFunction) {
-    AggregateFunction["Count"] = "count";
-    AggregateFunction["Sum"] = "sum";
-    AggregateFunction["Average"] = "avg";
-    AggregateFunction["Min"] = "min";
-    AggregateFunction["Max"] = "max";
-    AggregateFunction["CountDistinct"] = "count_distinct";
-})(AggregateFunction || (AggregateFunction = {}));
-// ============================================
-// CONNECTOR FILTERING
-// ============================================
-export var ConnectorType;
-(function (ConnectorType) {
-    ConnectorType["Database"] = "database";
-    ConnectorType["API"] = "api";
-    ConnectorType["CRM"] = "crm";
-    ConnectorType["Analytics"] = "analytics";
-    ConnectorType["Storage"] = "storage";
-    ConnectorType["FileStorage"] = "file_storage";
-    ConnectorType["Communication"] = "communication";
-    ConnectorType["Other"] = "other";
-})(ConnectorType || (ConnectorType = {}));