graphlient 0.8.0 → 0.9.0

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

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

@@ -0,0 +1,17 @@
+module Graphlient
+  class Query
+    class Serializer
+      module Directives
+        # Matches _skip, _include, _myCustomDirective etc.
+        # Does NOT match ___Fragment (three underscores -- checked first in method_missing).
+        DIRECTIVE_PREFIX = /\A_[a-z]/.freeze
+
+        private
+
+        def directive?(method_name)
+          method_name.to_s.match?(DIRECTIVE_PREFIX)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Graphlient
+  class Query
+    class Serializer
+      module Evaluator
+        private
+
+        def evaluate(&block)
+          @last_block = block || self
+          (@context ||= {})[@last_block] ||= @last_block.binding
+          instance_eval(&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Graphlient
+  class Query
+    class Serializer
+      module Fragments
+        # Pattern for the legacy ___Const::Name triple-underscore convention.
+        FRAGMENT_DEFINITION = /___(?<const>[A-Z][a-zA-Z0-9_]*(?:__[A-Z][a-zA-Z0-9_]*)*)/.freeze
+
+        private
+
+        def fragment?(method_name)
+          method_name.to_s.start_with?('___')
+        end
+
+        def resolve_fragment_constant(value)
+          return nil unless (match = value.to_s.match(FRAGMENT_DEFINITION))
+
+          raw_const = match[:const].gsub('__', '::')
+          @context[@last_block].eval(raw_const).tap do |const|
+            next if const.is_a?(GraphQL::Client::FragmentDefinition)
+
+            msg = "Expected constant #{raw_const} to be GraphQL::Client::FragmentDefinition. Given #{const.class}"
+            raise Graphlient::Errors::Error, msg
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Graphlient
+  class Query
+    class Serializer
+      module Scalars
+        BUILT_IN_SCALAR_TYPES = {
+          int: 'Int',
+          float: 'Float',
+          string: 'String',
+          boolean: 'Boolean'
+        }.freeze
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          # Register a custom scalar type for use in variable declarations.
+          #
+          #   Graphlient::Query::Serializer.scalar(:date, 'Date')
+          #
+          # Typically called via the client configuration block:
+          #   client = Graphlient::Client.new(url) do |c|
+          #     c.scalar :date,    'Date'
+          #     c.scalar :uuid,    'UUID'
+          #     c.scalar :decimal, 'Decimal'
+          #   end
+          #
+          # After registration, use the symbol in variable declarations:
+          #   query(created_after: :date) { ... }  # -> query($createdAfter: Date)
+          def scalar(sym, graphql_type)
+            custom_scalar_types[sym.to_sym] = graphql_type.to_s
+          end
+
+          def custom_scalar_types
+            @custom_scalar_types ||= {}
+          end
+
+          def all_scalar_types
+            BUILT_IN_SCALAR_TYPES.merge(custom_scalar_types)
+          end
+        end
+
+        private
+
+        def scalar?(value)
+          all_scalar_types.key?(value.to_s.delete('!').to_sym)
+        end
+
+        def scalar_type(value)
+          str      = value.to_s
+          base     = str.delete('!')
+          non_null = str.end_with?('!')
+          type     = all_scalar_types[base.to_sym]
+          non_null ? "#{type}!" : type
+        end
+
+        def all_scalar_types
+          self.class.all_scalar_types
+        end
+      end
+    end
+  end
+end

data/lib/graphlient/query/serializer.rb

@@ -0,0 +1,153 @@
+require_relative '../errors/error'
+require_relative 'directive'
+require_relative 'serializer/scalars'
+require_relative 'serializer/arguments'
+require_relative 'serializer/evaluator'
+require_relative 'serializer/fragments'
+require_relative 'serializer/directives'
+
+module Graphlient
+  class Query
+    # Builds a GraphQL query string from a DSL block.
+    # Composed from focused concern modules; Query is a thin public wrapper.
+    class Serializer
+      include Scalars
+      include Arguments
+      include Evaluator
+      include Fragments
+      include Directives
+
+      ROOT_NODES = %w[query mutation subscription].freeze
+
+      ROOT_NODES.each do |root_node|
+        define_method(root_node) do |*args, &block|
+          @variables = args.first || {}
+          append_node(root_node, args, arg_processor: variable_processor, &block)
+        end
+      end
+
+      attr_accessor :query_str
+
+      def initialize(&block)
+        @indents   = 0
+        @query_str = ''
+        @variables = {}
+        @fragments = {}
+        evaluate(&block) if block
+      end
+
+      # Full output: main query string + any inline fragment definitions.
+      def to_s
+        parts = [query_str.strip]
+        parts.concat(@fragments.values) unless @fragments.empty?
+        parts.join("\n\n")
+      end
+
+      # Raised when `spread` is called with neither a fragment name nor `on:`.
+      SPREAD_REQUIRES_NAME_OR_ON =
+        'spread requires a fragment name (`spread :InvoiceFields`) or an inline ' \
+        'type condition (`spread on: :PaidInvoice { ... }`).'.freeze
+      # Raised when a named spread is given a block (a named spread has no selection set).
+      SPREAD_NAME_TAKES_NO_BLOCK =
+        'a named fragment spread takes no block; for an inline fragment use ' \
+        '`spread on: :Type { ... }`.'.freeze
+
+      # Fragment spread OR inline fragment -- one consistent entry point.
+      #
+      # Named fragment spread: ...FragmentName [@directive ...]
+      #   spread :InvoiceFields
+      #   spread :InvoiceFields, _skip(if: :x)          # -> ...InvoiceFields @skip(if: $x)
+      #
+      # Inline fragment / type condition: ... on Type [@directive ...] { fields }
+      #   spread on: :PaidInvoice { amount_paid }       # -> ... on PaidInvoice { amountPaid }
+      #   spread on: :DraftInvoice, _skip(if: :skip) { draft_id }
+      #   spread on: :Invoice                           # bare type condition, no block
+      #
+      # A single verb covers both GraphQL forms; `on:` is the same keyword used by
+      # `fragment(name, on:)`, keeping the DSL consistent (and leaving room for a future
+      # `spread(:X).skip(...)` chaining form without a breaking change).
+      def spread(*args, on: nil, &block)
+        directives = args.select { |a| a.is_a?(Directive) }
+        if on
+          append_inline_fragment(on, directives, &block)
+        else
+          append_named_spread(args, directives, &block)
+        end
+        @query_str << "\n#{indent}"
+      end
+
+      # Inline fragment definition -- collected and appended after the main query.
+      #   fragment(:InvoiceFields, on: :Invoice) { id; fee_in_cents }
+      def fragment(name, on:, &block)
+        body = self.class.new(&block).query_str.strip
+        @fragments[name] = "fragment #{name} on #{on} {\n#{body}\n}"
+      end
+
+      def method_missing(method_name, *args, &block)
+        if fragment?(method_name)
+          append_node("...#{resolve_fragment_constant(method_name)}".to_sym, args, &block)
+        elsif directive?(method_name)
+          Directive.new(method_name, args.first || {})
+        else
+          append_node(method_name, args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        super
+      end
+
+      private
+
+      def indent
+        '  ' * @indents
+      end
+
+      # Inline fragment / type condition: ... on Type [@directive ...] [{ fields }]
+      def append_inline_fragment(type, directives, &block)
+        @query_str << "\n#{indent}... on #{type}"
+        directives.each { |d| @query_str << " #{d}" }
+        return unless block
+
+        @indents += 1
+        @query_str << '{'
+        evaluate(&block)
+        @query_str << '}'
+        @indents -= 1
+      end
+
+      # Named fragment spread: ...FragmentName [@directive ...]
+      def append_named_spread(args, directives, &block)
+        fragment_name = args.find { |a| !a.is_a?(Directive) }
+        raise Graphlient::Errors::Error, SPREAD_REQUIRES_NAME_OR_ON if fragment_name.nil?
+        raise Graphlient::Errors::Error, SPREAD_NAME_TAKES_NO_BLOCK if block
+
+        @query_str << "\n#{indent}...#{fragment_name}"
+        directives.each { |d| @query_str << " #{d}" }
+      end
+
+      def append_node(node, args, arg_processor: nil, &block)
+        regular = field_args(args)
+        dirs    = directive_args(args)
+
+        @query_str << "\n#{indent}#{node}"
+
+        if (h = hash_arg(regular))
+          @query_str << "(#{args_str(h, arg_processor: arg_processor)})"
+        end
+
+        dirs.each { |d| @query_str << " #{d}" }
+
+        if block_given?
+          @indents += 1
+          @query_str << '{'
+          evaluate(&block)
+          @query_str << '}'
+          @indents -= 1
+        end
+
+        @query_str << "\n#{indent}"
+      end
+    end
+  end
+end

data/lib/graphlient/query.rb

@@ -1,128 +1,29 @@
-module Graphlient
-  class Query
-    SCALAR_TYPES = {
-      int: 'Int',
-      float: 'Float',
-      string: 'String',
-      boolean: 'Boolean'
-    }.freeze
-
-    ROOT_NODES = %w[query mutation subscription].freeze
-
-    FRAGMENT_DEFITION = /___(?<const>[A-Z][a-zA-Z0-9_]*(__[A-Z][a-zA-Z0-9_]*)*)/
-
-    attr_accessor :query_str
-
-    def initialize(&block)
-      @indents = 0
-      @query_str = ''
-      @variables = []
-      evaluate(&block)
-    end
-
-    def method_missing(method_name, *args, &block)
-      append_node(method_name, args, &block)
-    end
-
-    ROOT_NODES.each do |root_node|
-      define_method(root_node) do |*args, &block|
-        @variables = args.first unless args.empty?
-        append_node(root_node, args, arg_processor: ->(k, v) { "$#{k}: #{variable_string(v)}" }, &block)
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      super
-    end
-
-    def to_s
-      query_str.strip
-    end
-
-    private
-
-    def evaluate(&block)
-      @last_block = block || self
-      (@context ||= {})[@last_block] ||= @last_block.binding
-      instance_eval(&block)
-    end
-
-    def resolve_fragment_constant(value)
-      return nil unless (match = value.to_s.match(FRAGMENT_DEFITION))
-      raw_const = match[:const].gsub('__', '::')
-      @context[@last_block].eval(raw_const).tap do |const|
-        msg = "Expected constant #{raw_const} to be GraphQL::Client::FragmentDefinition. Given #{const.class}"
-        raise Graphlient::Errors::Error, msg unless const.is_a? GraphQL::Client::FragmentDefinition
-      end
-    end
-
-    def append_node(node, args, arg_processor: nil, &block)
-      node = "...#{resolve_fragment_constant(node)}".to_sym if node.to_s.start_with?('___')
-
-      # add field
-      @query_str << "\n#{indent}#{node}"
-      # add filter
-      hash_arguments = hash_arg(args)
-      @query_str << "(#{args_str(hash_arguments, arg_processor: arg_processor)})" if hash_arguments
-
-      if block_given?
-        @indents += 1
-        @query_str << '{'
-        evaluate(&block)
-        @query_str << '}'
-        @indents -= 1
-      end
-
-      @query_str << "\n#{indent}"
-    end
-
-    def indent
-      '  ' * @indents
-    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 variable_string(val)
-      case val
-      when :id, :id!
-        val.to_s.upcase
-      when ->(v) { SCALAR_TYPES.key?(v.to_s.delete('!').to_sym) }
-        # scalar types
-        val.to_s.camelize
-      when Array
-        "[#{variable_string(val.first)}]"
-      else
-        val.to_s
-      end
-    end
-
-    def argument_value_string(value)
-      case value
-      when String
-        "\"#{value}\""
-      when Numeric
-        value.to_s
-      when Array
-        "[#{value.map { |v| argument_value_string(v) }.join(', ')}]"
-      when Hash
-        "{ #{value.map { |k, v| "#{k}: #{argument_value_string(v)}" }.join(', ')} }"
-      when Symbol
-        @variables.key?(value) ? "$#{value}" : value.to_s.camelize(:lower)
-      else
-        value
-      end
-    end
-  end
-end
+require_relative 'query/serializer'
+
+module Graphlient
+  # Public interface for building GraphQL query strings via a DSL block.
+  # Delegates all string-building work to Query::Serializer.
+  #
+  # Usage:
+  #   Graphlient::Query.new do
+  #     query do
+  #       invoice(id: 10) { id; fee_in_cents }
+  #     end
+  #   end.to_s
+  class Query
+    # Register a custom scalar type for variable declarations.
+    # Delegates to Serializer so client configuration works:
+    #   client = Graphlient::Client.new(url) { |c| c.scalar :date, 'Date' }
+    def self.scalar(sym, graphql_type)
+      Serializer.scalar(sym, graphql_type)
+    end
+
+    def initialize(&block)
+      @serializer = Serializer.new(&block)
+    end
+
+    def to_s
+      @serializer.to_s
+    end
+  end
+end

data/lib/graphlient/schema.rb

@@ -1,26 +1,27 @@
-require 'delegate'
-
-module Graphlient
-  class Schema < SimpleDelegator
-    PATH_ERROR_MESSAGE = 'schema_path is missing. Please add it like this: `Graphlient.new(url, schema_path: YOUR_PATH)`'.freeze
-
-    class MissingConfigurationError < StandardError; end
-
-    alias graphql_schema __getobj__
-
-    attr_reader :http, :path
-
-    def initialize(http, path)
-      schema_source = path || http
-      super(GraphQL::Client.load_schema(schema_source))
-
-      @path = path
-      @http = http
-    end
-
-    def dump!
-      raise MissingConfigurationError, PATH_ERROR_MESSAGE unless path
-      GraphQL::Client.dump_schema(http, path)
-    end
-  end
-end
+require 'delegate'
+
+module Graphlient
+  class Schema < SimpleDelegator
+    PATH_ERROR_MESSAGE = 'schema_path is missing. Please add it like this: `Graphlient.new(url, schema_path: YOUR_PATH)`'.freeze
+
+    class MissingConfigurationError < StandardError; end
+
+    alias graphql_schema __getobj__
+
+    attr_reader :http, :path
+
+    def initialize(http, path)
+      schema_source = path || http
+      super(GraphQL::Client.load_schema(schema_source))
+
+      @path = path
+      @http = http
+    end
+
+    def dump!
+      raise MissingConfigurationError, PATH_ERROR_MESSAGE unless path
+
+      GraphQL::Client.dump_schema(http, path)
+    end
+  end
+end

data/lib/graphlient/version.rb

@@ -1,3 +1,3 @@
-module Graphlient
-  VERSION = '0.8.0'.freeze
-end
+module Graphlient
+  VERSION = '0.9.0'.freeze
+end

data/lib/graphlient.rb

@@ -1,8 +1,8 @@
-require 'graphql/client'
-require 'graphlient/version'
-require 'graphlient/extensions'
-require 'graphlient/errors'
-require 'graphlient/query'
-require 'graphlient/adapters'
-require 'graphlient/client'
-require 'graphlient/schema'
+require 'graphql/client'
+require 'graphlient/version'
+require 'graphlient/extensions'
+require 'graphlient/errors'
+require 'graphlient/query'
+require 'graphlient/adapters'
+require 'graphlient/client'
+require 'graphlient/schema'