graphql_client 0.3.3

data/lib/graphql_client/adapters/http_adapter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Adapters
+      class HTTPAdapter
+        JSON_MIME_TYPE = 'application/json'.freeze
+        DEFAULT_HEADERS = { 'Accept' => JSON_MIME_TYPE, 'Content-Type' => JSON_MIME_TYPE }
+
+        attr_reader :config
+
+        def initialize(config)
+          @config = config
+        end
+
+        def request(query, operation_name: nil, variables: {})
+          req = build_request(query, operation_name: operation_name, variables: variables)
+
+          http_options = {
+            use_ssl: https?,
+            open_timeout: config.open_timeout,
+            read_timeout: config.read_timeout
+          }
+
+          # IMPORTANT: open_timeout is only respected when it's supplied as part of the options
+          # when you call Net::HTTP.start. It is not respected when it's set inside the block of
+          # Net::HTTP.start (i.e. http.open_timeout = 1)
+          response = Net::HTTP.start(config.url.hostname, config.url.port, http_options) do |http|
+            http.request(req)
+          end
+
+          case response
+          when Net::HTTPOK
+            puts "Response body: \n#{JSON.pretty_generate(JSON.parse(response.body))}" if debug?
+            Response.new(response.body)
+          else
+            raise ClientError, response
+          end
+        rescue Net::OpenTimeout
+          raise OpenTimeoutError, "timeout while waiting for a connection"
+        rescue Net::ReadTimeout
+          raise ReadTimeoutError, "timeout while waiting for a response"
+        end
+
+        private
+
+        def build_request(query, operation_name: nil, variables: {})
+          headers = DEFAULT_HEADERS.merge(config.headers)
+
+          Net::HTTP::Post.new(config.url, headers).tap do |req|
+            req.basic_auth(config.username, config.password)
+            puts "Query: #{query}" if debug?
+
+            req.body = {
+              query: query,
+              variables: variables,
+              operation_name: operation_name,
+            }.to_json
+          end
+        end
+
+        def debug?
+          config.debug
+        end
+
+        def https?
+          config.url.scheme == 'https'
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    class Base
+      attr_reader :adapter, :config, :schema
+
+      def initialize(schema, config: nil, adapter: nil, &block)
+        @config = config || Config.new
+        @schema = load_schema(schema)
+        @adapter = adapter || Adapters::HTTPAdapter.new(@config)
+
+        instance_eval(&block) if block_given?
+      end
+
+      def build_query
+        query = Query::Document.new(@schema)
+
+        if block_given?
+          yield query
+        else
+          query
+        end
+      end
+
+      def configure
+        yield @config
+      end
+
+      def query(query, operation_name: nil, variables: {})
+        response = adapter.request(query.to_query, operation_name: operation_name, variables: variables)
+        GraphObject.new(data: response.data, query: query)
+      end
+
+      def raw_query(query_string, operation_name: nil, variables: {})
+        response = adapter.request(query_string, operation_name: operation_name, variables: variables)
+        ResponseObject.new(response.data)
+      end
+
+      private
+
+      def load_schema(schema)
+        case schema
+        when Pathname
+          schema_string = JSON.parse(File.read(schema))
+          GraphQLSchema.new(schema_string)
+        else
+          GraphQLSchema.new(schema)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/config.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    class Config
+      attr_accessor(
+        :debug,
+        :headers,
+        :per_page,
+        :password,
+        :username,
+        :url,
+        :open_timeout,
+        :read_timeout
+      )
+
+      DEFAULTS = {
+        debug: false,
+        headers: {},
+        per_page: 100,
+        open_timeout: 5,
+        read_timeout: 5
+      }
+
+      def initialize(options = {})
+        @options = DEFAULTS.merge(options)
+        @debug = @options[:debug]
+        @headers = @options[:headers]
+        @per_page = @options[:per_page]
+        @password = @options[:password]
+        @username = @options[:username]
+        @open_timeout = @options[:open_timeout]
+        @read_timeout = @options[:read_timeout]
+        @url = URI(@options[:url]) if @options[:url]
+      end
+
+      def url=(url)
+        @url = URI(url)
+      end
+    end
+  end
+end

data/lib/graphql_client/deserialization.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Deserialization
+      private
+
+      def create_accessor_methods(field_name, graph_object)
+        define_singleton_method(field_name) do
+          ivar_name = "@#{field_name}"
+
+          if instance_variable_defined?(ivar_name)
+            instance_variable_get(ivar_name)
+          else
+            instance_variable_set(ivar_name, graph_object)
+          end
+        end
+
+        underscored_name = underscore(field_name)
+
+        if field_name != underscored_name
+          define_singleton_method(underscored_name) { send field_name }
+        end
+      end
+
+      def underscore(name)
+        name
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+    end
+  end
+end

data/lib/graphql_client/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    Error = Class.new(StandardError)
+    OpenTimeoutError = Class.new(Error)
+    ReadTimeoutError = Class.new(Error)
+    ResponseError = Class.new(Error)
+
+    class ClientError < Error
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def message
+        "#{response.code} #{response.message}"
+      end
+    end
+  end
+end

data/lib/graphql_client/graph_connection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    class GraphConnection < GraphObject
+      include Enumerable
+
+      def each
+        return enum_for(:each) unless block_given?
+        edges.each { |edge| yield edge.node }
+      end
+
+      def next_page_query
+        build_minimal_query do |connection|
+          connection.add_arguments(**query.arguments, after: edges.last.cursor)
+          connection.selection_set = query.selection_set
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/graph_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    class GraphNode < GraphObject
+      def build_minimal_query
+        Query::QueryDocument.new(query.schema) do |root|
+          root.add_field('node', id: data.fetch('id')) do |node|
+            node.add_inline_fragment(query.resolver_type.name) do |fragment|
+              fragment.add_field('id')
+              yield fragment
+            end
+          end
+        end
+      end
+
+      def refetch_query
+        build_minimal_query do |node_fragment|
+          node_fragment.selection_set = query.selection_set
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/graph_object.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    class GraphObject
+      include Deserialization
+
+      attr_reader :data, :parent, :query
+
+      def initialize(query:, data:, parent: nil)
+        @query = query
+        @data = Hash(data)
+        @parent = parent
+
+        @data.each do |field_name, value|
+          field = query.selection_set.lookup(field_name)
+
+          graph_object = case value
+          when Hash
+            klass = if field.connection?
+              GraphConnection
+            elsif field.node?
+              GraphNode
+            else
+              GraphObject
+            end
+
+            klass.new(query: field, data: value, parent: self)
+          when Array
+            value.map do |v|
+              if v.is_a? Hash
+                self.class.new(query: field, data: v, parent: self)
+              else
+                v
+              end
+            end
+          else
+            value
+          end
+
+          create_accessor_methods(field_name, graph_object)
+        end
+      end
+
+      def build_minimal_query
+        if parent
+          parent.build_minimal_query do |context|
+            yield context.add_field(query.field_defn.name, as: query.name, **query.arguments)
+          end
+        else
+          Query::QueryDocument.new(query.schema) { |root| yield root }
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/introspection_query.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    INTROSPECTION_QUERY = '
+      query IntrospectionQuery {
+        __schema {
+          queryType { name }
+          mutationType { name }
+          subscriptionType { name }
+          types {
+            ...FullType
+          }
+          directives {
+            name
+            description
+            locations
+            args {
+              ...InputValue
+            }
+          }
+        }
+      }
+      fragment FullType on __Type {
+        kind
+        name
+        description
+        fields(includeDeprecated: true) {
+          name
+          description
+          args {
+            ...InputValue
+          }
+          type {
+            ...TypeRef
+          }
+          isDeprecated
+          deprecationReason
+        }
+        inputFields {
+          ...InputValue
+        }
+        interfaces {
+          ...TypeRef
+        }
+        enumValues(includeDeprecated: true) {
+          name
+          description
+          isDeprecated
+          deprecationReason
+        }
+        possibleTypes {
+          ...TypeRef
+        }
+      }
+      fragment InputValue on __InputValue {
+        name
+        description
+        type { ...TypeRef }
+        defaultValue
+      }
+      fragment TypeRef on __Type {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+            }
+          }
+        }
+      }
+    '
+  end
+end

data/lib/graphql_client/query/add_inline_fragment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      module AddInlineFragment
+        INVALID_FRAGMENT_TARGET = Class.new(StandardError)
+
+        def add_inline_fragment(type_name = resolver_type.name)
+          target_type = validate_fragment_target(document.schema.type(type_name))
+
+          inline_fragment = InlineFragment.new(target_type, document: document)
+          selection_set.add_inline_fragment(inline_fragment)
+
+          if block_given?
+            yield inline_fragment
+          else
+            inline_fragment
+          end
+        end
+
+        private
+
+        def valid_concrete_type?(type_name)
+          return true if resolver_type.object? && resolver_type.implement?(type_name)
+
+          return false unless resolver_type.union? || resolver_type.interface?
+          resolver_type.possible_types.any? { |type| type.name == type_name }
+        end
+
+        def validate_fragment_target(type)
+          if resolver_type.name != type.name && !valid_concrete_type?(type.name)
+            raise INVALID_FRAGMENT_TARGET,
+              "invalid target type '#{type.name}' for fragment of type #{resolver_type.name}"
+          else
+            type
+          end
+        end
+      end
+    end
+  end
+end