gqli 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d34056882c2b95aeff8c3c1ff8155c0ebe1018480085e3a00ab84653124fc51
-  data.tar.gz: b32f2fd8fe6acd08587e71e36d11d7aedde72e3b30e106a10e9de017a3d9c908
+  metadata.gz: a2253633cb84598f7d7150f620b9161152c0c5961c92124ea2d517e97e7452b7
+  data.tar.gz: 84ceda416865f6295632b9044eeeeaeba29b24822a988a45e3cf8e1e6f85bfa9
 SHA512:
-  metadata.gz: 55f5936ee3d57ca83373627034f70f081cc599358f24328017f3e97f25d7e97de247cf3ce4292ce2b68ff5435110b118d24f6273ab3001fcabeb5868f2d74733
-  data.tar.gz: fa00c085ab0f2bc8d669425b769e0a7699fe6065024d5c6768dfa78a5f1934347bd95bcd1981689a4d9b41473739568c33f55ca6fd276fcb182547a9a3f9f226
+  metadata.gz: 298ecee49c25bca164942b594298fefe8ddd23d3757cac7ef3a5bd1c725aa4ee72be6ef583adf35469ff28f6a3d42bd9a7ec3ded93d76542109a35eda803ced4
+  data.tar.gz: bc5e10415ab97c885a816e856e5b2da73f18e3e49d6c34d81933f5bc80b6841b1be15c4596193cd270ac82bc51e2e5af4e59a99bd788ee2a692fd46f9ef5144c

data/.rubocop_todo.yml

@@ -9,6 +9,8 @@
 # Offense count: 3
 Metrics/AbcSize:
   Max: 20
+  Exclude:
+    - 'lib/gqli/validation.rb'
 
 # Blocks can be arbitrarily long due to GraphQL DSL syntax.
 Metrics/BlockLength:
@@ -17,6 +19,8 @@ Metrics/BlockLength:
 # Offense count: 1
 Metrics/CyclomaticComplexity:
   Max: 11
+  Exclude:
+    - 'lib/gqli/validation.rb'
 
 # Offense count: 8
 # Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
@@ -28,10 +32,14 @@ Metrics/LineLength:
 # Configuration parameters: CountComments.
 Metrics/MethodLength:
   Max: 15
+  Exclude:
+    - 'lib/gqli/validation.rb'
 
 # Offense count: 1
 Metrics/PerceivedComplexity:
   Max: 8
+  Exclude:
+    - 'lib/gqli/validation.rb'
 
 # Block delimiters are `{...}` to match GraphQL syntax more closely.
 Style/BlockDelimiters:

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## v0.3.0
+### Added
+* Refactored validations to their own `Validation` class, which now provide better error messages upon validation failure.
+
 ## v0.2.0
 ### Added
 * Added `__node` to be able to create nodes in case there's a name collision with a reserved keyword or a built-in method.

data/README.md

@@ -281,7 +281,7 @@ query = GQLi::DSL.query {
 
 The helper method `__node`, can also receive arguments and have children nodes as expected from any other node declaration, for example:
 
-```
+```ruby
 query = GQLi::DSL.query {
   __node('catCollection', limit: 5) {
     items {
@@ -295,7 +295,6 @@ query = GQLi::DSL.query {
 
 * Mutation queries
 * Subscription queries
-* Detailed validation errors
 
 ## Get involved
 

data/lib/gqli/base.rb

@@ -19,8 +19,7 @@ module GQLi
 
     # Adds type match node
     def __on(type_name, &block)
-      require_relative './node'
-      @__nodes << Node.new("... on #{type_name}", {}, __depth + 1, &block)
+      __node("... on #{type_name}", {}, &block)
     end
 
     # Adds children node into current node
@@ -52,8 +51,7 @@ module GQLi
     end
 
     def method_missing(name, *args, &block)
-      require_relative './node'
-      @__nodes << Node.new(name.to_s, __params_from_args(args), __depth + 1, &block)
+      __node(name.to_s, __params_from_args(args), &block)
     end
   end
 end

data/lib/gqli/client.rb

@@ -23,7 +23,10 @@ module GQLi
     # Executes a query
     # If validations are enabled, will perform validation check before request.
     def execute(query)
-      fail 'Validation Error: query is invalid - HTTP Request not sent' unless valid?(query)
+      if validate_query
+        validation = schema.validate(query)
+        fail validation_error_message(validation) unless validation.valid?
+      end
 
       execute!(query)
     end
@@ -44,11 +47,20 @@ module GQLi
     def valid?(query)
       return true unless validate_query
 
-      @schema.valid?(query)
+      schema.valid?(query)
     end
 
     protected
 
+    def validation_error_message(validation)
+      <<~ERROR
+        Validation Error: query is invalid - HTTP Request not sent.
+
+        Errors:
+          - #{validation.errors.join("\n  - ")}
+      ERROR
+    end
+
     def request_headers
       {
         accept: 'application/json',

data/lib/gqli/introspection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './dsl'
+require_relative './validation'
 
 module GQLi
   # Introspection schema and validator
@@ -85,131 +86,14 @@ module GQLi
       @types = schema.types
     end
 
-    # Returns wether the query is valid or not
-    def valid?(query)
-      return false unless query.is_a?(Query)
-
-      query_type = types.find { |t| t.name.casecmp('query').zero? }
-      query.__nodes.each do |node|
-        return false unless valid_node?(query_type, node)
-      end
-
-      true
-    end
-
-    private
-
-    def valid_node?(parent_type, node)
-      return true if parent_type.kind == 'SCALAR'
-
-      return valid_match_node?(parent_type, node) if node.__name.start_with?('... on')
-
-      node_type = parent_type.fetch('fields', []).find { |f| f.name == node.__name }
-      return false if node_type.nil?
-
-      return false unless valid_params?(node_type, node)
-
-      resolved_node_type = type_for(node_type)
-      return false if resolved_node_type.nil?
-
-      return false unless valid_nesting_node?(resolved_node_type, node)
-
-      node.__nodes.all? { |n| valid_node?(resolved_node_type, n) }
-    end
-
-    def valid_match_node?(parent_type, node)
-      return true if parent_type.fetch('possibleTypes', []).find { |t| t.name == node.__name.gsub('... on ', '') }
-      false
-    end
-
-    def valid_params?(node_type, node)
-      node.__params.each do |param, value|
-        arg = node_type.fetch('args', []).find { |a| a.name == param.to_s }
-        return false if arg.nil?
-
-        arg_type = type_for(arg)
-        return false if arg_type.nil?
-
-        return false unless valid_value_for_type?(arg_type, value)
-      end
-
-      true
+    # Returns the evaluated validation for a query
+    def validate(query)
+      Validation.new(self, query)
     end
 
-    def valid_nesting_node?(node_type, node)
-      return false unless valid_object_node?(node_type, node)
-      return false unless valid_array_node?(node_type, node)
-      true
-    end
-
-    def valid_object_node?(node_type, node)
-      return false if %w[OBJECT INTERFACE].include?(node_type.kind) && node.__nodes.empty?
-      true
-    end
-
-    def valid_array_node?(node_type, node)
-      return false if %w[OBJECT INTERFACE].include?(node_type.kind) && node.__nodes.empty?
-      true
-    end
-
-    def valid_value_for_type?(arg_type, value)
-      case value
-      when ::String
-        return false unless arg_type.name == 'String' || arg_type.name == 'ID'
-      when ::Integer
-        return false unless arg_type.name == 'Int'
-      when ::Float
-        return false unless arg_type.name == 'Float'
-      when ::Hash
-        return valid_hash_value?(arg_type, value)
-      when true, false
-        return false unless arg_type.name == 'Boolean'
-      else
-        return false
-      end
-
-      true
-    end
-
-    def valid_hash_value?(arg_type, value)
-      return false unless arg_type.kind == 'INPUT_OBJECT'
-
-      type = types.find { |f| f.name == arg_type.name }
-      return false if type.nil?
-
-      value.each do |k, v|
-        input_field = type.fetch('inputFields', []).find { |f| f.name == k.to_s }
-        return false if input_field.nil?
-
-        input_field_type = type_for(input_field)
-        return false if input_field_type.nil?
-
-        return false unless valid_value_for_type?(input_field_type, v)
-      end
-    end
-
-    def type_for(field_type)
-      type = case field_type.type.kind
-             when 'NON_NULL'
-               non_null_type(field_type.type.ofType)
-             when 'LIST'
-               field_type.type.ofType
-             when 'OBJECT', 'INTERFACE', 'INPUT_OBJECT'
-               field_type.type
-             when 'SCALAR'
-               field_type.type
-             end
-
-      types.find { |t| t.name == type.name }
-    end
-
-    def non_null_type(non_null)
-      case non_null.kind
-      when 'LIST'
-        non_null.ofType
-      else
-        non_null
-      end
+    # Returns if the query is valid
+    def valid?(query)
+      validate(query).valid?
     end
   end
 end

data/lib/gqli/validation.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module GQLi
+  # Validations
+  class Validation
+    attr_reader :schema, :query, :errors
+
+    def initialize(schema, query)
+      @schema = schema
+      @query = query
+      @errors = []
+
+      validate
+    end
+
+    # Returns wether the query is valid or not
+    def valid?
+      errors.empty?
+    end
+
+    protected
+
+    def validate
+      fail 'Not a Query object' unless query.is_a?(Query)
+
+      query_type = types.find { |t| t.name.casecmp('query').zero? }
+      query.__nodes.each do |node|
+        begin
+          validate_node(query_type, node)
+        rescue StandardError => e
+          errors << e
+        end
+      end
+
+      true
+    rescue StandardError => e
+      errors << e
+    end
+
+    private
+
+    def types
+      schema.types
+    end
+
+    def validate_node(parent_type, node)
+      return if parent_type.kind == 'SCALAR'
+
+      return valid_match_node?(parent_type, node) if node.__name.start_with?('... on')
+
+      node_type = parent_type.fetch('fields', []).find { |f| f.name == node.__name }
+      fail "Node type not found for '#{node.__name}'" if node_type.nil?
+
+      validate_params(node_type, node)
+
+      resolved_node_type = type_for(node_type)
+      fail "Node type not found for '#{node.__name}'" if resolved_node_type.nil?
+
+      validate_nesting_node(resolved_node_type, node)
+
+      node.__nodes.each { |n| validate_node(resolved_node_type, n) }
+    end
+
+    def valid_match_node?(parent_type, node)
+      return if parent_type.fetch('possibleTypes', []).find { |t| t.name == node.__name.gsub('... on ', '') }
+      fail "Match type '#{node.__name.gsub('... on ', '')}' invalid"
+    end
+
+    def validate_params(node_type, node)
+      node.__params.each do |param, value|
+        begin
+          arg = node_type.fetch('args', []).find { |a| a.name == param.to_s }
+          fail "Invalid argument '#{param}'" if arg.nil?
+
+          arg_type = type_for(arg)
+          fail "Argument type not found for '#{param}'" if arg_type.nil?
+
+          validate_value_for_type(arg_type, value, param)
+        rescue StandardError => e
+          errors << e
+        end
+      end
+    end
+
+    def validate_nesting_node(node_type, node)
+      fail "Invalid object for node '#{node.__name}'" unless valid_object_node?(node_type, node)
+    end
+
+    def valid_object_node?(node_type, node)
+      return false if %w[OBJECT INTERFACE].include?(node_type.kind) && node.__nodes.empty?
+      true
+    end
+
+    def valid_array_node?(node_type, node)
+      return false if %w[OBJECT INTERFACE].include?(node_type.kind) && node.__nodes.empty?
+      true
+    end
+
+    def value_type_error(is_type, should_be, for_arg)
+      fail "Value is '#{is_type}', but should be '#{should_be}' for '#{for_arg}'"
+    end
+
+    def validate_value_for_type(arg_type, value, for_arg)
+      case value
+      when ::String
+        unless arg_type.name == 'String' || arg_type.kind == 'ENUM' || arg_type.name == 'ID'
+          value_type_error('String, Enum or ID', arg_type.name, for_arg)
+        end
+        if arg_type.kind == 'ENUM' && !arg_type.enumValues.map(&:name).include?(value)
+          fail "Invalid value for Enum '#{arg_type.name}' for '#{for_arg}'"
+        end
+      when ::Integer
+        value_type_error('Integer', arg_type.name, for_arg) unless arg_type.name == 'Int'
+      when ::Float
+        value_type_error('Float', arg_type.name, for_arg) unless arg_type.name == 'Float'
+      when ::Hash
+        validate_hash_value(arg_type, value, for_arg)
+      when true, false
+        value_type_error('Boolean', arg_type.name, for_arg) unless arg_type.name == 'Boolean'
+      else
+        value_type_error(value.class.name, arg_type.name, for_arg)
+      end
+    end
+
+    def validate_hash_value(arg_type, value, for_arg)
+      value_type_error('Object', arg_type.name, for_arg) unless arg_type.kind == 'INPUT_OBJECT'
+
+      type = types.find { |f| f.name == arg_type.name }
+      fail "Type not found for '#{arg_type.name}'" if type.nil?
+
+      value.each do |k, v|
+        begin
+          input_field = type.fetch('inputFields', []).find { |f| f.name == k.to_s }
+          fail "Input field definition not found for '#{k}'" if input_field.nil?
+
+          input_field_type = type_for(input_field)
+          fail "Input field type not found for '#{k}'" if input_field_type.nil?
+
+          validate_value_for_type(input_field_type, v, k)
+        rescue StandardError => e
+          errors << e
+        end
+      end
+    end
+
+    def type_for(field_type)
+      type = case field_type.type.kind
+             when 'NON_NULL'
+               non_null_type(field_type.type.ofType)
+             when 'LIST'
+               field_type.type.ofType
+             when 'OBJECT', 'INTERFACE', 'INPUT_OBJECT'
+               field_type.type
+             when 'SCALAR'
+               field_type.type
+             end
+
+      types.find { |t| t.name == type.name }
+    end
+
+    def non_null_type(non_null)
+      case non_null.kind
+      when 'LIST'
+        non_null.ofType
+      else
+        non_null
+      end
+    end
+  end
+end

data/lib/gqli/version.rb

@@ -3,5 +3,5 @@
 # GraphQL Client and DSL library
 module GQLi
   # Gem version
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/lib/gqli/client_spec.rb

@@ -49,7 +49,12 @@ describe GQLi::Client do
           dsl.query {
             foobar
           }
-        )}.to raise_exception 'Validation Error: query is invalid - HTTP Request not sent'
+        )}.to raise_exception <<~ERROR
+          Validation Error: query is invalid - HTTP Request not sent.
+
+          Errors:
+            - Node type not found for 'foobar'
+        ERROR
       }
     end
 

data/spec/lib/gqli/introspection_spec.rb

@@ -54,6 +54,10 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_truthy
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_truthy
+      expect(validation.errors).to be_empty
     end
 
     it 'wrong node returns false' do
@@ -62,6 +66,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Node type not found for 'foo'")
     end
 
     it 'object node that doesnt have proper values returns false' do
@@ -70,6 +79,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Invalid object for node 'catCollection'")
     end
 
     it 'object list node that doesnt have proper values returns false' do
@@ -80,6 +94,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Invalid object for node 'items'")
     end
 
     it 'type matching on invalid type returns false' do
@@ -96,6 +115,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Match type 'InvalidType' invalid")
     end
 
     it 'invalid arguments return false' do
@@ -108,6 +132,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Invalid argument 'invalidParam'")
     end
 
     it 'invalid argument type returns false' do
@@ -120,6 +149,11 @@ describe GQLi::Introspection do
       }
 
       expect(subject.valid?(query)).to be_falsey
+
+      validation = subject.validate(query)
+      expect(validation.valid?).to be_falsey
+      expect(validation.errors).not_to be_empty
+      expect(validation.errors.map(&:to_s)).to include("Value is 'String, Enum or ID', but should be 'Int' for 'limit'")
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gqli
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Contentful GmbH (David Litvak Bruno)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-18 00:00:00.000000000 Z
+date: 2018-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -316,6 +316,7 @@ files:
 - doc/GQLi/Node.html
 - doc/GQLi/Query.html
 - doc/GQLi/Response.html
+- doc/GQLi/Validation.html
 - doc/_index.html
 - doc/class_list.html
 - doc/css/common.css
@@ -342,6 +343,7 @@ files:
 - lib/gqli/node.rb
 - lib/gqli/query.rb
 - lib/gqli/response.rb
+- lib/gqli/validation.rb
 - lib/gqli/version.rb
 - spec/fixtures/vcr_cassettes/catCollection.yml
 - spec/fixtures/vcr_cassettes/client.yml