graphlient 0.3.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7ed6aeee8ae9bf6da765d8142a11387f17bfff3f
-  data.tar.gz: 084a33299652bb41bd08b83dd752a9703f0d7c58
+SHA256:
+  metadata.gz: c049e978a0c48e45fe84d49470bc890ae3b6ea86b86aab8158322616c62968dd
+  data.tar.gz: c7307c2b5c6ac6ac2b55ee4d416bbfffee1e29ed0826916254077add10370ee9
 SHA512:
-  metadata.gz: af15ee7373138bea76bf1d01beacdafa28ad50240974539c1fd33b3513a571253ce3df7b8739f4fbbd1ff3cbbe776af51c5c719c7ac68bc46e011d72cd97a3b1
-  data.tar.gz: 4711176bd83a7d24d13ee8bef46ab8eaf54473d03da06912a00a1c4bb544057285801765e753ea5225e073f3e9bbcaf8f1769c75efc203767525f6a120354c44
+  metadata.gz: 627d0d04d5ecea5e4c33ea0e59b15ac46fc458f76f179ac624d3519036865ad29267f629b1b3fda7592a50c846ea2cf06cc58a8f188a06caee44715268c18d07
+  data.tar.gz: 9742adef6879fbd08b00350674dced4b4886e476b45388d6d1a1afaaebba440153632e878649ff68beb223b158f365dd180b6db76e8463a13dbbeb4cdf8aa88d

data/.rubocop.yml

@@ -1,9 +1,18 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
+Lint/SplatKeywordArguments:
+  Enabled: false
+
 Style/FrozenStringLiteralComment:
   Enabled: false
 
 Style/Documentation:
   Enabled: false
 
+Style/SafeNavigation:
+  Enabled: false
+
 Metrics/LineLength:
   Enabled: false
 

data/.travis.yml

@@ -3,9 +3,9 @@ language: ruby
 cache: bundler
 
 rvm:
-  - 2.3.6
-  - 2.4.3
   - 2.5.0
+  - 2.7.2
+  - 3.0.0
   - ruby-head
   - jruby-9.1.16.0
   - jruby-head
@@ -15,7 +15,7 @@ before_install:
 
 matrix:
   include:
-    - rvm: 2.3.6
+    - rvm: 2.7.2
       script:
         - bundle exec danger
   allow_failures:

data/CHANGELOG.md

@@ -1,6 +1,34 @@
-### 0.3.3 (Next)
-
+### 0.6.0 (Next)
 * Your contribution here.
+
+### 0.5.0 (12/28/2020)
+
+* [#81](https://github.com/ashkan18/graphlient/pull/81): Make graphlient run on ruby 3.0 - [@Burgestrand](https://github.com/Burgestrand).
+* [#79](https://github.com/ashkan18/graphlient/pull/79): Added client testing docs - [@GabrielDzul](https://github.com/GabrielDzul).
+
+### 0.4.0 (5/22/2020)
+
+* [#72](https://github.com/ashkan18/graphlient/pull/72): Add http_options - [@neroleung](https://github.com/neroleung).
+* [#71](https://github.com/ashkan18/graphlient/issues/70): Add `Graphlient::Errors::TimeoutError` - [@BenDrozdoff](https://github.com/BenDrozdoff).
+* [#75](https://github.com/ashkan18/graphlient/pull/75): Support Faraday 1.x - [@jfhinchcliffe](https://github.com/jfhinchcliffe).
+* [#78](https://github.com/ashkan18/graphlient/pull/78): Add description of timeout values - [@sap1enza](https://github.com/sap1enza).
+
+### 0.3.7 (11/14/2019)
+
+* [#68](https://github.com/ashkan18/graphlient/pull/68): Add `Graphlient::Errors::ConnectionFailedError` - [@neroleung](https://github.com/neroleung).
+
+### 0.3.6 (07/23/2019)
+
+* [#63](https://github.com/ashkan18/graphlient/pull/63): Remove unused method for attribute with typo - [@ashkan18](https://github.com/ashkan18).
+* [#62](https://github.com/ashkan18/graphlient/pull/62): Fix typo preventing access to response object on error - [@jmondo](https://github.com/jmondo).
+
+### 0.3.4 (01/31/2019)
+
+* [#56](https://github.com/ashkan18/graphlient/pull/56): Remove safe navigation usage to retain support for Ruby 2.2 - [@avinoth](https://github.com/avinoth).
+* [#57](https://github.com/ashkan18/graphlient/pull/57): Add support for parsing queries from a String - [@ateamlunchbox](https://github.com/ateamlunchbox).
+
+### 0.3.3 (09/23/2018)
+
 * [#50](https://github.com/ashkan18/graphlient/pull/50): More detailed error responses - [@ashkan18](https://github.com/ashkan18).
 
 ### 0.3.2 (07/03/2018)

data/Gemfile

@@ -4,6 +4,10 @@ gemspec
 
 gem 'rake'
 
+group :development, :test do
+  gem 'activesupport', '< 6'
+end
+
 group :development do
   gem 'byebug', platform: :ruby
   gem 'danger-changelog', '~> 0.2.1'
@@ -11,7 +15,7 @@ group :development do
 end
 
 group :test do
-  gem 'graphql'
+  gem 'graphql', '~> 1.9'
   gem 'graphql-errors'
   gem 'rack-parser'
   gem 'rack-test'

data/README.md

@@ -15,16 +15,25 @@ gem 'graphlient'
 
 ## Usage
 
-Create a new instance of `Graphlient::Client` with a URL and optional headers.
+Create a new instance of `Graphlient::Client` with a URL and optional headers/http_options.
 
 ```ruby
 client = Graphlient::Client.new('https://test-graphql.biz/graphql',
   headers: {
     'Authorization' => 'Bearer 123'
+  },
+  http_options: {
+    read_timeout: 20,
+    write_timeout: 30
   }
 )
 ```
 
+| http_options  | default | type    |
+|---------------|---------|---------|
+| read_timeout  | nil     | seconds |
+| write_timeout | nil     | seconds |
+
 The schema is available automatically via `.schema`.
 
 ```ruby
@@ -126,6 +135,9 @@ Unlike graphql-client, Graphlient will always raise an exception unless the quer
 * [Graphlient::Errors::ServerError](lib/graphlient/errors/server_error.rb): all transport errors raised by HTTP Adapters. You can access `inner_exception`, `status_code` and `response` on these errors to get more details on what went wrong
 * [Graphlient::Errors::FaradayServerError](lib/graphlient/errors/faraday_server_error.rb): this inherits from `ServerError` ☝️, we recommend using `ServerError` to rescue these
 * [Graphlient::Errors::HttpServerError](lib/graphlient/errors/http_server_error.rb): this inherits from `ServerError` ☝️, we recommend using `ServerError` to rescue these
+* [Graphlient::Errors::ConnectionFailedError](lib/graphlient/errors/connection_failed_error.rb): this inherits from `ServerError` ☝️, we recommend using `ServerError` to rescue these
+* [Graphlient::Errors::TimeoutError](lib/graphlient/errors/timeout_error.rb): this inherits from `ServerError` ☝️, we recommend using `ServerError` to rescue these
+* [Graphlient::Errors::HttpOptionsError](lib/graphlient/errors/http_options_error.rb): all NoMethodError raised by HTTP Adapters when given options in `http_options` are invalid
 
 
 All errors inherit from `Graphlient::Errors::Error` if you need to handle them in bulk.
@@ -208,6 +220,23 @@ end
 client.execute query, ids: [42]
 ```
 
+Or pass in a string instead of a block:
+
+```ruby
+# parse a query, returns a GraphQL::Client::OperationDefinition
+query = client.parse <<~GRAPHQL
+  query($some_id: Int) {
+    invoice(id: $some_id) {
+      id
+      feeInCents
+    }
+  }
+GRAPHQL
+
+# execute a query, returns a GraphQL::Client::Response
+client.execute query, ids: [42]
+```
+
 ### Dynamic vs. Static Queries
 
 Graphlient uses [graphql-client](https://github.com/github/graphql-client), which [recommends](https://github.com/github/graphql-client/blob/master/guides/dynamic-query-error.md) building queries as static module members along with dynamic variables during execution. This can be accomplished with graphlient the same way.
@@ -316,7 +345,7 @@ describe App do
     Graphlient::Client.new('http://test-graphql.biz/graphql') do |client|
       client.http do |h|
         h.connection do |c|
-          c.use Faraday::Adapter::Rack, app
+          c.adapter Faraday::Adapter::Rack, app
         end
       end
     end
@@ -360,6 +389,49 @@ describe App do
 end
 ```
 
+In order to stub the response to actual queries, [dump the schema into a JSON file](#schema-storing-and-loading-on-disk) and specify it via schema_path as follows.
+
+```ruby
+describe App do
+  let(:url) { 'http://graph.biz/graphql' }
+  let(:client) { Graphlient::Client.new(url, schema_path: 'spec/support/fixtures/invoice_api.json') }
+  let(:query) do
+    <<~GRAPHQL
+      query{
+        invoice(id: 42) {
+          id
+          feeInCents
+        }
+      }
+    GRAPHQL
+  end
+  let(:json_response) do
+    {
+      'data' => {
+        'invoice' => {
+          'id' => '42',
+          'feeInCents' => 2000
+        }
+      }
+    }.to_json
+  end
+
+  before do
+    stub_request(:post, url).to_return(
+      status: 200,
+      body: json_response
+    )
+  end
+
+  it 'returns invoice fees' do
+    response = client.query(query)
+    expect(response.data).to be_truthy
+    expect(response.data.invoice.id).to eq('42')
+    expect(response.data.invoice.fee_in_cents).to eq(2000)
+  end
+end
+```
+
 ## License
 
 MIT License, see [LICENSE](LICENSE)

data/RELEASING.md

@@ -21,6 +21,8 @@ Change next release in [CHANGELOG.md](CHANGELOG.md) to the new version.
 
 Remove the line with "Your contribution here.", since there will be no more contributions to this release.
 
+Update the version in `lib/graphlient/version.rb`.
+
 Commit your changes.
 
 ```

data/UPGRADING.md

@@ -0,0 +1,23 @@
+Upgrading Graphlient
+===========================
+
+### Upgrading to >= 0.4.0
+
+#### Requires Faraday >= 1.0
+
+See [#75](https://github.com/ashkan18/graphlient/pull/75).
+
+#### Changes in error handling of connection refused error
+
+When the GraphQL request was failing, we were receiving a `Faraday::ServerError`. After 0.4.0, Graphlient
+will return `Graphlient::Errors::FaradayServerError` instead.
+
+### Upgrading to >= 0.3.7
+
+#### Changes in error handling of connection refused error
+
+Prior to 0.3.7, Graphlient would return `NoMethodError: undefined method []' for nil:NilClass` error if connection is
+refused/failed when connecting to a remote host. After 0.3.7, Graphlient will return a new 
+`Graphlient::Errors::ConnectionFailedError` instead.
+
+See [#68](https://github.com/ashkan18/graphlient/pull/68) for more information.

data/graphlient.gemspec

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

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

@@ -14,9 +14,27 @@ module Graphlient
           options[:headers] if options
         end
 
+        def http_options
+          return {} unless options
+
+          options[:http_options] || {}
+        end
+
         def execute(*)
           raise NotImplementedError
         end
+
+        private
+
+        def configure_http_options(client_options)
+          http_options.each do |k, v|
+            begin
+              client_options.send("#{k}=", v)
+            rescue NoMethodError => e
+              raise Graphlient::Errors::HttpOptionsError, e.message
+            end
+          end
+        end
       end
     end
   end

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

@@ -15,8 +15,14 @@ module Graphlient
             }.to_json
           end
           response.body
+        rescue Faraday::ConnectionFailed => e
+          raise Graphlient::Errors::ConnectionFailedError, e
+        rescue Faraday::TimeoutError => e
+          raise Graphlient::Errors::TimeoutError, e
         rescue Faraday::ClientError => e
           raise Graphlient::Errors::FaradayServerError, e
+        rescue Faraday::ServerError => e
+          raise Graphlient::Errors::FaradayServerError, e
         end
 
         def connection
@@ -24,10 +30,13 @@ module Graphlient
             c.use Faraday::Response::RaiseError
             c.request :json
             c.response :json
+
+            configure_http_options(c.options)
+
             if block_given?
               yield c
             else
-              c.use Faraday::Adapter::NetHttp
+              c.adapter Faraday::Adapter::NetHttp
             end
           end
         end

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

@@ -9,7 +9,7 @@ module Graphlient
 
           request['Accept'] = 'application/json'
           request['Content-Type'] = 'application/json'
-          headers&.each { |name, value| request[name] = value }
+          headers && headers.each { |name, value| request[name] = value }
 
           body = {}
           body['query'] = document.to_query_string
@@ -29,6 +29,8 @@ module Graphlient
         def connection
           Net::HTTP.new(uri.host, uri.port).tap do |client|
             client.use_ssl = uri.scheme == 'https'
+
+            configure_http_options(client)
           end
         end
       end

data/lib/graphlient/client.rb

@@ -8,8 +8,8 @@ module Graphlient
       yield self if block_given?
     end
 
-    def parse(&block)
-      query_str = Graphlient::Query.new do
+    def parse(query_str = nil, &block)
+      query_str ||= Graphlient::Query.new do
         instance_eval(&block)
       end
       client.parse(query_str.to_s)
@@ -22,11 +22,11 @@ module Graphlient
       query_params[:context] = @options if @options
       query_params[:variables] = variables if variables
       query = client.parse(query) if query.is_a?(String)
-      rc = client.query(query, query_params)
+      rc = client.query(query, **query_params)
       raise Graphlient::Errors::GraphQLError, rc if rc.errors.any?
       # see https://github.com/github/graphql-client/pull/132
       # see https://github.com/exAspArk/graphql-errors/issues/2
-      raise Graphlient::Errors::ExecutionError, rc if rc.data&.errors && rc.data.errors.any?
+      raise Graphlient::Errors::ExecutionError, rc if errors_in_result?(rc)
       rc
     rescue GraphQL::Client::Error => e
       raise Graphlient::Errors::ClientError, e.message
@@ -45,7 +45,9 @@ module Graphlient
     end
 
     def http(&block)
-      @http ||= http_adapter_class.new(@url, headers: @options[:headers], &block)
+      adapter_options = { headers: @options[:headers], http_options: @options[:http_options] }
+
+      @http ||= http_adapter_class.new(@url, adapter_options, &block)
     end
 
     def schema
@@ -63,5 +65,9 @@ module Graphlient
         client.allow_dynamic_queries = @options.key?(:allow_dynamic_queries) ? options[:allow_dynamic_queries] : true
       end
     end
+
+    def errors_in_result?(response)
+      response.data && response.data.errors && response.data.errors.any?
+    end
   end
 end

data/lib/graphlient/errors.rb

@@ -4,4 +4,7 @@ require_relative 'errors/server_error'
 require_relative 'errors/graphql_error'
 require_relative 'errors/execution_error'
 require_relative 'errors/faraday_server_error'
+require_relative 'errors/http_options_error'
 require_relative 'errors/http_server_error'
+require_relative 'errors/connection_failed_error'
+require_relative 'errors/timeout_error'

data/lib/graphlient/errors/connection_failed_error.rb

@@ -0,0 +1,6 @@
+module Graphlient
+  module Errors
+    class ConnectionFailedError < ServerError
+    end
+  end
+end

data/lib/graphlient/errors/graphql_error.rb

@@ -1,7 +1,7 @@
 module Graphlient
   module Errors
     class GraphQLError < Error
-      attr_reader :responsee
+      attr_reader :response
       def initialize(response)
         super('the server responded with a GraphQL error')
         @response = response

data/lib/graphlient/errors/http_options_error.rb

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

data/lib/graphlient/errors/timeout_error.rb

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

data/lib/graphlient/version.rb

@@ -1,3 +1,3 @@
 module Graphlient
-  VERSION = '0.3.3'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/spec/graphlient/adapters/http/faraday_adapter_spec.rb

@@ -8,29 +8,32 @@ describe Graphlient::Adapters::HTTP::FaradayAdapter do
       Graphlient::Client.new('http://example.com/graphql') do |client|
         client.http do |h|
           h.connection do |c|
-            c.use Faraday::Adapter::Rack, app
+            c.adapter Faraday::Adapter::Rack, app
           end
         end
       end
     end
 
     it 'inserts a middleware into the connection' do
+      expect(client.http.connection.adapter).to eq Faraday::Adapter::Rack
       expect(client.http.connection.builder.handlers).to eq(
         [
           Faraday::Response::RaiseError,
           FaradayMiddleware::EncodeJson,
-          FaradayMiddleware::ParseJson,
-          Faraday::Adapter::Rack
+          FaradayMiddleware::ParseJson
         ]
       )
     end
   end
 
-  context 'with custom url and headers' do
+  context 'with custom url, headers and http_options' do
     let(:url) { 'http://example.com/graphql' }
     let(:headers) { { 'Foo' => 'bar' } }
+    let(:http_options) { { timeout: timeout, write_timeout: write_timeout } }
+    let(:timeout) { 123 }
+    let(:write_timeout) { 234 }
     let(:client) do
-      Graphlient::Client.new(url, headers: headers)
+      Graphlient::Client.new(url, headers: headers, http_options: http_options)
     end
 
     it 'sets url' do
@@ -40,6 +43,19 @@ describe Graphlient::Adapters::HTTP::FaradayAdapter do
     it 'sets headers' do
       expect(client.http.headers).to eq headers
     end
+
+    it 'sets http_options' do
+      expect(client.http.connection.options.timeout).to eq(timeout)
+      expect(client.http.connection.options.write_timeout).to eq(write_timeout)
+    end
+
+    context 'when http_options contains invalid option' do
+      let(:http_options) { { an_invalid_option: 'an invalid option' } }
+
+      it 'raises Graphlient::Errors::HttpOptionsError' do
+        expect { client.http.connection }.to raise_error(Graphlient::Errors::HttpOptionsError)
+      end
+    end
   end
 
   context 'default' do
@@ -57,4 +73,40 @@ describe Graphlient::Adapters::HTTP::FaradayAdapter do
       expect(client.schema).to be_a Graphlient::Schema
     end
   end
+
+  context 'Failed to open TCP connection error' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:error_message) do
+      'Failed to open TCP connection to localhost:3000 (Connection refused - connect(2) for "localhost" port 3000)'
+    end
+
+    before do
+      wrapped_error = Errno::ECONNREFUSED.new(error_message)
+      error = Faraday::ConnectionFailed.new(wrapped_error)
+
+      stub_request(:post, url).to_raise(error)
+    end
+
+    specify do
+      expected_error_message = "Connection refused - #{error_message}"
+
+      expect { client.schema }.to raise_error(Graphlient::Errors::ConnectionFailedError, expected_error_message)
+    end
+  end
+
+  context 'Faraday Timeout Error' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:error_message) { 'Failed to Connect' }
+
+    before do
+      stub_request(:post, url).to_raise(Faraday::TimeoutError.new(Net::ReadTimeout.new(error_message)))
+    end
+    it 'raises a Graphlient Timeout' do
+      expect { client.schema }.to raise_error(Graphlient::Errors::TimeoutError) { |error|
+        expect(error.message).to include(error_message)
+      }
+    end
+  end
 end