Skip to content

A platform for community discussion. Free, open, simple.

4.9 KB
Raw Blame
# frozen_string_literal: true

module DiscourseWorkflows
  module Schema
    class GraphResolver
      class NotConverged < StandardError
      end

      def self.call(nodes, connections)
        new(nodes, connections).call
      end

      def initialize(nodes, connections)
        @nodes = Array(nodes)
        @connection_records = WorkflowDocument.connection_records(@nodes, connections)
        @nodes_by_id = @nodes.index_by { |node| NodeData.read(node, "id").to_s }
        @node_classes =
          @nodes_by_id.transform_values do |node|
            Registry.find_node_type(
              NodeData.read(node, "type"),
              version: NodeData.type_version(node),
            )
          end
        @incoming_connections =
          @connection_records
            .reject { |record| record["source_node_id"].to_s == record["target_node_id"].to_s }
            .group_by { |record| record["target_node_id"].to_s }
        @incoming_connections.each_value do |records|
          records.sort_by! do |record|
            [
              record["target_input_index"].to_i,
              record["source_output_index"].to_i,
              record["source_node_id"].to_s,
            ]
          end
        end
        @input_schemas = {}
        @output_schemas = {}
        @resolved_output_schemas = {}
      end

      def call
        sweep_until_stable
        sweep_until_stable if promote_unresolved_outputs
        resolve_remaining_inputs

        {
          input_schemas: @input_schemas,
          output_schemas: @output_schemas,
          connection_records: @connection_records,
        }
      end

      private

      def sweep_until_stable
        changed = true
        sweeps = 0

        while changed
          raise NotConverged if (sweeps += 1) > @nodes.length + 2

          changed = false
          @nodes_by_id.each_key do |node_id|
            input_schemas, resolved = input_schemas_for(node_id)
            next unless resolved

            output_schemas = output_schemas_for(node_id, input_schemas)
            changed ||= @output_schemas[node_id] != output_schemas
            @input_schemas[node_id] = input_schemas
            @output_schemas[node_id] = output_schemas
          end
        end
      end

      def promote_unresolved_outputs
        unresolved = @nodes_by_id.keys.reject { |node_id| @output_schemas.key?(node_id) }
        unresolved.each do |node_id|
          @output_schemas[node_id] = Array.new(output_count(node_id)) { {} }
        end
        unresolved.any?
      end

      def resolve_remaining_inputs
        @nodes_by_id.each_key do |node_id|
          @input_schemas[node_id] ||= input_schemas_for(node_id).first
        end
      end

      def output_schemas_for(node_id, input_schemas)
        node_class = @node_classes[node_id]
        return [{}] unless node_class

        @resolved_output_schemas[[node_id, input_schemas]] ||= node_class.output_schemas(
          NodeData.parameters(@nodes_by_id.fetch(node_id)),
          input_schemas: input_schemas,
        )
      end

      def input_schemas_for(node_id)
        connections = Array(@incoming_connections[node_id])
        count = input_count(node_id, connections)
        return Array.new(count), true if connections.empty?

        schemas_by_index =
          Array.new(count) do |input_index|
            schemas =
              connections.filter_map do |connection|
                next if connection["target_input_index"].to_i != input_index

                source_outputs = @output_schemas[connection["source_node_id"].to_s]
                next if source_outputs.nil?

                source_outputs[connection["source_output_index"].to_i] || {}
              end

            Schema.union(*schemas) if schemas.any?
          end

        [
          schemas_by_index,
          schemas_by_index.any? { |schema| !schema.nil? } || replace_only?(node_id),
        ]
      end

      def replace_only?(node_id)
        node_class = @node_classes[node_id]
        return false unless node_class.respond_to?(:active_output_contracts)

        node_class
          .active_output_contracts(NodeData.parameters(@nodes_by_id.fetch(node_id)))
          .all? do |candidates|
            candidates.all? { |contract| contract.fetch(:mode).to_sym == :replace }
          end
      end

      def output_count(node_id)
        node_class = @node_classes[node_id]
        return 1 unless node_class.respond_to?(:ports)

        node_class.ports(NodeData.parameters(@nodes_by_id.fetch(node_id))).length
      end

      def input_count(node_id, connections)
        node_class = @node_classes[node_id]
        declared_count =
          if node_class.respond_to?(:input_ports)
            node_class.input_ports(NodeData.parameters(@nodes_by_id.fetch(node_id))).length
          else
            1
          end

        [
          declared_count,
          connections.map { |connection| connection["target_input_index"].to_i + 1 }.max.to_i,
        ].max
      end
    end
  end
end