Start on graphql-migrate-execution

Author: rmosolgo

bin/graphql-migrate-execution

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+require "graphql/migrate_execution"
+require "optparse"
+
+doctor_options = {}
+parser = OptionParser.new
+parser.on("-p", "--preview", "Preview migration strategies")
+parser.parse!(into: doctor_options)
+filename = ARGV.shift || raise(ArgumentError, "graphql-execution-doctor require a filename or path as a first argument, please pass one.")
+
+doctor = GraphQL::MigrateExecution.new(filename, **doctor_options)
+doctor.run

lib/graphql/migrate_execution.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require "prism"
+require "pp"
+require "graphql/migrate_execution/field_definition"
+require "graphql/migrate_execution/resolver_method"
+require "graphql/migrate_execution/type_definition"
+require "graphql/migrate_execution/visitor"
+
+module GraphQL
+  class MigrateExecution
+    NOT_CONFIGURED = Object.new
+    def initialize(filepath)
+      @filepath = filepath
+    end
+
+    def run
+      source = File.read(@filepath)
+      parse_result = Prism.parse(source)
+      visitor = Visitor.new(source)
+      visitor.visit(parse_result.value)
+
+      field_definitions_by_strategy = Hash.new { |h, k| h[k] = [] }
+
+      total_defns = 0
+      visitor.type_definitions.each do |name, type_defn|
+        type_defn.field_definitions.each do |f_name, f_defn|
+          total_defns += 1
+          field_definitions_by_strategy[f_defn.migration_strategy] << f_defn
+        end
+      end
+
+      puts "Found #{total_defns} field definitions:"
+      field_definitions_by_strategy.each do |strategy, definitions|
+        puts "\n#{strategy} (#{definitions.size}):"
+        max_path = definitions.map { |f| f.path.size }.max + 2
+        definitions.each do |field_defn|
+          name = field_defn.path.ljust(max_path)
+          puts "  - #{name} (#{field_defn.resolve_mode.inspect} -> #{field_defn.resolve_mode_key.inspect}) @ #{@filepath}:#{field_defn.source_line}"
+        end
+      end
+    end
+  end
+end

lib/graphql/migrate_execution/field_definition.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module GraphQL
+  class MigrateExecution
+    class FieldDefinition
+      def initialize(type_definition, name, node)
+        @type_definition = type_definition
+        @name = name.to_sym
+        @node = node
+
+        @resolve_mode = NOT_CONFIGURED
+        @hash_key = nil
+        @resolver = nil
+        @type_instance_method = nil
+        @object_direct_method = nil
+
+        @resolver_method = nil
+        @unknown_options = []
+      end
+
+      def migration_strategy
+        case resolve_mode
+        when NOT_CONFIGURED, nil, :implicit_resolve
+          :MANUAL
+        when :hash_key, :object_direct_method
+          :NONE_REQUIRED
+        when :type_instance_method
+          @resolver_method.migration_strategy
+        when :resolver
+          :TODO
+        else
+          raise "No migration strategy for resolve_mode #{@resolve_mode.inspect}"
+        end
+      end
+
+      attr_reader :name, :node, :resolver_method, :unknown_options, :type_definition
+
+      attr_writer :resolve_mode
+
+      attr_accessor :hash_key, :object_direct_method, :type_instance_method, :resolver
+
+      def path
+        @path ||= "#{type_definition.name}.#{@name}"
+      end
+
+      def source_line
+        @node.location.start_line
+      end
+
+      def resolve_mode
+        if NOT_CONFIGURED.equal?(@resolve_mode) || (@resolve_mode == :type_instance_method && @resolver_method.nil?)
+          method_name = @type_instance_method || @name
+          if (rm = @type_definition.resolver_methods[method_name])
+            @resolver_method = rm
+            @resolve_mode = :type_instance_method
+            @type_instance_method ||= @name
+          else
+            @resolve_mode = :implicit_resolve
+          end
+        end
+        @resolve_mode
+      end
+
+      def implicit_resolve
+        @name
+      end
+
+      def resolve_mode_key
+        resolve_mode && public_send(resolve_mode)
+      end
+    end
+  end
+end

lib/graphql/migrate_execution/resolver_method.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module GraphQL
+  class MigrateExecution
+
+    class ResolverMethod
+      def initialize(name, node)
+        @name = name
+        @node = node
+        @parameter_names = if node.parameters
+          node.parameters.keywords.map(&:name)
+        else
+          []
+        end
+        @self_sends = Set.new
+        @calls_object = false
+        @calls_context = false
+      end
+
+      attr_reader :name, :node, :parameter_names, :self_sends
+
+      attr_accessor :calls_object, :calls_context # TODO dataloader, others?
+
+      def migration_strategy
+        calls_to_self = self_sends.to_a
+        if @calls_context
+          calls_to_self.delete(:context)
+        end
+        if @calls_object
+          calls_to_self.delete(:object)
+        end
+        # These will be migrated to context:
+        calls_to_self.delete(:dataloader)
+        calls_to_self.delete(:dataload_association)
+        calls_to_self.delete(:dataload_record)
+
+        # Global-ish methods:
+        calls_to_self.delete(:raise)
+
+        # Locals:
+        calls_to_self -= @parameter_names
+
+        if calls_to_self.empty?
+          if calls_object
+            :RESOLVE_EACH
+          else
+            :STATIC_RESOLVE
+          end
+        else
+          :TODO
+        end
+      end
+      private
+
+      def calls_to_self
+
+      end
+    end
+  end
+end

lib/graphql/migrate_execution/type_definition.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module GraphQL
+  class MigrateExecution
+    class TypeDefinition
+      def initialize(name)
+        @name = name
+        @field_definitions = {}
+        @resolver_methods = {}
+      end
+
+      attr_reader :resolver_methods, :name, :field_definitions
+
+      def field_definition(name, node)
+        @field_definitions[name] = FieldDefinition.new(self, name, node)
+      end
+
+      def resolver_method(name, node)
+        @resolver_methods[name] = ResolverMethod.new(name, node)
+      end
+    end
+  end
+end

lib/graphql/migrate_execution/visitor.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module GraphQL
+  class MigrateExecution
+    class Visitor < Prism::Visitor
+      def initialize(source)
+        @source = source
+        @new_source = source.dup
+        @type_definitions = Hash.new { |h, k| h[k] = TypeDefinition.new(k) }
+        @type_definition_stack = []
+        @current_field_definition = nil
+        @current_resolver_method = nil
+      end
+
+      attr_reader :new_source, :type_definitions
+
+      def visit_class_node(node)
+        if node.superclass
+          td = @type_definitions[node.name]
+          @type_definition_stack << td
+        end
+        super
+      ensure
+        if td
+          @type_definition_stack.pop
+        end
+      end
+
+      def visit_module_node(node)
+        td = @type_definitions[node.name]
+        @type_definition_stack << td
+        super
+      ensure
+        @type_definition_stack.pop
+      end
+
+      def visit_keyword_hash_node(node)
+        if @current_field_definition
+          node.elements.each do |assoc|
+            if assoc.key.is_a?(Prism::SymbolNode)
+              case assoc.key.unescaped
+              when "hash_key"
+                @current_field_definition.resolve_mode = :hash_key
+                @current_field_definition.hash_key = get_keyword_value(assoc.value)
+              when "resolver"
+                @current_field_definition.resolve_mode = :resolver
+                @current_field_definition.resolver = get_keyword_value(assoc.value)
+              when "method"
+                @current_field_definition.resolve_mode = :object_direct_method
+                @current_field_definition.object_direct_method = get_keyword_value(assoc.value)
+              when "resolver_method"
+                @current_field_definition.resolve_mode = :type_instance_method
+                @current_field_definition.type_instance_method = get_keyword_value(assoc.value)
+              else
+                # fallback_value, dig, connection, extensions, extras
+                @current_field_definition.unknown_options << assoc.key.unescaped
+              end
+            end
+          end
+        end
+        super
+      end
+
+      def visit_call_node(node)
+        if node.receiver.nil? && node.name == :field
+          begin
+            first_arg = node.arguments.arguments.first # rubocop:disable Development/ContextIsPassedCop
+            if first_arg.is_a?(Prism::SymbolNode)
+              field_name = first_arg.unescaped
+              td = @type_definition_stack.last
+              @current_field_definition = td.field_definition(field_name, node)
+            else
+              puts "Skipping unrecognized field definition: #{node.inspect}"
+            end
+          end
+        elsif @current_resolver_method
+          if node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
+            @current_resolver_method.self_sends.add(node.name)
+            if node.name == :object
+              @current_resolver_method.calls_object = true
+            elsif node.name == :context
+              @current_resolver_method.calls_object = true
+            end
+          end
+        end
+        super
+      ensure
+        if td
+          @current_field_definition = nil
+        end
+      end
+
+      def visit_def_node(node)
+        if node.receiver.nil?
+          td = @type_definition_stack.last
+          @current_resolver_method = td.resolver_method(node.name, node)
+        end
+        super
+      ensure
+        @current_resolver_method = nil
+      end
+
+
+      private
+
+      def get_keyword_value(value_node)
+        case value_node
+        when Prism::SymbolNode
+          value_node.unescaped.to_sym
+        when Prism::StringNode
+          value_node.unescaped
+        when Prism::IntegerNode, Prism::FloatNode
+          value_node.value
+        when Prism::TrueNode
+          true
+        when Prism::FalseNode
+          false
+        when Prism::ConstantReadNode
+          value_node.name
+        when Prism::CallNode
+          :DYNAMIC_CALL_NODE
+        else
+          # nil, constants, `self` ...?
+          raise ArgumentError, "GraphQL-MigrateExecution can't parse this keyword argument yet, but it could. Please open an issue on GraphQL-Ruby with this error message (node class: #{value_node.class})\n\n#{value_node.inspect}"
+        end
+      end
+    end
+  end
+end