@octaviaflow/flow-rules 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -23,12 +23,12 @@ export { actionsRegistry, getAllActions, getActionById, getActionsByCategory, }
 export { validateNode, validateEdge, validateWorkflow, getNodeValidationStatus, getEdgeValidationStatus, type ValidationError, type ValidationResult, } from "./rules/workflowValidator";
 export { getNodeConfigStatus, type NodeConfigStatus, type NodeConfigStatusResult, } from "./rules/nodeConfigStatus";
 export { generateWorkflowId, generateStepId, generateEdgeId, generateUUIDv4, } from "./ids";
-export { CONDITION_OPERATORS, type ConditionConfig, type ConditionFilter, type ConditionOperator, } from "./catalog/logic/condition/config";
-export { type ForEachConfig, type ForEachConfigType, type ForEachMode, } from "./catalog/logic/for-each/config";
+export { CONDITION_OPERATORS, ConditionConfig, type ConditionFilter, type ConditionOperator, } from "./catalog/logic/condition/config";
+export { ForEachConfig, type ForEachConfigType, type ForEachMode, } from "./catalog/logic/for-each/config";
 export { buildPathOptions, collectArrayPaths, collectArrayPathsFromSample, inferSchemaFromSample, type UpstreamNodeRef, } from "./catalog/logic/for-each/pathOptions";
-export { type QueryMode, type QueryType } from "./catalog/general/query/types";
-export { type VariableField, type VariableSource, type VariableSourceKind, type VariableType, type VariablesConfig, } from "./catalog/utility/variables/config";
-export { type DebugConfig, type DebugConfigType, type DebugMode, type DebugSamplingStrategy, type WatchExpression, } from "./catalog/utility/debug/config";
+export { QueryMode, QueryType } from "./catalog/general/query/types";
+export { type VariableField, type VariableSource, type VariableSourceKind, type VariableType, VariablesConfig, } from "./catalog/utility/variables/config";
+export { DebugConfig, type DebugConfigType, type DebugMode, type DebugSamplingStrategy, type WatchExpression, } from "./catalog/utility/debug/config";
 export { migrateDelayConfig, } from "./catalog/actions/delay/migrate";
 export { type DelayConfig, } from "./catalog/actions/delay/types";
 export { emailDefinition, } from "./catalog/communication/email-send/index";

package/dist/index.js

@@ -1026,6 +1026,19 @@ var groupDefinition = {
 };
 
 // src/catalog/general/query/types.ts
+var QueryMode;
+((QueryMode) => {
+  QueryMode["Visual"] = "visual";
+  QueryMode["SQL"] = "sql";
+})(QueryMode ||= {});
+var QueryType;
+((QueryType) => {
+  QueryType["Select"] = "select";
+  QueryType["Insert"] = "insert";
+  QueryType["Update"] = "update";
+  QueryType["Delete"] = "delete";
+  QueryType["Custom"] = "custom";
+})(QueryType ||= {});
 var LogicalOperator;
 ((LogicalOperator) => {
   LogicalOperator["And"] = "and";
@@ -2983,6 +2996,135 @@ var CONDITION_OPERATORS = [
   { id: "is_not_null", label: "Is Not Null", needsValue: false },
   { id: "is_empty", label: "Is Empty", needsValue: false }
 ];
+var ConditionConfig = {
+  defaults: {
+    mode: "visual",
+    filters: [],
+    condition: ""
+  },
+  schema: {
+    mode: { type: "select", required: true },
+    filters: { type: "array", required: false },
+    condition: { type: "expression", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (config.mode === "expression") {
+      if (!config.condition) {
+        errors.push("Condition expression is required");
+      } else {
+        try {
+          new Function(`return ${config.condition}`);
+        } catch (e) {
+          errors.push(`Invalid expression: ${e instanceof Error ? e.message : "Unknown error"}`);
+        }
+      }
+    } else {
+      if (!config.filters || config.filters.length === 0) {
+        errors.push("At least one condition filter is required");
+      } else {
+        config.filters.forEach((f, i) => {
+          if (!f.field)
+            errors.push(`Filter ${i + 1}: Field is required`);
+          if (!f.operator)
+            errors.push(`Filter ${i + 1}: Operator is required`);
+          const opDef = CONDITION_OPERATORS.find((o) => o.id === f.operator);
+          if (opDef?.needsValue && !f.value) {
+            errors.push(`Filter ${i + 1}: Value is required`);
+          }
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ConditionConfig.defaults, ...userConfig };
+  },
+  generateName: (filters) => {
+    if (filters.length === 0)
+      return "If …";
+    const parts = filters.map((f, i) => {
+      const opLabel = CONDITION_OPERATORS.find((o) => o.id === f.operator)?.label || f.operator;
+      const base = `${f.field || "?"} ${opLabel}${f.value ? ` ${f.value}` : ""}`;
+      if (i === 0)
+        return base;
+      return `${(f.logicalOperator || "and").toUpperCase()} ${base}`;
+    });
+    return `If ${parts.join(" ")}`;
+  },
+  getLabel: (config) => {
+    if (config.mode === "expression")
+      return `If ${config.condition || "…"}`;
+    return ConditionConfig.generateName(config.filters);
+  },
+  createFilterId: () => `cond_${Date.now()}_${randomSuffix(5)}`
+};
+// src/catalog/logic/for-each/config.ts
+var SOURCELESS_MODES = new Set(["range", "cursor", "while"]);
+var ForEachConfig = {
+  defaults: {
+    arrayPath: "",
+    iterationMode: "records",
+    itemVariable: "item",
+    indexVariable: "index",
+    batchSize: 0,
+    continueOnError: false,
+    concurrency: "sequential",
+    collect: "array"
+  },
+  schema: {
+    arrayPath: { type: "select", required: false },
+    iterationMode: { type: "select", required: false },
+    itemVariable: { type: "string", required: true },
+    indexVariable: { type: "string", required: false },
+    batchSize: { type: "number", required: false },
+    continueOnError: { type: "boolean", required: false }
+  },
+  validate: (config) => {
+    const errors = [];
+    const mode = config.iterationMode || "records";
+    if (mode === "range") {
+      if (!config.count || config.count <= 0) {
+        errors.push("Range mode needs a positive iteration count");
+      }
+    } else if (mode === "nested") {
+      if (!config.arrayPath)
+        errors.push("Select the records to drill into");
+      if (!config.nestedPath)
+        errors.push('Nested mode needs the sub-array path to iterate (e.g. "lineItems")');
+    } else if (!SOURCELESS_MODES.has(mode)) {
+      if (!config.arrayPath) {
+        errors.push("Array path is required — select which records to iterate over");
+      }
+    }
+    if (config.concurrency === "parallel" && config.maxConcurrency !== undefined && config.maxConcurrency < 1) {
+      errors.push("Max concurrency must be at least 1");
+    }
+    if (config.batchSize !== undefined && config.batchSize < 0) {
+      errors.push("Batch size must be 0 (all) or a positive number");
+    }
+    if (config.collect === "groupBy" && !config.groupByPath) {
+      errors.push("Group-by collection needs a field path to group on");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => {
+    return { ...ForEachConfig.defaults, ...userConfig };
+  },
+  getLabel: (config) => {
+    const mode = config.iterationMode || "records";
+    if (mode === "range")
+      return `ForEach ×${config.count ?? "…"}`;
+    if (mode === "cursor")
+      return "ForEach (paginate)";
+    if (mode === "while")
+      return "ForEach (while)";
+    return `ForEach in ${config.arrayPath || "…"}`;
+  },
+  generateName: (arrayPath) => {
+    return `ForEach in ${arrayPath || "…"}`;
+  }
+};
 // src/catalog/logic/for-each/pathOptions.ts
 function inferSchemaFromSample(sample) {
   const properties = {};
@@ -3078,6 +3220,127 @@ function buildPathOptions(upstreamNodes) {
   }
   return paths;
 }
+// src/catalog/utility/variables/config.ts
+var RESERVED_KEYS = new Set(["_lineage", "_meta", "_redacted", "_error"]);
+var KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var VariablesConfig = {
+  defaults: {
+    fields: []
+  },
+  validate(config) {
+    const errors = [];
+    const fields = config.fields ?? [];
+    const seen = new Set;
+    for (const f of fields) {
+      if (!f.key) {
+        errors.push("Each field needs a key.");
+        continue;
+      }
+      if (RESERVED_KEYS.has(f.key)) {
+        errors.push(`"${f.key}" is reserved — pick another key.`);
+        continue;
+      }
+      if (!KEY_PATTERN.test(f.key)) {
+        errors.push(`"${f.key}" is not a valid identifier (letters, digits, underscore; must not start with a digit).`);
+        continue;
+      }
+      if (seen.has(f.key)) {
+        errors.push(`Duplicate key "${f.key}".`);
+        continue;
+      }
+      seen.add(f.key);
+      if (!f.type)
+        errors.push(`"${f.key}" is missing a type.`);
+      if (!f.source)
+        errors.push(`"${f.key}" is missing a source.`);
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  computeOutputSchema(fields) {
+    const properties = {};
+    for (const f of fields) {
+      properties[f.key] = fieldToJsonSchema(f);
+    }
+    return { type: "object", properties };
+  }
+};
+function fieldToJsonSchema(f) {
+  const node = { type: f.type };
+  if (f.description)
+    node.description = f.description;
+  if (f.validation?.enum)
+    node.enum = f.validation.enum;
+  return node;
+}
+// src/catalog/utility/debug/config.ts
+var DebugConfig = {
+  defaults: {
+    mode: "log",
+    label: "",
+    log: { level: "info", message: "" }
+  },
+  validate(config) {
+    const errors = [];
+    if (!config.mode)
+      errors.push("Mode is required.");
+    if (!config.label?.trim())
+      errors.push("Label is required.");
+    switch (config.mode) {
+      case "log":
+        if (!config.log?.message?.trim())
+          errors.push("Log mode: message is required.");
+        if (!config.log?.level)
+          errors.push("Log mode: level is required.");
+        break;
+      case "snapshot":
+        break;
+      case "watch":
+        if (!config.watch?.expressions?.length) {
+          errors.push("Watch mode: add at least one expression.");
+        } else {
+          for (const e of config.watch.expressions) {
+            if (!e.label?.trim())
+              errors.push("Watch mode: each expression needs a label.");
+            if (!e.expression?.trim())
+              errors.push("Watch mode: each expression needs an expression string.");
+          }
+        }
+        break;
+      case "assert":
+        if (!config.assert?.predicate?.trim())
+          errors.push("Assert mode: predicate is required.");
+        if (!config.assert?.failureMessage?.trim())
+          errors.push("Assert mode: failure message is required.");
+        break;
+      case "profile":
+        if (!config.profile?.scope)
+          errors.push("Profile mode: scope is required.");
+        break;
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  migrateLegacyStub(config) {
+    if (config.mode) {
+      const { value: _stub, ...rest } = config;
+      return { ...DebugConfig.defaults, ...rest };
+    }
+    return {
+      mode: "log",
+      label: config.label ?? "Debug",
+      log: {
+        level: "info",
+        message: config.label ?? "Debug",
+        includeInputData: true
+      }
+    };
+  },
+  merge(userConfig) {
+    return { ...DebugConfig.defaults, ...userConfig };
+  },
+  getLabel(config) {
+    return `Debug [${config.mode}]: ${config.label}`;
+  }
+};
 // src/catalog/actions/delay/migrate.ts
 var LEGACY_UNITS = new Set([
   "milliseconds",
@@ -3435,16 +3698,22 @@ export {
   ActionType,
   AggregateFunction,
   CONDITION_OPERATORS,
+  ConditionConfig,
   DATABASE_CONNECTOR_IDS,
+  DebugConfig,
   EmailConfig,
   FieldType,
+  ForEachConfig,
   JoinType,
   LogicalOperator,
   ManualTriggerConfig,
+  QueryMode,
+  QueryType,
   STORAGE_CONNECTOR_IDS,
   SortDirection,
   TRANSFORM_OPERATIONS,
   TransformConfig,
+  VariablesConfig,
   actionsRegistry,
   buildPathOptions,
   collectArrayPaths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octaviaflow/flow-rules",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "The flow action catalog and the rules engine behind Flow Doctor — one definition of what a step accepts and what makes a flow valid, shared by the editor and the server",
   "type": "module",
   "main": "./dist/index.js",