graphlient 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f73350b469913784302c46b7305cef2d8949ad32
-  data.tar.gz: 91e1a47a61c402174bef0f15a0568e05d26b73cc
+  metadata.gz: cd0db2077a31028524926bedc3c7ac54c5f3e6eb
+  data.tar.gz: d78c92a97b670680fc056c0996c975ee7a9df80c
 SHA512:
-  metadata.gz: aaadb8bf32399b399fae81c4ce62a3d73508317eb4a157f90c9bf1665a77f5d91116dc0e263a6d27a2d5dfad9eeca1ea730b3d81966d68d0519c65b2dd9cb3cc
-  data.tar.gz: f50b03492b2e1c82b974fd5e59952e00cd38f82e992d5a2be84efdb4afa146a4ec65cf3370b4d77054a9de3094b7fb483453aea6f48655695c73e76bbbd83d59
+  metadata.gz: c00966fb20008a0b9524c46b24a249d4551aef3d8543855e923ce6f2c40b71fefa8cb68874fbc660e90d7c8fd196b8c1dc3376a2e641968f83de271629ce016d
+  data.tar.gz: 183d86c88b7344be098af445c96504dc866271cd1210b7d4e1b57da446dff1c919be8cebe79592c936792952d42257a1c23a9506442bdf1302e8e63b120c1501

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.2.0 (11/09/2017)
+
+* [#33](https://github.com/ashkan18/graphlient/pull/33): Added dsl for supporting parametrized queries/mutations - [@ashkan18](https://github.com/ashkan18).
+* [#34](https://github.com/ashkan18/graphlient/issues/34): Fix: don't convert variables to `String` - [@dblock](https://github.com/dblock).
+
 ### 0.1.0 (10/27/2017)
 
 * [#31](https://github.com/ashkan18/graphlient/issues/31): Fix: catch execution errors that don't contain field names - [@dblock](https://github.com/dblock).

data/README.md

@@ -144,21 +144,31 @@ With a block.
 
 ```ruby
 client.query(ids: [42]) do
-  query(:$ids => :'[Int]') do
-    invoices(ids: :$ids) do
+  query(ids: [:int]) do
+    invoices(ids: :ids) do
       id
       fee_in_cents
     end
   end
 end
 ```
+Graphlient supports following Scalar types for parameterized queries by default:
+- `:id` maps to `ID`
+- `:boolean` maps to `Boolean`
+- `:float` maps to `Float`
+- `:int` maps to `Int`
+- `:string` maps to `String`
+
+You can use any of the above types with `!` to make it required or use them in `[]` for array parameters.
+
+For any other costume types, graphlient will simply use `to_s` of the symbol provided for the type, so `query(ids: [:InvoiceType!])` will result in `query($ids: [InvoiceType!])`.
 
 The following mutation accepts a custom type that requires `fee_in_cents`.
 
 ```ruby
 client.query(input: { fee_in_cents: 12_345 }) do
-  mutation(:$input => :createInvoiceInput!) do
-    createInvoice(input: :$input) do
+  mutation(input: :createInvoiceInput!) do
+    createInvoice(input: :input) do
       id
       fee_in_cents
     end
@@ -174,8 +184,8 @@ You can `parse` and `execute` queries separately with optional variables. This i
 ```ruby
 # parse a query, returns a GraphQL::Client::OperationDefinition
 query = client.parse do
-  query(:$ids => :'[Int]') do
-    invoices(ids: :$ids) do
+  query(ids: [:int]) do
+    invoices(ids: :ids) do
       id
       fee_in_cents
     end
@@ -214,8 +224,8 @@ Define a query.
 ```ruby
 module SWAPI
   InvoiceQuery = Client.parse do
-    query(:$id => :Int) do
-      invoice(id: :$id) do
+    query(id: :int) do
+      invoice(id: :id) do
         id
         fee_in_cents
       end

data/lib/graphlient/adapters/http/faraday_adapter.rb

@@ -11,7 +11,7 @@ module Graphlient
             req.body = {
               query: document.to_query_string,
               operationName: operation_name,
-              variables: variables.to_json
+              variables: variables
             }.to_json
           end
           response.body

data/lib/graphlient/query.rb

@@ -1,15 +1,32 @@
 module Graphlient
   class Query
+    SCALAR_TYPES = {
+      int: 'Int',
+      float: 'Float',
+      string: 'String',
+      boolean: 'Boolean'
+    }.freeze
+
+    ROOT_NODES = %w(query mutation subscription).freeze
+
     attr_accessor :query_str
 
     def initialize(&block)
       @indents = 0
       @query_str = ''
+      @variables = []
       instance_eval(&block)
     end
 
     def method_missing(m, *args, &block)
-      append(m, args, &block)
+      append_node(m, args, &block)
+    end
+
+    ROOT_NODES.each do |root_node|
+      define_method(root_node) do |*args, &block|
+        @variables = args.first unless args.empty?
+        append_node(root_node, args, arg_processor: ->(k, v) { "$#{k}: #{variable_string(v)}" }, &block)
+      end
     end
 
     def respond_to_missing?(m, include_private = false)
@@ -22,11 +39,12 @@ module Graphlient
 
     private
 
-    def append(query_field, args, &block)
+    def append_node(node, args, arg_processor: nil, &block)
       # add field
-      @query_str << "\n#{indent}#{query_field}"
+      @query_str << "\n#{indent}#{node}"
       # add filter
-      @query_str << "(#{get_args_str(args)})" if find_hash_arg(args)
+      hash_arguments = hash_arg(args)
+      @query_str << "(#{args_str(hash_arguments, arg_processor: arg_processor)})" if hash_arguments
 
       if block_given?
         @indents += 1
@@ -43,28 +61,46 @@ module Graphlient
       '  ' * @indents
     end
 
-    def get_args_str(args)
-      hash_args_str(find_hash_arg(args))
+    def hash_arg(args)
+      args.detect { |arg| arg.is_a? Hash }
+    end
+
+    def args_str(hash_args, arg_processor: nil)
+      hash_args.map do |k, v|
+        arg_processor ? arg_processor.call(k, v) : argument_string(k, v)
+      end.join(', ')
     end
 
-    def find_hash_arg(args)
-      args.detect { |arg| arg.is_a? Hash }
+    def argument_string(k, v)
+      "#{k}: #{argument_value_string(v)}"
     end
 
-    def hash_args_str(hash)
-      hash.map { |k, v| "#{k}: #{get_arg_value_str(v)}" }.join(', ')
+    def variable_string(v)
+      case v
+      when :id, :id!
+        v.to_s.upcase
+      when ->(value) { SCALAR_TYPES.key?(value.to_s.delete('!').to_sym) }
+        # scalar types
+        v.to_s.camelize
+      when Array
+        "[#{variable_string(v.first)}]"
+      else
+        v.to_s
+      end
     end
 
-    def get_arg_value_str(value)
+    def argument_value_string(value)
       case value
       when String
         "\"#{value}\""
       when Numeric
         value.to_s
       when Array
-        "[#{value.map { |v| get_arg_value_str(v) }.join(', ')}]"
+        "[#{value.map { |v| argument_value_string(v) }.join(', ')}]"
       when Hash
-        "{ #{hash_args_str(value)} }"
+        "{ #{value.map { |k, v| "#{k}: #{argument_value_string(v)}" }.join(', ')} }"
+      when Symbol
+        @variables.keys.include?(value) ? "$#{value}" : value.to_s.camelize(:lower)
       else
         value
       end

data/lib/graphlient/version.rb

@@ -1,3 +1,3 @@
 module Graphlient
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/spec/graphlient/client_query_spec.rb

@@ -30,8 +30,8 @@ describe Graphlient::Client do
     context 'parameterized query' do
       let(:query) do
         client.parse do
-          query(:$ids => :'[Int]') do
-            invoices(ids: :$ids) do
+          query(some_ids: [:int]) do
+            invoices(ids: :some_ids) do
               id
               fee_in_cents
             end
@@ -44,7 +44,7 @@ describe Graphlient::Client do
       end
 
       it '#execute' do
-        response = client.execute(query, ids: [42])
+        response = client.execute(query, some_ids: [42])
         invoices = response.data.invoices
         expect(invoices.first.id).to eq 42
         expect(invoices.first.fee_in_cents).to eq 20_000
@@ -162,8 +162,8 @@ describe Graphlient::Client do
       it 'fails when missing input' do
         expect do
           client.query do
-            mutation('$input' => :createInvoiceInput!) do
-              createInvoice(input: :$input) do
+            mutation(input: :createInvoiceInput!) do
+              createInvoice(input: :input) do
                 id
                 fee_in_cents
               end
@@ -175,8 +175,8 @@ describe Graphlient::Client do
 
       it 'returns a response from a query' do
         response = client.query(ids: [42]) do
-          query(:$ids => :'[Int]') do
-            invoices(ids: :$ids) do
+          query(ids: [:int]) do
+            invoices(ids: :ids) do
               id
               fee_in_cents
             end
@@ -190,8 +190,8 @@ describe Graphlient::Client do
 
       it 'executes the mutation' do
         response = client.query(input: { fee_in_cents: 12_345 }) do
-          mutation(:$input => :createInvoiceInput!) do
-            createInvoice(input: :$input) do
+          mutation(input: :createInvoiceInput!) do
+            createInvoice(input: :input) do
               id
               fee_in_cents
             end
@@ -206,8 +206,8 @@ describe Graphlient::Client do
       it 'fails when mutation missing a field' do
         expect do
           client.query(input: {}) do
-            mutation(:$input => :createInvoiceInput!) do
-              createInvoice(input: :$input) do
+            mutation(input: :createInvoiceInput!) do
+              createInvoice(input: :input) do
                 id
                 fee_in_cents
               end

data/spec/graphlient/query_spec.rb

@@ -51,7 +51,7 @@ describe Graphlient::Query do
         expect(query.to_s).to eq "query{\n  invoice(id: 10, threshold: 10.3, item_list: [\"str_item\", 2]){\n    line_items(name: \"new name\")\n    }\n  }"
       end
 
-      it 'returns proper query with query name' do
+      it 'returns proper query' do
         query = Graphlient::Query.new do
           query do
             invoice(id: 10) do
@@ -63,6 +63,19 @@ describe Graphlient::Query do
         end
         expect(query.to_s).to eq "query{\n  invoice(id: 10){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
       end
+
+      it 'returns proper query with query variables' do
+        query = Graphlient::Query.new do
+          query(invoice_id: :int, names: [:string!]) do
+            invoice(id: :invoice_id, name: :names) do
+              line_items do
+                line_item_type
+              end
+            end
+          end
+        end
+        expect(query.to_s).to eq "query($invoice_id: Int, $names: [String!]){\n  invoice(id: $invoice_id, name: $names){\n    line_items{\n      line_item_type\n      }\n    }\n  }"
+      end
     end
 
     context 'mutation' do

data/spec/graphlient/static_client_query_spec.rb

@@ -16,8 +16,8 @@ describe Graphlient::Client do
       end
 
       Query = Client.parse do
-        query(:$ids => :'[Int]') do
-          invoices(ids: :$ids) do
+        query(some_ids: [:int]) do
+          invoices(ids: :some_ids) do
             id
             fee_in_cents
           end
@@ -30,7 +30,7 @@ describe Graphlient::Client do
     end
 
     it '#execute' do
-      response = Graphlient::Client::Spec::Client.execute(Graphlient::Client::Spec::Query, ids: [42])
+      response = Graphlient::Client::Spec::Client.execute(Graphlient::Client::Spec::Query, some_ids: [42])
       invoices = response.data.invoices
       expect(invoices.first.id).to eq 42
       expect(invoices.first.fee_in_cents).to eq 20_000

data/spec/support/dummy_app.rb

@@ -12,7 +12,7 @@ post '/graphql' do
   headers['Content-Type'] = 'application/json'
   DummySchema.execute(
     params[:query],
-    variables: params[:variables] ? JSON.parse(params[:variables]) : {},
+    variables: params[:variables] || {},
     context: {},
     operation_name: params[:operationName]
   ).to_json

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlient
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ashkan Nasseri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-27 00:00:00.000000000 Z
+date: 2017-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql-client