gqli 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2253633cb84598f7d7150f620b9161152c0c5961c92124ea2d517e97e7452b7
-  data.tar.gz: 84ceda416865f6295632b9044eeeeaeba29b24822a988a45e3cf8e1e6f85bfa9
+  metadata.gz: 972ad0f4a3e57ffe7e87a9492805b5d206ff0825ac335dbbf4a24b4981aed375
+  data.tar.gz: d60e39618526584c5291bfe1fa050e1639cc458e01d1038bb62e88693764c833
 SHA512:
-  metadata.gz: 298ecee49c25bca164942b594298fefe8ddd23d3757cac7ef3a5bd1c725aa4ee72be6ef583adf35469ff28f6a3d42bd9a7ec3ded93d76542109a35eda803ced4
-  data.tar.gz: bc5e10415ab97c885a816e856e5b2da73f18e3e49d6c34d81933f5bc80b6841b1be15c4596193cd270ac82bc51e2e5af4e59a99bd788ee2a692fd46f9ef5144c
+  metadata.gz: 40b7e0a94c6c543993131280bb00dc56e9d7600c9dc698970f66ccb3ff67613820c35199d60f74d7c2ec75417f52bd73ce528b9263193b70ed7e5a6498bc835f
+  data.tar.gz: 00c23e2e51019bcf85a608507062d0fb46662b008674e09c546aa6151bedbb45d3c4098fd0e7fcc247d39794d96315003544429a9dd097dda172bec6ee2f36d1

data/.rubocop.yml

@@ -29,3 +29,6 @@ Style/MutableConstant:
 
 Style/SignalException:
   EnforcedStyle: 'semantic'
+
+Style/DoubleNegation:
+  Enabled: false

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+## v0.4.0
+### Added
+* Add directive support.
+
 ## v0.3.0
 ### Added
 * Refactored validations to their own `Validation` class, which now provide better error messages upon validation failure.

data/README.md

@@ -291,6 +291,34 @@ query = GQLi::DSL.query {
 }
 ```
 
+### Directives
+
+In GraphQL, nodes can be selectively included or removed by the usage of directives, there are 2 directives available for the querying specification to do this: `@include` and `@skip`.
+
+```ruby
+query = GQLi::DSL.query {
+  someNode(:@include => {if: object.includes_some_node?})
+}
+```
+
+This will get transformed to:
+
+```graphql
+query {
+  someNode @include(if: true) # or false
+}
+```
+
+This behaviour is equivalent to using native Ruby to include/exclude a field from the query:
+
+```ruby
+query = GQLi::DSL.query {
+  someNode if object.includes_some_node?
+}
+```
+
+The difference is that by using the native implementation, in case of the condition not being met, the node will be completely not included in the outgoing query.
+
 ## Yet to be implemented
 
 * Mutation queries

data/lib/gqli/enum_value.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GQLi
+  # Wrapper for Enum values
+  class EnumValue
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    # Serializes the enum value to string
+    def to_s
+      value
+    end
+  end
+end

data/lib/gqli/node.rb

@@ -15,7 +15,7 @@ module GQLi
     # Serializes to a GraphQL string
     def to_gql
       result = '  ' * __depth + __name
-      result += '(' + __params_to_s(__params, true) + ')' unless __params.empty?
+      result += __params_to_s(__params, true) unless __params.empty?
       unless __nodes.empty?
         result += " {\n"
         result += __nodes.map(&:to_gql).join("\n")
@@ -27,14 +27,27 @@ module GQLi
 
     private
 
+    def __directive?(params)
+      params.size == 1 && params.keys.first.to_s.start_with?('@')
+    end
+
+    def __directive(params)
+      params.first.tap do |directive, directive_params|
+        return " #{directive}#{__params_to_s(directive_params, true)}"
+      end
+    end
+
     def __params_to_s(params, initial = false)
       case params
       when ::Hash
+        return __directive(params) if __directive?(params)
+
         result = params.map do |k, v|
           "#{k}: #{__params_to_s(v)}"
         end.join(', ')
 
-        return result if initial
+        return "(#{result})" if initial
+
         "{#{result}}"
       when ::Array
         "[#{params.map { |p| __params_to_s(p) }.join(', ')}]"

data/lib/gqli/validation.rb

@@ -44,7 +44,7 @@ module GQLi
     end
 
     def validate_node(parent_type, node)
-      return if parent_type.kind == 'SCALAR'
+      validate_directives(node)
 
       return valid_match_node?(parent_type, node) if node.__name.start_with?('... on')
 
@@ -66,8 +66,26 @@ module GQLi
       fail "Match type '#{node.__name.gsub('... on ', '')}' invalid"
     end
 
+    def validate_directives(node)
+      return unless node.__params.size == 1
+      node.__params.first.tap do |k, v|
+        break unless k.to_s.start_with?('@')
+
+        fail "Directive unknown '#{k}'" unless %i[@include @skip].include?(k)
+        fail "Missing arguments for directive '#{k}'" if v.nil? || !v.is_a?(::Hash) || v.empty?
+        v.each do |arg, value|
+          begin
+            fail "Invalid argument '#{arg}' for directive '#{k}'" if arg.to_s != 'if'
+            fail "Invalid value for 'if`, must be a boolean" if value != !!value
+          rescue StandardError => e
+            errors << e
+          end
+        end
+      end
+    end
+
     def validate_params(node_type, node)
-      node.__params.each do |param, value|
+      node.__params.reject { |p, _| p.to_s.start_with?('@') }.each do |param, value|
         begin
           arg = node_type.fetch('args', []).find { |a| a.name == param.to_s }
           fail "Invalid argument '#{param}'" if arg.nil?

data/lib/gqli/version.rb

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

data/spec/lib/gqli/dsl_spec.rb

@@ -116,6 +116,20 @@ describe GQLi::DSL do
       GRAPHQL
     end
 
+    it 'nodes can have directives' do
+      query = subject.query {
+        someNode(:@include => {if: true})
+        otherNode(:@skip => {if: false})
+      }
+
+      expect(query.to_gql).to eq <<~GRAPHQL
+        query {
+          someNode @include(if: true)
+          otherNode @skip(if: false)
+        }
+      GRAPHQL
+    end
+
     it 'nodes can have arbitrarily nested nodes' do
       query = subject.query {
         aNode {

data/spec/lib/gqli/introspection_spec.rb

@@ -155,5 +155,98 @@ describe GQLi::Introspection do
       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
+
+    describe 'directives' do
+      it 'can create a query with a directive and validations should not fail' do
+        query = dsl.query {
+          catCollection {
+            items {
+              name(:@include => { if: true })
+            }
+          }
+        }
+
+        validation = subject.validate(query)
+        expect(validation.valid?).to be_truthy
+      end
+
+      it 'unknown directives will fail' do
+        query = dsl.query {
+          catCollection(:@unknownDirective => nil)
+        }
+
+        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("Directive unknown '@unknownDirective'")
+      end
+
+      it 'known directive will fail if no arguments are passed' do
+        query = dsl.query {
+          catCollection(:@include => nil)
+        }
+
+        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("Missing arguments for directive '@include'")
+      end
+
+      it 'known directive will fail if arguments are empty' do
+        query = dsl.query {
+          catCollection(:@include => {})
+        }
+
+        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("Missing arguments for directive '@include'")
+      end
+
+      it 'known directive will fail if arguments is not if' do
+        query = dsl.query {
+          catCollection {
+            items {
+              name(:@include => { else: true })
+            }
+          }
+        }
+
+        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 'else' for directive '@include'")
+      end
+
+      it 'known directive will fail when if value is not boolean' do
+        query = dsl.query {
+          catCollection {
+            items {
+              name(:@include => { if: 123 })
+            }
+          }
+        }
+
+        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 value for 'if`, must be a boolean")
+      end
+
+      it 'known directive will fail when multiple arguments are passed' do
+        query = dsl.query {
+          catCollection {
+            items {
+              name(:@include => { if: true, else: false })
+            }
+          }
+        }
+
+        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 'else' for directive '@include'")
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gqli
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Contentful GmbH (David Litvak Bruno)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-19 00:00:00.000000000 Z
+date: 2018-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -311,6 +311,7 @@ files:
 - doc/GQLi/Base.html
 - doc/GQLi/Client.html
 - doc/GQLi/DSL.html
+- doc/GQLi/EnumValue.html
 - doc/GQLi/Fragment.html
 - doc/GQLi/Introspection.html
 - doc/GQLi/Node.html
@@ -338,6 +339,7 @@ files:
 - lib/gqli/base.rb
 - lib/gqli/client.rb
 - lib/gqli/dsl.rb
+- lib/gqli/enum_value.rb
 - lib/gqli/fragment.rb
 - lib/gqli/introspection.rb
 - lib/gqli/node.rb