@octaviaflow/flow-rules 0.1.0

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

@@ -0,0 +1,205 @@
+/**
+ * Build Query Action Types
+ *
+ * Type definitions for the Build Query action supporting both visual builder and SQL editor modes
+ */
+export declare enum QueryMode {
+    Visual = "visual",
+    SQL = "sql"
+}
+export declare enum QueryType {
+    Select = "select",
+    Insert = "insert",
+    Update = "update",
+    Delete = "delete",
+    Custom = "custom"
+}
+export declare enum FilterOperator {
+    Equals = "equals",
+    NotEquals = "not_equals",
+    GreaterThan = "greater_than",
+    LessThan = "less_than",
+    GreaterThanOrEqual = "greater_than_or_equal",
+    LessThanOrEqual = "less_than_or_equal",
+    Contains = "contains",
+    NotContains = "not_contains",
+    StartsWith = "starts_with",
+    EndsWith = "ends_with",
+    In = "in",
+    NotIn = "not_in",
+    IsNull = "is_null",
+    IsNotNull = "is_not_null",
+    Between = "between"
+}
+export declare enum LogicalOperator {
+    And = "and",
+    Or = "or"
+}
+export declare enum SortDirection {
+    Ascending = "asc",
+    Descending = "desc"
+}
+export declare enum JoinType {
+    Inner = "inner",
+    Left = "left",
+    Right = "right",
+    Full = "full"
+}
+export declare enum AggregateFunction {
+    Count = "count",
+    Sum = "sum",
+    Average = "avg",
+    Min = "min",
+    Max = "max",
+    CountDistinct = "count_distinct"
+}
+export interface QueryField {
+    id: string;
+    table: string;
+    column: string;
+    alias?: string;
+    aggregate?: AggregateFunction;
+}
+export interface QueryFilter {
+    id: string;
+    field: string;
+    operator: FilterOperator;
+    value?: unknown;
+    values?: unknown[];
+    logicalOperator?: LogicalOperator;
+}
+export interface QueryFilterGroup {
+    id: string;
+    filters: (QueryFilter | QueryFilterGroup)[];
+    logicalOperator: LogicalOperator;
+}
+export interface QuerySort {
+    id: string;
+    field: string;
+    direction: SortDirection;
+}
+export interface QueryJoin {
+    id: string;
+    type: JoinType;
+    table: string;
+    leftField: string;
+    rightField: string;
+}
+export interface QueryGroupBy {
+    id: string;
+    field: string;
+}
+export interface VisualQueryConfig {
+    tables: string[];
+    fields: QueryField[];
+    filters?: QueryFilterGroup;
+    joins?: QueryJoin[];
+    groupBy?: QueryGroupBy[];
+    sort?: QuerySort[];
+    limit?: number;
+    offset?: number;
+}
+export interface SQLQueryConfig {
+    sql: string;
+    parameters?: Record<string, unknown>;
+}
+export interface TableSchema {
+    name: string;
+    schema?: string;
+    columns: ColumnSchema[];
+    primaryKey?: string[];
+    foreignKeys?: ForeignKeySchema[];
+}
+export interface ColumnSchema {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: unknown;
+    isPrimaryKey?: boolean;
+    isForeignKey?: boolean;
+    description?: string;
+    children?: ColumnSchema[];
+    /**
+     * For array columns: the element type (e.g. `text`, `int4`, `jsonb`,
+     * `record`). The UI uses this to decide whether sampling the column
+     * would surface a richer per-item shape (jsonb / record / composite)
+     * or only a primitive leaf (text / int / uuid / etc).
+     */
+    arrayElementType?: string;
+}
+export interface ForeignKeySchema {
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+}
+export interface ConnectorSchema {
+    tables: TableSchema[];
+    views?: TableSchema[];
+    procedures?: string[];
+    functions?: string[];
+}
+export interface BuildQueryConfig {
+    connectorId: string;
+    mode: QueryMode;
+    queryType: QueryType;
+    visualConfig?: VisualQueryConfig;
+    sqlConfig?: SQLQueryConfig;
+    timeout?: number;
+    maxRows?: number;
+}
+export interface QueryExecutionResult {
+    success: boolean;
+    data?: unknown[];
+    rowCount?: number;
+    columns?: string[];
+    executionTime?: number;
+    error?: string;
+    sql?: string;
+    _outputSchema?: {
+        type?: string;
+        properties?: Record<string, unknown>;
+        [k: string]: unknown;
+    };
+    _outputSchemaHash?: string;
+}
+export interface QueryPreviewRequest {
+    connectorId: string;
+    config: BuildQueryConfig;
+    limit?: number;
+}
+export interface QueryPreviewResult {
+    success: boolean;
+    preview?: unknown[];
+    rowCount?: number;
+    columns?: string[];
+    generatedSQL?: string;
+    error?: string;
+}
+export declare enum ConnectorType {
+    Database = "database",
+    API = "api",
+    CRM = "crm",
+    Analytics = "analytics",
+    Storage = "storage",
+    FileStorage = "file_storage",
+    Communication = "communication",
+    Other = "other"
+}
+export interface QueryableConnector {
+    id: string;
+    name: string;
+    type: ConnectorType;
+    supportsSQL: boolean;
+    supportsVisualBuilder: boolean;
+    schema?: ConnectorSchema;
+}
+export interface QueryValidationError {
+    field: string;
+    message: string;
+    severity: 'error' | 'warning';
+}
+export interface QueryValidationResult {
+    valid: boolean;
+    errors: QueryValidationError[];
+    warnings: QueryValidationError[];
+}

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

@@ -0,0 +1,82 @@
+/**
+ * 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 = {}));

package/dist/catalog/general/transform/config.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Transform Configuration
+ *
+ * Configuration for data transformation and field mapping between workflow steps.
+ * Supports visual field mapping (drag-and-drop) and expression-based transforms.
+ */
+/**
+ * A single field mapping from source (upstream data) to target (output field).
+ */
+export interface FieldMapping {
+    /** Unique ID for this mapping row */
+    id: string;
+    /** Dot-path to the source field, e.g. "rows[].firstName" */
+    sourceField: string;
+    /** Name of the output field, e.g. "name" */
+    targetField: string;
+    /** Expected type of the target field */
+    targetType: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array' | 'any';
+    /** Optional per-field transform expression, e.g. "concat(firstName, ' ', lastName)" */
+    transform?: string;
+    /** ID of the upstream node this source field comes from */
+    sourceNodeId?: string;
+    /** Parent mapping ID for nested fields (empty = root level) */
+    parentId?: string;
+    /** Nesting depth (0 = root) */
+    depth?: number;
+}
+export type TransformMode = 'visual' | 'expression';
+/** Data operation the user wants to perform */
+export type TransformOperation = 'upsert' | 'insert' | 'update' | 'delete';
+export declare const TRANSFORM_OPERATIONS: {
+    id: TransformOperation;
+    label: string;
+}[];
+/** Database connector IDs that support the database dropdown */
+export declare const DATABASE_CONNECTOR_IDS: Set<string>;
+export interface TransformConfigType {
+    /** Auto-generated from operation + target + object selections */
+    name: string;
+    /** What operation to perform on the target: upsert, insert, update, delete */
+    operation: TransformOperation;
+    /** Connected app / connector ID (like Query's source selector) */
+    connectorId: string;
+    /** Optional database name — shown for all DB connectors (MongoDB, PostgreSQL, MySQL) */
+    database?: string;
+    /** Table / entity / object name from the selected connector */
+    objectName: string;
+    /** Transform mode: visual field mapper or JS expression */
+    mode: TransformMode;
+    /** Field mappings (used in visual mode) */
+    mappings: FieldMapping[];
+    /** JavaScript expression (used in expression mode) */
+    expression?: string;
+    /** Constant fallbacks keyed by target field name — applied when the mapped
+     *  value is null/undefined/'' (legacy DBSync "default values" parity). */
+    fieldDefaults?: Record<string, unknown>;
+    /** Explicit upsert/update match field (legacy externalid/pkey). Empty =
+     *  per-connector auto-detection (Mongo _id, SF Id, SQL primary key). */
+    upsertMatchKey?: string;
+    /** Ordered column header names — the exact columns + header text written. */
+    sheetHeaders?: string[];
+    /** Create the target tab on first write if it doesn't exist (default true). */
+    createTabIfMissing?: boolean;
+    /** Write the header row into a new/empty tab (default true). */
+    writeHeaderRow?: boolean;
+    /** Clear existing data rows before writing (update/upsert only; default false). */
+    clearBeforeWrite?: boolean;
+    /** Non-destructive custom layout: header not in row 1 / restricted columns. */
+    sheetCustomLayout?: boolean;
+    /** Header row number for custom layout (default 1). */
+    sheetHeaderRow?: number;
+    /** Column range for custom layout, e.g. "A:H". */
+    sheetColumns?: string;
+}
+export declare const TransformConfig: {
+    defaults: TransformConfigType;
+    schema: {
+        operation: {
+            type: string;
+            required: boolean;
+        };
+        connectorId: {
+            type: string;
+            required: boolean;
+        };
+        database: {
+            type: string;
+            required: boolean;
+        };
+        objectName: {
+            type: string;
+            required: boolean;
+        };
+        mode: {
+            type: string;
+            required: boolean;
+        };
+        mappings: {
+            type: string;
+            required: boolean;
+        };
+        expression: {
+            type: string;
+            required: boolean;
+        };
+    };
+    /** Auto-generate a descriptive name from the 3 dropdown selections */
+    generateName: (operation: TransformOperation, connectorLabel: string, objectName: string) => string;
+    validate: (config: Partial<TransformConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<TransformConfigType>) => TransformConfigType;
+    getLabel: (config: TransformConfigType) => string;
+    /** Generate a unique ID for a new mapping row */
+    createMappingId: () => string;
+};

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

@@ -0,0 +1,95 @@
+/**
+ * Transform Configuration
+ *
+ * Configuration for data transformation and field mapping between workflow steps.
+ * Supports visual field mapping (drag-and-drop) and expression-based transforms.
+ */
+import { randomSuffix } from '../../../ids';
+export const TRANSFORM_OPERATIONS = [
+    { id: 'upsert', label: 'Upsert' },
+    { id: 'insert', label: 'Insert' },
+    { id: 'update', label: 'Update' },
+    { id: 'delete', label: 'Delete' },
+];
+/** Database connector IDs that support the database dropdown */
+export const DATABASE_CONNECTOR_IDS = new Set(['mongodb', 'postgresql', 'mysql', 'sqlite', 'google_sheets']);
+export const TransformConfig = {
+    defaults: {
+        name: 'Transform',
+        operation: 'upsert',
+        connectorId: '',
+        database: '',
+        objectName: '',
+        mode: 'visual',
+        mappings: [],
+        expression: '',
+        fieldDefaults: {},
+        upsertMatchKey: '',
+        sheetHeaders: [],
+        createTabIfMissing: true,
+        writeHeaderRow: true,
+        clearBeforeWrite: false,
+        sheetCustomLayout: false,
+        sheetHeaderRow: 1,
+        sheetColumns: '',
+    },
+    schema: {
+        operation: { type: 'select', required: true },
+        connectorId: { type: 'connection', required: true },
+        database: { type: 'text', required: false },
+        objectName: { type: 'select', required: true },
+        mode: { type: 'select', required: true },
+        mappings: { type: 'array', required: false },
+        expression: { type: 'code', required: false },
+    },
+    /** Auto-generate a descriptive name from the 3 dropdown selections */
+    generateName: (operation, connectorLabel, objectName) => {
+        const opLabel = TRANSFORM_OPERATIONS.find(o => o.id === operation)?.label || 'Transform';
+        const target = connectorLabel || 'Target';
+        const obj = objectName || 'Object';
+        return `${opLabel} → ${target} · ${obj}`;
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.operation) {
+            errors.push('Operation is required');
+        }
+        if (!config.connectorId) {
+            errors.push('Target connector is required');
+        }
+        if (!config.objectName) {
+            errors.push('Object (table) is required');
+        }
+        // The Visual Field Mapper is the only authoring mode. Legacy steps saved
+        // in the retired JavaScript-expression mode still execute (the engine keeps
+        // that path for back-compat), so don't flag them invalid for lacking mappings.
+        const isLegacyExpression = config.mode === 'expression' && !!config.expression?.trim();
+        if (!isLegacyExpression) {
+            if (!config.mappings || config.mappings.length === 0) {
+                errors.push('At least one field mapping is required');
+            }
+            else {
+                config.mappings.forEach((mapping, index) => {
+                    if (!mapping.sourceField) {
+                        errors.push(`Mapping ${index + 1}: Source field is required`);
+                    }
+                    if (!mapping.targetField) {
+                        errors.push(`Mapping ${index + 1}: Target field is required`);
+                    }
+                });
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...TransformConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        const count = config.mappings?.length ?? 0;
+        return `${config.name || 'Transform'} (${count} field${count !== 1 ? 's' : ''})`;
+    },
+    /** Generate a unique ID for a new mapping row */
+    createMappingId: () => {
+        return `map_${Date.now()}_${randomSuffix(5)}`;
+    },
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Transform Action
+ *
+ * Data transformation action that maps and reshapes data between workflow steps
+ * using the visual field mapper (drag-and-drop from the upstream schema).
+ */
+import { ActionDefinition } from '../../types';
+export declare const transformDefinition: ActionDefinition;

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

@@ -0,0 +1,63 @@
+/**
+ * Transform Action
+ *
+ * Data transformation action that maps and reshapes data between workflow steps
+ * using the visual field mapper (drag-and-drop from the upstream schema).
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const transformDefinition = {
+    id: 'transform',
+    name: 'Transform',
+    description: 'Map and transform data between workflow steps using the visual field mapper',
+    category: ActionCategory.Transform,
+    type: ActionType.Transform,
+    tags: ['transform', 'mapping', 'data', 'reshape', 'convert', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Transform',
+    color: '#0043ce',
+    inputSchema: {
+        fields: [
+            {
+                key: 'name',
+                label: 'Transform Name',
+                type: FieldType.String,
+                description: 'A descriptive name for this transform step',
+                defaultValue: 'Transform',
+                validation: { required: false },
+            },
+            {
+                key: 'mappings',
+                label: 'Field Mappings',
+                type: FieldType.Array,
+                description: 'Map source fields from upstream nodes to target output fields',
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'result',
+                type: FieldType.JSON,
+                description: 'Transformed data output',
+            },
+            {
+                key: 'mappedFieldCount',
+                type: FieldType.Number,
+                description: 'Number of fields that were mapped/transformed',
+            },
+        ],
+        sampleOutput: {
+            result: { name: 'John Doe', email: 'john@example.com', age: 30 },
+            mappedFieldCount: 3,
+        },
+        dynamic: true,
+    },
+    version: '2.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2026-02-13T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/index.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Actions Registry
+ *
+ * Central registry for all built-in actions
+ * Each action is self-contained with its own configuration, UI, and metadata
+ */
+import { ActionDefinition, ActionCategory } from './types';
+import { manualTriggerDefinition } from './triggers/manual-trigger';
+import { scheduleTriggerDefinition } from './triggers/schedule-trigger';
+import { webhookTriggerDefinition } from './triggers/webhook-trigger';
+import { httpRequestDefinition } from './actions/http-request';
+import { consoleLogDefinition } from './actions/console-log';
+import { delayDefinition } from './actions/delay';
+import { conditionDefinition } from './logic/condition';
+import { forEachDefinition } from './logic/for-each';
+import { groupDefinition } from './logic/group';
+import { queryDefinition } from './general/query';
+import { transformDefinition } from './general/transform';
+import { csvActionDefinition } from './storage/csv-action';
+import { jsonActionDefinition } from './storage/json-action';
+import { xmlActionDefinition } from './storage/xml-action';
+import { excelActionDefinition } from './storage/excel-action';
+import { s3ActionDefinition } from './storage/s3-action';
+import { ftpActionDefinition } from './storage/ftp-action';
+import { googleDriveActionDefinition } from './storage/google-drive-action';
+import { dropboxActionDefinition } from './storage/dropbox-action';
+import { onedriveActionDefinition } from './storage/onedrive-action';
+import { emailDefinition } from './communication/email-send';
+import { slackMessageDefinition } from './communication/slack-message';
+import { whatsappSendDefinition } from './communication/whatsapp-send';
+import { teamsMessageDefinition } from './communication/teams-message';
+import { googleChatDefinition } from './communication/google-chat';
+import { webhookCallDefinition } from './communication/webhook-call';
+import { debugDefinition } from './utility/debug';
+import { errorDefinition } from './utility/error';
+import { variablesDefinition } from './utility/variables';
+import { graphqlQueryDefinition } from './api/graphql-query';
+import { aiAgentDefinition } from './ai/ai-agent';
+import { idpExtractDefinition } from './ai/idp-extract';
+/**
+ * Registry of all available actions
+ * Organized by category for easy lookup and management
+ */
+export declare const actionsRegistry: Record<string, Record<string, ActionDefinition>>;
+/**
+ * Get all actions as a flat array
+ */
+export declare const getAllActions: () => ActionDefinition[];
+/**
+ * Get action by ID
+ */
+export declare const getActionById: (id: string) => ActionDefinition | undefined;
+/**
+ * Get actions by category
+ */
+export declare const getActionsByCategory: (category: ActionCategory) => ActionDefinition[];
+export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };