graphlyte 0.3.0 → 1.0.0

data/lib/graphlyte/editors/collect_variable_references.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require_relative '../editor'
+require_relative './inline_fragments'
+
+module Graphlyte
+  module Editors
+    # Find all variable references in a document
+    class CollectVariableReferences
+      attr_reader :references
+
+      def initialize
+        @references = { Syntax::Operation => {}, Syntax::Fragment => {} }
+      end
+
+      def edit(doc)
+        doc = doc.dup
+
+        InlineFragments.new.edit(doc)
+        collector.edit(doc)
+
+        references
+      end
+
+      def collector
+        Editor.new.on_variable_reference do |ref, action|
+          d = action.definition
+          references[d.class][d.name] ||= [].to_set
+          references[d.class][d.name] << ref
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/editors/infer_signature.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../editor'
+require_relative '../syntax'
+require_relative './collect_variable_references'
+require_relative './with_variables'
+
+module Graphlyte
+  module Editors
+    # Subclass of the full variable inference editor that runs
+    # solely on static information (no knowledge of variable
+    # runtime values or the exact selected operation).
+    #
+    # The main difference is that we are more lenient about raising.
+    class InferSignature < WithVariables
+      def initialize(schema = nil)
+        super(schema, nil, nil)
+      end
+
+      def select_operation(_doc)
+        # no-op
+      end
+
+      # We should *always* be able to infer if there is a schema
+      # But if we are in dynamic mode, defer inferrence errors until
+      # we have runtime values (see `WithVariables`)
+      def cannot_infer!(ref)
+        super if @schema
+      end
+
+      def runtime_type_of(_ref)
+        # no-op
+      end
+    end
+  end
+end

data/lib/graphlyte/editors/inline_fragments.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../editor'
+
+module Graphlyte
+  module Editors
+    # Replace all uses of fragment spreads by inlining the fragment. This will
+    # increase the size of the document, sometimes by rather a lot.
+    #
+    # But doing so then makes other analysis (such as variable usage) much simpler.
+    class InlineFragments
+      FragmentNotFound = Class.new(StandardError)
+
+      def edit(doc)
+        inliner.edit(doc)
+        defragmenter.edit(doc)
+      end
+
+      private
+
+      def inliner
+        @inliner ||= Editor.new.on_fragment_spread do |spread, action|
+          fragment = action.document.fragments[spread.name]
+          raise FragmentNotFound, spread.name unless fragment
+
+          action.replace fragment.inline
+        end
+      end
+
+      def defragmenter
+        @defragmenter ||= Editor.new.on_fragment_definition do |_, action|
+          action.delete
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/editors/remove_unneeded_spreads.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../editor'
+require_relative '../syntax'
+require_relative './annotate_types'
+
+module Graphlyte
+  module Editors
+    # Remove unnecessary spreads.
+    #
+    # For example in the query:
+    #
+    # ```
+    # query {
+    #   User(id: 1) {
+    #     ... on User {
+    #       name
+    #     }
+    #   }
+    # }
+    # ```
+    #
+    # If the `Query.User` field has the type `User` then the spread `... on User` is
+    # tautological, and we can replace this with:
+    #
+    # ```
+    # query {
+    #   User(id: 1) {
+    #     name
+    #   }
+    # }
+    # ```
+    class RemoveUnneededSpreads
+      def initialize(schema = nil)
+        @schema = schema
+      end
+
+      def edit(doc)
+        AnnotateTypes.new(@schema).edit(doc)
+
+        inliner.edit(doc)
+      end
+
+      def inliner
+        @inliner ||= Editor.top_down.on_inline_fragment do |frag, action|
+          action.expand(frag.selection) if inlinable?(frag, action.parent)
+        end
+      end
+
+      def inlinable?(fragment, parent)
+        fragment.directives.none? && type_of(parent) == fragment.type_name
+      end
+
+      def type_of(node)
+        case node
+        when Syntax::Field
+          node.type&.inner
+        when Syntax::InlineFragment
+          node.type_name
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/editors/select_operation.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../editor'
+require_relative '../syntax'
+
+module Graphlyte
+  module Editors
+    # Reduce a document down to a single operation, removing unnecessary fragments
+    #
+    # eg:
+    #
+    #   pry(main)> puts doc
+    #
+    #   query A {
+    #     foo(bar: $baz) {
+    #       ...foos
+    #     }
+    #   }
+    #
+    #   fragment foos on Foo {
+    #     a
+    #     b
+    #     ...bars
+    #   }
+    #
+    #   fragment bars on Foo { d e f }
+    #
+    #   query B {
+    #     foo {
+    #       ...bars
+    #     }
+    #   }
+    #
+    #   pry(main)> puts Graphlyte::Editors::SelectOperation.new('A').edit(doc.dup)
+    #
+    #   query A {
+    #     foo(bar: $baz) {
+    #       ...foos
+    #     }
+    #   }
+    #
+    #   fragment foos on Foo {
+    #     a
+    #     b
+    #     ...bars
+    #   }
+    #
+    #   fragment bars on Foo { d e f }
+    #
+    #   pry(main)> puts Graphlyte::Editors::SelectOperation.new('B').edit(doc.dup)
+    #
+    #   fragment bars on Foo { d e f }
+    #
+    #   query B {
+    #     foo {
+    #       ...bars
+    #     }
+    #   }
+    #
+    class SelectOperation
+      def initialize(operation)
+        @operation = operation
+      end
+
+      def edit(doc)
+        to_keep = build_fragment_tree(doc)[@operation]
+
+        doc.definitions.select! do |definition|
+          case definition
+          when Syntax::Operation
+            definition.name == @operation
+          else
+            to_keep.include?(definition.name)
+          end
+        end
+
+        doc
+      end
+
+      # Compute the transitive closure of fragments used in each operation.
+      def build_fragment_tree(doc)
+        names = collect_fragment_names(doc)
+
+        # Promote fragments in fragments to the operation at the root
+        names[Syntax::Operation].each do |_op_name, spreads|
+          unvisited = spreads.to_a
+
+          until unvisited.empty?
+            names[Syntax::Fragment][unvisited.pop]&.each do |name|
+              next if spreads.include?(name)
+
+              spreads << name
+              unvisited << name
+            end
+          end
+        end
+
+        names_per_op
+      end
+
+      def collect_fragment_names(doc)
+        names = { Syntax::Operation => {}, Syntax::Fragment => {} }
+
+        collect = Editor.new.on_fragment_spread do |spread, action|
+          set = (names[action.definition.class] ||= [].to_set)
+
+          set << spread.name
+        end
+
+        collect.edit(doc)
+
+        names
+      end
+    end
+  end
+end

data/lib/graphlyte/editors/with_variables.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../editor'
+require_relative '../syntax'
+require_relative './collect_variable_references'
+require_relative './annotate_types'
+
+module Graphlyte
+  module Editors
+    # Use variable values to infer missing variables in the query signature
+    class WithVariables
+      CannotInfer = Class.new(StandardError)
+      TypeMismatch = Class.new(StandardError)
+
+      def initialize(schema, operation, variables)
+        @schema = schema
+        @operation = operation
+        @variables = variables
+      end
+
+      def edit(doc)
+        select_operation(doc)
+        annotate_types(doc)
+
+        references = Editors::CollectVariableReferences.new.edit(doc)
+        editor = infer_variable_type(references)
+
+        editor.edit(doc)
+      end
+
+      def annotate_types(doc)
+        Editors::AnnotateTypes.new(@schema).edit(doc) if @schema
+      end
+
+      def select_operation(doc)
+        Editors::SelectOperation.new(@operation).edit(doc) if @operation
+      end
+
+      def infer_variable_type(references)
+        Editor.new.on_operation do |operation, editor|
+          refs = references[operation.class][operation.name]
+          next unless refs
+
+          infer_operation(operation, refs, editor.document)
+        end
+      end
+
+      def infer_operation(operation, refs, document)
+        current_vars = current_operation_variables(operation)
+
+        added = {}
+        refs.to_a.reject { current_vars[_1.variable] }.each do |ref|
+          # Only way this could happen is if `uniq` produces duplicate names
+          # And that can only happen if there are two types inferred
+          # for the same reference.
+          if (prev = added[ref.variable])
+            raise TypeMismatch, "#{ref.variable}: #{ref.inferred_type} != #{prev.type}"
+          end
+
+          infer(operation.variables, added, document, ref)
+        end
+      end
+
+      def current_operation_variables(operation)
+        operation.variables ||= []
+        operation.variables.to_h { [_1.variable, _1] }
+      end
+
+      def infer(variables, added, doc, ref)
+        var = doc.variables.fetch(ref.variable, ref.to_definition)
+        type = var.type || ref.inferred_type || runtime_type_of(ref)
+
+        if type
+          var.type ||= type
+          variables << var
+          added[ref.variable] = var
+        else
+          cannot_infer!(ref)
+        end
+      end
+
+      def cannot_infer!(ref)
+        raise CannotInfer, ref.variable
+      end
+
+      def runtime_type_of(ref)
+        value = @variables[ref.variable]
+
+        case value
+        when Integer
+          Syntax::Type.non_null('Int')
+        when Float
+          Syntax::Type.non_null('Float')
+        when String
+          Syntax::Type.non_null('String')
+        when Date
+          Syntax::Type.non_null('Date')
+        when TrueClass, FalseClass
+          Syntax::Type.non_null('Boolean')
+        when Array
+          Syntax::Type.list_of(runtime_type_of(value.first)) unless value.empty?
+        end
+      end
+    end
+  end
+end

data/lib/graphlyte/errors.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Graphlyte
+  IllegalValue = Class.new(ArgumentError)
+
+  ParseError = Class.new(StandardError)
+
+  TooDeep = Class.new(StandardError) do
+    def initialize(location)
+      super("Max parse depth exceeded at #{location}")
+    end
+  end
+
+  Unexpected = Class.new(ParseError) do
+    def initialize(token)
+      super("Unexpected token at #{token.location}: #{token.lexeme.inspect}")
+    end
+  end
+
+  Expected = Class.new(ParseError) do
+    def initialize(token, expected:)
+      super("Unexpected token at #{token.location}: #{token.lexeme.inspect}, expected #{expected}")
+    end
+  end
+
+  Illegal = Class.new(ParseError) do
+    def initialize(token, reason = nil)
+      msg = "Illegal token at #{token.location}: #{token.lexeme}"
+      msg << ", #{reason}" if reason
+      super(msg)
+    end
+  end
+end