@oomol-lab/open-flow 0.1.0-beta.72 → 0.1.0-beta.74

package/src/flow/common/codePermissions.ts

@@ -0,0 +1,2 @@
+// Shared Code permissions are parked. Keep their data and execution contracts intact.
+export const codeSharedPermissionsEnabled = false

package/src/flow/common/condition.ts

@@ -0,0 +1,265 @@
+import type {
+  ConditionExpression,
+  ConditionNode,
+  ConditionOperand,
+  ConditionOperator,
+  GraphNode,
+  InputMapping,
+  InputPortDefinition,
+  JsonValue,
+  Source,
+} from './change.ts'
+
+import { dequal } from 'dequal/lite'
+
+export const otherwiseOutput = 'otherwise'
+export const conditionOperators: readonly ConditionOperator[] = [
+  '==',
+  '!=',
+  '<',
+  '<=',
+  '>',
+  '>=',
+  'contains',
+  'notContains',
+  'startsWith',
+  'endsWith',
+  'hasKey',
+  'notHasKey',
+  'hasValue',
+  'notHasValue',
+  'isEmpty',
+  'isNotEmpty',
+  'isNull',
+  'isNotNull',
+  'isTrue',
+  'isFalse',
+]
+export const unaryOperator = (operator: ConditionOperator): boolean => operator.startsWith('is')
+export const operandHandle = (caseIndex: number, groupIndex: number, expressionIndex: number, side: 'left' | 'right'): string =>
+  `${caseIndex}/${groupIndex}/${expressionIndex}/${side}`
+
+/** Derived addresses let operand bindings use the ordinary input analysis and editor. Never persisted as node inputs. */
+export function conditionOperands(
+  node: Pick<ConditionNode, 'cases'>,
+): readonly { handle: string; operand: ConditionOperand; expression: ConditionExpression; side: 'left' | 'right' }[] {
+  return node.cases.flatMap((item, c) =>
+    item.groups.flatMap((group, g) =>
+      group.expressions.flatMap((expression, e) => [
+        { handle: operandHandle(c, g, e, 'left'), operand: expression.left, expression, side: 'left' as const },
+        ...(!unaryOperator(expression.operator)
+          ? [{ handle: operandHandle(c, g, e, 'right'), operand: expression.right ?? { kind: 'value' as const }, expression, side: 'right' as const }]
+          : []),
+      ]),
+    ),
+  )
+}
+
+export function nodeInputMappings(node: GraphNode): Readonly<Record<string, InputMapping>> {
+  if (node.kind == 'outputs') return node.outputMappings
+  if (node.kind != 'condition') return 'inputs' in node ? node.inputs : {}
+  return Object.fromEntries(
+    conditionOperands(node).flatMap<[string, InputMapping]>(({ handle, operand }) =>
+      operand.kind == 'source'
+        ? [[handle, { kind: 'sources' as const, sources: [operand.source] }]]
+        : operand.value === undefined
+          ? []
+          : [[handle, { kind: 'value' as const, value: operand.value }]],
+    ),
+  )
+}
+
+export function conditionInputPorts(node: ConditionNode): Readonly<Record<string, InputPortDefinition>> {
+  return Object.fromEntries(
+    conditionOperands(node).map(({ handle, operand }) => [
+      handle,
+      { jsonSchema: operand.kind === 'value' ? (operand.jsonSchema ?? {}) : {}, nullable: operand.kind === 'value' ? operand.value === null : true },
+    ]),
+  )
+}
+
+export function mapConditionSources(node: ConditionNode, map: (source: Source) => Source): ConditionNode {
+  const operand = (value: ConditionOperand): ConditionOperand => (value.kind == 'source' ? { ...value, source: map(value.source) } : value)
+  return {
+    ...node,
+    cases: node.cases.map((item) => ({
+      ...item,
+      groups: item.groups.map((group) => ({
+        ...group,
+        expressions: group.expressions.map((expression) => ({
+          ...expression,
+          left: operand(expression.left),
+          ...(expression.right == null ? {} : { right: operand(expression.right) }),
+        })),
+      })),
+    })),
+  }
+}
+
+function clearConditionBinding(operand: ConditionOperand): ConditionOperand {
+  return operand.kind == 'source' && operand.source.kind == 'binding' ? { kind: 'value' } : operand
+}
+
+export function clearConditionBindings(node: ConditionNode): ConditionNode {
+  return {
+    ...node,
+    cases: node.cases.map((item) => ({
+      ...item,
+      groups: item.groups.map((group) => ({
+        ...group,
+        expressions: group.expressions.map((expression) => ({
+          ...expression,
+          left: clearConditionBinding(expression.left),
+          ...(expression.right == null ? {} : { right: clearConditionBinding(expression.right) }),
+        })),
+      })),
+    })),
+  }
+}
+
+export function setConditionInput(node: ConditionNode, handle: string, mapping: InputMapping | undefined): ConditionNode {
+  const entry = conditionOperands(node).find((item) => item.handle == handle)
+  if (entry == null) throw new Error('Condition operand does not exist.')
+  if (mapping?.kind == 'sources' && mapping.sources.length != 1) throw new Error('A Condition operand requires one Source.')
+  const value: ConditionOperand =
+    mapping?.kind == 'sources'
+      ? { kind: 'source', source: mapping.sources[0]! }
+      : {
+          kind: 'value',
+          ...(entry.operand.kind === 'value' && entry.operand.jsonSchema != null ? { jsonSchema: entry.operand.jsonSchema } : {}),
+          ...(mapping?.kind == 'value' ? { value: mapping.value } : {}),
+        }
+  const [c, g, e] = handle.split('/').map(Number)
+  return {
+    ...node,
+    cases: node.cases.map((item, ci) =>
+      ci != c
+        ? item
+        : {
+            ...item,
+            groups: item.groups.map((group, gi) =>
+              gi != g
+                ? group
+                : { ...group, expressions: group.expressions.map((expression, ei) => (ei != e ? expression : { ...expression, [entry.side]: value })) },
+            ),
+          },
+    ),
+  }
+}
+
+export function valueType(value: JsonValue): string {
+  return value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value
+}
+export function operatorsForType(type?: string): readonly ConditionOperator[] {
+  if (type == null) return conditionOperators
+  const specific: Record<string, readonly ConditionOperator[]> = {
+    number: ['<', '<=', '>', '>='],
+    integer: ['<', '<=', '>', '>='],
+    string: ['contains', 'notContains', 'startsWith', 'endsWith', 'isEmpty', 'isNotEmpty'],
+    array: ['contains', 'notContains', 'isEmpty', 'isNotEmpty'],
+    object: ['hasKey', 'notHasKey', 'hasValue', 'notHasValue', 'isEmpty', 'isNotEmpty'],
+    boolean: ['isTrue', 'isFalse'],
+    null: [],
+  }
+  return ['==', '!=', ...(specific[type] ?? []), 'isNull', 'isNotNull']
+}
+const normalized = (type: string | undefined) => (type == 'integer' ? 'number' : type)
+
+export interface ComparisonIssue {
+  readonly target: 'operator' | 'right'
+  readonly message: string
+}
+
+export function comparisonIssue(operator: ConditionOperator, leftType?: string, rightType?: string): ComparisonIssue | undefined {
+  if (leftType != null && !operatorsForType(leftType).includes(operator)) {
+    return { target: 'operator', message: `Operator ${operator} is not compatible with ${leftType}.` }
+  }
+  if (unaryOperator(operator) || rightType == null) return
+  const required = ['<', '<=', '>', '>='].includes(operator)
+    ? 'number'
+    : ['startsWith', 'endsWith', 'hasKey', 'notHasKey'].includes(operator) || (['contains', 'notContains'].includes(operator) && leftType == 'string')
+      ? 'string'
+      : ['==', '!='].includes(operator)
+        ? normalized(leftType)
+        : undefined
+  if (required != null && required != normalized(rightType)) {
+    return { target: 'right', message: `Operator ${operator} requires a ${required} right operand.` }
+  }
+}
+export function compareCondition(operator: ConditionOperator, left: JsonValue, right?: JsonValue): boolean {
+  if (!unaryOperator(operator) && right === undefined) throw new Error('Condition right operand is missing.')
+  const issue = comparisonIssue(operator, valueType(left), right === undefined ? undefined : valueType(right))
+  if (issue != null) throw new Error(issue.message)
+  switch (operator) {
+    case '==':
+      return dequal(left, right)
+    case '!=':
+      return !dequal(left, right)
+    case '<':
+      return (left as number) < (right as number)
+    case '<=':
+      return (left as number) <= (right as number)
+    case '>':
+      return (left as number) > (right as number)
+    case '>=':
+      return (left as number) >= (right as number)
+    case 'contains':
+    case 'notContains': {
+      const contains = typeof left == 'string' ? left.includes(right as string) : (left as readonly JsonValue[]).some((item) => dequal(item, right))
+      return operator == 'contains' ? contains : !contains
+    }
+    case 'startsWith':
+      return (left as string).startsWith(right as string)
+    case 'endsWith':
+      return (left as string).endsWith(right as string)
+    case 'hasKey':
+    case 'notHasKey': {
+      const has = Object.hasOwn(left as object, right as string)
+      return operator == 'hasKey' ? has : !has
+    }
+    case 'hasValue':
+    case 'notHasValue': {
+      const has = Object.values(left as object).some((item) => dequal(item, right))
+      return operator == 'hasValue' ? has : !has
+    }
+    case 'isEmpty':
+    case 'isNotEmpty': {
+      const empty = typeof left == 'string' || Array.isArray(left) ? left.length == 0 : Object.keys(left as object).length == 0
+      return operator == 'isEmpty' ? empty : !empty
+    }
+    case 'isNull':
+      return left === null
+    case 'isNotNull':
+      return left !== null
+    case 'isTrue':
+      return left === true
+    case 'isFalse':
+      return left === false
+  }
+}
+
+export function selectConditionBranches(node: ConditionNode, values: Readonly<Record<string, JsonValue>>): readonly string[] {
+  // Check every resolved operand before matching, including later cases in first mode.
+  for (const { handle } of conditionOperands(node)) if (!Object.hasOwn(values, handle)) throw new Error(`Condition operand ${handle} is missing.`)
+  const results = node.cases.map((item, c) => {
+    if (item.groups.length == 0) throw new Error('Condition Case requires a group.')
+    return item.groups.map((group, g) => {
+      if (group.expressions.length == 0) throw new Error('Condition group requires an expression.')
+      return group.expressions.map((expression, e) => {
+        const left = values[operandHandle(c, g, e, 'left')]!
+        const right = unaryOperator(expression.operator) ? undefined : values[operandHandle(c, g, e, 'right')]
+        const issue = comparisonIssue(expression.operator, valueType(left), right === undefined ? undefined : valueType(right))
+        if (issue != null || (!unaryOperator(expression.operator) && right === undefined))
+          throw new Error(issue?.message ?? 'Condition right operand is missing.')
+        return () => compareCondition(expression.operator, left, right)
+      })
+    })
+  })
+  const selected: string[] = []
+  for (const [index, groups] of results.entries()) {
+    if (!groups.some((expressions) => expressions.every((evaluate) => evaluate()))) continue
+    selected.push(node.cases[index]!.output)
+    if (node.matchMode == 'first') break
+  }
+  return selected.length == 0 ? [otherwiseOutput] : selected
+}

package/src/flow/common/connectionUsage.ts

@@ -0,0 +1,131 @@
+import type { FlowDocument, RevisionContent } from './change.ts'
+
+export interface ConnectionUsage {
+  readonly providerId: string
+  readonly connectionId?: string
+  readonly actionId?: string
+  readonly triggerId?: string
+  readonly nodeId: string
+  readonly name: string
+
+  readonly kind: 'connector' | 'agent' | 'trigger' | 'notification' | 'code'
+}
+
+export function connectionUsage(document: FlowDocument): readonly ConnectionUsage[] {
+  const uses: ConnectionUsage[] = []
+
+  for (const [nodeId, node] of Object.entries(document.graph.nodes)) {
+    const task = node.kind == 'task' && 'executor' in node.task ? node.task : undefined
+    const name = node.name ?? task?.name ?? nodeId
+    const add = (kind: ConnectionUsage['kind'], actionId: string, connectionId?: string) => {
+      uses.push({ kind, providerId: actionId.split('.')[0]!, actionId, connectionId, nodeId, name })
+    }
+    if (node.kind == 'poll' || node.kind == 'integration') {
+      uses.push({
+        kind: 'trigger',
+        triggerId: node.definition.key,
+        providerId: node.definition.provider,
+        connectionId: node.connectionId,
+        nodeId,
+        name,
+      })
+    }
+    if (task?.executor.kind == 'connector') add('connector', task.executor.action, task.executor.connectionId)
+    if (node.kind == 'task' && 'moduleId' in node.task) {
+      for (const capability of node.task.capabilities ?? []) {
+        if ('mode' in capability && capability.mode == 'independent') for (const action of capability.actions) add('code', action.action, action.connectionId)
+      }
+    }
+    if (task?.executor.kind == 'agent') {
+      for (const tool of task.executor.tools) if (tool.kind != 'workflow') add('agent', tool.action, tool.connectionId)
+      const notification = task.executor.notification
+      if (notification != null) add('notification', notification.action, notification.connectionId)
+    }
+  }
+  return uses
+}
+
+export function removeConnectionUsage(content: RevisionContent, connectionId: string): RevisionContent {
+  const document = content.document
+  return {
+    ...content,
+    document: {
+      ...document,
+      graph: clearNodeConnections(document.graph, connectionId),
+    },
+  }
+}
+
+export function clearNodeConnections(graph: FlowDocument['graph'], connectionId?: string): FlowDocument['graph'] {
+  return {
+    ...graph,
+    nodes: Object.fromEntries(
+      Object.entries(graph.nodes).map(([id, node]) => {
+        if ((node.kind == 'poll' || node.kind == 'integration') && (connectionId == null || node.connectionId == connectionId)) {
+          const { connectionId: _, ...remaining } = node
+          return [id, remaining]
+        }
+        if (node.kind != 'task') return [id, node]
+        if ('executor' in node.task) {
+          const executor = node.task.executor
+          const clear = <T extends { readonly connectionId?: string }>(value: T): T => {
+            if (value.connectionId === '') return value
+            if (connectionId != null && value.connectionId != connectionId) return value
+            const { connectionId: _, ...rest } = value
+            return rest as T
+          }
+          if (executor.kind == 'connector') return [id, { ...node, task: { ...node.task, executor: clear(executor) } }]
+          if (executor.kind == 'agent')
+            return [
+              id,
+              {
+                ...node,
+                task: {
+                  ...node.task,
+                  executor: {
+                    ...executor,
+                    tools: executor.tools.map(clear),
+                    ...(executor.notification == null ? {} : { notification: clear(executor.notification) }),
+                  },
+                },
+              },
+            ]
+          return [id, node]
+        }
+        const capabilities = node.task.capabilities?.map((capability) => {
+          if (capability.kind == 'workflow') return capability
+          if (!('mode' in capability)) {
+            if ('action' in capability) {
+              const { connectionId: selected, ...rest } = capability
+              return {
+                ...rest,
+                connections: capability.connections.filter((item) => connectionId != null && item.connectionId != connectionId),
+                ...(selected != null && connectionId != null && selected != connectionId ? { connectionId: selected } : {}),
+              }
+            }
+            return {
+              ...capability,
+              ...(connectionId == null && (capability.connectionHints?.length ?? 0) > 0
+                ? { actionHints: [...new Set([...(capability.actionHints ?? []), ...capability.connectionHints!.map((hint) => hint.action)])] }
+                : {}),
+              ...(capability.connectionHints == null
+                ? {}
+                : { connectionHints: capability.connectionHints.filter((item) => connectionId != null && item.connectionId != connectionId) }),
+            }
+          }
+          if (capability.mode != 'independent') return capability
+          return {
+            ...capability,
+            actions: capability.actions.map((action) => {
+              if (action.connectionId === '') return action
+              if (connectionId != null && action.connectionId != connectionId) return action
+              const { connectionId: _, ...remaining } = action
+              return remaining
+            }),
+          }
+        })
+        return [id, capabilities == null ? node : { ...node, task: { ...node.task, capabilities } }]
+      }),
+    ),
+  }
+}

package/src/flow/common/edgeChanges.ts

@@ -0,0 +1,35 @@
+import type { ChangeOperation, GraphEdge, RevisionContent } from './change.ts'
+
+import { dequal } from 'dequal/lite'
+
+export function connect(content: RevisionContent, edge: GraphEdge): readonly ChangeOperation[] {
+  const selected = content.document.graph
+  if (selected?.edges.some((candidate) => dequal(candidate, edge))) return []
+  const changes: ChangeOperation[] = [{ edge, kind: 'graph.edge.connect' }]
+  const source = selected.nodes[edge.source]
+  const target = selected.nodes[edge.target]
+  if (
+    edge.sourceHandle == 'pending' &&
+    (source?.kind == 'approval' || source?.kind == 'wait') &&
+    target?.kind == 'task' &&
+    'executor' in target.task &&
+    target.task.executor.kind == 'connector' &&
+    target.task.executor.action == 'leina.send_notification' &&
+    (target.inputs.message == null || target.inputs.message.kind == 'unset')
+  ) {
+    changes.push({
+      kind: 'graph.node.input.set',
+      nodeId: edge.target,
+      handle: 'message',
+      before: target.inputs.message,
+      value: { kind: 'sources', sources: [{ kind: 'node', nodeId: edge.source, output: 'pending', field: 'message' }] },
+    })
+  }
+  return changes
+}
+
+export function disconnect(content: RevisionContent, edge: GraphEdge): readonly ChangeOperation[] {
+  const selected = content.document.graph
+  if (!selected?.edges.some((candidate) => dequal(candidate, edge))) return []
+  return [{ edge, kind: 'graph.edge.disconnect' }]
+}