graphlient 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa3b9416b7374b0c3881224177f2a5646432e27ce9fcfdb2454b31ba318e231a
-  data.tar.gz: 6ca64471c0129dc021248fa309ed187bde0c9f9e58cf07a98d9072768e5446fe
+  metadata.gz: ed5f47ad98345af440481f9dca800767524807bc667eace999d7ba36826e59fa
+  data.tar.gz: 22ec20f5b725b3bb85bc9c8e8371693824f7fd85b2db43336ce7f6a6be31543f
 SHA512:
-  metadata.gz: f035b28bfd747c72574b124cd5130e92798ac6b14d9000b73c6ce25357489f23ded22ca11dd74cc777c96dfeada948f86a9dd3b754838abf230cf82849e8f893
-  data.tar.gz: e6fd794359759c72051ddd7114fbe85c1110d0b743f55cd521cdcbb56fc9e6cecd4a70b6a6383f76d5304fd542d889e965d28738394995282768794059067b6c
+  metadata.gz: 1c5ddbaafe24dfbdd6e99535bedb7a021eba55a956b4b716661c9c8778018a96118afc5a6def029aad14da883de8d47a747b4a85ead2cee0868d5ddcfb298359
+  data.tar.gz: 3fd8b40976687fd83b00b865f62d514a87571de0bf68015486328d526a2d9cc76a8c4454a5d78f86acba6480860ac1abde3ff2edda1e92c26b03c58f60b067e2

data/.github/workflows/ci.yml

@@ -14,8 +14,9 @@ jobs:
           - { ruby: 2.7.2 }
           - { ruby: 3.0.0 }
           - { ruby: 3.1.2 }
+          - { ruby: 3.2.2 }
           - { ruby: "ruby-head", ignore: true }
-          - { ruby: "jruby-9.1.17", ignore: true }
+          - { ruby: "jruby-9.3.9.0", ignore: true }
           - { ruby: "jruby-head", ignore: true }
     steps:
     - uses: actions/checkout@v3

data/.github/workflows/danger.yml

@@ -18,5 +18,5 @@ jobs:
         bundler-cache: true
     - run: |
         # the personal token is public, this is ok, base64 encode to avoid tripping Github
-        TOKEN=$(echo -n NWY1ZmM5MzEyMzNlYWY4OTZiOGU3MmI3MWQ3Mzk0MzgxMWE4OGVmYwo= | base64 --decode)
+        TOKEN=$(echo -n Z2hwX0xNQ3VmanBFeTBvYkZVTWh6NVNqVFFBOEUxU25abzBqRUVuaAo= | base64 --decode)
         DANGER_GITHUB_API_TOKEN=$TOKEN bundle exec danger --verbose

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 ### (Next)
 * Your contribution here.
 
+### 0.8.0 (2024/01/06)
+* [#110](https://github.com/ashkan18/graphlient/pull/110): Ensure correct Faraday JSON response body parsing with invalid response header - [@taylorthurlow](https://github.com/taylorthurlow).
+* [#107](https://github.com/ashkan18/graphlient/pull/107): Pass in initialized schema as an option - [@kbaum](https://github.com/kbaum).
+* [#106](https://github.com/ashkan18/graphlient/pull/106): Add 3.2 to the list of ruby ci versions - [@igor-drozdov](https://github.com/igor-drozdov).
+* [#102](https://github.com/ashkan18/graphlient/pull/102): Update ci to test latest jruby - [@ashkan18](https://github.com/ashkan18).
+
 ### 0.7.0 (2022/10/11)
 * [#98](https://github.com/ashkan18/graphlient/pull/98): Bring back danger checks and improve them - [@ashkan18](https://github.com/ashkan18).
 * [#94](https://github.com/ashkan18/graphlient/pull/94): Enabled fragments - [@rellampec](https://github.com/rellampec).

data/README.md

@@ -9,7 +9,8 @@ A friendlier Ruby client for consuming GraphQL-based APIs. Built on top of your
 
 - [Installation](#installation)
 - [Usage](#usage)
-  - [Schema storing and loading on disk](#schema-storing-and-loading-on-disk)
+  - [Schema Storing and Loading on Disk](#schema-storing-and-loading-on-disk)
+  - [Preloading Schema Once](#preloading-schema-once)
   - [Error Handling](#error-handling)
   - [Executing Parameterized Queries and Mutations](#executing-parameterized-queries-and-mutations)
   - [Parse and Execute Queries Separately](#parse-and-execute-queries-separately)
@@ -140,6 +141,30 @@ client = Client.new(url, schema_path: 'config/your_graphql_schema.json')
 client.schema.dump! # you only need to call this when graphql schema changes
 ```
 
+### Preloading Schema Once
+
+Even if caching the schema on disk, instantiating `Graphlient::Client` often can be both time and memory intensive due to loading the schema for each instance. This is especially true if the schema is a large file. To get around these performance issues, instantiate your schema once and pass it in as a configuration option.
+
+One time in an initializer
+
+```ruby
+schema = Graphlient::Schema.new(
+  'https://graphql.foo.com/graphql', 'lib/graphql_schema_foo.json'
+)
+```
+
+Pass in each time you initialize a client
+
+```
+client = Graphlient::Client.new(
+  'https://graphql.foo.com/graphql',
+  schema: schema,
+  headers: {
+    'Authorization' => 'Bearer 123',
+  }
+)
+```
+
 ### Error Handling
 
 Unlike graphql-client, Graphlient will always raise an exception unless the query has succeeded.
@@ -341,7 +366,7 @@ invoice_query = client.parse do
   query do
     invoice(id: 10) do
       id
-      ___Graphlient__InvoiceFragment
+      ___Fragments__Invoice
     end
   end
 end

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

@@ -1,4 +1,5 @@
 require 'faraday'
+require 'json'
 
 module Graphlient
   module Adapters
@@ -13,7 +14,8 @@ module Graphlient
               variables: variables
             }.to_json
           end
-          response.body
+
+          parse_body(response.body)
         rescue Faraday::ConnectionFailed => e
           raise Graphlient::Errors::ConnectionFailedError, e
         rescue Faraday::TimeoutError => e
@@ -39,6 +41,38 @@ module Graphlient
             end
           end
         end
+
+        private
+
+        # Faraday 2.x's JSON response middleware will only parse a JSON
+        # response body into a Hash (or Array) object if the response headers
+        # match a specific content type regex. See Faraday's response JSON
+        # middleware definition for specifics on what the datatype of the
+        # response body will be. This method will handle the situation where
+        # the response header is not set appropriately, but contains JSON
+        # anyways. If the body cannot be parsed as JSON, an exception will be
+        # raised.
+        def parse_body(body)
+          case body
+          when Hash, Array
+            body
+          when String
+            begin
+              JSON.parse(body)
+            rescue JSON::ParserError
+              raise Graphlient::Errors::ServerError, 'Failed to parse response body as JSON'
+            end
+          else
+            inner_exception = StandardError.new <<~ERR.strip.tr("\n", ' ')
+              Unexpected response body type '#{body.class}'. Graphlient doesn't
+              know how to handle a response body of this type, but Faraday is
+              returning it. Please open an issue, particularly if the response
+              body does actually contain valid JSON.
+            ERR
+
+            raise Graphlient::Errors::ClientError, inner_exception
+          end
+        end
       end
     end
   end

data/lib/graphlient/client.rb

@@ -2,9 +2,12 @@ module Graphlient
   class Client
     attr_accessor :uri, :options
 
+    class InvalidConfigurationError < StandardError; end
+
     def initialize(url, options = {}, &_block)
       @url = url
       @options = options.dup
+      raise_error_if_invalid_configuration!
       yield self if block_given?
     end
 
@@ -51,11 +54,15 @@ module Graphlient
     end
 
     def schema
-      @schema ||= Graphlient::Schema.new(http, schema_path)
+      @schema ||= options[:schema] || Graphlient::Schema.new(http, schema_path)
     end
 
     private
 
+    def raise_error_if_invalid_configuration!
+      raise InvalidConfigurationError, 'schema_path and schema cannot both be provided' if options.key?(:schema_path) && options.key?(:schema)
+    end
+
     def schema_path
       return options[:schema_path].to_s if options[:schema_path]
     end

data/lib/graphlient/version.rb

@@ -1,3 +1,3 @@
 module Graphlient
-  VERSION = '0.7.0'.freeze
+  VERSION = '0.8.0'.freeze
 end

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

@@ -75,6 +75,61 @@ describe Graphlient::Adapters::HTTP::FaradayAdapter do
     end
   end
 
+  context 'a non-error response without an appropriate JSON header' do
+    let(:url) { 'http://example.com/graphql' }
+    let(:headers) { { 'Content-Type' => 'application/notjson' } }
+    let(:client) { Graphlient::Client.new(url) }
+    let(:response_headers) { { 'Content-Type' => 'application/notjson' } }
+
+    context 'when the response body is valid JSON' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers,
+          body: DummySchema.execute(GraphQL::Introspection::INTROSPECTION_QUERY).to_json
+        )
+      end
+
+      it 'retrieves schema' do
+        expect(client.schema).to be_a Graphlient::Schema
+      end
+    end
+
+    context 'when the response body is not valid JSON' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers,
+          body: ''
+        )
+      end
+
+      it 'raises Graphlient::Errors::ServerError' do
+        expect { client.schema }.to raise_error(Graphlient::Errors::ServerError) { |error|
+          expect(error.message).to include('Failed to parse response body as JSON')
+        }
+      end
+    end
+
+    context 'when the Faraday response body object is not a type we expect from Faraday' do
+      before do
+        stub_request(:post, url).to_return(
+          status: 200,
+          headers: response_headers
+        )
+      end
+
+      it 'raises Graphlient::Errors::ClientError' do
+        mock_response = double('response', body: nil)
+        allow(client.http.connection).to receive(:post).and_return(mock_response)
+
+        expect { client.schema }.to raise_error(Graphlient::Errors::ClientError) { |error|
+          expect(error.message).to include "Unexpected response body type 'NilClass'"
+        }
+      end
+    end
+  end
+
   context 'Failed to open TCP connection error' do
     let(:url) { 'http://example.com/graphql' }
     let(:client) { Graphlient::Client.new(url) }

data/spec/graphlient/client_schema_spec.rb

@@ -51,5 +51,25 @@ describe Graphlient::Client do
         expect(client.schema.path).to eq 'config/schema.json'
       end
     end
+
+    context 'when preloaded schema is provided' do
+      let(:schema) { Graphlient::Schema.new(url, 'spec/support/fixtures/invoice_api.json') }
+      let(:client) { described_class.new(url, schema: schema) }
+
+      it 'returns the passed in schema' do
+        expect(client.schema).not_to be_nil
+        expect(client.schema).to eq(schema)
+      end
+    end
+
+    context 'when and a schema and a schema path are provided' do
+      let(:schema) { Graphlient::Schema.new(url, 'spec/support/fixtures/invoice_api.json') }
+      let(:client) { described_class.new(url, schema: schema, schema_path: 'spec/support/fixtures/invoice_api.json') }
+
+      it 'raises an invalid configuration error' do
+        expect { client }.to raise_error(Graphlient::Client::InvalidConfigurationError,
+                                         /schema_path and schema cannot both be provided/)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphlient
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Ashkan Nasseri
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-11 00:00:00.000000000 Z
+date: 2024-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A friendlier Ruby client for consuming GraphQL-based APIs.