@octaviaflow/flow-rules 0.11.1 → 0.13.0

package/dist/catalog/actions/console-log/config.d.ts

@@ -36,6 +36,7 @@ export declare const ConsoleLogConfig: {
         level: {
             type: string;
             required: boolean;
+            options: string[];
             description: string;
         };
         data: {

package/dist/catalog/actions/delay/config.d.ts

@@ -25,6 +25,7 @@ export declare const DelayConfig: {
         unit: {
             type: string;
             required: boolean;
+            options: string[];
             description: string;
         };
     };

package/dist/catalog/actions/http-request/config.d.ts

@@ -72,6 +72,7 @@ export declare const HTTPRequestConfig: {
         apiType: {
             type: string;
             required: boolean;
+            options: string[];
         };
         baseUrl: {
             type: string;
@@ -84,6 +85,7 @@ export declare const HTTPRequestConfig: {
         bodyType: {
             type: string;
             required: boolean;
+            options: string[];
         };
         formData: {
             type: string;
@@ -124,6 +126,7 @@ export declare const HTTPRequestConfig: {
         responseType: {
             type: string;
             required: boolean;
+            options: string[];
         };
         expectedContentTypes: {
             type: string;
@@ -132,6 +135,7 @@ export declare const HTTPRequestConfig: {
         method: {
             type: string;
             required: boolean;
+            options: string[];
             description: string;
         };
         url: {

package/dist/catalog/communication/email-send/config.d.ts

@@ -29,6 +29,8 @@ export declare const EmailConfig: {
         operation: {
             type: string;
             required: boolean;
+            options: string[];
+            description: string;
         };
         to: {
             type: string;

package/dist/catalog/communication/webhook-call/config.d.ts

@@ -17,6 +17,7 @@ export declare const WebhookCallConfig: {
         method: {
             type: string;
             required: boolean;
+            options: string[];
         };
         payload: {
             type: string;

package/dist/catalog/communication/whatsapp-send/config.d.ts

@@ -25,6 +25,7 @@ export declare const WhatsappSendConfig: {
         mode: {
             type: string;
             required: boolean;
+            options: string[];
         };
         templateName: {
             type: string;

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

@@ -0,0 +1,126 @@
+/**
+ * Aggregate Action — Config Contract
+ *
+ * Fold the upstream records into ONE row — or one row per group — of computed
+ * values. It exists because nothing else could total a column (DEV-422): a
+ * Transform maps one record at a time and cannot see the others, and the only
+ * built-in sum was ForEach's `collect: 'reduce'`, which reduces loop-body
+ * results and is reachable from nowhere an author, or an agent reading
+ * `describe_action_type`, would look.
+ *
+ * Output: `{ data: [ { ...groupKeys, ...metrics } ], _meta }` — the same
+ * `data: row[]` envelope Query, Transform and Variables emit, so the Transform
+ * after it maps `{{totals[].TotalAmount}}` exactly as it maps a Query's rows.
+ *
+ * The Engine's `aggregateExecutor.ts` reads this shape; the two stay in step.
+ */
+/** The functions a metric can apply. `describe_action_type` lists them. */
+export declare const AGGREGATE_FUNCTIONS: readonly ["sum", "count", "avg", "min", "max", "count_distinct", "first", "last"];
+export type AggregateFn = (typeof AGGREGATE_FUNCTIONS)[number];
+/** What each function computes — the panel's help text and the contract's description. */
+export declare const AGGREGATE_FUNCTION_DESCRIPTIONS: Readonly<Record<AggregateFn, string>>;
+export interface AggregateMetric {
+    /** One of `AGGREGATE_FUNCTIONS`. */
+    fn: AggregateFn;
+    /**
+     * The record field it reads — a dot-path such as "Balance" or
+     * "CustomerRef.name". `count` may omit it to count records.
+     */
+    field?: string;
+    /** The key the value lands under on the output row. An identifier, unique within the step. */
+    as: string;
+    /** Round a sum or avg to this many decimal places (0–10). Omit to keep the value as computed. */
+    decimals?: number;
+}
+export interface AggregateConfigType {
+    /**
+     * Which upstream records: a path to an array in the upstream step's output.
+     * Empty means the records the previous step produced (its `data`). Resolved
+     * exactly as ForEach's `arrayPath`.
+     */
+    arrayPath?: string;
+    /**
+     * Record fields (dot-paths) to group by. Empty: one row for all records.
+     * Each key lands on the output row under its last segment
+     * ("CustomerRef.name" → "name").
+     */
+    groupBy?: string[];
+    /** The values to compute. At least one. */
+    metrics: AggregateMetric[];
+    /**
+     * The name later steps use for this result, e.g. `totals` →
+     * `{{totals[].TotalAmount}}`. Defaults to the step's name.
+     */
+    outputAs?: string;
+    /**
+     * The output ROW's schema, written by the panel at save time so the picker
+     * shows the keys before a run. The Backend contributor derives the same
+     * thing from the config with `computeOutputSchema`.
+     */
+    _outputSchema?: {
+        type: 'object';
+        properties: Record<string, unknown>;
+    };
+}
+/** A JSON-schema-like node, as the DataStream and `_outputSchema` carry it. */
+export interface AggregateSchemaNode {
+    type?: string;
+    properties?: Record<string, AggregateSchemaNode>;
+    items?: AggregateSchemaNode;
+    description?: string;
+}
+/**
+ * The output key a group-by field lands under: its last path segment, with a
+ * trailing `[]` removed. "CustomerRef.name" → "name"; "Region" → "Region".
+ * The Engine names the group keys the same way.
+ */
+export declare function groupKeyName(path: string): string;
+export declare const AggregateConfig: {
+    schema: {
+        arrayPath: {
+            type: string;
+            required: boolean;
+            dynamic: boolean;
+            description: string;
+        };
+        groupBy: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        metrics: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+        outputAs: {
+            type: string;
+            required: boolean;
+            description: string;
+        };
+    };
+    defaults: AggregateConfigType;
+    /**
+     * What blocks execution, refused before the run (a 409 on an active flow
+     * over MCP, a warning on a draft): no metrics, an unknown function, a
+     * function with nothing to read, an output key that is not an identifier or
+     * is taken, decimals outside 0–10, an outputAs that is not a single name.
+     */
+    validate(config: Partial<AggregateConfigType>): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * The schema of ONE output row: the group keys (typed from the source record
+     * when `source` is known) and each metric under its `as`. The panel writes
+     * it to `_outputSchema`; the Backend contributor wraps it as `array<row>` at
+     * the step's output path. One implementation, two callers.
+     */
+    computeOutputSchema(config: Partial<AggregateConfigType>, source?: AggregateSchemaNode): {
+        type: "object";
+        properties: Record<string, unknown>;
+    };
+    merge(userConfig: Partial<AggregateConfigType>): AggregateConfigType;
+    /** "sum(Balance), count by name" — the node's auto label. */
+    getLabel(config: Partial<AggregateConfigType>): string;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * Aggregate Action
+ *
+ * Totals, counts, averages, min/max, distinct counts and first/last over the
+ * upstream records — one output row, or one per group. Sits after the step
+ * that produces the rows and before the step that writes the result (the
+ * "TOTAL row" case: Query → Transform (insert rows) → Aggregate → Transform
+ * (insert one row)). The config contract is `./config.ts` (DEV-422).
+ */
+import { ActionDefinition } from '../../types';
+export declare const aggregateDefinition: ActionDefinition;

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

@@ -48,10 +48,14 @@ export declare const BuildQueryContractSchema: {
     readonly mode: {
         readonly type: "select";
         readonly required: true;
+        readonly options: readonly ["visual", "sql"];
+        readonly description: "visual: the query is built from visualConfig; sql: the query is the text in sqlConfig.sql";
     };
     readonly queryType: {
         readonly type: "select";
         readonly required: true;
+        readonly options: readonly ["select", "insert", "update", "delete", "custom"];
+        readonly description: "Only select is a read; the write types exist for the SQL mode of database connectors";
     };
     readonly visualConfig: {
         readonly type: "object";

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

@@ -26,6 +26,14 @@ export interface FieldMapping {
     depth?: number;
 }
 export type TransformMode = 'visual' | 'expression';
+/**
+ * The authoring modes. `visual` is the Field Mapper and the only mode the panel
+ * offers; `expression` is the retired JavaScript mode, kept so steps saved in it
+ * still run. Anything else is not a mode: the Engine fails the step with
+ * "Unknown transform mode" at run time, against the customer's live systems —
+ * which is how an agent's guess of `"append"` surfaced (DEV-421).
+ */
+export declare const TRANSFORM_MODES: readonly TransformMode[];
 /** Data operation the user wants to perform */
 export type TransformOperation = 'upsert' | 'insert' | 'update' | 'delete';
 export declare const TRANSFORM_OPERATIONS: {
@@ -82,6 +90,8 @@ export declare const TransformConfig: {
         operation: {
             type: string;
             required: boolean;
+            options: readonly TransformOperation[];
+            description: string;
         };
         connectorId: {
             type: string;
@@ -90,14 +100,19 @@ export declare const TransformConfig: {
         database: {
             type: string;
             required: boolean;
+            description: string;
         };
         objectName: {
             type: string;
             required: boolean;
+            dynamic: boolean;
+            description: string;
         };
         mode: {
             type: string;
             required: boolean;
+            options: readonly TransformMode[];
+            description: string;
         };
         mappings: {
             type: string;

package/dist/catalog/index.d.ts

@@ -16,6 +16,7 @@ import { forEachDefinition } from './logic/for-each';
 import { groupDefinition } from './logic/group';
 import { queryDefinition } from './general/query';
 import { transformDefinition } from './general/transform';
+import { aggregateDefinition } from './general/aggregate';
 import { csvActionDefinition } from './storage/csv-action';
 import { jsonActionDefinition } from './storage/json-action';
 import { xmlActionDefinition } from './storage/xml-action';
@@ -54,4 +55,4 @@ 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, };
+export { csvActionDefinition, jsonActionDefinition, xmlActionDefinition, excelActionDefinition, s3ActionDefinition, ftpActionDefinition, googleDriveActionDefinition, dropboxActionDefinition, onedriveActionDefinition, manualTriggerDefinition, scheduleTriggerDefinition, webhookTriggerDefinition, httpRequestDefinition, consoleLogDefinition, delayDefinition, conditionDefinition, forEachDefinition, groupDefinition, queryDefinition, transformDefinition, aggregateDefinition, debugDefinition, errorDefinition, variablesDefinition, graphqlQueryDefinition, emailDefinition, slackMessageDefinition, whatsappSendDefinition, teamsMessageDefinition, googleChatDefinition, webhookCallDefinition, aiAgentDefinition, idpExtractDefinition, };

package/dist/catalog/isOneOf.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Membership test for a readonly string tuple, narrowing the value to the
+ * tuple's union. Shared by the contracts that refuse a value outside a fixed
+ * set (Transform's mode/operation, Aggregate's function) so each names the
+ * allowed values in its message instead of failing at run time.
+ */
+export declare const isOneOf: <T extends string>(set: readonly T[], value: unknown) => value is T;

package/dist/catalog/logic/condition/config.d.ts

@@ -32,6 +32,7 @@ export declare const ConditionConfig: {
         mode: {
             type: string;
             required: boolean;
+            options: string[];
         };
         filters: {
             type: string;

package/dist/catalog/logic/for-each/config.d.ts

@@ -68,10 +68,14 @@ export declare const ForEachConfig: {
         arrayPath: {
             type: string;
             required: boolean;
+            dynamic: boolean;
+            description: string;
         };
         iterationMode: {
             type: string;
             required: boolean;
+            options: string[];
+            description: string;
         };
         itemVariable: {
             type: string;

package/dist/catalog/logic/for-each/recordSchema.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The shape of ONE record at a path in an upstream step's output — what a
+ * step that reads those records sees per row — and the field names it
+ * carries. Pure and framework-free, so a panel that picks a record field
+ * (Aggregate's group-by and metric fields, DEV-422) offers the fields the
+ * Engine's `resolveArrayPath` will actually hand the step.
+ *
+ * Resolution order mirrors the ForEach panel's source resolution: the
+ * upstream node's static schema (`outputSchema`, else the editor's
+ * `config._outputSchema`) walked along the path; then the last run's sample
+ * output; then the static schema as a whole. Only the first upstream node is
+ * consulted — it is the one the step is wired from.
+ */
+import { type UpstreamNodeRef } from './pathOptions';
+export interface RecordSchemaLike {
+    type?: string;
+    properties?: Record<string, any>;
+    items?: any;
+}
+export declare function resolveRecordSchema(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): RecordSchemaLike | undefined;
+/**
+ * The field names a record at `arrayPath` carries: the resolved schema's
+ * keys, unioned with the ACTUAL keys of the last run's records — live rows
+ * can be sparse or carry system fields a describe-derived schema omits.
+ */
+export declare function detectRecordFields(upstreamNodes: UpstreamNodeRef[] | undefined, arrayPath: string): string[];

package/dist/catalog/storage/file-operation/config.d.ts

@@ -21,6 +21,7 @@ export declare const FileOperationConfig: {
         operation: {
             type: string;
             required: boolean;
+            options: string[];
         };
         sourcePath: {
             type: string;

package/dist/catalog/transforms/format/config.d.ts

@@ -12,6 +12,7 @@ export declare const FormatConfig: {
         format: {
             type: string;
             required: boolean;
+            options: string[];
         };
     };
     validate: (config: Partial<FormatConfigType>) => {

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

@@ -14,6 +14,7 @@ export declare const ScheduleTriggerConfig: {
         scheduleType: {
             type: string;
             required: boolean;
+            options: string[];
         };
         interval: {
             type: string;
@@ -23,6 +24,7 @@ export declare const ScheduleTriggerConfig: {
         intervalUnit: {
             type: string;
             required: boolean;
+            options: string[];
         };
         cronExpression: {
             type: string;

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

@@ -16,6 +16,7 @@ export declare const WebhookTriggerConfig: {
         method: {
             type: string;
             required: boolean;
+            options: string[];
         };
         requireAuth: {
             type: string;

package/dist/catalog/types.d.ts

@@ -47,6 +47,7 @@ export declare enum ActionType {
     SpeechToText = "speech_to_text",
     TextToSpeech = "text_to_speech",
     Transform = "transform",
+    Aggregate = "aggregate",
     FileOperation = "file_operation",
     FileAction = "file_action",
     CsvAction = "csv_action",

package/dist/catalog/utility/debug/config.d.ts

@@ -55,6 +55,7 @@ export declare const DebugConfig: {
         mode: {
             type: string;
             required: boolean;
+            options: string[];
         };
         label: {
             type: string;