artemis 0.1.0

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_42.gemfile

@@ -0,0 +1,12 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "pry"
+gem "pry-byebug", platforms: :mri
+gem "rails", "~> 4.2"
+gem "railties", "~> 4.2"
+gem "activesupport", "~> 4.2"
+gem "minitest", "5.10.3"
+
+gemspec path: "../"

data/gemfiles/rails_50.gemfile

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

data/gemfiles/rails_51.gemfile

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

data/gemfiles/rails_52.gemfile

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

data/gemfiles/rails_edge.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+git "git://github.com/rails/rails.git" do
+  gem "rails"
+  gem "railties"
+  gem "activesupport"
+end
+
+gem "pry"
+gem "pry-byebug", platforms: :mri
+
+gemspec path: "../"

data/lib/artemis.rb

@@ -0,0 +1,3 @@
+require "artemis/version"
+require "artemis/client"
+require "artemis/railtie" if defined?(Rails)

data/lib/artemis/adapters.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Artemis
+  module Adapters
+    extend ActiveSupport::Autoload
+
+    autoload :CurbAdapter
+    autoload :NetHttpAdapter
+    autoload :NetHttpPersistentAdapter
+    autoload :TestAdapter
+
+    class << self
+      ##
+      # Returns the constant for the specified adapter name.
+      #
+      #   Artemis::Adapters.lookup(:net_http)
+      #   # => Artemis::Adapters::NetHttpAdapter
+      def lookup(name)
+        const_get("#{name.to_s.camelize}Adapter")
+      end
+    end
+  end
+end

data/lib/artemis/adapters/abstract_adapter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'graphql/client/http'
+
+module Artemis
+  module Adapters
+    class AbstractAdapter < ::GraphQL::Client::HTTP
+      attr_reader :service_name, :timeout, :pool_size
+
+      EMPTY_HEADERS = {}.freeze
+
+      def initialize(uri, service_name: , timeout: , pool_size: )
+        super(uri) # Do not pass in the block to avoid getting #headers and #connection overridden.
+
+        @service_name = service_name.to_s
+        @timeout      = timeout
+        @pool_size    = pool_size
+      end
+
+      # Public: Extension point for subclasses to set custom request headers.
+      #
+      # Returns Hash of String header names and values.
+      def headers(_context)
+        _context[:headers] || EMPTY_HEADERS
+      end
+
+      # Public: Make an HTTP request for GraphQL query.
+      #
+      # A subclass that inherits from +AbstractAdapter+ can override this method if it needs more flexibility for how
+      # it makes a request.
+      #
+      # For more details, see +GraphQL::Client::HTTP#execute+.
+      def execute(*)
+        super
+      end
+
+      # Public: Extension point for subclasses to customize the Net:HTTP client
+      #
+      # A subclass that inherits from +AbstractAdapter+ should returns a Net::HTTP object or an object that responds
+      # to +request+ that is given a Net::HTTP request object.
+      def connection
+        raise "AbstractAdapter is an abstract class that can not be instantiated!"
+      end
+    end
+  end
+end

data/lib/artemis/adapters/curb_adapter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'delegate'
+require 'json'
+
+require 'curb'
+
+require 'artemis/adapters/abstract_adapter'
+require 'artemis/exceptions'
+
+module Artemis
+  module Adapters
+    class CurbAdapter < AbstractAdapter
+      attr_reader :multi
+
+      def initialize(uri, service_name: , timeout: , pool_size: )
+        super
+
+        @multi = Curl::Multi.new
+        @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)
+
+        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     = 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
+          # possible to pipeline/multiplex on before it continues.
+          easy.setopt(Curl::CURLOPT_PIPEWAIT, 1)
+          easy.version = Curl::HTTP_2_0
+        end
+
+        easy.http_post
+
+        case easy.response_code
+        when 200, 400
+          JSON.parse(easy.body)
+        when 500..599
+          raise Artemis::GraphQLServerError, "Received server error status #{easy.response_code}: #{easy.body}"
+        else
+          { "errors" => [{ "message" => "#{easy.response_code} #{easy.body}" }] }
+        end
+      end
+    end
+  end
+end

data/lib/artemis/adapters/net_http_adapter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+
+require 'artemis/adapters/abstract_adapter'
+require 'artemis/exceptions'
+
+module Artemis
+  module Adapters
+    class NetHttpAdapter < AbstractAdapter
+      # 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
+
+        request["Accept"] = "application/json"
+        request["Content-Type"] = "application/json"
+        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
+        request.body = JSON.generate(body)
+
+        response = connection.request(request)
+
+        case response.code.to_i
+        when 200, 400
+          JSON.parse(response.body)
+        when 500..599
+          raise Artemis::GraphQLServerError, "Received server error status #{response.code}: #{response.body}"
+        else
+          { "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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'net/http/persistent'
+
+require 'artemis/adapters/net_http_adapter'
+
+module Artemis
+  module Adapters
+    class NetHttpPersistentAdapter < NetHttpAdapter
+      attr_reader :_connection, :raw_connection
+
+      def initialize(uri, service_name: , timeout: , pool_size: )
+        super
+
+        @raw_connection = Net::HTTP::Persistent.new(name: service_name, pool_size: pool_size)
+        @raw_connection.open_timeout = timeout
+        @raw_connection.read_timeout = timeout
+
+        @_connection = ConnectionWrapper.new(@raw_connection, uri)
+      end
+
+      # Public: Extension point for subclasses to customize the Net:HTTP client
+      #
+      # Returns a Net::HTTP object
+      def connection
+        _connection
+      end
+
+      class ConnectionWrapper < SimpleDelegator
+        def initialize(obj, url)
+          super(obj)
+
+          @url = url
+        end
+
+        def request(req)
+          __getobj__.request(@url, req)
+        end
+      end
+
+      private_constant :ConnectionWrapper
+    end
+  end
+end

data/lib/artemis/adapters/test_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Artemis
+  module Adapters
+    class TestAdapter
+      cattr_accessor :requests
+      self.requests = []
+
+      Request = Struct.new(:document, :operation_name, :variables, :context)
+
+      private_constant :Request
+
+      def initialize(*)
+      end
+
+      def execute(**arguments)
+        self.requests << Request.new(*arguments.values_at(:document, :operation_name, :variables, :context))
+
+        {
+          'data' => { 'test' => 'data' },
+          'errors' => [],
+          'extensions' => {}
+        }
+      end
+    end
+  end
+end

data/lib/artemis/client.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+require 'active_support/configurable'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/string/inflections'
+
+require 'artemis/graphql_endpoint'
+require 'artemis/exceptions'
+
+module Artemis
+  class Client
+    include ActiveSupport::Configurable
+
+    # 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 = []
+
+    # Default context that is appended to every GraphQL request for the client.
+    config.default_context = {}
+
+    # List of before callbacks that get invoked in every +execute+ call.
+    #
+    # @api  private
+    config.before_callbacks = []
+
+    # List of after callbacks that get invoked in every +execute+ call.
+    #
+    # @api private
+    config.after_callbacks = []
+
+    # Returns a plain +GraphQL::Client+ object. For more details please refer to the official documentation for
+    # {the +graphql-client+ gem}[https://github.com/github/graphql-client].
+    attr_reader :client
+
+    # Creates a new instance of the GraphQL client for the service.
+    #
+    #   # app/operations/github/user.graphql
+    #   query($id: String!) {
+    #     user(login: $id) {
+    #       name
+    #     }
+    #   }
+    #
+    #   # app/operations/github.rb
+    #   class GitHub < Artemis::Client
+    #   end
+    #
+    #   github = GitHub.new
+    #   github.user(id: 'yuki24').data.user.name # => "Yuki Nishijima"
+    #
+    #   github = GitHub.new(context: { headers: { Authorization: "bearer ..." } })
+    #   github.user(id: 'yuki24').data.user.name # => "Yuki Nishijima"
+    #
+    def initialize(context = {})
+      @client = self.class.instantiate_client(context)
+    end
+
+    class << self
+      delegate :query_paths, :default_context, :query_paths=, :default_context=, to: :config
+
+      alias with_context new
+
+      def endpoint
+        Artemis::GraphQLEndpoint.lookup(name)
+      end
+
+      def instantiate_client(context = {})
+        ::GraphQL::Client.new(schema: endpoint.schema, execute: connection(context))
+      end
+
+      # Defines a callback that will get called right before the
+      # client's execute method is executed.
+      #
+      #   class GitHub < Artemis::Client
+      #
+      #     before_execute do |document, operation_name, variables, context|
+      #       Analytics.log(operation_name, variables, context[:user_id])
+      #     end
+      #
+      #     ...
+      #   end
+      #
+      def before_execute(&block)
+        config.before_callbacks << block
+      end
+
+      # Defines a callback that will get called right after the
+      # client's execute method has finished.
+      #
+      #   class GitHub < Artemis::Client
+      #
+      #     after_execute do |data, errors, extensions|
+      #       if errors.present?
+      #         Rails.logger.error(errors.to_json)
+      #       end
+      #     end
+      #
+      #     ...
+      #   end
+      #
+      def after_execute(&block)
+        config.after_callbacks << block
+      end
+
+      def resolve_graphql_file_path(filename, fragment: false)
+        namespace = name.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"))
+        end
+      end
+
+      def graphql_file_paths
+        @graphql_file_paths ||= query_paths.flat_map {|path| Dir["#{path}/#{name.underscore}/*.graphql"] }
+      end
+
+      def preload!
+        graphql_file_paths.each do |path|
+          load_constant(File.basename(path, File.extname(path)).camelize)
+        end
+      end
+
+      def load_constant(const_name)
+        graphql_file = resolve_graphql_file_path(const_name.to_s.underscore, fragment: true)
+
+        if graphql_file
+          graphql = File.open(graphql_file).read
+          ast     = instantiate_client.parse(graphql)
+
+          const_set(const_name, ast)
+        end
+      end
+      alias load_query load_constant
+
+      # @api private
+      def connection(context = {})
+        Executor.new(endpoint.connection, callbacks, default_context.deep_merge(context))
+      end
+
+      private
+
+      # @api private
+      def const_missing(const_name)
+        load_constant(const_name) || super
+      end
+
+      # @api private
+      def method_missing(method_name, *arguments, &block)
+        if resolve_graphql_file_path(method_name)
+          new(default_context).public_send(method_name, *arguments, &block)
+        else
+          super
+        end
+      end
+
+      # @api private
+      def respond_to_missing?(method_name, *_, &block)
+        resolve_graphql_file_path(method_name) || super
+      end
+
+      Callbacks = Struct.new(:before_callbacks, :after_callbacks)
+
+      private_constant :Callbacks
+
+      # @api private
+      def callbacks
+        Callbacks.new(config.before_callbacks, config.after_callbacks)
+      end
+    end
+
+    private
+
+    # @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.deep_transform_keys {|key| key.to_s.camelize(:lower) },
+          context: context
+        )
+      else
+        super
+      end
+    end
+
+    # @api private
+    def respond_to_missing?(method_name, *_, &block)
+      self.class.resolve_graphql_file_path(method_name) || super
+    end
+
+    # @api private
+    def compile_query_method!(method_name)
+      const_name = method_name.to_s.camelize
+
+      self.class.send(:class_eval, <<-RUBY, __FILE__, __LINE__ + 1)
+        def #{method_name}(context: {}, **arguments)
+          client.query(
+            self.class::#{const_name},
+            variables: arguments.deep_transform_keys {|key| key.to_s.camelize(:lower) },
+            context: context
+          )
+        end
+      RUBY
+    end
+  end
+
+  # @api private
+  class Executor < SimpleDelegator
+    def initialize(connection, callbacks, default_context)
+      super(connection)
+
+      @callbacks = callbacks
+      @default_context = default_context
+    end
+
+    def execute(document:, operation_name: nil, variables: {}, context: {})
+      _context = @default_context.deep_merge(context)
+
+      @callbacks.before_callbacks.each do |callback|
+        callback.call(document, operation_name, variables, _context)
+      end
+
+      response = __getobj__.execute(document: document, operation_name: operation_name, variables: variables, context: _context)
+
+      @callbacks.after_callbacks.each do |callback|
+        callback.call(response['data'], response['errors'], response['extensions'])
+      end
+
+      response
+    end
+  end
+
+  private_constant :Executor
+end