artemis 0.1.0

data/lib/artemis/exceptions.rb

@@ -0,0 +1,19 @@
+module Artemis
+  class Error < StandardError
+  end
+
+  class EndpointNotFound < Error
+  end
+
+  class ConfigurationError < Error
+  end
+
+  class GraphQLFileNotFound < Error
+  end
+
+  class GraphQLError < Error
+  end
+
+  class GraphQLServerError < GraphQLError
+  end
+end

data/lib/artemis/graphql_endpoint.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+require 'graphql/client'
+
+require 'artemis/adapters'
+require 'artemis/exceptions'
+
+module Artemis
+  class GraphQLEndpoint
+    # Hash object that holds references to adapter instances.
+    ENDPOINT_INSTANCES = {}
+
+    private_constant :ENDPOINT_INSTANCES
+
+    class << self
+      ##
+      # Provides an endpoint instance specified in the +configuration+. If the endpoint is not found in
+      # +ENDPOINT_INSTANCES+, it'll raise an exception.
+      def lookup(service_name)
+        ENDPOINT_INSTANCES[service_name.to_s.underscore] || raise(Artemis::EndpointNotFound, "Service `#{service_name}' not registered.")
+      end
+
+      def register!(service_name, configurations)
+        ENDPOINT_INSTANCES[service_name.to_s.underscore] = new(service_name.to_s, configurations.symbolize_keys)
+      end
+    end
+
+    attr_reader :name, :url, :adapter, :timeout, :schema_path, :pool_size
+
+    def initialize(name, url: , adapter: :net_http, timeout: 30, schema_path: nil, pool_size: 5)
+      @name, @url, @adapter, @timeout, @schema_path, @pool_size = name.to_s, url, adapter, timeout, schema_path, pool_size
+
+      @mutex_for_schema     = Mutex.new
+      @mutex_for_connection = Mutex.new
+    end
+
+    def schema
+      @schema || @mutex_for_schema.synchronize do
+        @schema ||= ::GraphQL::Client.load_schema(schema_path.presence || connection)
+      end
+    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)
+      end
+    end
+  end
+end

data/lib/artemis/railtie.rb

@@ -0,0 +1,50 @@
+require 'active_support/file_update_checker'
+
+module Artemis
+  class Railtie < ::Rails::Railtie #:nodoc:
+    initializer 'graphql.client.attach_log_subscriber' do
+      if !defined?(GraphQL::Client::LogSubscriber)
+        require "graphql/client/log_subscriber"
+        GraphQL::Client::LogSubscriber.attach_to :graphql
+      end
+    end
+
+    initializer 'graphql.client.set_query_paths' do |app|
+      app.paths.add "app/operations"
+
+      Artemis::Client.query_paths = app.paths["app/operations"].existent
+    end
+
+    initializer 'graphql.client.set_reloader', after: 'graphql.client.set_query_paths' do |app|
+      files_to_watch = Artemis::Client.query_paths.map {|path| [path, ["graphql"]] }.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")
+          end
+        end
+      end
+    end
+
+    initializer 'graphql.client.load_config' do |app|
+      # TODO: Remove the +rescue+ call
+      (app.config_for(:graphql) rescue {}).each do |endpoint_name, options|
+        Artemis::GraphQLEndpoint.register!(endpoint_name, { 'schema_path' => app.root.join("vendor/graphql/schema/#{endpoint_name}.json").to_s }.merge(options))
+      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!
+        end
+      end
+    end
+
+    rake_tasks do
+      load "tasks/artemis.rake"
+    end
+  end
+end

data/lib/artemis/version.rb

@@ -0,0 +1,3 @@
+module Artemis
+  VERSION = "0.1.0"
+end

data/lib/generators/artemis/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Generates a client stub and config files and downloads the schema from the given endpoint.
+
+Example:
+    rails generate install Artsy https://metaphysics-production.artsy.net
+
+    This will create:
+        app/operations/artsy.rb
+        app/operations/artsy/.gitkeep
+        config/graphql.yml
+        vendor/graphql/schema/artsy.json

data/lib/generators/artemis/install_generator.rb

@@ -0,0 +1,59 @@
+require 'graphql/client'
+require 'graphql/client/http'
+
+class Artemis::InstallGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('../templates', __FILE__)
+
+  argument :endpoint_url, type: :string, banner: "The endpoint URL for a GraphQL service"
+
+  class_option :authorization, type: :string, default: nil, aliases: "-A"
+
+  def generate_client
+    template "client.rb", client_file_name
+    create_file query_dir_gitkeep, ""
+  end
+
+  def generate_config
+    in_root do
+      if behavior == :invoke && !File.exist?(config_file_name)
+        template "graphql.yml", config_file_name
+      end
+    end
+  end
+
+  def download_schema
+    say "      downloading GraphQL schema from #{endpoint_url}..."
+
+    if options['authorization'].present?
+      rake "graphql:schema:update SERVICE=#{file_name} AUTHORIZATION='#{options['authorization']}'"
+    else
+      rake "graphql:schema:update SERVICE=#{file_name}"
+    end
+  end
+
+  private
+
+  def file_name # :doc:
+    @_file_name ||= super.underscore
+  end
+
+  def client_file_name
+    if mountable_engine?
+      "app/operations/#{namespaced_path}/#{file_name}.rb"
+    else
+      "app/operations/#{file_name}.rb"
+    end
+  end
+
+  def query_dir_gitkeep
+    if mountable_engine?
+      "app/operations/#{namespaced_path}/#{file_name}/.gitkeep"
+    else
+      "app/operations/#{file_name}/.gitkeep"
+    end
+  end
+
+  def config_file_name
+    "config/graphql.yml"
+  end
+end

data/lib/generators/artemis/templates/client.rb

@@ -0,0 +1,10 @@
+<% module_namespacing do -%>
+class <%= class_name %> < Artemis::Client
+  # If an access token needs to be assigned to every request:
+  # self.default_context = {
+  #   headers: {
+  #     Authorization: "token ..."
+  #   }
+  # }
+end
+<% end %>

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

@@ -0,0 +1,19 @@
+default: &default
+  adapter: :net_http
+  timeout: 10
+  pool_size: 25
+
+development:
+  <%= file_name %>:
+    <<: *default
+    url: <%= endpoint_url %>
+
+test:
+  <%= file_name %>:
+    <<: *default
+    url: <%= endpoint_url %>
+
+production:
+  <%= file_name %>:
+    <<: *default
+    url: <%= endpoint_url %>

data/lib/tasks/artemis.rake

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require 'active_support/core_ext/string/inflections'
+require 'graphql/client'
+
+namespace :graphql do
+  namespace :schema do
+    desc "Downloads and saves the GraphQL schema (options: SERVICE=service_name AUTHORIZATION='token ...')"
+    task update: :environment do
+      service = if ENV['SERVICE']
+                  ENV['SERVICE']
+                else
+                  services = Rails.application.config_for(:graphql).keys
+
+                  if services.size == 1
+                    services.first
+                  else
+                    raise "Please specify a service name (available services: #{services.join(", ")}): rake graphql:schema:update SERVICE=service"
+                  end
+                end
+
+      headers          = ENV['AUTHORIZATION'] ? { Authorization: ENV['AUTHORIZATION'] } : {}
+      service_class    = service.camelize.constantize
+      schema_path      = service_class.endpoint.schema_path
+      schema           = service_class.connection
+                           .execute(
+                             document: GraphQL::Client::IntrospectionDocument,
+                             operation_name: "IntrospectionQuery",
+                             variables: {},
+                             context: { headers: headers }
+                           ).to_h
+
+      if schema['errors'].nil? || schema['errors'].empty?
+        FileUtils.mkdir_p(File.dirname(schema_path))
+        File.open(schema_path, 'w') do |file|
+          file.write(JSON.pretty_generate(schema))
+        end
+
+        puts "saved schema to: #{schema_path.gsub("#{Dir.pwd}/", '')}"
+      else
+        raise "received error from server: #{schema}\n\n"
+      end
+    end
+  end
+end

data/spec/adapters_spec.rb

@@ -0,0 +1,106 @@
+require 'json'
+require 'rack'
+
+describe 'Adapters' do
+  FakeServer = ->(env) {
+    case env['PATH_INFO']
+    when '/slow_server'
+      sleep 2.1
+
+      [200, {}, ['{}']]
+    when '/500'
+      [500, {}, ['Server error']]
+    else
+      body = {
+        data: {
+          body: JSON.parse(env['rack.input'].read),
+          headers: env.select {|key, val| key.start_with?('HTTP_') }
+                     .collect {|key, val| [key.gsub(/^HTTP_/, ''), val.downcase] }
+                     .to_h,
+        },
+        errors: [],
+        extensions: {}
+      }.to_json
+
+      [200, {}, [body]]
+    end
+  }
+
+  before :all do
+    Artemis::Adapters::AbstractAdapter.send(:attr_writer, :uri, :timeout)
+
+    @server_thread = Thread.new do
+      Rack::Handler::WEBrick.run(FakeServer, Port: 8000, Logger: WEBrick::Log.new('/dev/null'), AccessLog: [])
+    end
+
+    loop do
+      begin
+        TCPSocket.open('localhost', 8000)
+        break
+      rescue Errno::ECONNREFUSED
+        # no-op
+      end
+    end
+  end
+
+  after :all do
+    Rack::Handler::WEBrick.shutdown
+    @server_thread.terminate
+  end
+
+  shared_examples 'an adapter' do
+    describe '#execute' do
+      it 'makes an actual HTTP request' do
+        response = adapter.execute(
+          document: GraphQL::Client::IntrospectionDocument,
+          operation_name: 'IntrospectionQuery',
+          variables: { id: 'yayoi-kusama' },
+          context: { user_id: 1 }
+        )
+
+        expect(response['data']['body']['query']).to eq(GraphQL::Client::IntrospectionDocument.to_query_string)
+        expect(response['data']['body']['variables']).to eq('id' => 'yayoi-kusama')
+        expect(response['data']['body']['operationName']).to eq('IntrospectionQuery')
+        expect(response['errors']).to eq([])
+        expect(response['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.execute(document: GraphQL::Client::IntrospectionDocument, operation_name: 'IntrospectionQuery')
+        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.execute(document: GraphQL::Client::IntrospectionDocument, operation_name: 'IntrospectionQuery')
+        end.to raise_error(timeout_error)
+      end
+    end
+  end
+
+  describe Artemis::Adapters::NetHttpAdapter do
+    let(:adapter) { Artemis::Adapters::NetHttpAdapter.new('http://localhost:8000', service_name: nil, timeout: 2, pool_size: 5) }
+    let(:timeout_error) { Net::ReadTimeout }
+
+    it_behaves_like 'an adapter'
+  end
+
+  describe Artemis::Adapters::NetHttpPersistentAdapter do
+    let(:adapter) { Artemis::Adapters::NetHttpPersistentAdapter.new('http://localhost:8000', service_name: nil, timeout: 2, pool_size: 5) }
+    let(:timeout_error) { Net::HTTP::Persistent::Error }
+
+    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 }
+
+    it_behaves_like 'an adapter'
+  end
+end

data/spec/autoloading_spec.rb

@@ -0,0 +1,146 @@
+describe "#{GraphQL::Client} Autoloading" do
+  describe ".load_constant" do
+    it "loads the specified constant if there is a matching graphql file" do
+      Metaphysics.send(:remove_const, :Artist) if Metaphysics.constants.include?(:Artist)
+
+      Metaphysics.load_constant(:Artist)
+
+      expect(defined?(Metaphysics::Artist)).to eq('constant')
+    end
+
+    it "does nothing and returns nil if there is no matching file" do
+      expect(Metaphysics.load_constant(:DoesNotExist)).to be_nil
+    end
+  end
+
+  describe ".preload!" do
+    it "preloads all the graphQL files in the query paths" do
+      %i(Artist Artwork ArtistFragment)
+        .select {|const_name| Metaphysics.constants.include?(const_name) }
+        .each {|const_name| Metaphysics.send(:remove_const, const_name) }
+
+      Metaphysics.preload!
+
+      expect(defined?(Metaphysics::Artist)).to eq('constant')
+      expect(defined?(Metaphysics::Artwork)).to eq('constant')
+    end
+  end
+
+  it "dynamically loads the matching GraphQL query and sets it to a constant" do
+    Metaphysics.send(:remove_const, :Artist) if Metaphysics.constants.include?(:Artist)
+
+    query = Metaphysics::Artist
+
+    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
+      query Metaphysics__Artist($id: String!) {
+        artist(id: $id) {
+          name
+          bio
+          birthday
+        }
+      }
+    GRAPHQL
+  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)
+
+    query = Metaphysics::ArtistFragment
+
+    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
+      fragment Metaphysics__ArtistFragment on Artist {
+        hometown
+        deathday
+      }
+    GRAPHQL
+  end
+
+  it "correctly loads the matching GraphQL query even when the top-level constant with the same name exists" do
+    # In Ruby <= 2.4 top-level constants can be looked up through a namespace, which turned out to be a bad practice.
+    # This has been removed in 2.5, but in earlier versions still suffer from this behaviour.
+    Metaphysics.send(:remove_const, :Artist) if Metaphysics.constants.include?(:Artist)
+    Object.send(:remove_const, :Artist) if Object.constants.include?(:Artist)
+
+    begin
+      Object.send(:const_set, :Artist, 1)
+
+      Metaphysics.artist
+    ensure
+      Object.send(:remove_const, :Artist)
+    end
+
+    query = Metaphysics::Artist
+
+    expect(query.document.to_query_string).to eq(<<~GRAPHQL.strip)
+      query Metaphysics__Artist($id: String!) {
+        artist(id: $id) {
+          name
+          bio
+          birthday
+        }
+      }
+    GRAPHQL
+  end
+
+  it "raises an exception when the path was resolved but the file does not exist" do
+    begin
+      Metaphysics.graphql_file_paths << "metaphysics/removed.graphql"
+
+      expect { Metaphysics::Removed }.to raise_error(Errno::ENOENT)
+    ensure
+      Metaphysics.graphql_file_paths.delete("metaphysics/removed.graphql")
+    end
+  end
+
+  it "raises an NameError when there is no graphql file that matches the const name" do
+    expect { Metaphysics::DoesNotExist }.to raise_error(NameError)
+  end
+
+  xit "defines the query method when the matching class method gets called for the first time" do
+    Metaphysics.undef_method(:artwork) if Metaphysics.public_instance_methods.include?(:artwork)
+
+    Metaphysics.artwork
+
+    expect(Metaphysics.public_instance_methods).to include(:artwork)
+  end
+
+  it "raises an NameError when there is no graphql file that matches the class method name" do
+    expect { Metaphysics.does_not_exist }.to raise_error(NameError)
+  end
+
+  it "raises an NameError when the class method name matches a fragment name" do
+    expect { Metaphysics.artist_fragment }.to raise_error(NameError)
+  end
+
+  it "responds to a class method that has a matching graphQL file" do
+    expect(Metaphysics).to respond_to(:artwork)
+  end
+
+  it "does not respond to class methods that do not have a matching graphQL file" do
+    expect(Metaphysics).not_to respond_to(:does_not_exist)
+  end
+
+  xit "defines the query method when the matching instance method gets called for the first time" do
+    Metaphysics.undef_method(:artwork) if Metaphysics.public_instance_methods.include?(:artwork)
+
+    Metaphysics.new.artwork
+
+    expect(Metaphysics.public_instance_methods).to include(:artwork)
+  end
+
+  it "raises an NameError when there is no graphql file that matches the instance method name" do
+    expect { Metaphysics.new.does_not_exist }.to raise_error(NameError)
+  end
+
+  it "raises an NameError when the instance method name matches a fragment name" do
+    expect { Metaphysics.new.artist_fragment }.to raise_error(NameError)
+  end
+
+  it "responds to the method that has a matching graphQL file" do
+    expect(Metaphysics.new).to respond_to(:artwork)
+  end
+
+  it "does not respond to methods that do not have a matching graphQL file" do
+    expect(Metaphysics.new).not_to respond_to(:does_not_exist)
+  end
+end