@octaviaflow/flow-rules 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -23,3 +23,9 @@ 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 { 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";

package/dist/index.js

@@ -2872,12 +2872,127 @@ function getEdgeValidationStatus(edgeId, validationResult) {
     return "warning";
   return "valid";
 }
+// src/catalog/logic/condition/config.ts
+var CONDITION_OPERATORS = [
+  { id: "equals", label: "Equals", needsValue: true },
+  { id: "not_equals", label: "Not Equals", needsValue: true },
+  { id: "greater_than", label: "Greater Than", needsValue: true },
+  { id: "greater_than_equals", label: "Greater Than or Equals", needsValue: true },
+  { id: "less_than", label: "Less Than", needsValue: true },
+  { id: "less_than_equals", label: "Less Than or Equals", needsValue: true },
+  { id: "like", label: "Like", needsValue: true },
+  { id: "contains", label: "Contains", needsValue: true },
+  { id: "starts_with", label: "Starts With", needsValue: true },
+  { id: "ends_with", label: "Ends With", needsValue: true },
+  { id: "is_null", label: "Is Null", needsValue: false },
+  { id: "is_not_null", label: "Is Not Null", needsValue: false },
+  { id: "is_empty", label: "Is Empty", needsValue: false }
+];
+// src/catalog/logic/for-each/pathOptions.ts
+function inferSchemaFromSample(sample) {
+  const properties = {};
+  for (const [key, value] of Object.entries(sample)) {
+    if (value === null || value === undefined) {
+      properties[key] = { type: "string" };
+    } else if (Array.isArray(value)) {
+      if (value.length > 0 && typeof value[0] === "object" && value[0] !== null) {
+        properties[key] = { type: "array", items: inferSchemaFromSample(value[0]) };
+      } else {
+        properties[key] = { type: "array" };
+      }
+    } else if (typeof value === "object") {
+      properties[key] = inferSchemaFromSample(value);
+    } else if (typeof value === "number") {
+      properties[key] = { type: "number" };
+    } else if (typeof value === "boolean") {
+      properties[key] = { type: "boolean" };
+    } else {
+      properties[key] = { type: "string" };
+    }
+  }
+  return { type: "object", properties };
+}
+function collectArrayPaths(schema, prefix, add, depth = 0) {
+  if (!schema || typeof schema !== "object" || depth > 8)
+    return;
+  if (schema.type === "array") {
+    if (prefix) {
+      const itemsType = schema.items?.type;
+      const label = itemsType === "object" ? "array of objects" : "array";
+      add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+    }
+    if (schema.items) {
+      collectArrayPaths(schema.items, prefix, add, depth + 1);
+    }
+    return;
+  }
+  if (schema.type === "object" && schema.properties) {
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const next = prefix ? `${prefix}.${key}` : key;
+      collectArrayPaths(child, next, add, depth + 1);
+    }
+  }
+}
+function collectArrayPathsFromSample(sample, prefix, add, depth = 0) {
+  if (!sample || typeof sample !== "object" || depth > 8)
+    return;
+  if (Array.isArray(sample)) {
+    if (prefix) {
+      const itemsObj = sample.length > 0 && typeof sample[0] === "object" && sample[0] !== null;
+      const label = itemsObj ? "array of objects" : "array";
+      add(prefix, `${prefix}  (${label})`, `Iterate over "${prefix}"`);
+    }
+    if (sample.length > 0) {
+      collectArrayPathsFromSample(sample[0], prefix, add, depth + 1);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(sample)) {
+    const next = prefix ? `${prefix}.${key}` : key;
+    collectArrayPathsFromSample(value, next, add, depth + 1);
+  }
+}
+function buildPathOptions(upstreamNodes) {
+  const paths = [];
+  const seen = new Set;
+  const add = (id, text, description) => {
+    if (seen.has(id))
+      return;
+    seen.add(id);
+    paths.push({ id, text, description });
+  };
+  if (upstreamNodes) {
+    for (const node of upstreamNodes) {
+      const label = node.label || node.type || "Upstream";
+      const queryTable = node.config?.visualConfig?.tables?.[0];
+      add("data", queryTable ? `${queryTable} (${label})` : `All records (${label})`, queryTable ? `Iterate over every ${queryTable} record` : "Iterate over every record from upstream");
+      const schema = node.outputSchema || node.config?._outputSchema;
+      if (schema)
+        collectArrayPaths(schema, "", add);
+      const output = node.executionData?.output;
+      if (output) {
+        const records = Array.isArray(output.data) ? output.data : Array.isArray(output) ? output : null;
+        if (records && records.length > 0 && typeof records[0] === "object") {
+          collectArrayPathsFromSample(records[0], "", add);
+        }
+      }
+    }
+  }
+  if (paths.length === 0) {
+    add("data", "data (upstream output)");
+  }
+  return paths;
+}
 export {
   ActionCategory,
   ActionStatus,
   ActionType,
+  CONDITION_OPERATORS,
   FieldType,
   actionsRegistry,
+  buildPathOptions,
+  collectArrayPaths,
+  collectArrayPathsFromSample,
   generateEdgeId,
   generateStepId,
   generateUUIDv4,
@@ -2888,6 +3003,7 @@ export {
   getEdgeValidationStatus,
   getNodeConfigStatus,
   getNodeValidationStatus,
+  inferSchemaFromSample,
   validateEdge,
   validateNode,
   validateWorkflow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octaviaflow/flow-rules",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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",