graphlient 0.7.0 → 0.9.0

data/lib/graphlient/client.rb

@@ -1,73 +1,98 @@
-module Graphlient
-  class Client
-    attr_accessor :uri, :options
-
-    def initialize(url, options = {}, &_block)
-      @url = url
-      @options = options.dup
-      yield self if block_given?
-    end
-
-    def parse(query_str = nil, &block)
-      query_str ||= Graphlient::Query.new do
-        instance_eval(&block)
-      end
-      client.parse(query_str.to_s)
-    rescue GraphQL::Client::Error => e
-      raise Graphlient::Errors::ClientError, e.message
-    end
-
-    def execute(query, variables = nil)
-      query_params = {}
-      query_params[:context] = @options if @options
-      query_params[:variables] = variables if variables
-      query = client.parse(query) if query.is_a?(String)
-      rc = client.query(query, **query_params)
-      raise Graphlient::Errors::GraphQLError, rc if rc.errors.any?
-      # see https://github.com/github/graphql-client/pull/132
-      # see https://github.com/exAspArk/graphql-errors/issues/2
-      raise Graphlient::Errors::ExecutionError, rc if errors_in_result?(rc)
-      rc
-    rescue GraphQL::Client::Error => e
-      raise Graphlient::Errors::ClientError, e.message
-    end
-
-    def query(query_or_variables = nil, variables = nil, &block)
-      if block_given?
-        execute(parse(&block), query_or_variables)
-      else
-        execute(query_or_variables, variables)
-      end
-    end
-
-    def http_adapter_class
-      options[:http] || Adapters::HTTP::FaradayAdapter
-    end
-
-    def http(&block)
-      adapter_options = { headers: @options[:headers], http_options: @options[:http_options] }
-
-      @http ||= http_adapter_class.new(@url, adapter_options, &block)
-    end
-
-    def schema
-      @schema ||= Graphlient::Schema.new(http, schema_path)
-    end
-
-    private
-
-    def schema_path
-      return options[:schema_path].to_s if options[:schema_path]
-    end
-
-    def client
-      @client ||= GraphQL::Client.new(schema: schema.graphql_schema, execute: http).tap do |client|
-        client.allow_dynamic_queries = @options.key?(:allow_dynamic_queries) ? options[:allow_dynamic_queries] : true
-      end
-    end
-
-    def errors_in_result?(response)
-      response.data && response.data.errors && response.data.errors.all.any?
-    end
-  end
-end
+module Graphlient
+  class Client
+    attr_accessor :uri, :options
+
+    class InvalidConfigurationError < StandardError; end
+
+    def initialize(url, options = {}, &_block)
+      @url = url
+      @options = options.dup
+      raise_error_if_invalid_configuration!
+      yield self if block_given?
+    end
+
+    def parse(query_str = nil, &block)
+      query_str ||= Graphlient::Query.new do
+        instance_eval(&block)
+      end
+      client.parse(query_str.to_s)
+    rescue GraphQL::Client::Error => e
+      raise Graphlient::Errors::ClientError, e.message
+    end
+
+    def to_query_string(**_kargs, &block)
+      Graphlient::Query.new do
+        instance_eval(&block)
+      end.to_s
+    end
+
+    def execute(query, variables = nil)
+      query_params = {}
+      query_params[:context] = @options if @options
+      query_params[:variables] = variables if variables
+      query = client.parse(query) if query.is_a?(String)
+      rc = client.query(query, **query_params)
+      raise Graphlient::Errors::GraphQLError, rc if rc.errors.any?
+      # see https://github.com/github-community-projects/graphql-client/pull/132
+      # see https://github.com/exAspArk/graphql-errors/issues/2
+      raise Graphlient::Errors::ExecutionError, rc if errors_in_result?(rc)
+
+      rc
+    rescue GraphQL::Client::Error => e
+      raise Graphlient::Errors::ClientError, e.message
+    end
+
+    def query(query_or_variables = nil, variables = nil, &block)
+      if block_given?
+        execute(parse(&block), query_or_variables)
+      else
+        execute(query_or_variables, variables)
+      end
+    end
+
+    def http_adapter_class
+      options[:http] || Adapters::HTTP::FaradayAdapter
+    end
+
+    def http(&block)
+      adapter_options = { headers: @options[:headers], http_options: @options[:http_options] }
+
+      @http ||= http_adapter_class.new(@url, adapter_options, &block)
+    end
+
+    # Register a custom scalar type for use in variable declarations.
+    # Call inside the client initialiser block:
+    #   client = Graphlient::Client.new(url) do |c|
+    #     c.scalar :date,    'Date'
+    #     c.scalar :uuid,    'UUID'
+    #     c.scalar :decimal, 'Decimal'
+    #   end
+    def scalar(sym, graphql_type)
+      Query.scalar(sym, graphql_type)
+    end
+
+    def schema
+      @schema ||= options[:schema] || Graphlient::Schema.new(http, schema_path)
+    end
+
+    private
+
+    def raise_error_if_invalid_configuration!
+      raise InvalidConfigurationError, 'schema_path and schema cannot both be provided' if options.key?(:schema_path) && options.key?(:schema)
+    end
+
+    def schema_path
+      options[:schema_path].to_s if options[:schema_path]
+    end
+
+    def client
+      @client ||= GraphQL::Client.new(schema: schema.graphql_schema, execute: http).tap do |client|
+        client.allow_dynamic_queries = @options.key?(:allow_dynamic_queries) ? options[:allow_dynamic_queries] : true
+      end
+    end
+
+    def errors_in_result?(response)
+      response.data && response.data.errors && response.data.errors.all.any?
+    end
+  end
+end

data/lib/graphlient/errors/client_error.rb

@@ -1,6 +1,6 @@
-module Graphlient
-  module Errors
-    class ClientError < Error
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class ClientError < Error
+    end
+  end
+end

data/lib/graphlient/errors/connection_failed_error.rb

@@ -1,6 +1,6 @@
-module Graphlient
-  module Errors
-    class ConnectionFailedError < ServerError
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class ConnectionFailedError < ServerError
+    end
+  end
+end

data/lib/graphlient/errors/error.rb

@@ -1,12 +1,13 @@
-module Graphlient
-  module Errors
-    class Error < StandardError
-      attr_reader :inner_exception
-      def initialize(message, inner_exception = nil)
-        super(message)
-
-        @inner_exception = inner_exception
-      end
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class Error < StandardError
+      attr_reader :inner_exception
+
+      def initialize(message, inner_exception = nil)
+        super(message)
+
+        @inner_exception = inner_exception
+      end
+    end
+  end
+end

data/lib/graphlient/errors/execution_error.rb

@@ -1,29 +1,29 @@
-module Graphlient
-  module Errors
-    class ExecutionError < Error
-      attr_reader :response
-
-      def initialize(response)
-        super('the server responded with a GraphQL execution error')
-        @response = response
-      end
-
-      def errors
-        response.data.errors
-      end
-
-      def to_s
-        errors.details.map do |key, details|
-          details = create_details(details).join("\n")
-          [key, details].compact.join(': ')
-        end.join("\n")
-      end
-
-      private
-
-      def create_details(details)
-        details.map { |detail| detail['message'] }
-      end
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class ExecutionError < Error
+      attr_reader :response
+
+      def initialize(response)
+        super('the server responded with a GraphQL execution error')
+        @response = response
+      end
+
+      def errors
+        response.data.errors
+      end
+
+      def to_s
+        errors.details.map do |key, details|
+          details = create_details(details).join("\n")
+          [key, details].compact.join(': ')
+        end.join("\n")
+      end
+
+      private
+
+      def create_details(details)
+        details.map { |detail| detail['message'] }
+      end
+    end
+  end
+end

data/lib/graphlient/errors/faraday_server_error.rb

@@ -1,12 +1,12 @@
-module Graphlient
-  module Errors
-    class FaradayServerError < ServerError
-      def initialize(inner_exception)
-        super(inner_exception.message, inner_exception)
-        @inner_exception = inner_exception
-        @response = inner_exception.response[:body]
-        @status_code = inner_exception.response[:status]
-      end
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class FaradayServerError < ServerError
+      def initialize(inner_exception)
+        super(inner_exception.message, inner_exception)
+        @inner_exception = inner_exception
+        @response = inner_exception.response[:body]
+        @status_code = inner_exception.response[:status]
+      end
+    end
+  end
+end

data/lib/graphlient/errors/graphql_error.rb

@@ -1,52 +1,53 @@
-module Graphlient
-  module Errors
-    class GraphQLError < Error
-      attr_reader :response
-      def initialize(response)
-        super('the server responded with a GraphQL error')
-        @response = response
-      end
-
-      def errors
-        @response.errors
-      end
-
-      def to_s
-        errors.details.map do |key, details|
-          details = create_details(details).join("\n")
-          [key == 'data' ? nil : key, details].compact.join(': ')
-        end.join("\n")
-      end
-
-      private
-
-      def create_details(details)
-        details.map { |detail| create_detail(detail) }
-      end
-
-      ##
-      # Generates human readable error explanation from a GraphQL error message
-      # It first tries `problem` attribute of the error response
-      # then checks for error root level `path` and tries to generate error from that
-      # and if none exist, it fallbacks to just return error message
-      def create_detail(detail)
-        if detail.key?('problems')
-          [detail['message'], create_problems(detail['problems']).compact.join("\n  ")].join("\n  ")
-        elsif detail.key?('path')
-          [detail['path'].compact.join(' '), detail['message']].join(': ')
-        else
-          detail['message']
-        end
-      end
-
-      def create_problems(problems)
-        problems.map { |problem| create_problem(problem) }
-      end
-
-      def create_problem(problem)
-        paths = problem.key?('path') && !problem['path'].empty? ? "#{problem['path'].join(', ')}: " : ''
-        [paths, problem['explanation']].compact.join
-      end
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class GraphQLError < Error
+      attr_reader :response
+
+      def initialize(response)
+        super('the server responded with a GraphQL error')
+        @response = response
+      end
+
+      def errors
+        @response.errors
+      end
+
+      def to_s
+        errors.details.map do |key, details|
+          details = create_details(details).join("\n")
+          [key == 'data' ? nil : key, details].compact.join(': ')
+        end.join("\n")
+      end
+
+      private
+
+      def create_details(details)
+        details.map { |detail| create_detail(detail) }
+      end
+
+      ##
+      # Generates human readable error explanation from a GraphQL error message
+      # It first tries `problem` attribute of the error response
+      # then checks for error root level `path` and tries to generate error from that
+      # and if none exist, it fallbacks to just return error message
+      def create_detail(detail)
+        if detail.key?('problems')
+          [detail['message'], create_problems(detail['problems']).compact.join("\n  ")].join("\n  ")
+        elsif detail.key?('path')
+          [detail['path'].compact.join(' '), detail['message']].join(': ')
+        else
+          detail['message']
+        end
+      end
+
+      def create_problems(problems)
+        problems.map { |problem| create_problem(problem) }
+      end
+
+      def create_problem(problem)
+        paths = problem.key?('path') && !problem['path'].empty? ? "#{problem['path'].join(', ')}: " : ''
+        [paths, problem['explanation']].compact.join
+      end
+    end
+  end
+end

data/lib/graphlient/errors/http_options_error.rb

@@ -1,6 +1,6 @@
-module Graphlient
-  module Errors
-    class HttpOptionsError < Error
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class HttpOptionsError < Error
+    end
+  end
+end

data/lib/graphlient/errors/http_server_error.rb

@@ -1,13 +1,13 @@
-module Graphlient
-  module Errors
-    class HttpServerError < Error
-      attr_reader :status_code, :response
-
-      def initialize(message, response)
-        super(message, response)
-        @status_code = response.code
-        @response = response.body
-      end
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class HttpServerError < Error
+      attr_reader :status_code, :response
+
+      def initialize(message, response)
+        super(message, response)
+        @status_code = response.code
+        @response = response.body
+      end
+    end
+  end
+end

data/lib/graphlient/errors/server_error.rb

@@ -1,7 +1,7 @@
-module Graphlient
-  module Errors
-    class ServerError < Error
-      attr_reader :status_code, :response
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class ServerError < Error
+      attr_reader :status_code, :response
+    end
+  end
+end

data/lib/graphlient/errors/timeout_error.rb

@@ -1,6 +1,6 @@
-module Graphlient
-  module Errors
-    class TimeoutError < Error
-    end
-  end
-end
+module Graphlient
+  module Errors
+    class TimeoutError < Error
+    end
+  end
+end

data/lib/graphlient/errors.rb

@@ -1,10 +1,10 @@
-require_relative 'errors/error'
-require_relative 'errors/client_error'
-require_relative 'errors/server_error'
-require_relative 'errors/graphql_error'
-require_relative 'errors/execution_error'
-require_relative 'errors/faraday_server_error'
-require_relative 'errors/http_options_error'
-require_relative 'errors/http_server_error'
-require_relative 'errors/connection_failed_error'
-require_relative 'errors/timeout_error'
+require_relative 'errors/error'
+require_relative 'errors/client_error'
+require_relative 'errors/server_error'
+require_relative 'errors/graphql_error'
+require_relative 'errors/execution_error'
+require_relative 'errors/faraday_server_error'
+require_relative 'errors/http_options_error'
+require_relative 'errors/http_server_error'
+require_relative 'errors/connection_failed_error'
+require_relative 'errors/timeout_error'

data/lib/graphlient/extensions/query.rb

@@ -1,15 +1,15 @@
-module Graphlient
-  module Extensions
-    module Query
-      def method_missing(method_name, *args, &block)
-        Graphlient::Query.new do
-          send(method_name, *args, &block)
-        end
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        super
-      end
-    end
-  end
-end
+module Graphlient
+  module Extensions
+    module Query
+      def method_missing(method_name, *args, &block)
+        Graphlient::Query.new do
+          send(method_name, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+    end
+  end
+end

data/lib/graphlient/extensions.rb

@@ -1 +1 @@
-require_relative 'extensions/query'
+require_relative 'extensions/query'

data/lib/graphlient/query/directive.rb

@@ -0,0 +1,47 @@
+module Graphlient
+  class Query
+    # Value object returned by `_directive_name(args)` in the DSL.
+    #
+    # Rather than writing directly to the query string (which would produce
+    # the wrong position -- before the field name), _skip / _include etc.
+    # return a Directive instance.  append_node / spread / on detect Directive
+    # objects in their argument list and place them AFTER the field name,
+    # producing correct GraphQL output:
+    #
+    #   feeInCents _skip(if: :skip_fee)
+    #   -> feeInCents @skip(if: $skip_fee)
+    #
+    #   spread :InvoiceFields, _skip(if: :x)
+    #   -> ...InvoiceFields @skip(if: $x)
+    #
+    #   spread(_skip(if: :x), on: :DraftInvoice) { draft_id }
+    #   -> ... on DraftInvoice @skip(if: $x) { draftId }
+    class Directive
+      attr_reader :name, :args
+
+      def initialize(name, args = {})
+        @name = name.to_s.delete_prefix('_').freeze
+        @args = args
+      end
+
+      def to_s
+        return "@#{name}" if args.empty?
+
+        formatted = args.map { |k, v| "#{k}: #{format_value(v)}" }.join(', ')
+        "@#{name}(#{formatted})"
+      end
+
+      private
+
+      # Symbols become variable references ($name); everything else is literal.
+      def format_value(value)
+        case value
+        when Symbol                  then "$#{value}"
+        when String                  then "\"#{value}\""
+        when Numeric, TrueClass, FalseClass then value.to_s
+        else value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/graphlient/query/serializer/arguments.rb

@@ -0,0 +1,67 @@
+module Graphlient
+  class Query
+    class Serializer
+      module Arguments
+        private
+
+        def variable_processor
+          @variable_processor ||= ->(k, v) { "$#{k}: #{variable_string(v)}" }
+        end
+
+        # Translate a DSL variable type symbol to its GraphQL type string.
+        # :id/:id! -> ID/ID!   :int -> Int   :date -> Date (if registered)   [:int] -> [Int]
+        def variable_string(val)
+          case val
+          when :id, :id!
+            val.to_s.upcase
+          when ->(v) { scalar?(v) }
+            scalar_type(val)
+          when Array
+            "[#{variable_string(val.first)}]"
+          else
+            val.to_s
+          end
+        end
+
+        # Separate Directive objects from regular field arguments.
+        def field_args(args)
+          args.reject { |a| a.is_a?(Directive) }
+        end
+
+        def directive_args(args)
+          args.select { |a| a.is_a?(Directive) }
+        end
+
+        def hash_arg(args)
+          args.detect { |arg| arg.is_a?(Hash) }
+        end
+
+        def args_str(hash_args, arg_processor: nil)
+          hash_args.map do |k, v|
+            arg_processor ? arg_processor.call(k, v) : argument_string(k, v)
+          end.join(', ')
+        end
+
+        def argument_string(key, val)
+          "#{key}: #{argument_value_string(val)}"
+        end
+
+        def argument_value_string(value)
+          case value
+          when String  then "\"#{value}\""
+          when Numeric then value.to_s
+          when Array   then "[#{value.map { |v| argument_value_string(v) }.join(', ')}]"
+          when Hash    then "{ #{value.map { |k, v| "#{k}: #{argument_value_string(v)}" }.join(', ')} }"
+          when Symbol  then symbol_argument_value(value)
+          else
+            value
+          end
+        end
+
+        def symbol_argument_value(value)
+          @variables.respond_to?(:key?) && @variables.key?(value) ? "$#{value}" : value.to_s.camelize(:lower)
+        end
+      end
+    end
+  end
+end