graphlient 0.0.5 → 0.0.6

data/graphlient.gemspec

@@ -14,4 +14,7 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/ashkan18/graphlient'
   s.licenses = ['MIT']
   s.summary = 'Ruby Gem for consuming GraphQL endpoints'
+  s.add_dependency 'graphql-client'
+  s.add_dependency 'faraday'
+  s.add_dependency 'faraday_middleware'
 end

data/lib/graphlient.rb

@@ -1,9 +1,4 @@
-require 'net/http'
-require 'uri'
-require 'json'
-
 require 'graphlient/version'
-require 'graphlient/config.rb'
 require 'graphlient/extensions'
 require 'graphlient/errors'
 require 'graphlient/query'

data/lib/graphlient/adapters/faraday_adapter.rb

@@ -0,0 +1,43 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Graphlient
+  module Adapters
+    class FaradayAdapter
+      attr_accessor :url, :headers
+
+      def initialize(url, headers:, &_block)
+        @url = url
+        @headers = headers.dup if headers
+        yield self if block_given?
+      end
+
+      def execute(document:, operation_name:, variables:, context:)
+        response = connection.post do |req|
+          req.headers.merge!(context[:headers] || {})
+          req.body = {
+            query: document.to_query_string,
+            operationName: operation_name,
+            variables: variables.to_json
+          }.to_json
+        end
+        response.body
+      rescue Faraday::ClientError => e
+        raise Graphlient::Errors::Server.new(e.message, e)
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: url, headers: headers) do |c|
+          c.use Faraday::Response::RaiseError
+          c.request :json
+          c.response :json
+          if block_given?
+            yield c
+          else
+            c.use Faraday::Adapter::NetHttp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphlient/client.rb

@@ -1,37 +1,52 @@
+require 'graphql/client'
+require 'graphlient/adapters/faraday_adapter'
+
 module Graphlient
   class Client
-    attr_reader :uri
-    attr_reader :options
+    attr_accessor :uri, :options
 
-    def initialize(url, options = {})
-      @uri = URI(url)
+    def initialize(url, options = {}, &_block)
+      @url = url
       @options = options.dup
+      yield self if block_given?
     end
 
-    def query(&block)
-      query = Graphlient::Query.new do
+    def parse(&block)
+      query_str = Graphlient::Query.new do
         instance_eval(&block)
       end
-      response = post(query)
-      raise Graphlient::Errors::HTTP.new(response.message, response) unless response.is_a? Net::HTTPSuccess
-      parse(response.body)
+      client.parse(query_str.to_s)
     end
 
-    def connection
-      @connection ||= Net::HTTP.new(uri.host, uri.port)
+    def execute(query, variables = nil)
+      query_params = {}
+      query_params[:context] = @options if @options
+      query_params[:variables] = variables if variables
+      client.query(query, query_params)
+    rescue GraphQL::Client::Error => e
+      raise Graphlient::Errors::Client.new(e.message, e)
     end
 
-    def post(query)
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request.body = { query: query.to_s }.to_json
-      options[:headers].each do |k, v|
-        request[k] = v
-      end
-      connection.request(request)
+    def query(variables = nil, &block)
+      execute(parse(&block), variables)
+    rescue GraphQL::Client::Error => e
+      raise Graphlient::Errors::Client.new(e.message, e)
+    end
+
+    def http(&block)
+      @http ||= Adapters::FaradayAdapter.new(@url, headers: @options[:headers], &block)
     end
 
-    def parse(response)
-      JSON.parse(response, symbolize_names: true)
+    def schema
+      @schema ||= GraphQL::Client.load_schema(http)
+    end
+
+    private
+
+    def client
+      @client ||= GraphQL::Client.new(schema: schema, execute: http).tap do |client|
+        client.allow_dynamic_queries = @options.key?(:allow_dynamic_queries) ? options[:allow_dynamic_queries] : true
+      end
     end
   end
 end

data/lib/graphlient/errors.rb

@@ -1,2 +1,3 @@
 require_relative 'errors/error'
-require_relative 'errors/http'
+require_relative 'errors/client'
+require_relative 'errors/server'

data/lib/graphlient/errors/client.rb

@@ -0,0 +1,6 @@
+module Graphlient
+  module Errors
+    class Client < Error
+    end
+  end
+end

data/lib/graphlient/errors/error.rb

@@ -1,6 +1,13 @@
 module Graphlient
   module Errors
     class Error < StandardError
+      attr_reader :inner_exception
+
+      def initialize(message, inner_exception = nil)
+        super(message)
+
+        @inner_exception = inner_exception
+      end
     end
   end
 end

data/lib/graphlient/errors/server.rb

@@ -0,0 +1,6 @@
+module Graphlient
+  module Errors
+    class Server < Error
+    end
+  end
+end

data/lib/graphlient/query.rb

@@ -17,7 +17,7 @@ module Graphlient
     end
 
     def to_s
-      "{ #{query_str} }"
+      query_str.strip
     end
 
     private
@@ -26,7 +26,7 @@ module Graphlient
       # add field
       @query_str << "\n#{indent}#{query_field}"
       # add filter
-      @query_str << "(#{get_args_str(args)})" if args.any?
+      @query_str << "(#{get_args_str(args)})" if find_hash_arg(args)
 
       if block_given?
         @indents += 1
@@ -44,9 +44,15 @@ module Graphlient
     end
 
     def get_args_str(args)
-      args.detect { |arg| arg.is_a? Hash }.map do |k, v|
-        "#{k}: #{get_arg_value_str(v)}"
-      end.join(', ')
+      hash_args_str(find_hash_arg(args))
+    end
+
+    def find_hash_arg(args)
+      args.detect { |arg| arg.is_a? Hash }
+    end
+
+    def hash_args_str(hash)
+      hash.map { |k, v| "#{k}: #{get_arg_value_str(v)}" }.join(', ')
     end
 
     def get_arg_value_str(value)
@@ -57,6 +63,8 @@ module Graphlient
         value.to_s
       when Array
         "[#{value.map { |v| get_arg_value_str(v) }.join(', ')}]"
+      when Hash
+        "{ #{hash_args_str(value)} }"
       else
         value
       end

data/lib/graphlient/version.rb

@@ -1,3 +1,3 @@
 module Graphlient
-  VERSION = '0.0.5'.freeze
+  VERSION = '0.0.6'.freeze
 end

data/spec/graphlient/adapters/faraday_adapter_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Graphlient::Adapters::FaradayAdapter do
+  let(:app) { Object.new }
+
+  context 'with a custom middleware' do
+    let(:client) do
+      Graphlient::Client.new('http://example.com/graphql') do |client|
+        client.http do |h|
+          h.connection do |c|
+            c.use Faraday::Adapter::Rack, app
+          end
+        end
+      end
+    end
+
+    it 'inserts a middleware into the connection' do
+      expect(client.http.connection.builder.handlers).to eq(
+        [
+          Faraday::Response::RaiseError,
+          FaradayMiddleware::EncodeJson,
+          FaradayMiddleware::ParseJson,
+          Faraday::Adapter::Rack
+        ]
+      )
+    end
+  end
+
+  context 'with custom url and headers' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:headers) { { 'Foo' => 'bar' } }
+    let(:client) do
+      Graphlient::Client.new(url, headers: headers)
+    end
+
+    it 'sets url' do
+      expect(client.http.url).to eq url
+    end
+
+    it 'sets headers' do
+      expect(client.http.headers).to eq headers
+    end
+  end
+end

data/spec/graphlient/client_query_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Graphlient::Client do
+  include_context 'Dummy Client'
+
+  describe 'parse and execute' do
+    context 'non-parameterized query' do
+      let(:query) do
+        client.parse do
+          query do
+            invoices(ids: [10]) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+      end
+
+      it '#parse' do
+        expect(query).to be_a GraphQL::Client::OperationDefinition
+      end
+
+      it '#execute' do
+        response = client.execute(query)
+        invoices = response.data.invoices
+        expect(invoices.first.id).to eq 10
+      end
+    end
+
+    context 'parameterized query' do
+      let(:query) do
+        client.parse do
+          query(:$ids => :'[Int]') do
+            invoices(ids: :$ids) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+      end
+
+      it '#parse' do
+        expect(query).to be_a GraphQL::Client::OperationDefinition
+      end
+
+      it '#execute' do
+        response = client.execute(query, ids: [42])
+        invoices = response.data.invoices
+        expect(invoices.first.id).to eq 42
+        expect(invoices.first.fee_in_cents).to eq 20_000
+      end
+
+      it '#execute without variables' do
+        response = client.execute(query)
+        invoices = response.data.invoices
+        expect(invoices).to eq([])
+      end
+    end
+  end
+
+  describe '#query' do
+    context 'non-parameterized query' do
+      it 'fails client-side on invalid schema' do
+        expect do
+          client.query do
+            query do
+              invoice(id: 10) do
+                id
+                fee_in_cents
+              end
+            end
+          end
+        end.to raise_error Graphlient::Errors::Client do |e|
+          expect(e.to_s).to eq "Field 'invoice' doesn't exist on type 'Query'"
+        end
+      end
+
+      it 'returns a response from a query' do
+        response = client.query do
+          query do
+            invoices(ids: [10]) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+
+        invoices = response.data.invoices
+        expect(invoices.first.id).to eq 10
+        expect(invoices.first.fee_in_cents).to eq 20_000
+      end
+
+      it 'returns a response from a mutation' do
+        response = client.query do
+          mutation do
+            createInvoice(input: { fee_in_cents: 12_345 }) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+
+        invoice = response.data.create_invoice.first
+        expect(invoice.id).to eq 1231
+        expect(invoice.fee_in_cents).to eq 12_345
+      end
+    end
+
+    context 'parameterized query' do
+      it 'fails when missing input' do
+        response = client.query do
+          mutation('$input' => :createInvoiceInput!) do
+            createInvoice(input: :$input) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+
+        expect(response.errors.messages['data']).to eq(
+          [
+            'Variable input of type createInvoiceInput! was provided invalid value'
+          ]
+        )
+      end
+
+      it 'returns a response from a query' do
+        response = client.query(ids: [42]) do
+          query(:$ids => :'[Int]') do
+            invoices(ids: :$ids) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+
+        invoices = response.data.invoices
+        expect(invoices.first.id).to eq 42
+        expect(invoices.first.fee_in_cents).to eq 20_000
+      end
+
+      it 'executes the mutation' do
+        response = client.query(input: { fee_in_cents: 12_345 }) do
+          mutation(:$input => :createInvoiceInput!) do
+            createInvoice(input: :$input) do
+              id
+              fee_in_cents
+            end
+          end
+        end
+
+        invoice = response.data.create_invoice.first
+        expect(invoice.id).to eq 1231
+        expect(invoice.fee_in_cents).to eq 12_345
+      end
+    end
+  end
+end

data/spec/graphlient/client_schema_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Graphlient::Client do
+  let(:client) { Graphlient::Client.new('http://graph.biz/graphql') }
+
+  describe '#schema' do
+    before do
+      stub_request(:post, 'http://graph.biz/graphql').to_return(status: 500)
+    end
+
+    it 'fails with an exception' do
+      expect do
+        client.schema
+      end.to raise_error Graphlient::Errors::Server do |e|
+        expect(e.to_s).to eq 'the server responded with status 500'
+      end
+    end
+  end
+end