@octaviaflow/flow-rules 0.1.0

package/dist/catalog/triggers/schedule-trigger/config.js

@@ -0,0 +1,42 @@
+/**
+ * Schedule Trigger Configuration
+ */
+export const ScheduleTriggerConfig = {
+    defaults: {
+        scheduleType: 'interval',
+        interval: 60,
+        intervalUnit: 'minutes',
+        timezone: 'UTC',
+    },
+    schema: {
+        scheduleType: { type: 'select', required: true },
+        interval: { type: 'number', required: false, min: 1 },
+        intervalUnit: { type: 'select', required: false },
+        cronExpression: { type: 'string', required: false },
+        timezone: { type: 'string', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.scheduleType) {
+            errors.push('Schedule type is required');
+        }
+        if (config.scheduleType === 'interval') {
+            if (!config.interval || config.interval < 1) {
+                errors.push('Interval must be at least 1');
+            }
+        }
+        if (config.scheduleType === 'cron' && !config.cronExpression) {
+            errors.push('Cron expression is required');
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...ScheduleTriggerConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        if (config.scheduleType === 'interval') {
+            return `Every ${config.interval} ${config.intervalUnit}`;
+        }
+        return `Schedule: ${config.scheduleType}`;
+    },
+};

package/dist/catalog/triggers/schedule-trigger/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Schedule Trigger Action
+ *
+ * Trigger workflows on a schedule using cron expressions or intervals
+ */
+import { ActionDefinition } from '../../types';
+export declare const scheduleTriggerDefinition: ActionDefinition;

package/dist/catalog/triggers/schedule-trigger/index.js

@@ -0,0 +1,102 @@
+/**
+ * Schedule Trigger Action
+ *
+ * Trigger workflows on a schedule using cron expressions or intervals
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const scheduleTriggerDefinition = {
+    id: 'schedule_trigger',
+    name: 'Schedule Trigger',
+    description: 'Trigger workflow on a schedule using cron or intervals',
+    category: ActionCategory.Trigger,
+    type: ActionType.Schedule,
+    tags: ['trigger', 'schedule', 'cron', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'Time',
+    color: '#0f62fe',
+    inputSchema: {
+        fields: [
+            {
+                key: 'scheduleType',
+                label: 'Schedule Type',
+                type: FieldType.Select,
+                description: 'Type of schedule',
+                defaultValue: 'interval',
+                options: [
+                    { label: 'Interval', value: 'interval' },
+                    { label: 'Cron Expression', value: 'cron' },
+                    { label: 'Specific Time', value: 'specific' },
+                ],
+                validation: { required: true },
+            },
+            {
+                key: 'interval',
+                label: 'Interval',
+                type: FieldType.Number,
+                description: 'Interval value (used with interval type)',
+                validation: { required: false, min: 1 },
+            },
+            {
+                key: 'intervalUnit',
+                label: 'Interval Unit',
+                type: FieldType.Select,
+                description: 'Unit for interval (minutes, hours, days)',
+                defaultValue: 'minutes',
+                options: [
+                    { label: 'Minutes', value: 'minutes' },
+                    { label: 'Hours', value: 'hours' },
+                    { label: 'Days', value: 'days' },
+                    { label: 'Weeks', value: 'weeks' },
+                ],
+                validation: { required: false },
+            },
+            {
+                key: 'cronExpression',
+                label: 'Cron Expression',
+                type: FieldType.String,
+                description: 'Cron expression (e.g., 0 0 * * * for daily at midnight)',
+                placeholder: '0 0 * * *',
+                validation: { required: false },
+            },
+            {
+                key: 'timezone',
+                label: 'Timezone',
+                type: FieldType.String,
+                description: 'Timezone for schedule (e.g., UTC, America/New_York)',
+                defaultValue: 'UTC',
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'scheduledAt',
+                type: FieldType.DateTime,
+                description: 'When the schedule was triggered',
+            },
+            {
+                key: 'nextRun',
+                type: FieldType.DateTime,
+                description: 'When the next run is scheduled',
+            },
+            {
+                key: 'scheduleType',
+                type: FieldType.String,
+                description: 'Type of schedule that triggered',
+            },
+        ],
+        sampleOutput: {
+            scheduledAt: new Date().toISOString(),
+            nextRun: new Date(Date.now() + 3600000).toISOString(),
+            scheduleType: 'interval',
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/triggers/webhook-trigger/config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Webhook Trigger Configuration
+ */
+export interface WebhookTriggerConfigType {
+    webhookPath?: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    requireAuth?: boolean;
+}
+export declare const WebhookTriggerConfig: {
+    defaults: WebhookTriggerConfigType;
+    schema: {
+        webhookPath: {
+            type: string;
+            required: boolean;
+        };
+        method: {
+            type: string;
+            required: boolean;
+        };
+        requireAuth: {
+            type: string;
+            required: boolean;
+        };
+    };
+    validate: (config: Partial<WebhookTriggerConfigType>) => {
+        valid: boolean;
+        errors: string[];
+    };
+    merge: (userConfig: Partial<WebhookTriggerConfigType>) => WebhookTriggerConfigType;
+    getLabel: (config: WebhookTriggerConfigType) => string;
+};

package/dist/catalog/triggers/webhook-trigger/config.js

@@ -0,0 +1,27 @@
+/**
+ * Webhook Trigger Configuration
+ */
+export const WebhookTriggerConfig = {
+    defaults: {
+        method: 'POST',
+        requireAuth: true,
+    },
+    schema: {
+        webhookPath: { type: 'string', required: false },
+        method: { type: 'select', required: true },
+        requireAuth: { type: 'boolean', required: false },
+    },
+    validate: (config) => {
+        const errors = [];
+        if (!config.method) {
+            errors.push('HTTP method is required');
+        }
+        return { valid: errors.length === 0, errors };
+    },
+    merge: (userConfig) => {
+        return { ...WebhookTriggerConfig.defaults, ...userConfig };
+    },
+    getLabel: (config) => {
+        return `Webhook ${config.method}${config.webhookPath ? ` ${config.webhookPath}` : ''}`;
+    },
+};

package/dist/catalog/triggers/webhook-trigger/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Webhook Trigger Action
+ *
+ * Trigger workflows via HTTP webhooks
+ */
+import { ActionDefinition } from '../../types';
+export declare const webhookTriggerDefinition: ActionDefinition;

package/dist/catalog/triggers/webhook-trigger/index.js

@@ -0,0 +1,89 @@
+/**
+ * Webhook Trigger Action
+ *
+ * Trigger workflows via HTTP webhooks
+ */
+import { ActionCategory, ActionType, ActionStatus, FieldType } from '../../types';
+export const webhookTriggerDefinition = {
+    id: 'webhook_trigger',
+    name: 'Webhook Trigger',
+    description: 'Trigger workflow via HTTP webhook',
+    category: ActionCategory.Trigger,
+    type: ActionType.Webhook,
+    tags: ['trigger', 'webhook', 'http', 'built-in'],
+    status: ActionStatus.Stable,
+    icon: 'WebhookAlt',
+    color: '#0f62fe',
+    inputSchema: {
+        fields: [
+            {
+                key: 'webhookPath',
+                label: 'Webhook Path',
+                type: FieldType.String,
+                description: 'Custom path for the webhook URL',
+                placeholder: '/my-webhook',
+                validation: { required: false },
+            },
+            {
+                key: 'method',
+                label: 'HTTP Method',
+                type: FieldType.Select,
+                description: 'Allowed HTTP methods',
+                defaultValue: 'POST',
+                options: [
+                    { label: 'GET', value: 'GET' },
+                    { label: 'POST', value: 'POST' },
+                    { label: 'PUT', value: 'PUT' },
+                    { label: 'PATCH', value: 'PATCH' },
+                    { label: 'DELETE', value: 'DELETE' },
+                ],
+                validation: { required: true },
+            },
+            {
+                key: 'requireAuth',
+                label: 'Require Authentication',
+                type: FieldType.Boolean,
+                description: 'Require API key or token for webhook',
+                defaultValue: true,
+                validation: { required: false },
+            },
+        ],
+    },
+    outputSchema: {
+        type: 'object',
+        properties: [
+            {
+                key: 'webhookUrl',
+                type: FieldType.URL,
+                description: 'The generated webhook URL',
+            },
+            {
+                key: 'method',
+                type: FieldType.String,
+                description: 'HTTP method used',
+            },
+            {
+                key: 'payload',
+                type: FieldType.JSON,
+                description: 'Request payload received',
+            },
+            {
+                key: 'headers',
+                type: FieldType.Object,
+                description: 'Request headers',
+            },
+        ],
+        sampleOutput: {
+            webhookUrl: 'https://api.example.com/webhooks/trigger-123',
+            method: 'POST',
+            payload: { data: 'example' },
+            headers: { 'content-type': 'application/json' },
+        },
+    },
+    version: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-12-15T00:00:00Z',
+    createdBy: 'system',
+    isOfficial: true,
+    testable: true,
+};

package/dist/catalog/types.d.ts

@@ -0,0 +1,360 @@
+/**
+ * Action System Type Definitions
+ *
+ * Complete type definitions for the action system including enums, interfaces, and utilities
+ */
+export declare enum ActionCategory {
+    Trigger = "trigger",
+    Action = "action",
+    Logic = "logic",
+    Transform = "transform",
+    AI = "ai",
+    Database = "database",
+    API = "api",
+    Storage = "storage",
+    FileStorage = "file_storage",
+    Communication = "communication",
+    CRM = "crm",
+    Ecommerce = "ecommerce",
+    Marketing = "marketing",
+    Analytics = "analytics",
+    Productivity = "productivity",
+    Custom = "custom",
+    Utility = "utility"
+}
+export declare enum ActionType {
+    Schedule = "schedule",
+    Webhook = "webhook",
+    Manual = "manual",
+    DataChange = "data_change",
+    Event = "event",
+    Read = "read",
+    Write = "write",
+    Update = "update",
+    Delete = "delete",
+    Query = "query",
+    HTTPRequest = "http_request",
+    GraphQLQuery = "graphql_query",
+    Condition = "condition",
+    ForEach = "for_each",
+    Group = "group",
+    Format = "format",
+    AIAgent = "ai_agent",
+    Embedding = "embedding",
+    VectorSearch = "vector_search",
+    ImageGeneration = "image_generation",
+    ImageAnalysis = "image_analysis",
+    SpeechToText = "speech_to_text",
+    TextToSpeech = "text_to_speech",
+    Transform = "transform",
+    FileOperation = "file_operation",
+    FileAction = "file_action",
+    CsvAction = "csv_action",
+    JsonAction = "json_action",
+    XmlAction = "xml_action",
+    ExcelAction = "excel_action",
+    S3Action = "s3_action",
+    FtpAction = "ftp_action",
+    GoogleDriveAction = "google_drive_action",
+    DropboxAction = "dropbox_action",
+    OneDriveAction = "onedrive_action",
+    StorageAction = "storage_action",
+    EmailSend = "email_send",
+    SlackMessage = "slack_message",
+    WhatsappSend = "whatsapp_send",
+    TeamsMessage = "teams_message",
+    GoogleChat = "google_chat",
+    WebhookCall = "webhook_call",
+    Delay = "delay",
+    Wait = "wait",
+    Console = "console",
+    Debug = "debug",
+    Error = "error",
+    CustomCode = "custom_code",
+    CustomAction = "custom_action",
+    IdpExtract = "idp_extract"
+}
+export declare enum ActionStatus {
+    Stable = "stable",
+    Beta = "beta",
+    Alpha = "alpha",
+    Experimental = "experimental",
+    Deprecated = "deprecated"
+}
+export declare enum FieldType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Date = "date",
+    DateTime = "datetime",
+    Array = "array",
+    Object = "object",
+    JSON = "json",
+    File = "file",
+    Image = "image",
+    Select = "select",
+    MultiSelect = "multi_select",
+    Code = "code",
+    Expression = "expression",
+    Mapping = "mapping",
+    Connection = "connection",
+    Secret = "secret",
+    Color = "color",
+    URL = "url",
+    Email = "email",
+    Phone = "phone",
+    RichText = "rich_text",
+    Markdown = "markdown"
+}
+export interface FieldValidation {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    custom?: string;
+}
+export interface FieldOption {
+    label: string;
+    value: string | number;
+    description?: string;
+    icon?: string;
+    disabled?: boolean;
+}
+export interface FieldConditional {
+    field: string;
+    operator: '==' | '!=' | '>' | '<' | '>=' | '<=' | 'in' | 'not_in' | 'contains';
+    value: unknown;
+    action: 'show' | 'hide' | 'enable' | 'disable' | 'require';
+}
+export interface FieldConfig {
+    key: string;
+    label: string;
+    type: FieldType;
+    description?: string;
+    placeholder?: string;
+    helpText?: string;
+    tooltip?: string;
+    defaultValue?: unknown;
+    value?: unknown;
+    options?: FieldOption[];
+    optionsSource?: {
+        type: 'static' | 'dynamic' | 'api';
+        apiEndpoint?: string;
+        dependsOn?: string[];
+    };
+    validation?: FieldValidation;
+    hidden?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    advanced?: boolean;
+    conditional?: FieldConditional[];
+    language?: 'javascript' | 'python' | 'sql' | 'json' | 'markdown';
+    mappingSource?: string;
+    connectorId?: string;
+    itemSchema?: FieldConfig;
+    properties?: FieldConfig[];
+}
+export interface FieldGroup {
+    id: string;
+    label: string;
+    description?: string;
+    collapsed?: boolean;
+    fields: string[];
+}
+export interface ActionIOSchema {
+    fields: FieldConfig[];
+    groups?: FieldGroup[];
+    dynamic?: {
+        enabled: boolean;
+        source: 'connector' | 'api' | 'function';
+        endpoint?: string;
+        dependsOn?: string[];
+    };
+}
+export interface ActionOutputProperty {
+    key: string;
+    type: FieldType;
+    description?: string;
+    example?: unknown;
+}
+export interface ActionOutputSchema {
+    type: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'void';
+    properties?: ActionOutputProperty[];
+    itemType?: string;
+    sampleOutput?: unknown;
+    dynamic?: boolean;
+}
+export interface ActionExecutionConfig {
+    timeout?: number;
+    retryable?: boolean;
+    requiresAuth?: boolean;
+    costPerExecution?: number;
+    rateLimitPerMinute?: number;
+    rateLimitPerHour?: number;
+}
+export interface ActionExample {
+    name: string;
+    description: string;
+    inputExample: unknown;
+    outputExample: unknown;
+}
+export interface ActionAIMetadata {
+    modelProvider?: string;
+    defaultModel?: string;
+    estimatedTokens?: number;
+    estimatedCost?: number;
+    supportsStreaming?: boolean;
+}
+export interface ActionRequirements {
+    minPlan?: 'free' | 'starter' | 'growth' | 'enterprise';
+    permissions?: string[];
+    features?: string[];
+}
+export interface ActionDefinition {
+    id: string;
+    name: string;
+    description: string;
+    longDescription?: string;
+    category: ActionCategory;
+    type: ActionType;
+    tags: string[];
+    status: ActionStatus;
+    icon?: string;
+    iconString?: string;
+    color?: string;
+    connectorId?: string;
+    inputSchema: ActionIOSchema;
+    outputSchema: ActionOutputSchema;
+    execution?: ActionExecutionConfig;
+    testable?: boolean;
+    testInputExample?: unknown;
+    documentationUrl?: string;
+    videoTutorialUrl?: string;
+    examples?: ActionExample[];
+    aiMetadata?: ActionAIMetadata;
+    requires?: ActionRequirements;
+    version: string;
+    deprecated?: boolean;
+    deprecatedSince?: string;
+    replacedBy?: string;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string;
+    isOfficial?: boolean;
+    isVerified?: boolean;
+    isCommunity?: boolean;
+    author?: string;
+    authorUrl?: string;
+    usageCount?: number;
+    popularityScore?: number;
+}
+export interface ActionCategoryInfo {
+    id: ActionCategory;
+    label: string;
+    description: string;
+    icon: string;
+    order: number;
+}
+export interface ActionLibrary {
+    actions: ActionDefinition[];
+    categories: ActionCategoryInfo[];
+    featured: string[];
+    recommended: string[];
+    recentlyUsed?: string[];
+    customActions?: ActionDefinition[];
+    version: string;
+    lastUpdated: string;
+}
+export interface ActionErrorHandler {
+    type: 'skip' | 'retry' | 'goto' | 'fail';
+    gotoStepId?: string;
+    retries?: number;
+}
+export interface ActionValidationError {
+    field: string;
+    message: string;
+}
+export interface ActionInstance {
+    id: string;
+    actionDefinitionId: string;
+    name: string;
+    description?: string;
+    notes?: string;
+    config: Record<string, unknown>;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    condition?: string;
+    continueOnError?: boolean;
+    errorHandler?: ActionErrorHandler;
+    position: {
+        x: number;
+        y: number;
+    };
+    expanded?: boolean;
+    minimized?: boolean;
+    isValid?: boolean;
+    validationErrors?: ActionValidationError[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ActionTestResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    duration?: number;
+    cost?: number;
+}
+export interface DynamicSchemaRequest {
+    actionDefinitionId: string;
+    dependentValues: Record<string, unknown>;
+}
+export interface DynamicSchemaResponse {
+    fields: FieldConfig[];
+}
+export interface AIFieldMappingSuggestion {
+    mappings: Record<string, string>;
+    confidence: Record<string, number>;
+}
+export interface ActionConnection {
+    from: string;
+    to: string;
+    condition?: string;
+}
+export type TriggerAction = ActionDefinition & {
+    category: ActionCategory.Trigger;
+};
+export type AIAction = ActionDefinition & {
+    category: ActionCategory.AI;
+};
+export type DatabaseAction = ActionDefinition & {
+    category: ActionCategory.Database;
+};
+export type APIAction = ActionDefinition & {
+    category: ActionCategory.API;
+};
+export type LogicAction = ActionDefinition & {
+    category: ActionCategory.Logic;
+};
+export type TransformAction = ActionDefinition & {
+    category: ActionCategory.Transform;
+};
+export type ConnectorBasedAction = ActionDefinition & {
+    connectorId: string;
+};
+export type BuiltInAction = ActionDefinition & {
+    connectorId: null | undefined;
+};
+export type ConditionalField = FieldConfig & {
+    conditional: FieldConditional[];
+};
+export type DynamicField = FieldConfig & {
+    optionsSource: {
+        type: 'dynamic' | 'api';
+    };
+};
+export type AdvancedField = FieldConfig & {
+    advanced: true;
+};