artemis 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a0f96c5c92adae8e2b52b173e05240aaa8967d8184887f25e3b986abe7db6a6
-  data.tar.gz: bf731d81af95a1ae12c6cc0d1bc01b4f0b13e3d563717d7ee97d3bdbbbc2c18f
+  metadata.gz: be41d5677f98282ad274f675f696c6d092fb7d0279d8986492a615e81c024d93
+  data.tar.gz: d9877242e814d7c20b24b217eb2a3c762699ae21d69ddf1e926e762c79854e59
 SHA512:
-  metadata.gz: 448933d593a7cb931dca4fb128e4a7052792e2c6405f42a797e9f1e9f4bde557fb6845f123a0132e89a53b6f56310c2c0585af74a87acace334dd34d5f74b105
-  data.tar.gz: 6865a729838c972eda26707ea12cddb846a21aea6d1b2c0cd252054054f2f5758b2c81bdd543ddbac5dfc1fd6ca127c31fd83a5a67f6e847230d7eec787d7375
+  metadata.gz: 3c16b35fa42042a378ea42920155fd4ea35d1289f65868be9883a50d3ba5dfd329978ea24847f4de4372c585bdb351ab8f4a6c65072fa7d49013d9948d5f08ed
+  data.tar.gz: a6c6034a1b524165b193a5dc96efa60a4516aa28a36fbb0a16b5fdec5bdcb868d4142f97c756cb62cfc46926d14de8aaf233b7c1876627e5806366088c898f57

data/.github/workflows/ruby.yml

@@ -5,23 +5,43 @@ on:
   - pull_request
 
 jobs:
-  build:
+  mri:
     strategy:
       matrix:
         ruby_version:
+          - '3.2'
+          - '3.1'
           - '3.0'
           - '2.7'
           - '2.6'
-          - '2.5'
-          # - 'jruby-9.2.17.0'
         gemfile:
+          - gemfiles/rails_70.gemfile
           - gemfiles/rails_61.gemfile
           - gemfiles/rails_60.gemfile
           - gemfiles/rails_52.gemfile
           - gemfiles/rails_51.gemfile
           - gemfiles/rails_50.gemfile
-          # - gemfiles/rails_edge.gemfile
         exclude:
+          - ruby_version: '3.2'
+            gemfile: gemfiles/rails_61.gemfile
+          - ruby_version: '3.2'
+            gemfile: gemfiles/rails_60.gemfile
+          - ruby_version: '3.2'
+            gemfile: gemfiles/rails_52.gemfile
+          - ruby_version: '3.2'
+            gemfile: gemfiles/rails_51.gemfile
+          - ruby_version: '3.2'
+            gemfile: gemfiles/rails_50.gemfile
+          - ruby_version: '3.1'
+            gemfile: gemfiles/rails_61.gemfile
+          - ruby_version: '3.1'
+            gemfile: gemfiles/rails_60.gemfile
+          - ruby_version: '3.1'
+            gemfile: gemfiles/rails_52.gemfile
+          - ruby_version: '3.1'
+            gemfile: gemfiles/rails_51.gemfile
+          - ruby_version: '3.1'
+            gemfile: gemfiles/rails_50.gemfile
           - ruby_version: '3.0'
             gemfile: gemfiles/rails_52.gemfile
           - ruby_version: '3.0'
@@ -34,15 +54,13 @@ jobs:
             gemfile: gemfiles/rails_51.gemfile
           - ruby_version: '2.7'
             gemfile: gemfiles/rails_50.gemfile
-          # - ruby_version: '2.6'
-          #   gemfile: gemfiles/rails_edge.gemfile
-          # - ruby_version: '2.5'
-          #   gemfile: gemfiles/rails_edge.gemfile
-    runs-on: ubuntu-18.04
+          - ruby_version: '2.6'
+            gemfile: gemfiles/rails_70.gemfile
+    runs-on: ubuntu-22.04
     env:
       BUNDLE_GEMFILE: ${{ matrix.gemfile }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - name: Install curl
         run: sudo apt-get install curl libcurl4-openssl-dev
       - name: Set up Ruby
@@ -51,3 +69,67 @@ jobs:
           ruby-version: ${{ matrix.ruby_version }}
           bundler-cache: true
       - run: bundle exec rake
+
+  rails_edge:
+    needs:
+      - mri
+    runs-on: ubuntu-22.04
+    env:
+      BUNDLE_GEMFILE: gemfiles/rails_edge.gemfile
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install curl
+        run: sudo apt-get install curl libcurl4-openssl-dev
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+          bundler-cache: true
+      - run: bundle exec rake || echo "Rails edge test is done."
+
+  ruby_edge:
+    needs:
+      - mri
+    strategy:
+      matrix:
+        ruby_version:
+          - 'ruby-head'
+        gemfile:
+          - gemfiles/rails_edge.gemfile
+          - gemfiles/rails_70.gemfile
+    runs-on: ubuntu-22.04
+    env:
+      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install curl
+        run: sudo apt-get install curl libcurl4-openssl-dev
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby_version }}
+          bundler-cache: true
+      - run: bundle exec rake || echo "Ruby edge test is done."
+
+#  The curb gem does not work well with JRuby, so skipping for now...
+#  jruby:
+#    needs:
+#      - mri
+#    strategy:
+#      matrix:
+#        ruby_version:
+#          - 'jruby-9.4'
+#          - 'jruby-head'
+#        gemfile:
+#          - gemfiles/rails_70.gemfile
+#    runs-on: ubuntu-22.04
+#    env:
+#      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+#    steps:
+#      - uses: actions/checkout@v3
+#      - name: Set up Ruby
+#        uses: ruby/setup-ruby@v1
+#        with:
+#          ruby-version: ${{ matrix.ruby_version }}
+#          bundler-cache: true
+#      - run: bundle exec rake || echo "JRuby test is done."

data/.gitignore

@@ -8,3 +8,4 @@
 /tmp/
 Gemfile.lock
 gemfiles/*.lock
+.byebug_history

data/Appraisals

@@ -6,6 +6,12 @@ appraise "rails_edge" do
   end
 end
 
+appraise "rails_70" do
+  gem "rails", '~> 7.0.0'
+  gem "railties", '~> 7.0.0'
+  gem "activesupport", '~> 7.0.0'
+end
+
 appraise "rails_61" do
   gem "rails", '~> 6.1.0'
   gem "railties", '~> 6.1.0'

data/CHANGELOG.md

@@ -1,17 +1,33 @@
-## v0.6.0
+## Unreleased
 
-_<sup>(unreleased)</sup>_
+- New entries come here...
+
+## [v0.7.0](https://github.com/yuki24/artemis/tree/v0.7.0)
+
+_<sup>released at 2022-03-05 08:24:45 UTC</sup>_
+
+#### Features
+
+- Add support for Ruby 3.1 and Rails 7.0
+- Add support for [the Multiplex query](https://graphql-ruby.org/queries/multiplex.html)
+- Do not allow the usage of the `multi_domain` adapter to be nested ([<tt>9b7b520</tt>](https://github.com/yuki24/artemis/commit/9b7b5202c9fbe424d4ca22f05dc9c9759b5202c3))
+- Do not require fragment files to end with `_fragment.graphql` ([<tt>3c6c0fa</tt>](https://github.com/yuki24/artemis/commit/3c6c0fa))
+- Allow for overriding the namespace used for resolving graphql file paths ([<tt>bd18762</tt>](https://github.com/yuki24/artemis/commit/bd18762))
+
+## [v0.6.0](https://github.com/yuki24/artemis/tree/v0.6.0)
+
+_<sup>released at 2021-09-03 04:17:55 UTC</sup>_
 
 #### Features
 
- * Add support for Ruby 3.0 and Rails 6.0, 6.1
- * Add the multi domain adapter (744b8ea3)
+- Add support for Ruby 3.0 and Rails 6.0, 6.1
+- Add the multi domain adapter ([<tt>744b8ea</tt>](https://github.com/yuki24/artemis/commit/744b8ea35795b4e6cc4fdc1ebb63dd9a4e9819f0))
 
 #### Fixes
 
- * ~~Generate fixture YAML files on `rails g artemis:query queryName` (#78)~~ Removed due to a bug for now.
- * Address warnings from Ruby 2.7 (408adcb3)
- * Avoid crashing when config/graphql.yml does not exist (@dlackty, #76)
+- ~~Generate fixture YAML files on `rails g artemis:query queryName` ([#78](https://github.com/yuki24/artemis/pull/78))~~ Removed due to a bug for now.
+- Address warnings from Ruby 2.7 ([<tt>408adcb</tt>](https://github.com/yuki24/artemis/commit/408adcb3f39912f7afb7b3690a52f1d593662b7b))
+- Avoid crashing when config/graphql.yml does not exist ([@dlackty](https://github.com/dlackty), [#76](https://github.com/yuki24/artemis/pull/76))
 
 ## [v0.5.2](https://github.com/yuki24/artemis/tree/v0.5.2)
 

data/README.md

@@ -1,4 +1,4 @@
-# Artemis [![Build Status](https://travis-ci.org/yuki24/artemis.svg?branch=master)](https://travis-ci.org/yuki24/artemis)
+# Artemis [![build](https://github.com/yuki24/artemis/actions/workflows/ruby.yml/badge.svg)](https://github.com/yuki24/artemis/actions/workflows/ruby.yml) [![Gem Version](https://badge.fury.io/rb/artemis.svg)](https://rubygems.org/gems/artemis)
 
 Artemis is a GraphQL client that is designed to fit well on Rails.
 
@@ -92,6 +92,32 @@ Artemis assumes that the files related to GraphQL are organized in a certain way
 └──vendor/graphql/schema/artsy.json
 ```
 
+### Fragments
+Fragments are defined in defined in a standard way in a file named `_artwork_fragment.graphql` with the standard convention:
+
+```graphql
+fragment on Artwork {
+  id,
+  name,
+  artist_id
+  # other artwork fields here
+}
+```
+
+The way of calling an Artemis fragment on other queries or models is with a **Rails convention**. Let us suppose we have the Artist model and its corresponding artwork. The way of nesting or calling the artwork on the artist model would look like this:
+
+```graphql
+fragment on Artist {
+  id,
+  name,
+  artworks {
+    ...Artsy::ArtworkFragment
+  }
+}
+```
+
+Where `Artsy` is the name of the folder/module.
+
 ## Callbacks
 
 You can use the `before_execute` callback to intercept outgoing requests and the `after_execute` callback to observe the
@@ -121,6 +147,44 @@ class Artsy < Artemis::Client
 end
 ```
 
+## Multi domain support
+
+Services like Shopify provide
+[a different endpoint per customer](https://shopify.dev/api/admin/graphql/reference#graphql-endpoint) (e.g.
+`https://{shop}.myshopify.com`). In order to switch the endpoint on a per-request basis, you will have to use the
+`:multi_domain` adapter. This is a wrapper adapter that relies on an actual HTTP adapter such as `:net_http` and
+`:curb` so that e.g. it can maintain multiple connections for each endpoint if necessary. This could be configured
+as shown below:
+
+```yaml
+default: &default
+  # Specify the :multi_domain adapter:
+  adapter: :multi_domain
+
+  # Other configurations such as `timeout` and `pool_size` are passed down to the underlying adapter:
+  timeout: 10
+  pool_size: 25
+
+  # Additional adapter-specific configurations could be configured as `adapter_options`:
+  adapter_options:
+    # Here you can configure the actual adapter to use. By default, it is set to :net_http. Available adapters are
+    # :net_http, :net_http_persistent, :curb, and :test. You can not nest the use of the `:multi_domain` adapter.
+    adapter: :net_http
+
+development:
+  shopify:
+    <<: *default
+
+...
+```
+
+Upon making a request you will also have to specify the `url` option:
+
+```ruby
+# Makes a request to https://myawesomeshop.myshopify.com:
+Shopify.with_context(url: "https://myawesomeshop.myshopify.com").product(id: "...")
+```
+
 ## Configuration
 
 You can configure the GraphQL client using the following options. Those configurations are found in the
@@ -143,7 +207,8 @@ There are four adapter options available. Choose the adapter that best fits on y
 | `:curb`                | HTTP/1.1, **HTTP/2**     | **Yes**     | **Fastest** | [`curb 0.9.6+`][curb]<br>[`libcurl 7.64.0+`][curl]<br>[`nghttp2 1.0.0+`][nghttp]
 | `:net_http` (default)  | HTTP/1.1 only            | No          | Slow        | **None**
 | `:net_http_persistent` | HTTP/1.1 only            | **Yes**     | **Fast**    | [`net-http-persistent 3.0.0+`][nhp]
-| `:test`                | N/A (See Testing)
+| `:multi_domain`        | See [multi domain support](#multi-domain-support)
+| `:test`                | See [Testing](#testing)
 
 #### Third-party adapters
 

data/gemfiles/rails_70.gemfile

@@ -0,0 +1,13 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "pry"
+gem "pry-byebug", platforms: :mri
+gem "curb", ">= 0.9.6"
+gem "webrick"
+gem "rails", "~> 7.0.0"
+gem "railties", "~> 7.0.0"
+gem "activesupport", "~> 7.0.0"
+
+gemspec path: "../"

data/gemfiles/rails_edge.gemfile

@@ -11,5 +11,6 @@ end
 gem "pry"
 gem "pry-byebug", platforms: :mri
 gem "curb", ">= 0.9.6"
+gem "webrick"
 
 gemspec path: "../"

data/lib/artemis/adapters/curb_adapter.rb

@@ -20,18 +20,28 @@ module Artemis
         @multi.pipeline = Curl::CURLPIPE_MULTIPLEX if defined?(Curl::CURLPIPE_MULTIPLEX)
       end
 
-      def execute(document:, operation_name: nil, variables: {}, context: {})
-        easy = Curl::Easy.new(uri.to_s)
+      def multiplex(queries, context: {})
+        make_request({ _json: queries }, context)
+      end
 
+      def execute(document:, operation_name: nil, variables: {}, context: {})
         body = {}
         body["query"] = document.to_query_string
         body["variables"] = variables if variables.any?
         body["operationName"] = operation_name if operation_name
 
-        easy.timeout     = timeout
-        easy.multi       = multi
-        easy.headers     = DEFAULT_HEADERS.merge(headers(context))
-        easy.post_body   = JSON.generate(body)
+        make_request(body, context)
+      end
+
+      private
+
+      def make_request(body, context)
+        easy = Curl::Easy.new(uri.to_s)
+
+        easy.timeout   = timeout
+        easy.multi     = multi
+        easy.headers   = DEFAULT_HEADERS.merge(headers(context))
+        easy.post_body = JSON.generate(body)
 
         if defined?(Curl::CURLPIPE_MULTIPLEX)
           # This ensures libcurl waits for the connection to reveal if it is

data/lib/artemis/adapters/multi_domain_adapter.rb

@@ -8,6 +8,10 @@ module Artemis
       attr_reader :adapter
 
       def initialize(_uri, service_name: , timeout: , pool_size: , adapter_options: {})
+        if adapter_options[:adapter] == :multi_domain
+          raise ArgumentError, "You can not use the :multi_domain adapter with the :multi_domain adapter."
+        end
+
         @connection_by_url    = {}
         @service_name         = service_name.to_s
         @timeout              = timeout
@@ -16,6 +20,17 @@ module Artemis
         @mutex_for_connection = Mutex.new
       end
 
+      def multiplex(queries, context: {})
+        url = context[:url]
+
+        if url.nil?
+          raise ArgumentError, 'The MultiDomain adapter requires a url on every request. Please specify a url with a context: ' \
+                               'Client.multiplex(url: "https://awesomeshop.domain.conm") { ... }'
+        end
+
+        connection_for_url(url).multiplex(queries, context: context)
+      end
+
       # Makes an HTTP request for GraphQL query.
       def execute(document:, operation_name: nil, variables: {}, context: {})
         url = context[:url]

data/lib/artemis/adapters/net_http_adapter.rb

@@ -9,20 +9,39 @@ require 'artemis/exceptions'
 module Artemis
   module Adapters
     class NetHttpAdapter < AbstractAdapter
+      def multiplex(queries, context: {})
+        make_request({ _json: queries }, context)
+      end
+
       # Makes an HTTP request for GraphQL query.
       def execute(document:, operation_name: nil, variables: {}, context: {})
-        request = Net::HTTP::Post.new(uri.request_uri)
-
-        request.basic_auth(uri.user, uri.password) if uri.user || uri.password
-
-        DEFAULT_HEADERS.merge(headers(context)).each { |name, value| request[name] = value }
-
         body = {}
         body["query"] = document.to_query_string
         body["variables"] = variables if variables.any?
         body["operationName"] = operation_name if operation_name
+
+        make_request(body, context)
+      end
+
+      # Returns a fresh Net::HTTP object that creates a new connection.
+      def connection
+        Net::HTTP.new(uri.host, uri.port).tap do |client|
+          client.use_ssl       = uri.scheme == "https"
+          client.open_timeout  = timeout
+          client.read_timeout  = timeout
+          client.write_timeout = timeout if client.respond_to?(:write_timeout=)
+        end
+      end
+
+      private
+
+      def make_request(body, context)
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.basic_auth(uri.user, uri.password) if uri.user || uri.password
         request.body = JSON.generate(body)
 
+        DEFAULT_HEADERS.merge(headers(context)).each { |name, value| request[name] = value }
+
         response = connection.request(request)
 
         case response.code.to_i
@@ -34,16 +53,6 @@ module Artemis
           { "errors" => [{ "message" => "#{response.code} #{response.message}" }] }
         end
       end
-
-      # Returns a fresh Net::HTTP object that creates a new connection.
-      def connection
-        Net::HTTP.new(uri.host, uri.port).tap do |client|
-          client.use_ssl       = uri.scheme == "https"
-          client.open_timeout  = timeout
-          client.read_timeout  = timeout
-          client.write_timeout = timeout if client.respond_to?(:write_timeout=)
-        end
-      end
     end
   end
 end

data/lib/artemis/adapters/net_http_persistent_adapter.rb

@@ -2,6 +2,12 @@
 
 require 'delegate'
 
+begin
+  require "active_support/isolated_execution_state"
+rescue LoadError
+  # no-op... Rails 7.0 requires this.
+end
+
 require 'active_support/core_ext/numeric/time'
 require 'net/http/persistent'
 

data/lib/artemis/adapters/test_adapter.rb

@@ -12,12 +12,25 @@ module Artemis
       self.responses = []
 
       Request = Struct.new(:document, :operation_name, :variables, :context)
+      Multiplex = Struct.new(:queries, :context)
 
-      private_constant :Request
+      private_constant :Request, :Multiplex
 
       def initialize(*)
       end
 
+      def multiplex(queries, context: {})
+        self.requests << Multiplex.new(queries, context)
+
+        queries.map do |query|
+          result = responses.detect do |mock|
+            query[:operationName] == mock.operation_name && (mock.arguments == :__unspecified__ || query[:variables] == mock.arguments)
+          end
+
+          result&.data || fake_response
+        end
+      end
+
       def execute(**arguments)
         self.requests << Request.new(*arguments.values_at(:document, :operation_name, :variables, :context))
 
@@ -25,7 +38,13 @@ module Artemis
           arguments[:operation_name] == mock.operation_name && (mock.arguments == :__unspecified__ || arguments[:variables] == mock.arguments)
         end
 
-        response&.data || {
+        response&.data || fake_response
+      end
+
+      private
+
+      def fake_response
+        {
           'data' => { 'test' => 'data' },
           'errors' => [],
           'extensions' => {}

data/lib/artemis/client.rb

@@ -167,17 +167,19 @@ module Artemis
       end
 
       def resolve_graphql_file_path(filename, fragment: false)
-        namespace = name.underscore
-        filename  = filename.to_s.underscore
+        filename = filename.to_s.underscore
 
         graphql_file_paths.detect do |path|
-          path.end_with?("#{namespace}/#{filename}.graphql") ||
-            (fragment && filename.end_with?('fragment') && path.end_with?("#{namespace}/_#{filename}.graphql"))
+          path.end_with?("#{namespace}/#{filename}.graphql") || (fragment && path.end_with?("#{namespace}/_#{filename}.graphql"))
         end
       end
 
       def graphql_file_paths
-        @graphql_file_paths ||= query_paths.flat_map {|path| Dir["#{path}/#{name.underscore}/*.graphql"] }
+        @graphql_file_paths ||= query_paths.flat_map {|path| Dir["#{path}/#{namespace}/*.graphql"] }
+      end
+
+      def namespace
+        name.underscore
       end
 
       def preload!
@@ -218,6 +220,19 @@ module Artemis
         new(default_context).execute(query, context: context, **arguments)
       end
 
+      def multiplex(**context, &block)
+        queue            = MultiplexQueue.new
+        wrapped_executor = Executor.new(queue, callbacks, default_context.deep_merge(context))
+        api_client       = ::GraphQL::Client.new(schema: endpoint.schema, execute: wrapped_executor)
+
+        service_client = new
+        service_client.instance_variable_set(:@client, api_client)
+
+        block.call(service_client)
+
+        connection.multiplex(queue.queries, context: context)
+      end
+
       private
 
       # Looks up the GraphQL file that matches the given +const_name+ and sets it to a constant. If the files it not
@@ -345,6 +360,25 @@ module Artemis
       end
     end
 
-    private_constant :Callbacks, :Executor
+    class MultiplexQueue
+      attr_reader :queries
+
+      def initialize
+        @queries = []
+      end
+
+      def execute(document:, operation_name: nil, variables: {}, context: {}) #:nodoc:
+        @queries << {
+          query: document.to_query_string,
+          variables: variables.presence || {},
+          operationName: operation_name,
+          context: context
+        }
+
+        {}
+      end
+    end
+
+    private_constant :Callbacks, :Executor, :MultiplexQueue
   end
 end

data/lib/artemis/railtie.rb

@@ -35,10 +35,9 @@ module Artemis
         files_to_watch = Artemis::Client.query_paths.map {|path| [path, config.artemis.graphql_extentions] }.to_h
 
         app.reloaders << ActiveSupport::FileUpdateChecker.new([], files_to_watch) do
-          endpoint_names = Artemis.config_for_graphql(app).keys
-          endpoint_names.each do |endpoint_name|
+          Artemis.config_for_graphql(app).each_key do |endpoint_name|
             Artemis::Client.query_paths.each do |path|
-              FileUtils.touch("#{path}/#{endpoint_name}.rb")
+              FileUtils.touch("#{path}/#{endpoint_name}.rb") if File.exist?("#{path}/#{endpoint_name}.rb")
             end
           end
         end
@@ -48,9 +47,12 @@ module Artemis
     initializer 'graphql.client.load_config' do |app|
       if Pathname.new("#{app.paths["config"].existent.first}/graphql.yml").exist?
         Artemis.config_for_graphql(app).each do |endpoint_name, options|
-          Artemis::GraphQLEndpoint.register!(endpoint_name, {
-            schema_path: app.root.join(config.artemis.schema_path, "#{endpoint_name}.json").to_s
-          }.merge(options.symbolize_keys))
+          Artemis::GraphQLEndpoint
+            .register!(
+              endpoint_name,
+              schema_path: app.root.join(config.artemis.schema_path, "#{endpoint_name}.json").to_s,
+              **options.symbolize_keys
+            )
         end
       end
     end
@@ -58,6 +60,12 @@ module Artemis
     initializer 'graphql.client.preload', after: 'graphql.client.load_config' do |app|
       if app.config.eager_load && app.config.cache_classes
         Artemis::GraphQLEndpoint.registered_services.each do |endpoint_name|
+          begin
+            require endpoint_name # Rails 7.0 requires this.
+          rescue LoadError
+            # no-op...
+          end
+
           endpoint_name.camelize.constantize.preload!
         end
       end

data/lib/artemis/version.rb

@@ -1,3 +1,3 @@
 module Artemis
-  VERSION = "0.6.0"
+  VERSION = "0.8.0"
 end

data/lib/generators/artemis/query/query_generator.rb

@@ -37,7 +37,7 @@ class Artemis::QueryGenerator < Rails::Generators::Base
   end
 
   def target_query
-    schema.find("Query").fields[query_type] ||
+    schema.query.fields[query_type] ||
       raise(GraphQL::Schema::Finder::MemberNotFoundError, "Could not find type `#{query_type}` in schema.")
   end
 

data/lib/generators/artemis/query/templates/query.graphql

@@ -1,5 +1,5 @@
-query<%= arguments.present? && "(#{ arguments.map {|name, type| "$#{name}: #{type.type.to_type_signature}" }.join(", ") })" %> {
-  <%= target_query.name %><%= arguments.present? && "(#{ arguments.map {|name, type| "#{name}: $#{name}" }.join(", ") })" %> {
+query<%= arguments.present? ? "(#{ arguments.map {|name, type| "$#{name}: #{type.type.to_type_signature}" }.join(", ") })" : "" %> {
+  <%= target_query.name %><%= arguments.present? ? "(#{ arguments.map {|name, type| "#{name}: $#{name}" }.join(", ") })" : "" %> {
     # Add fields here...
   }
 }

data/spec/adapters_spec.rb

@@ -6,7 +6,7 @@ describe 'Adapters' do
   FakeServer = ->(env) {
     case env['PATH_INFO']
     when '/slow_server'
-      sleep 1.1
+      sleep 2.1
 
       [200, {}, ['{}']]
     when '/500'
@@ -15,6 +15,9 @@ describe 'Adapters' do
       body = {
         data: {
           body: "Endpoint switched.",
+          headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
+                      .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
+                      .to_h,
         },
         errors: [],
         extensions: {}
@@ -22,18 +25,35 @@ describe 'Adapters' do
 
       [200, {}, [body]]
     else
-      body = {
-        data: {
-          body: JSON.parse(env['rack.input'].read),
-          headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
-                     .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
-                     .to_h,
-        },
-        errors: [],
-        extensions: {}
-      }.to_json
+      request_body = JSON.parse(env['rack.input'].read)
 
-      [200, {}, [body]]
+      response_body = if request_body['_json']
+                        request_body['_json'].map do |query|
+                          {
+                            data: {
+                              body: query,
+                              headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
+                                          .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
+                                          .to_h,
+                            },
+                            errors: [],
+                            extensions: {}
+                          }
+                        end.to_json
+                      else
+                        {
+                          data: {
+                            body: request_body,
+                            headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
+                                        .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
+                                        .to_h,
+                          },
+                          errors: [],
+                          extensions: {}
+                        }.to_json
+                      end
+
+      [200, {}, [response_body]]
     end
   }
 
@@ -102,6 +122,51 @@ describe 'Adapters' do
         end.to raise_error(timeout_error)
       end
     end
+
+    describe '#multiplex' do
+      it 'makes an HTTP request with multiple queries' do
+        response = adapter.multiplex(
+          [
+            {
+              query: GraphQL::Client::IntrospectionDocument.to_query_string,
+              operationName: 'IntrospectionQuery',
+              variables: {
+                id: 'yayoi-kusama'
+              },
+            },
+          ],
+          context: {
+            user_id: 1
+          }
+        )
+
+        introspection_query = response[0]
+
+        expect(introspection_query['data']['body']['query']).to eq(GraphQL::Client::IntrospectionDocument.to_query_string)
+        expect(introspection_query['data']['body']['variables']).to eq('id' => 'yayoi-kusama')
+        expect(introspection_query['data']['body']['operationName']).to eq('IntrospectionQuery')
+        expect(introspection_query['data']['headers']['CONTENT_TYPE']).to eq('application/json')
+        expect(introspection_query['data']['headers']['ACCEPT']).to eq('application/json')
+        expect(introspection_query['errors']).to eq([])
+        expect(introspection_query['extensions']).to eq({})
+      end
+
+      it 'raises an error when it receives a server error' do
+        adapter.uri = URI.parse('http://localhost:8000/500')
+
+        expect do
+          adapter.multiplex([])
+        end.to raise_error(Artemis::GraphQLServerError, "Received server error status 500: Server error")
+      end
+
+      it 'allows for overriding timeout' do
+        adapter.uri = URI.parse('http://localhost:8000/slow_server')
+
+        expect do
+          adapter.multiplex([])
+        end.to raise_error(timeout_error)
+      end
+    end
   end
 
   describe Artemis::Adapters::NetHttpAdapter do
@@ -129,6 +194,52 @@ describe 'Adapters' do
       expect(response['extensions']).to eq({})
     end
 
+    it 'can make a multiplex (the graphql feature, not HTTP/2) request' do
+      response = adapter.multiplex(
+        [
+          {
+            query: GraphQL::Client::IntrospectionDocument.to_query_string,
+            operationName: 'IntrospectionQuery',
+            variables: {
+              id: 'yayoi-kusama'
+            },
+          },
+        ],
+        context: {
+          url: 'http://localhost:8000/test_multi_domain'
+        }
+      )
+
+      expect(response['data']['body']).to eq("Endpoint switched.")
+      expect(response['errors']).to eq([])
+      expect(response['extensions']).to eq({})
+    end
+
+    it 'can make a multiplex request with custom HTTP headers' do
+      response = adapter.multiplex(
+        [
+          {
+            query: GraphQL::Client::IntrospectionDocument.to_query_string,
+            operationName: 'IntrospectionQuery',
+          },
+        ],
+        context: {
+          headers: {
+            Authorization: "Token token",
+          },
+          url: 'http://localhost:8000/test_multi_domain'
+        }
+      )
+
+      expect(response['data']['headers']['AUTHORIZATION']).to eq("token token")
+    end
+
+    it 'raises an error when adapter_options.adapter is set to :multi domain' do
+      expect do
+        Artemis::Adapters::MultiDomainAdapter.new('ignored', service_name: nil, timeout: 0.5, pool_size: 5, adapter_options: { adapter: :multi_domain })
+      end.to raise_error(ArgumentError, 'You can not use the :multi_domain adapter with the :multi_domain adapter.')
+    end
+
     it 'raises an error when context.url is not specified' do
       expect do
         adapter.execute(document: GraphQL::Client::IntrospectionDocument)

data/spec/autoloading_spec.rb

@@ -15,7 +15,7 @@ describe "#{GraphQL::Client} Autoloading" do
 
   describe ".preload!" do
     it "preloads all the graphQL files in the query paths" do
-      %i(Artist Artwork ArtistFragment)
+      %i(Artist Artists Artwork ArtistFields)
         .select {|const_name| Metaphysics.constants.include?(const_name) }
         .each {|const_name| Metaphysics.send(:remove_const, const_name) }
 
@@ -43,12 +43,12 @@ describe "#{GraphQL::Client} Autoloading" do
   end
 
   it "dynamically loads the matching GraphQL fragment and sets it to a constant" do
-    Metaphysics.send(:remove_const, :ArtistFragment) if Metaphysics.constants.include?(:ArtistFragment)
+    Metaphysics.send(:remove_const, :ArtistFields) if Metaphysics.constants.include?(:ArtistFields)
 
-    query = Metaphysics::ArtistFragment
+    query = Metaphysics::ArtistFields
 
     expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
-      fragment Metaphysics__ArtistFragment on Artist {
+      fragment Metaphysics__ArtistFields on Artist {
         hometown
         deathday
       }

data/spec/client_spec.rb

@@ -86,11 +86,11 @@ describe GraphQL::Client do
           name
           bio
           birthday
-          ...Metaphysics__ArtistFragment
+          ...Metaphysics__ArtistFields
         }
       }
 
-      fragment Metaphysics__ArtistFragment on Artist {
+      fragment Metaphysics__ArtistFields on Artist {
         hometown
         deathday
       }
@@ -171,6 +171,42 @@ describe GraphQL::Client do
     end
   end
 
+  it "can batch multiple requests using Multiplex" do
+    responses = Metaphysics.multiplex do |queue|
+      queue.artist(id: "yayoi-kusama", context: { headers: { Authorization: 'bearer ...' } })
+      queue.artwork
+    end
+
+    artist_query, artwork_query = requests[0].queries
+
+    expect(artist_query[:operationName]).to eq('Metaphysics__Artist')
+    expect(artist_query[:variables]).to eq('id' => 'yayoi-kusama')
+    expect(artist_query[:context]).to eq({ headers: { Authorization: 'bearer ...' } })
+    expect(artist_query[:query]).to eq(<<~GRAPHQL.strip)
+      query Metaphysics__Artist($id: String!) {
+        artist(id: $id) {
+          name
+          bio
+          birthday
+        }
+      }
+    GRAPHQL
+
+    expect(artwork_query[:operationName]).to eq('Metaphysics__Artwork')
+    expect(artwork_query[:variables]).to be_empty
+    expect(artwork_query[:context]).to eq({})
+    expect(artwork_query[:query]).to eq(<<~GRAPHQL.strip)
+      query Metaphysics__Artwork {
+        artwork(id: "yayoi-kusama-pumpkin-yellow-and-black") {
+          title
+          artist {
+            name
+          }
+        }
+      }
+    GRAPHQL
+  end
+
   private
 
   def requests

data/spec/fixtures/metaphysics/artists.graphql

@@ -3,6 +3,6 @@ query($size: Int!) {
     name
     bio
     birthday
-    ...Metaphysics::ArtistFragment
+    ...Metaphysics::ArtistFields
   }
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: artemis
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jon Allured
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-03 00:00:00.000000000 Z
+date: 2023-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -167,6 +167,7 @@ files:
 - gemfiles/rails_52.gemfile
 - gemfiles/rails_60.gemfile
 - gemfiles/rails_61.gemfile
+- gemfiles/rails_70.gemfile
 - gemfiles/rails_edge.gemfile
 - lib/artemis.rb
 - lib/artemis/adapters.rb
@@ -201,7 +202,7 @@ files:
 - spec/client_spec.rb
 - spec/endpoint_spec.rb
 - spec/fixtures/metaphysics.rb
-- spec/fixtures/metaphysics/_artist_fragment.graphql
+- spec/fixtures/metaphysics/_artist_fields.graphql
 - spec/fixtures/metaphysics/artist.graphql
 - spec/fixtures/metaphysics/artists.graphql
 - spec/fixtures/metaphysics/artwork.graphql
@@ -231,7 +232,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.26
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: GraphQL on Rails