graphql-client 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f327b5063c82073f7208c75d7a8e178694b67ce5
-  data.tar.gz: 2fba5fd397e36ff3f3cd81cc1515a9dd2573476a
+  metadata.gz: 852686ecf24561871545329aeb4868baaccb99de
+  data.tar.gz: 2bd0845ad82f0ba555497e0a46c315a9d8a6fa0f
 SHA512:
-  metadata.gz: 55bf804e30c3d080d899d49c2016aab6932699565a95d0eae7e90a16bfcd645077a179ac11c08aba366bb583b4ee7ddf73dafad57bea2c0851f081587a6a0191
-  data.tar.gz: f1fe23003faefe5a176c696cfe6fb68b63cb2edc6c0c14bfb65ffb12c823943e4518bffb39b718d5f04270f3f8e8be224280a4990e3e527212b83ba83dcee97c
+  metadata.gz: 58701e7031146155bcf9584bf61cdbee25f6ac9bf61121eccd5e915970624d2755aef071f18c781d38fcbf3ca1878fccff4f22d33b7dbe3c537598a597658f23
+  data.tar.gz: 8dfe674b8d2c39233fcdfd533e8ea516c010e0cecb7be38fb01c2128f76dc466e61e7dd334e0dff36e810465d9e9f6064d7c5f9969de9e65e081fa0dba0bc9ea

data/lib/graphql/client.rb

@@ -1,14 +1,100 @@
+require "active_support/inflector"
 require "graphql"
-require "graphql/client/document"
-require "graphql/client/fragment"
-require "graphql/client/node"
+require "graphql/client/const_proxy"
 require "graphql/client/query_result"
-require "graphql/client/query"
+require "graphql/language/mutator"
+require "graphql/language/nodes/deep_freeze_ext"
+require "graphql/language/operation_slice"
+require "graphql/relay/parser"
 
 module GraphQL
-  module Client
-    class << self
-      attr_accessor :schema
+  class Client
+    class Error < StandardError; end
+    class ValidationError < Error; end
+
+    attr_reader :schema
+
+    def initialize(schema:)
+      @schema = schema
+      @definitions = []
+    end
+
+    class Definition
+      def initialize(name:, client:, source:)
+        @name = name
+        @client = client
+        @_nodes = @client._parse(@name, source)
+        @query_result = GraphQL::Client::QueryResult.wrap(@_nodes.first, name: name)
+      end
+
+      attr_reader :_nodes
+
+      def operation_name
+        if op = @_nodes.find { |d| d.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+          op.name
+        else
+          nil
+        end
+      end
+
+      def document
+        @document ||= Language::OperationSlice.slice(@client.document, operation_name).deep_freeze
+      end
+
+      def new(*args)
+        @query_result.new(*args)
+      end
+    end
+
+    def parse(str)
+      definition = ConstProxy.new { |name| Definition.new(client: self, name: name, source: str) }
+      @definitions << definition
+      definition
+    end
+
+    def _parse(name, str)
+      str = str.strip
+
+      str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)(\.([a-zA-Z0-9_]+))?/) { |m|
+        const_name, fragment_name = $1, $4
+        nodes = ActiveSupport::Inflector.constantize(const_name)._nodes
+
+        fragment_name = fragment_name ?
+          nodes.find { |n| n.name.end_with?(fragment_name) }.name : # XXX
+          nodes.first.name
+
+        "...#{fragment_name}"
+      }
+
+      doc = GraphQL::Relay::Parser.parse(str)
+
+      mutator = GraphQL::Language::Mutator.new(doc)
+
+      aliases = {}
+      doc.definitions.each do |definition|
+        aliases[definition.name] = (name.split("::") << definition.name).compact.join("__")
+      end
+      mutator.rename_definitions(aliases)
+
+      # TODO: Make this __typename injection optional
+      mutator.prepend_selection(GraphQL::Language::Nodes::Field.new(name: "__typename").deep_freeze)
+
+      doc.definitions.map(&:deep_freeze)
+    end
+
+    def document
+      GraphQL::Language::Nodes::Document.new(definitions: @definitions.flat_map(&:_nodes)).deep_freeze
+    end
+
+    def validate!
+      validator = StaticValidation::Validator.new(schema: @schema)
+      query = Query.new(@schema, document: document)
+
+      validator.validate(query).fetch(:errors).each do |error|
+        raise ValidationError, error["message"]
+      end
+
+      nil
     end
   end
 end

data/lib/graphql/client/const_proxy.rb

@@ -0,0 +1,29 @@
+module GraphQL
+  class Client
+    # Internal: Hack to track the constant name an object is assigned to.
+    #
+    #   FooConstant = ConstProxy.new { |name|
+    #     name # "FooConstant"
+    #   }
+    #
+    module ConstProxy
+      def self.new(&initializer)
+        raise ArgumentError, "initializer required" unless block_given?
+
+        Module.new do
+          extend ConstProxy
+          @initializer = initializer
+        end
+      end
+
+      def name
+        super || raise(RuntimeError, "expected object to be assigned to a constant")
+      end
+
+      def method_missing(*args, &block)
+        @target ||= @initializer.call(self.name)
+        @target.send(*args, &block)
+      end
+    end
+  end
+end

data/lib/graphql/client/query_result.rb

@@ -1,15 +1,38 @@
-require "graphql"
 require "active_support/inflector"
+require "graphql"
+require "set"
 
 module GraphQL
-  module Client
+  class Client
     class QueryResult
-      def self.fields
-        @fields
+      # Internal: Get QueryResult class for result of query.
+      #
+      # Returns subclass of QueryResult or nil.
+      def self.wrap(node, name: nil)
+        fields = {}
+
+        node.selections.each do |selection|
+          case selection
+          when Language::Nodes::FragmentSpread
+          when Language::Nodes::Field
+            field_name = selection.alias || selection.name
+            field_klass = selection.selections.any? ? wrap(selection, name: "#{name}.#{field_name}") : nil
+            fields[field_name] ? fields[field_name] |= field_klass : fields[field_name] = field_klass
+          when Language::Nodes::InlineFragment
+            wrap(selection, name: name).fields.each do |fragment_name, klass|
+              fields[fragment_name.to_s] ? fields[fragment_name.to_s] |= klass : fields[fragment_name.to_s] = klass
+            end
+          end
+        end
+
+        define(name: name, source_node: node, fields: fields)
       end
 
-      def self.define(fields: {})
+      # Internal
+      def self.define(name:, source_node:, fields: {})
         Class.new(self) do
+          @name = name
+          @source_node = source_node
           @fields = {}
 
           fields.each do |field, type|
@@ -62,8 +85,20 @@ module GraphQL
         end
       end
 
+      def self.source_node
+        @source_node
+      end
+
+      def self.fields
+        @fields
+      end
+
+      def self.name
+        @name || super || GraphQL::Client::QueryResult.name
+      end
+
       def self.inspect
-        "#<GraphQL::Client::QueryResult fields=#{@fields.keys.inspect}>"
+        "#<#{self.name} fields=#{@fields.keys.inspect}>"
       end
 
       def self.cast(obj)
@@ -71,6 +106,14 @@ module GraphQL
         when Hash
           new(obj)
         when QueryResult
+          spreads = Set.new(obj.class.source_node.selections.select { |s| s.is_a?(GraphQL::Language::Nodes::FragmentSpread) }.map(&:name))
+
+          if !spreads.include?(self.source_node.name)
+            message = "couldn't cast #{obj.inspect} to #{self.inspect}\n\n"
+            suggestion = "\n  ...#{name || "YourFragment"} # SUGGESTION"
+            message << GraphQL::Language::Generation.generate(obj.class.source_node).sub(/\n}$/, "#{suggestion}\n}")
+            raise TypeError, message
+          end
           cast(obj.to_h)
         when Array
           obj.map { |e| cast(e) }
@@ -99,7 +142,8 @@ module GraphQL
             new_fields[name] = value
           end
         end
-        define(fields: new_fields)
+        # TODO: Picking first source node seems error prone
+        define(name: self.name, source_node: self.source_node, fields: new_fields)
       end
 
       attr_reader :data
@@ -107,7 +151,7 @@ module GraphQL
 
       def inspect
         ivars = (self.class.fields.keys - [:__typename]).map { |sym| "#{sym}=#{instance_variable_get("@#{sym}").inspect}" }
-        buf = "#<GraphQL::Client::QueryResult"
+        buf = "#<#{self.class.name}"
         buf << " " << @__typename if @__typename
         buf << " " << ivars.join(" ") if ivars.any?
         buf << ">"

data/lib/graphql/language/mutator.rb

@@ -0,0 +1,45 @@
+require "graphql"
+require "set"
+
+module GraphQL
+  module Language
+    class Mutator
+      def initialize(document)
+        @document = document
+      end
+
+      def rename_definitions(definitions)
+        rename_node = -> (node, parent) {
+          node.name = definitions.fetch(node.name, node.name)
+        }
+
+        visitor = Visitor.new(@document)
+        visitor[Nodes::FragmentDefinition].leave << rename_node
+        visitor[Nodes::OperationDefinition].leave << rename_node
+        visitor[Nodes::FragmentSpread].leave << rename_node
+        visitor.visit
+
+        nil
+      end
+
+      def prepend_selection(selection)
+        on_selections = -> (node, parent) {
+          return if !node.selections.any?
+          # TODO: Simplify if AbstractNode#eql? is implemented
+          existing_selections = Set.new(node.selections.map { |s| s.respond_to?(:name) ? s.name : nil }.compact)
+          selections_to_prepend = [selection].reject { |s| existing_selections.include?(s.name) }
+          node.selections = selections_to_prepend + node.selections
+        }
+
+        visitor = Visitor.new(@document)
+        visitor[Nodes::Field].leave << on_selections
+        visitor[Nodes::FragmentDefinition].leave << on_selections
+        visitor[Nodes::InlineFragment].leave << on_selections
+        visitor[Nodes::OperationDefinition].leave << on_selections
+        visitor.visit
+
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/language/operation_slice.rb

@@ -0,0 +1,31 @@
+require "graphql"
+
+module GraphQL
+  module Language
+    module OperationSlice
+      # Public: Return's minimal document to represent operation.
+      #
+      # Find's target operation and any fragment dependencies and returns a
+      # new document with just those definitions.
+      #
+      # document - The Nodes::Document to find definitions.
+      # operation_name - The String name of Nodes::OperationDefinition
+      #
+      # Returns new Nodes::Document.
+      def self.slice(document, operation_name)
+        definitions = []
+        definitions << document.definitions.find { |d| d.name == operation_name }
+
+        visitor = Visitor.new(document)
+        visitor[Nodes::FragmentSpread] << -> (node, parent) {
+          if fragment = document.definitions.find { |d| d.name == node.name }
+            definitions << fragment
+          end
+        }
+        visitor.visit
+
+        Nodes::Document.new(definitions: definitions.uniq)
+      end
+    end
+  end
+end

data/lib/graphql/relay/parser.rb

@@ -0,0 +1,27 @@
+require "graphql"
+
+module GraphQL
+  module Relay
+    module Parser
+      ANONYMOUS_SENTINEL = "__anonymous__".freeze
+
+      # Public: Extended GraphQL.parse that supports Relay style anonymous
+      # fragments.
+      #
+      # TODO: See about getting support for this upstreamed to the graphql-ruby
+      # gem.
+      #
+      # str - A GraphQL String
+      #
+      # Returns a GraphQL::Language::Nodes::Document.
+      def self.parse(str)
+        str = str.sub(/fragment on /, "fragment #{ANONYMOUS_SENTINEL} on ")
+        document = GraphQL.parse(str)
+        document.definitions.each do |node|
+          node.name = nil if node.name == ANONYMOUS_SENTINEL
+        end
+        document
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-19 00:00:00.000000000 Z
+date: 2016-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -74,20 +74,12 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - lib/graphql/client.rb
-- lib/graphql/client/document.rb
-- lib/graphql/client/fragment.rb
-- lib/graphql/client/node.rb
-- lib/graphql/client/query.rb
+- lib/graphql/client/const_proxy.rb
 - lib/graphql/client/query_result.rb
+- lib/graphql/language/mutator.rb
 - lib/graphql/language/nodes/deep_freeze_ext.rb
-- lib/graphql/language/nodes/inject_selection_ext.rb
-- lib/graphql/language/nodes/query_result_class_ext.rb
-- lib/graphql/language/nodes/replace_fragment_spread_ext.rb
-- lib/graphql/language/nodes/selection_ext.rb
-- lib/graphql/language/nodes/validate_ext.rb
-- lib/graphql/relay/node_query.rb
-- lib/graphql/schema/json_loader.rb
-- lib/graphql/schema_load_json.rb
+- lib/graphql/language/operation_slice.rb
+- lib/graphql/relay/parser.rb
 homepage: 
 licenses:
 - MIT
@@ -108,9 +100,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: "???"
 test_files: []
-has_rdoc: 

data/lib/graphql/client/document.rb

@@ -1,47 +0,0 @@
-require "graphql"
-require "graphql/client/fragment"
-require "graphql/client/node"
-require "graphql/client/query"
-require "graphql/language/nodes/deep_freeze_ext"
-require "graphql/language/nodes/inject_selection_ext"
-require "graphql/language/nodes/replace_fragment_spread_ext"
-require "graphql/language/nodes/validate_ext"
-
-module GraphQL
-  module Client
-    class Document < Node
-      def self.parse(str, schema: GraphQL::Client.schema)
-        str = str.strip
-        str, fragments = scan_interpolated_fragments(str)
-
-        document = GraphQL.parse(str)
-        document = document.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
-
-        document.definitions.each do |definition|
-          fragments[definition.name.to_sym] = definition if definition.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-        end
-
-        document = document.replace_fragment_spread(fragments)
-
-        document.definitions.inject({}) do |doc, definition|
-          name = definition.name.to_sym
-
-          case definition
-          when GraphQL::Language::Nodes::OperationDefinition
-            query = GraphQL::Client::Query.new(definition.deep_freeze, fragments.values).freeze
-            query.node.validate!(schema: schema) if schema
-            doc[name] = query
-
-          when GraphQL::Language::Nodes::FragmentDefinition
-            definition = GraphQL::Language::Nodes::InlineFragment.new(type: definition.type, directives: definition.directives, selections: definition.selections)
-            fragment = GraphQL::Client::Fragment.new(definition.deep_freeze, fragments.values).freeze
-            fragment.node.validate!(schema: schema) if schema
-            doc[name] = fragment
-          end
-
-          doc
-        end
-      end
-    end
-  end
-end

data/lib/graphql/client/fragment.rb

@@ -1,32 +0,0 @@
-require "graphql"
-require "graphql/client/node"
-require "graphql/language/nodes/deep_freeze_ext"
-require "graphql/language/nodes/inject_selection_ext"
-require "graphql/language/nodes/replace_fragment_spread_ext"
-require "graphql/language/nodes/validate_ext"
-
-module GraphQL
-  module Client
-    class Fragment < Node
-      def self.parse(str, schema: GraphQL::Client.schema)
-        str = str.strip
-        str, fragments = scan_interpolated_fragments(str)
-
-        if str.start_with?("fragment")
-          str = str.sub(/^fragment on /, "fragment __anonymous__ on ")
-          doc = GraphQL.parse(str)
-          doc = doc.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
-          doc = doc.replace_fragment_spread(fragments)
-          fragment = doc.definitions.first
-          node = GraphQL::Language::Nodes::InlineFragment.new(type: fragment.type, directives: fragment.directives, selections: fragment.selections)
-        else
-          raise ArgumentError, "expected string to be a fragment:\n#{str}"
-        end
-
-        fragment = new(node.deep_freeze, fragments.values).freeze
-        fragment.node.validate!(schema: schema) if schema
-        fragment
-      end
-    end
-  end
-end

data/lib/graphql/client/node.rb

@@ -1,36 +0,0 @@
-require "active_support/inflector"
-require "graphql"
-require "graphql/language/nodes/query_result_class_ext"
-
-module GraphQL
-  module Client
-    class Node
-      def self.scan_interpolated_fragments(str)
-        fragments, index = {}, 1
-        str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) { |m|
-          index += 1
-          name = "__fragment#{index}__"
-          fragments[name.to_sym] = ActiveSupport::Inflector.constantize($1).node
-          "...#{name}"
-        }
-        return str, fragments
-      end
-
-      attr_reader :node
-
-      attr_reader :fragments
-
-      attr_reader :type
-
-      def initialize(node, fragments)
-        @node = node
-        @fragments = fragments
-        @type = node.query_result_class(shadow: fragments)
-      end
-
-      def new(*args)
-        type.new(*args)
-      end
-    end
-  end
-end

data/lib/graphql/client/query.rb

@@ -1,30 +0,0 @@
-require "graphql"
-require "graphql/client/node"
-require "graphql/language/nodes/deep_freeze_ext"
-require "graphql/language/nodes/inject_selection_ext"
-require "graphql/language/nodes/replace_fragment_spread_ext"
-require "graphql/language/nodes/validate_ext"
-
-module GraphQL
-  module Client
-    class Query < Node
-      def self.parse(str, schema: GraphQL::Client.schema)
-        str = str.strip
-        str, fragments = scan_interpolated_fragments(str)
-
-        if str.start_with?("query")
-          doc = GraphQL.parse(str)
-          doc = doc.inject_selection(GraphQL::Language::Nodes::Field.new(name: "__typename"))
-          doc = doc.replace_fragment_spread(fragments)
-          node = doc.definitions.first
-        else
-          raise ArgumentError, "expected string to be a query:\n#{str}"
-        end
-
-        query = new(node.deep_freeze, fragments.values).freeze
-        query.node.validate!(schema: schema) if schema
-        query
-      end
-    end
-  end
-end

data/lib/graphql/language/nodes/inject_selection_ext.rb

@@ -1,44 +0,0 @@
-require "graphql"
-require "graphql/language/nodes/selection_ext"
-
-module GraphQL
-  module Language
-    module Nodes
-      module Selections
-        def inject_selection(*selections)
-          other = self.dup
-          other.selections = selections + self.selections.map do |selection|
-            case selection
-            when Selections
-              selection.inject_selection(*selections)
-            else
-              selection
-            end
-          end
-          other
-        end
-      end
-
-      class Document < AbstractNode
-        def inject_selection(*args)
-          other = self.dup
-          other.definitions = self.definitions.map do |definition|
-            case definition
-            when Selections
-              definition.inject_selection(*args)
-            else
-              definition
-            end
-          end
-          other
-        end
-      end
-
-      class Field < AbstractNode
-        def inject_selection(*selections)
-          self.selections.any? ? super : self
-        end
-      end
-    end
-  end
-end

data/lib/graphql/language/nodes/query_result_class_ext.rb

@@ -1,70 +0,0 @@
-require "graphql"
-require "graphql/language/nodes/selection_ext"
-require "graphql/client/query_result"
-require "set"
-
-module GraphQL
-  module Language
-    module Nodes
-      module Selections
-        # Public: Get GraphQL::QueryResult class for result of query.
-        #
-        # Returns subclass of QueryResult or nil.
-        def query_result_class(**kargs)
-          GraphQL::Client::QueryResult.define(fields: selections_query_result_classes(**kargs))
-        end
-
-        def selection_query_result_classes(**kargs)
-          selections_query_result_classes(**kargs)
-        end
-
-        # Internal: Gather QueryResult classes for each selection.
-        #
-        # Returns a Hash[String => (QueryResult|nil)].
-        def selections_query_result_classes(shadow: Set.new, **kargs)
-          self.selections.inject({}) do |h, selection|
-            case selection
-            when Selection
-              if !shadow.include?(selection)
-                selection.selection_query_result_classes(shadow: shadow, **kargs).each do |name, klass|
-                  h[name] ? h[name] |= klass : h[name] = klass
-                end
-              end
-              h
-            else
-              raise TypeError, "expected selection to be of type Selection, but was #{selection.class}"
-            end
-          end
-        end
-      end
-
-      class Field < AbstractNode
-        # Public: Get GraphQL::QueryResult class for result of query.
-        #
-        # Returns subclass of QueryResult or nil.
-        def query_result_class(**kargs)
-          if self.selections.any?
-            super
-          else
-            nil
-          end
-        end
-
-        def selection_query_result_classes(**kargs)
-          name = self.alias || self.name
-          { name => query_result_class(**kargs) }
-        end
-      end
-
-      class FragmentSpread < AbstractNode
-        def selection_query_result_classes(fragments: {}, shadow: Set.new, **kargs)
-          unless fragment = fragments[name.to_sym]
-            raise ArgumentError, "missing fragment '#{name}'"
-          end
-          return {} if shadow.include?(fragment)
-          fragment.selection_query_result_classes(fragments: fragments, shadow: shadow, **kargs)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/language/nodes/replace_fragment_spread_ext.rb

@@ -1,44 +0,0 @@
-require "graphql"
-require "graphql/language/nodes/selection_ext"
-
-module GraphQL
-  module Language
-    module Nodes
-      module Selections
-        def replace_fragment_spread(fragments)
-          other = self.dup
-          other.selections = self.selections.map do |selection|
-            case selection
-            when FragmentSpread
-              if fragment = fragments[selection.name.to_sym]
-                InlineFragment.new(type: fragment.type, directives: fragment.directives, selections: fragment.selections)
-              else
-                selection
-              end
-            when Selections
-              selection.replace_fragment_spread(fragments)
-            else
-              selection
-            end
-          end
-          other
-        end
-      end
-
-      class Document < AbstractNode
-        def replace_fragment_spread(fragments)
-          other = self.dup
-          other.definitions = self.definitions.map do |definition|
-            case definition
-            when Selections
-              definition.replace_fragment_spread(fragments)
-            else
-              definition
-            end
-          end
-          other
-        end
-      end
-    end
-  end
-end

data/lib/graphql/language/nodes/selection_ext.rb

@@ -1,37 +0,0 @@
-require "graphql"
-
-module GraphQL
-  module Language
-    module Nodes
-      # Public: Define shared trait for Nodes that have a "selections" collection.
-      module Selections
-      end
-
-      # Public: Define shared trait for Nodes that may be in a "selections" collection.
-      module Selection
-      end
-
-      class Field < AbstractNode
-        include Selection
-        include Selections
-      end
-
-      class FragmentDefinition < AbstractNode
-        include Selections
-      end
-
-      class FragmentSpread < AbstractNode
-        include Selection
-      end
-
-      class InlineFragment < AbstractNode
-        include Selection
-        include Selections
-      end
-
-      class OperationDefinition < AbstractNode
-        include Selections
-      end
-    end
-  end
-end

data/lib/graphql/language/nodes/validate_ext.rb

@@ -1,45 +0,0 @@
-require "graphql"
-
-module GraphQL
-  class ValidationError < GraphQL::ExecutionError
-  end
-
-  module Language
-    module Nodes
-      class Document < AbstractNode
-        def validate!(schema:, rules: StaticValidation::ALL_RULES)
-          validator = StaticValidation::Validator.new(schema: schema, rules: rules)
-          query = Query.new(schema, document: self)
-
-          validator.validate(query).fetch(:errors).each do |error|
-            raise ValidationError, error["message"]
-          end
-
-          nil
-        end
-      end
-
-      class FragmentDefinition < AbstractNode
-        def validate!(schema:, **kargs)
-          document = Document.new(definitions: [self])
-          rules = StaticValidation::ALL_RULES - [StaticValidation::FragmentsAreUsed]
-          document.validate!(schema: schema, rules: rules, **kargs)
-        end
-      end
-
-      class OperationDefinition < AbstractNode
-        def validate!(schema:, **kargs)
-          document = Document.new(definitions: [self])
-          document.validate!(schema: schema, **kargs)
-        end
-      end
-
-      class InlineFragment < AbstractNode
-        def validate!(schema:, **kargs)
-          fragment = FragmentDefinition.new(name: "FooFragment", type: self.type, directives: self.directives, selections: self.selections)
-          fragment.validate!(schema: schema, **kargs)
-        end
-      end
-    end
-  end
-end

data/lib/graphql/relay/node_query.rb

@@ -1,19 +0,0 @@
-require "graphql"
-require "graphql/language/nodes/deep_freeze_ext"
-
-module GraphQL
-  module Relay
-    NODE_QUERY = GraphQL.parse(<<-'GRAPHQL').definitions.first.deep_freeze
-      query($id: ID!) {
-        node(id: $id) {
-          ...NodeFragment
-        }
-      }
-    GRAPHQL
-
-    def self.NodeQuery(fragment)
-      fragment = GraphQL::Language::Nodes::FragmentDefinition.new(name: "NodeFragment", type: fragment.type, selections: fragment.selections)
-      GraphQL::Language::Nodes::Document.new(definitions: [NODE_QUERY, fragment])
-    end
-  end
-end

data/lib/graphql/schema/json_loader.rb

@@ -1,101 +0,0 @@
-require "graphql"
-require "json"
-
-module GraphQL
-  class Schema
-    module JSONLoader
-      def self.define_schema(json)
-        schema = JSON.load(json).fetch("data").fetch("__schema")
-        types = Schema::JSONLoader.define_types(schema)
-        # TODO: handle schema["mutationType"]
-        # TODO: handle schema["subscriptionType"]
-        query = types.fetch(schema.fetch("queryType").fetch("name"))
-        Schema.new(query: query, types: types.values)
-      end
-
-      def self.define_types(schema)
-        schema.fetch("types").inject({}) do |types, type|
-          type_kind, type_name = type.fetch("kind"), type.fetch("name")
-
-          if !type_name.start_with?("__")
-            case type_kind
-            when "INTERFACE"
-              types[type_name] = define_interface(types, type)
-            when "OBJECT"
-              types[type_name] = define_object(types, type)
-            when "SCALAR"
-              types[type_name] = define_scalar(types, type)
-            else
-              # TODO: handle other type kinds
-              fail NotImplementedError, type_kind + " not implemented"
-            end
-          end
-
-          types
-        end
-      end
-
-      def self.resolve_type(types, type)
-        case kind = type.fetch("kind")
-        when "INTERFACE"
-          types.fetch(type.fetch("name"))
-        when "LIST"
-          ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
-        when "NON_NULL"
-          NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
-        when "OBJECT"
-          types.fetch(type.fetch("name"))
-        when "SCALAR"
-          types.fetch(type.fetch("name"))
-        else
-          # TODO: handle other type kinds
-          fail NotImplementedError, kind + " not implemented"
-        end
-      end
-
-      def self.define_interface(types, type)
-        InterfaceType.define do
-          name type.fetch("name")
-        end
-      end
-
-      def self.define_object(types, type)
-        ObjectType.define do
-          name type.fetch("name")
-          description type["description"]
-
-          Array(type["fields"]).each do |field_data|
-            field field_data["name"] do
-              type JSONLoader.resolve_type(types, field_data["type"])
-              description field_data["description"]
-              field_data["args"].each do |arg|
-                argument arg["name"] do
-                  type JSONLoader.resolve_type(types, arg["type"])
-                  description arg["description"]
-                end
-              end
-            end
-          end
-        end
-      end
-
-      def self.define_scalar(types, type)
-        case name = type.fetch("name")
-        when "Int"
-          INT_TYPE
-        when "String"
-          STRING_TYPE
-        when "Float"
-          FLOAT_TYPE
-        when "Boolean"
-          BOOLEAN_TYPE
-        when "ID"
-          ID_TYPE
-        else
-          # TODO: handle other scalar names
-          fail NotImplementedError, name + " scalar not implemented"
-        end
-      end
-    end
-  end
-end

data/lib/graphql/schema_load_json.rb

@@ -1,10 +0,0 @@
-require "graphql"
-require "graphql/schema/json_loader"
-
-module GraphQL
-  class Schema
-    def self.load_json(json)
-      Schema::JSONLoader.define_schema(json)
-    end
-  end
-end