graphql-client 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8414ab402cf8454eb7d34081edc3c17fff0611de
-  data.tar.gz: 2a1351fe377f4e9999b9a0c5cfedd04081240753
+  metadata.gz: cee45489051065d2c8d47c6f8c68c6b3c98d75ca
+  data.tar.gz: e462bb5c2fb1997f8679bb0fea315f8abd751539
 SHA512:
-  metadata.gz: b1b30fc5a6c9f06f03a8c3ed9e69614bb1f7d3a0cbd449bb72a2077d34a154a6b2b48bd3d0b988997b2d59716941a3121fe2958f5948dff6afcce17c779c3cdd
-  data.tar.gz: dfbe13c52c3bd8d9df76129b8de2ec7f4fe2bb430c1788f9d77966c8a75f57d8fcbdc973e280239f763fba1d6976be8babaffdb86590b0da35819b40e1c0fb26
+  metadata.gz: 9f335b9446f04fe5e684218b1f0f377b16412ac4918065ac610b2abff61d00792a461131b1ab615cd6512ba611a8dde6929af9c1b229f4a36c713e7e0983a22d
+  data.tar.gz: 428487913828790e402b3a3c51daceafe8c338ebabfd234d0570424c8af426bc54bfa6f8fbf306d365fd674174a5708936e8a350cce5fcdf5c6426f5d3f1bd37

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/client.rb

@@ -1,14 +1,138 @@
+require "active_support/inflector"
 require "graphql"
-require "graphql/client/document"
-require "graphql/client/fragment"
-require "graphql/client/node"
 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 = []
+      @document = GraphQL::Language::Nodes::Document.new(definitions: @definitions)
+      @document_slices = {}
+    end
+
+    class Definition < Module
+      def initialize(node:)
+        @definition_node = node
+      end
+
+      # Internal: Get underlying operation or fragment defintion AST node for
+      # definition.
+      #
+      # Returns OperationDefinition or FragmentDefinition object.
+      attr_reader :definition_node
+
+      # Public: Ruby constant name of definition.
+      #
+      # Returns String or errors if definition was not assigned to a constant.
+      def name
+        @name ||= super || raise(RuntimeError, "definition must be assigned to a constant")
+      end
+
+      # Public: Global name of definition in client document.
+      #
+      # Returns a GraphQL safe name of the Ruby constant String.
+      #
+      #   "Users::UserQuery" #=> "Users__UserQuery"
+      #
+      # Returns String.
+      def definition_name
+        @definition_name ||= name.gsub("::", "__").freeze
+      end
+
+      def new(*args)
+        query_result_class.new(*args)
+      end
+
+      private
+        def query_result_class
+          @query_result_class ||= GraphQL::Client::QueryResult.wrap(definition_node, name: name)
+        end
+    end
+
+    class OperationDefinition < Definition
+      # Public: Alias for definition name.
+      alias_method :operation_name, :definition_name
+    end
+
+    class FragmentDefinition < Definition
+    end
+
+    def parse(str)
+      str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) { |m|
+        const_name = $1
+        case fragment = ActiveSupport::Inflector.safe_constantize(const_name)
+        when FragmentDefinition
+          "...#{fragment.definition_name}"
+        when nil
+          raise NameError, "uninitialized constant #{const_name}\n#{str}"
+        else
+          raise TypeError, "expected #{const_name} to be a #{FragmentDefinition}, but was a #{fragment.class}"
+        end
+      }
+
+      doc = GraphQL::Relay::Parser.parse(str)
+
+      mutator = GraphQL::Language::Mutator.new(doc)
+
+      # TODO: Make this __typename injection optional
+      mutator.prepend_selection(GraphQL::Language::Nodes::Field.new(name: "__typename").deep_freeze)
+
+      definitions, renames = {}, {}
+      doc.definitions.each do |node|
+        local_name = node.name
+        definition = case node
+        when Language::Nodes::OperationDefinition
+          OperationDefinition.new(node: node)
+        when Language::Nodes::FragmentDefinition
+          FragmentDefinition.new(node: node)
+        end
+        definitions[local_name] = definition
+        renames[local_name] = -> { definition.definition_name }
+      end
+      mutator.rename_definitions(renames)
+
+      doc.deep_freeze
+
+      self.document.definitions.concat(doc.definitions)
+
+      if definitions[nil]
+        definitions[nil]
+      else
+        Module.new do
+          definitions.each do |name, definition|
+            const_set(name, definition)
+          end
+        end
+      end
+    end
+
+    def document
+      @document
+    end
+
+    def document_slice(operation_name)
+      @document_slices[operation_name] ||= Language::OperationSlice.slice(document, operation_name).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/language/mutator.rb

@@ -0,0 +1,54 @@
+require "graphql"
+require "set"
+
+module GraphQL
+  module Language
+    class Mutator
+      def initialize(document)
+        @document = document
+      end
+
+      module LazyName
+        def name
+          @name.call
+        end
+      end
+
+      def rename_definitions(definitions)
+        rename_node = -> (node, parent) {
+          if name = definitions[node.name]
+            node.extend(LazyName) if name.is_a?(Proc)
+            node.name = name
+          end
+        }
+
+        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,40 @@
+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)
+        seen = Set.new([operation_name])
+        stack = [operation_name]
+
+        while name = stack.pop
+          names = find_definition_fragment_spreads(document, name)
+          seen.merge(names)
+          stack.concat(names.to_a)
+        end
+
+        Nodes::Document.new(definitions: document.definitions.select { |node| seen.include?(node.name) })
+      end
+
+      def self.find_definition_fragment_spreads(document, definition_name)
+        definition = document.definitions.find { |node| node.name == definition_name }
+        spreads = Set.new
+        visitor = Visitor.new(definition)
+        visitor[Nodes::FragmentSpread].enter << -> (node, parent) {
+          spreads << node.name
+        }
+        visitor.visit
+        spreads
+      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.7
+  version: 0.0.8
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-05 00:00:00.000000000 Z
+date: 2016-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -74,20 +74,11 @@ 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/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

data/lib/graphql/client/document.rb

@@ -1,48 +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 = document.replace_fragment_spread(fragments) # XXX: Multiple pass
-
-        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