artemis 0.5.1 → 0.7.0

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
@@ -248,9 +263,9 @@ module Artemis
       #   Github.user # => delegates to Github.new(default_context).user
       #
       # @api private
-      def method_missing(method_name, *arguments, &block)
+      def method_missing(method_name, **arguments, &block)
         if resolve_graphql_file_path(method_name)
-          new(default_context).public_send(method_name, *arguments, &block)
+          new(default_context).public_send(method_name, **arguments, &block)
         else
           super
         end
@@ -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/graphql_endpoint.rb

@@ -33,7 +33,7 @@ module Artemis
       end
 
       def register!(service_name, configurations)
-        ENDPOINT_INSTANCES[service_name.to_s.underscore] = new(service_name.to_s, configurations.symbolize_keys)
+        ENDPOINT_INSTANCES[service_name.to_s.underscore] = new(service_name.to_s, **configurations.symbolize_keys)
       end
 
       ##
@@ -44,10 +44,16 @@ module Artemis
       end
     end
 
-    attr_reader :name, :url, :adapter, :timeout, :schema_path, :pool_size
+    attr_reader :name, :url, :adapter, :timeout, :schema_path, :pool_size, :adapter_options
 
-    def initialize(name, url: nil, adapter: :net_http, timeout: 10, schema_path: nil, pool_size: 25)
-      @name, @url, @adapter, @timeout, @schema_path, @pool_size = name.to_s, url, adapter, timeout, schema_path, pool_size
+    def initialize(name, url: nil, adapter: :net_http, timeout: 10, schema_path: nil, pool_size: 25, adapter_options: {})
+      @name            = name.to_s
+      @url             = url
+      @adapter         = adapter
+      @timeout         = timeout
+      @schema_path     = schema_path
+      @pool_size       = pool_size
+      @adapter_options = adapter_options
 
       @mutex_for_schema     = Mutex.new
       @mutex_for_connection = Mutex.new
@@ -66,7 +72,7 @@ module Artemis
 
     def connection
       @connection || @mutex_for_connection.synchronize do
-        @connection ||= ::Artemis::Adapters.lookup(adapter).new(url, service_name: name, timeout: timeout, pool_size: pool_size)
+        @connection ||= ::Artemis::Adapters.lookup(adapter).new(url, service_name: name, timeout: timeout, pool_size: pool_size, adapter_options: adapter_options)
       end
     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,17 +47,26 @@ 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
 
     initializer 'graphql.client.preload', after: 'graphql.client.load_config' do |app|
       if app.config.eager_load && app.config.cache_classes
-        Artemis.config_for_graphql(app).keys.each do |endpoint_name|
-          endpoint_name.to_s.camelize.constantize.preload!
+        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
     end

data/lib/artemis/test_helper.rb

@@ -4,6 +4,7 @@ require 'erb'
 require 'yaml'
 
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
 
 require 'artemis/exceptions'
 
@@ -110,7 +111,7 @@ module Artemis
 
       def find_fixture_set
         fixture_set = fixture_sets
-                        .detect { |fixture| %r{#{service_name.downcase}/#{query_name}\.(yml|json)\z} =~ fixture.path }
+                        .detect { |fixture| %r{#{service_name.underscore}/#{query_name}\.(yml|json)\z} =~ fixture.path }
         fixture_set ||= fixture_sets.detect { |fixture| fixture.name == query_name.to_s }
 
         if fixture_set.nil?

data/lib/artemis/version.rb

@@ -1,3 +1,3 @@
 module Artemis
-  VERSION = "0.5.1"
+  VERSION = "0.7.0"
 end

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

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

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

@@ -14,6 +14,10 @@ class Artemis::QueryGenerator < Rails::Generators::Base
     template "query.graphql", graphql_file_path
   end
 
+  # def generate_text_fixture_file
+  #   template "fixture.yml", text_fixture_path
+  # end
+
   private
 
   def query_name
@@ -21,7 +25,11 @@ class Artemis::QueryGenerator < Rails::Generators::Base
   end
 
   def graphql_file_path
-    "app/operations/#{service_name.underscore}/#{graphql_file_name.presence || query_name}.graphql"
+    "app/operations/#{service_name.underscore}/#{qualified_name}.graphql"
+  end
+
+  def text_fixture_path
+    File.join(Artemis::Railtie.config.artemis.fixture_path, service_name.underscore, "#{qualified_name}.yml")
   end
 
   def arguments
@@ -29,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
 
@@ -49,4 +57,8 @@ class Artemis::QueryGenerator < Rails::Generators::Base
       end
     end
   end
+
+  def qualified_name
+    graphql_file_name.presence || query_name
+  end
 end

data/lib/generators/artemis/query/templates/fixture.yml

@@ -0,0 +1,19 @@
+# You can stub GraphQL queries by calling the `stub_graphql' method in test:
+#
+#   stub_graphql(<%= service_name.camelize %>, :<%= qualified_name.underscore %>).to_return(:<%= target_query.name %>_1)
+#
+# Or with a arguments matcher:
+#
+#   stub_graphql(<%= service_name.camelize %>, :<%= qualified_name.underscore %>, <%= arguments.map {|name, _| "#{name}: \"...\"" }.join(", ") %>).to_return(:<%= target_query.name %>_2)
+#
+
+<%= target_query.name %>_1:
+  data:
+  <% target_query.type.fields.values.each do |field| -%>
+  <%= field.name %>: # type: <%= field.type.to_type_signature %>
+  <% end %>
+<%= target_query.name %>_2:
+  data:
+  <% target_query.type.fields.values.each do |field| -%>
+  <%= field.name %>: # type: <%= field.type.to_type_signature %>
+  <% end %>

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

@@ -1,5 +1,5 @@
-query<%= arguments.present? && "(#{ arguments.map {|name, type| "$#{name}: #{type.type}" }.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

@@ -1,28 +1,59 @@
 require 'json'
 require 'rack'
+require 'webrick'
 
 describe 'Adapters' do
   FakeServer = ->(env) {
     case env['PATH_INFO']
     when '/slow_server'
-      sleep 1.1
+      sleep 2.1
 
       [200, {}, ['{}']]
     when '/500'
       [500, {}, ['Server error']]
-    else
+    when '/test_multi_domain'
       body = {
         data: {
-          body: JSON.parse(env['rack.input'].read),
+          body: "Endpoint switched.",
           headers: env.select {|key, val| key.match("^HTTP.*|^CONTENT.*|^AUTHORIZATION.*") }
-                     .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
-                     .to_h,
+                      .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
+                      .to_h,
         },
         errors: [],
         extensions: {}
       }.to_json
 
       [200, {}, [body]]
+    else
+      request_body = JSON.parse(env['rack.input'].read)
+
+      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
   }
 
@@ -91,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
@@ -102,15 +178,94 @@ describe 'Adapters' do
 
   describe Artemis::Adapters::NetHttpPersistentAdapter do
     let(:adapter) { Artemis::Adapters::NetHttpPersistentAdapter.new('http://localhost:8000', service_name: nil, timeout: 0.5, pool_size: 5) }
-    let(:timeout_error) { Net::HTTP::Persistent::Error }
+    let(:timeout_error) { Net::ReadTimeout }
 
     it_behaves_like 'an adapter'
   end
 
-  describe Artemis::Adapters::CurbAdapter do
-    let(:adapter) { Artemis::Adapters::CurbAdapter.new('http://localhost:8000', service_name: nil, timeout: 2, pool_size: 5) }
-    let(:timeout_error) { Curl::Err::TimeoutError }
+  describe Artemis::Adapters::MultiDomainAdapter do
+    let(:adapter) { Artemis::Adapters::MultiDomainAdapter.new('ignored', service_name: nil, timeout: 0.5, pool_size: 5, adapter_options: { adapter: :net_http }) }
 
-    it_behaves_like 'an adapter'
+    it 'makes an actual HTTP request' do
+      response = adapter.execute(document: GraphQL::Client::IntrospectionDocument, 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 (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)
+      end.to raise_error(ArgumentError, 'The MultiDomain adapter requires a url on every request. Please specify a ' \
+                                        'url with a context: Client.with_context(url: "https://awesomeshop.domain.conm")')
+    end
+
+    it 'raises an error when it receives a server error' do
+      expect do
+        adapter.execute(document: GraphQL::Client::IntrospectionDocument, context: { url: 'http://localhost:8000/500' })
+      end.to raise_error(Artemis::GraphQLServerError, "Received server error status 500: Server error")
+    end
+
+    it 'allows for overriding timeout' do
+      expect do
+        adapter.execute(document: GraphQL::Client::IntrospectionDocument, context: { url: 'http://localhost:8000/slow_server' })
+      end.to raise_error(Net::ReadTimeout)
+    end
+  end
+
+  if RUBY_ENGINE == 'ruby'
+    describe Artemis::Adapters::CurbAdapter do
+      let(:adapter) { Artemis::Adapters::CurbAdapter.new('http://localhost:8000', service_name: nil, timeout: 2, pool_size: 5) }
+      let(:timeout_error) { Curl::Err::TimeoutError }
+
+      it_behaves_like 'an adapter'
+    end
   end
 end

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
   }
 }

data/spec/test_helper_spec.rb

@@ -70,8 +70,17 @@ describe Artemis::TestHelper do
     expect(yoshiki.data.artist.name).to eq("Artist Yoshiki")
   end
 
+  it "can mock separate GraphQL queries with the same arguments" do
+    stub_graphql("SpotifyClient", :artist, id: "yoshiki").to_return(:yoshiki)
+    stub_graphql(Metaphysics, :artist, id: "yoshiki").to_return(:yoshiki)
+
+    yoshiki = Metaphysics.artist(id: "yoshiki")
+    
+    expect(yoshiki.data.artist.name).to eq("Artist Yoshiki")
+  end
+
   it "allows to get raw fixture data as a Hash" do
-    data = stub_graphql("Spotify", :artist).get(:yoshiki)
+    data = stub_graphql("SpotifyClient", :artist).get(:yoshiki)
 
     expect(data).to eq({
       "data" => {