artemis 0.4.0 → 0.6.0

data/gemfiles/rails_edge.gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-git "git://github.com/rails/rails.git" do
+git "https://github.com/rails/rails.git" do
   gem "rails"
   gem "railties"
   gem "activesupport"
@@ -10,5 +10,6 @@ end
 
 gem "pry"
 gem "pry-byebug", platforms: :mri
+gem "curb", ">= 0.9.6"
 
 gemspec path: "../"

data/lib/artemis/adapters/abstract_adapter.rb

@@ -10,7 +10,12 @@ module Artemis
 
       EMPTY_HEADERS = {}.freeze
 
-      def initialize(uri, service_name: , timeout: , pool_size: )
+      DEFAULT_HEADERS = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json"
+      }.freeze
+
+      def initialize(uri, service_name: , timeout: , pool_size: , adapter_options: {})
         raise ArgumentError, "url is required (given `#{uri.inspect}')" if uri.blank?
 
         super(uri) # Do not pass in the block to avoid getting #headers and #connection overridden.

data/lib/artemis/adapters/curb_adapter.rb

@@ -13,7 +13,7 @@ module Artemis
     class CurbAdapter < AbstractAdapter
       attr_reader :multi
 
-      def initialize(uri, service_name: , timeout: , pool_size: )
+      def initialize(uri, service_name: , timeout: , pool_size: , adapter_options: {})
         super
 
         @multi = Curl::Multi.new
@@ -30,7 +30,7 @@ module Artemis
 
         easy.timeout     = timeout
         easy.multi       = multi
-        easy.headers     = headers(context) || {}
+        easy.headers     = DEFAULT_HEADERS.merge(headers(context))
         easy.post_body   = JSON.generate(body)
 
         if defined?(Curl::CURLPIPE_MULTIPLEX)

data/lib/artemis/adapters/multi_domain_adapter.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'artemis/adapters/abstract_adapter'
+
+module Artemis
+  module Adapters
+    class MultiDomainAdapter < AbstractAdapter
+      attr_reader :adapter
+
+      def initialize(_uri, service_name: , timeout: , pool_size: , adapter_options: {})
+        @connection_by_url    = {}
+        @service_name         = service_name.to_s
+        @timeout              = timeout
+        @pool_size            = pool_size
+        @adapter              = adapter_options[:adapter] || :net_http
+        @mutex_for_connection = Mutex.new
+      end
+
+      # Makes an HTTP request for GraphQL query.
+      def execute(document:, operation_name: nil, variables: {}, 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.with_context(url: "https://awesomeshop.domain.conm")'
+        end
+
+        connection_for_url(url).execute(document: document, operation_name: operation_name, variables: variables, context: context)
+      end
+
+      def connection
+        raise NotImplementedError, "Calling the #connection method without a URI is not supported. Please use the " \
+                                   "#connection_for_url(uri) instead."
+      end
+
+      def connection_for_url(url)
+        @connection_by_url[url.to_s] || @mutex_for_connection.synchronize do
+          @connection_by_url[url.to_s] ||= ::Artemis::Adapters.lookup(adapter).new(url, service_name: service_name, timeout: timeout, pool_size: pool_size)
+        end
+      end
+    end
+  end
+end

data/lib/artemis/adapters/net_http_adapter.rb

@@ -15,9 +15,7 @@ module Artemis
 
         request.basic_auth(uri.user, uri.password) if uri.user || uri.password
 
-        request["Accept"] = "application/json"
-        request["Content-Type"] = "application/json"
-        headers(context).each { |name, value| request[name] = value }
+        DEFAULT_HEADERS.merge(headers(context)).each { |name, value| request[name] = value }
 
         body = {}
         body["query"] = document.to_query_string

data/lib/artemis/adapters/net_http_persistent_adapter.rb

@@ -12,7 +12,7 @@ module Artemis
     class NetHttpPersistentAdapter < NetHttpAdapter
       attr_reader :_connection, :raw_connection
 
-      def initialize(uri, service_name: , timeout: , pool_size: )
+      def initialize(uri, service_name: , timeout: , pool_size: , adapter_options: {})
         super
 
         @raw_connection = Net::HTTP::Persistent.new(name: service_name, pool_size: pool_size)

data/lib/artemis/adapters/test_adapter.rb

@@ -22,7 +22,7 @@ module Artemis
         self.requests << Request.new(*arguments.values_at(:document, :operation_name, :variables, :context))
 
         response = responses.detect do |mock|
-          arguments[:operation_name] == mock.operation_name && mock.arguments == :__unspecified__ || arguments[:variables] == mock.arguments
+          arguments[:operation_name] == mock.operation_name && (mock.arguments == :__unspecified__ || arguments[:variables] == mock.arguments)
         end
 
         response&.data || {

data/lib/artemis/adapters.rb

@@ -7,6 +7,7 @@ module Artemis
     extend ActiveSupport::Autoload
 
     autoload :CurbAdapter
+    autoload :MultiDomainAdapter
     autoload :NetHttpAdapter
     autoload :NetHttpPersistentAdapter
     autoload :TestAdapter

data/lib/artemis/client.rb

@@ -4,6 +4,8 @@ require 'delegate'
 
 require 'active_support/configurable'
 require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/string/inflections'
 
 require 'artemis/graphql_endpoint'
@@ -15,10 +17,10 @@ module Artemis
 
     # The paths in which the Artemis client looks for files that have the +.graphql+ extension.
     # In a rails app, this value will be set to +["app/operations"]+ by Artemis' +Artemis::Railtie+.
-    config.query_paths = []
+    cattr_accessor :query_paths
 
     # Default context that is appended to every GraphQL request for the client.
-    config.default_context = {}
+    config.default_context = nil
 
     # List of before callbacks that get invoked in every +execute+ call.
     #
@@ -58,7 +60,7 @@ module Artemis
     end
 
     class << self
-      delegate :query_paths, :default_context, :query_paths=, :default_context=, to: :config
+      delegate :default_context=, to: :config
 
       # Creates a new instance of the GraphQL client for the service.
       #
@@ -136,7 +138,7 @@ module Artemis
       #   end
       #
       def before_execute(&block)
-        config.before_callbacks << block
+        config.before_callbacks = [*config.before_callbacks, block]
       end
 
       # Defines a callback that will get called right after the
@@ -154,7 +156,14 @@ module Artemis
       #   end
       #
       def after_execute(&block)
-        config.after_callbacks << block
+        config.after_callbacks = [*config.after_callbacks, block]
+      end
+
+      # Returns the default configured context or an empty hash by default
+      #
+      # @return [Hash]
+      def default_context
+        config.default_context || {}
       end
 
       def resolve_graphql_file_path(filename, fragment: false)
@@ -205,6 +214,10 @@ module Artemis
         Executor.new(endpoint.connection, callbacks, default_context.deep_merge(context))
       end
 
+      def execute(query, context: {}, **arguments)
+        new(default_context).execute(query, context: context, **arguments)
+      end
+
       private
 
       # Looks up the GraphQL file that matches the given +const_name+ and sets it to a constant. If the files it not
@@ -235,9 +248,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
@@ -255,6 +268,28 @@ module Artemis
       end
     end
 
+    # Executes a given query, raises if we didn't define the operation
+    #
+    # @param [String] operation
+    # @param [Hash] context
+    # @param [Hash] arguments
+    #
+    # @return [GraphQL::Client::Response]
+    def execute(query, context: {}, **arguments)
+      if self.class.resolve_graphql_file_path(query)
+        const_name = query.to_s.camelize
+
+        # This check will be unnecessary once we drop support for Ruby 2.4 and earlier
+        if !self.class.const_get(const_name).is_a?(GraphQL::Client::OperationDefinition)
+          self.class.load_constant(const_name)
+        end
+
+        client.query(self.class.const_get(const_name), variables: arguments, context: context)
+      else
+        raise GraphQLFileNotFound.new("Query #{query}.graphql not found in: #{query_paths.join(", ")}")
+      end
+    end
+
     private
 
     # Delegates a method call to a GraphQL call.
@@ -268,18 +303,9 @@ module Artemis
     #
     # @api private
     def method_missing(method_name, context: {}, **arguments)
-      if self.class.resolve_graphql_file_path(method_name)
-        const_name = method_name.to_s.camelize
-
-        # This check will be unnecessary once we drop support for Ruby 2.4 and earlier
-        if !self.class.const_get(const_name).is_a?(GraphQL::Client::OperationDefinition)
-          self.class.load_constant(const_name)
-        end
-
-        client.query(self.class.const_get(const_name), variables: arguments, context: context)
-      else
-        super
-      end
+      execute(method_name, context: context, **arguments)
+    rescue GraphQLFileNotFound
+      super
     end
 
     def respond_to_missing?(method_name, *_, &block) #:nodoc:

data/lib/artemis/graphql_endpoint.rb

@@ -2,6 +2,7 @@
 
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/inflections'
 require 'graphql/client'
@@ -11,6 +12,13 @@ require 'artemis/exceptions'
 
 module Artemis
   class GraphQLEndpoint
+
+    # Whether or not to suppress warnings on schema load. Use it with caution.
+    #
+    # @private
+    cattr_accessor :suppress_warnings_on_schema_load
+    self.suppress_warnings_on_schema_load = false
+
     # Hash object that holds references to adapter instances.
     ENDPOINT_INSTANCES = {}
 
@@ -25,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
 
       ##
@@ -36,26 +44,36 @@ 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
     end
 
     def schema
+      org, $stderr = $stderr, File.new("/dev/null", "w") if self.class.suppress_warnings_on_schema_load
+
       @schema || @mutex_for_schema.synchronize do
         @schema ||= ::GraphQL::Client.load_schema(schema_path.presence || connection)
       end
+    ensure
+      $stderr = org if self.class.suppress_warnings_on_schema_load
     end
     alias load_schema! schema
 
     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
-end
+end

data/lib/artemis/railtie.rb

@@ -31,13 +31,15 @@ module Artemis
     end
 
     initializer 'graphql.client.set_reloader', after: 'graphql.client.set_query_paths' do |app|
-      files_to_watch = Artemis::Client.query_paths.map {|path| [path, config.artemis.graphql_extentions] }.to_h
+      if !config.respond_to?(:autoloader) || config.autoloader != :zeitwerk
+        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 = app.config_for(:graphql).keys
-        endpoint_names.each do |endpoint_name|
-          Artemis::Client.query_paths.each do |path|
-            FileUtils.touch("#{path}/#{endpoint_name}.rb")
+        app.reloaders << ActiveSupport::FileUpdateChecker.new([], files_to_watch) do
+          endpoint_names = Artemis.config_for_graphql(app).keys
+          endpoint_names.each do |endpoint_name|
+            Artemis::Client.query_paths.each do |path|
+              FileUtils.touch("#{path}/#{endpoint_name}.rb")
+            end
           end
         end
       end
@@ -45,18 +47,18 @@ module Artemis
 
     initializer 'graphql.client.load_config' do |app|
       if Pathname.new("#{app.paths["config"].existent.first}/graphql.yml").exist?
-        app.config_for(:graphql).each do |endpoint_name, options|
+        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))
+            schema_path: app.root.join(config.artemis.schema_path, "#{endpoint_name}.json").to_s
+          }.merge(options.symbolize_keys))
         end
       end
     end
 
     initializer 'graphql.client.preload', after: 'graphql.client.load_config' do |app|
-      if app.config.eager_load
-        app.config_for(:graphql).keys.each do |endpoint_name|
-          endpoint_name.to_s.camelize.constantize.preload!
+      if app.config.eager_load && app.config.cache_classes
+        Artemis::GraphQLEndpoint.registered_services.each do |endpoint_name|
+          endpoint_name.camelize.constantize.preload!
         end
       end
     end
@@ -65,4 +67,4 @@ module Artemis
       load "tasks/artemis.rake"
     end
   end
-end
+end

data/lib/artemis/test_helper.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require 'erb'
+require 'yaml'
 
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
 
 require 'artemis/exceptions'
 
 module Artemis
   # TODO: Write documentation for +TestHelper+
   module TestHelper
-    cattr_accessor :__graphql_fixture_path__
+    mattr_accessor :__graphql_fixture_path__
 
     # Creates an object that stubs a GraphQL request for the given +service+. No mock response is registered until the
     # +to_return+ method.
@@ -41,7 +43,7 @@ module Artemis
     #   da_vinci.data.artist.name      # => "Leonardo da Vinci"
     #
     def stub_graphql(service, query_name, arguments =  :__unspecified__)
-      StubbingDSL.new(service.to_s, graphql_fixtures(query_name), arguments)
+      StubbingDSL.new(service.to_s, query_name, graphql_fixture_files, arguments)
     end
 
     # Returns out-going GraphQL requests.
@@ -60,15 +62,11 @@ module Artemis
       __graphql_fixture_path__ || raise(Artemis::ConfigurationError, "GraphQL fixture path is unset")
     end
 
-    def graphql_fixtures(query_name) #:nodoc:
-      graphql_fixture_files.detect {|fixture| fixture.name == query_name.to_s } || \
-        raise(Artemis::FixtureNotFound, "Fixture file `#{File.join(graphql_fixture_path, "#{query_name}.{yml,json}")}' not found")
-    end
-
     def graphql_fixture_files #:nodoc:
       @graphql_fixture_sets ||= Dir["#{graphql_fixture_path}/{**,*}/*.{yml,json}"]
-                              .select {|file| ::File.file?(file) }
-                              .map    {|file| GraphQLFixture.new(File.basename(file, File.extname(file)), file, read_erb_yaml(file)) }
+                                  .uniq
+                                  .select {|file| ::File.file?(file) }
+                                  .map    {|file| GraphQLFixture.new(File.basename(file, File.extname(file)), file, read_erb_yaml(file)) }
     end
 
     def read_erb_yaml(path) #:nodoc:
@@ -76,15 +74,30 @@ module Artemis
     end
 
     class StubbingDSL #:nodoc:
-      attr_reader :service_name, :fixture_set, :arguments
+      attr_reader :service_name, :query_name, :fixture_sets, :arguments
+
+      def initialize(service_name, query_name, fixture_sets, arguments) #:nodoc:
+        @service_name, @query_name, @fixture_sets, @arguments = service_name, query_name, fixture_sets, arguments
+      end
+
+      def get(fixture_key)
+        fixture_set = find_fixture_set
+        fixture     = fixture_set.data[fixture_key.to_s]
+
+        if fixture.nil?
+          raise Artemis::FixtureNotFound, "Fixture `#{fixture_key}' not found in #{fixture_set.path}"
+        end
 
-      def initialize(service_name, fixture_set, arguments) #:nodoc:
-        @service_name, @fixture_set, @arguments = service_name, fixture_set, arguments
+        fixture
       end
 
       def to_return(fixture_key) #:nodoc:
-        fixture = fixture_set.data[fixture_key.to_s] || \
-          raise(Artemis::FixtureNotFound, "Fixture `#{fixture_key}' not found in #{fixture_set.path}")
+        fixture_set = find_fixture_set
+        fixture     = fixture_set.data[fixture_key.to_s]
+
+        if fixture.nil?
+          raise Artemis::FixtureNotFound, "Fixture `#{fixture_key}' not found in #{fixture_set.path}"
+        end
 
         Artemis::Adapters::TestAdapter.responses <<
           TestResponse.new(
@@ -93,6 +106,20 @@ module Artemis
             fixture
           )
       end
+
+      private
+
+      def find_fixture_set
+        fixture_set = fixture_sets
+                        .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?
+          raise Artemis::FixtureNotFound, "Fixture file `#{query_name}.{yml,json}' not found"
+        end
+
+        fixture_set
+      end
     end
 
     TestResponse      = Struct.new(:operation_name, :arguments, :data) #:nodoc: