graphql_client 0.3.3

data/lib/graphql_client/query/argument.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      Argument = Struct.new(:value) do
+        def to_query
+          case value
+          when FalseClass, Float, Integer, NilClass, String, TrueClass
+            generate_query_value(value)
+          when Array
+            "[#{value.map { |v| generate_query_value(v) }.join(', ')}]"
+          when Hash
+            "{ #{value.map { |k, v| "#{k}: #{generate_query_value(v)}" }.join(', ')} }"
+          end
+        end
+
+        private
+
+        def generate_query_value(value)
+          if value.to_s.start_with?('$')
+            value
+          else
+            JSON.generate(value, quirks_mode: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/document.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class Document
+        DEFAULT_OPERATION_NAME = 'default'
+
+        DUPLICATE_OPERATION_NAME = Class.new(StandardError)
+        INVALID_DOCUMENT = Class.new(StandardError)
+        INVALID_FRAGMENT_TARGET = Class.new(StandardError)
+
+        attr_reader :fragments, :operations, :schema
+
+        def initialize(schema)
+          @schema = schema
+          @fragments = {}
+          @operations = {}
+
+          yield self if block_given?
+        end
+
+        def add_mutation(name = nil, &block)
+          add_operation(MutationOperation, name, &block)
+        end
+
+        def add_query(name = nil, &block)
+          add_operation(QueryOperation, name, &block)
+        end
+
+        def define_fragment(name, on:)
+          type = schema.type(on)
+
+          unless type.object? || type.interface? || type.union?
+            raise INVALID_FRAGMENT_TARGET, "invalid target type (#{type.kind}) for fragment #{name}"
+          end
+
+          fragment = Fragment.new(name, type, document: self)
+          @fragments[name] = fragment
+
+          if block_given?
+            yield fragment
+          else
+            fragment
+          end
+        end
+
+        def fragment_definitions
+          fragments.values.map(&:to_definition).join("\n")
+        end
+
+        def to_query
+          ''.dup.tap do |query_string|
+            query_string << "#{fragment_definitions}\n" unless fragments.empty?
+            query_string << operations.values.map(&:to_query).join("\n")
+          end
+        end
+
+        alias_method :to_s, :to_query
+
+        private
+
+        def add_operation(operation_type, name)
+          if operations.key?(DEFAULT_OPERATION_NAME)
+            raise INVALID_DOCUMENT, 'a document with multiple operations must have named operations'
+          end
+
+          operation = operation_type.new(self, name: name)
+          operation_name = operation.name || DEFAULT_OPERATION_NAME
+
+          if operations.key?(operation_name)
+            raise DUPLICATE_OPERATION_NAME, "an operation named #{operation_name} already exists in the document"
+          end
+
+          @operations[operation_name] = operation
+
+          if block_given?
+            yield operation
+          else
+            operation
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/field.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class Field
+        include AddInlineFragment
+        include HasSelectionSet
+
+        INVALID_ARGUMENTS = Class.new(StandardError)
+
+        attr_reader :arguments, :as, :document, :field_defn
+
+        def initialize(field_defn, document:, arguments: {}, as: nil)
+          @field_defn = field_defn
+          @document = document
+          @arguments = validate_arguments(arguments)
+          @as = as
+          @selection_set = SelectionSet.new
+        end
+
+        def add_arguments(**arguments)
+          new_arguments = validate_arguments(arguments)
+          @arguments.merge!(new_arguments)
+        end
+
+        def aliased?
+          name != field_defn.name
+        end
+
+        def arguments=(arguments)
+          @arguments = validate_arguments(arguments)
+        end
+
+        def connection?
+          resolver_type.name.to_s.end_with?('Connection')
+        end
+
+        def name
+          as || field_defn.name
+        end
+
+        def node?
+          field_defn.name == 'Node' || (resolver_type.object? && resolver_type.implement?('Node'))
+        end
+
+        def resolver_type
+          @resolver_type ||= schema.type(field_defn.type.unwrap.name)
+        end
+
+        def schema
+          document.schema
+        end
+
+        def to_query(indent: '')
+          indent.dup.tap do |query_string|
+            query_string << "#{as}: " if aliased?
+            query_string << field_defn.name
+            query_string << "(#{arguments_string.join(', ')})" if arguments.any?
+
+            unless selection_set.empty?
+              query_string << " {\n"
+              query_string << selection_set.to_query(indent)
+              query_string << "\n#{indent}}"
+            end
+          end
+        end
+
+        alias_method :to_s, :to_query
+
+        private
+
+        def arguments_string
+          arguments.map do |name, value|
+            "#{name}: #{value.to_query}"
+          end
+        end
+
+        def validate_arguments(arguments)
+          arguments.each_with_object({}) do |(arg_name, value), hash|
+            if field_defn.args.any? { |arg| arg.name == arg_name.to_s }
+              hash[arg_name] = value.is_a?(Argument) ? value : Argument.new(value)
+            else
+              raise INVALID_ARGUMENTS, "#{arg_name} is not a valid arg for #{name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/fragment.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class Fragment
+        include AddInlineFragment
+        include HasSelectionSet
+
+        attr_reader :document, :name, :type
+
+        def initialize(name, type, document:)
+          @name = name
+          @type = type
+          @document = document
+          @selection_set = SelectionSet.new
+
+          yield self if block_given?
+        end
+
+        def resolver_type
+          type
+        end
+
+        def to_definition(indent: '')
+          indent.dup.tap do |query_string|
+            query_string << "fragment #{name} on #{type.name} {\n"
+            query_string << selection_set.to_query(indent)
+            query_string << "\n#{indent}}\n"
+          end
+        end
+
+        def to_query(indent: '')
+          "#{indent}...#{name}"
+        end
+
+        alias_method :to_s, :to_query
+      end
+    end
+  end
+end

data/lib/graphql_client/query/has_selection_set.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      module HasSelectionSet
+        ID_FIELD_NAME = 'id'
+        INVALID_FIELD = Class.new(StandardError)
+        UNDEFINED_FRAGMENT = Class.new(StandardError)
+
+        attr_accessor :selection_set
+
+        def add_connection(connection_name, as: nil, **arguments)
+          node_field = nil
+
+          add_field(connection_name, as: as, **arguments) do |connection|
+            connection.add_field('edges') do |edges|
+              edges.add_field('cursor')
+              edges.add_field('node') do |node|
+                node_field = node
+                yield node
+              end
+            end
+
+            connection.add_field('pageInfo') do |page_info|
+              page_info.add_field('hasPreviousPage')
+              page_info.add_field('hasNextPage')
+            end
+          end
+
+          node_field
+        end
+
+        def add_field(field_name, as: nil, **arguments)
+          field_defn = resolve(field_name)
+          field = Field.new(field_defn, arguments: arguments, as: as, document: document)
+          selection_set.add_field(field)
+
+          field.add_field(ID_FIELD_NAME) if field.node?
+
+          if block_given?
+            yield field
+          else
+            field
+          end
+        end
+
+        def add_fields(*field_names)
+          field_names.each do |field_name|
+            add_field(field_name)
+          end
+        end
+
+        def add_fragment(fragment_name)
+          fragment = document.fragments.fetch(fragment_name) do
+            raise UNDEFINED_FRAGMENT, "a fragment named #{fragment_name} has not been defined"
+          end
+
+          selection_set.add_fragment(fragment)
+        end
+
+        private
+
+        def resolve(field_name)
+          resolver_type.field(field_name) do
+            raise INVALID_FIELD, "#{field_name} is not a valid field for #{resolver_type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/inline_fragment.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class InlineFragment
+        include HasSelectionSet
+
+        attr_reader :document, :type
+
+        def initialize(type, document:)
+          @type = type
+          @document = document
+          @selection_set = SelectionSet.new
+
+          yield self if block_given?
+        end
+
+        def resolver_type
+          type
+        end
+
+        def to_query(indent: '')
+          indent.dup.tap do |query_string|
+            query_string << "... on #{type.name} {\n"
+            query_string << selection_set.to_query(indent)
+            query_string << "\n#{indent}}"
+          end
+        end
+
+        alias_method :to_s, :to_query
+      end
+    end
+  end
+end

data/lib/graphql_client/query/mutation_document.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class MutationDocument
+        def self.new(schema, name = nil)
+          document = Document.new(schema)
+          mutation = document.add_mutation(name)
+
+          if block_given?
+            yield mutation
+          end
+
+          mutation
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/operation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class Operation
+        include HasSelectionSet
+
+        attr_reader :document, :name, :selection_set, :variables
+
+        def initialize(document, name: nil, variables: {})
+          @document = document
+          @name = name
+          @selection_set = SelectionSet.new
+          @variables = variables
+
+          yield self if block_given?
+        end
+
+        def schema
+          document.schema
+        end
+
+        def to_query
+          operation_type.dup.tap do |query_string|
+            query_string << " #{name}" if name
+            query_string << "(#{variables_string.join(', ')})" if variables.any?
+            query_string << " {\n"
+            query_string << selection_set.to_query
+            query_string << "\n}\n"
+          end
+        end
+
+        alias_method :to_s, :to_query
+
+        private
+
+        def variables_string
+          variables.map do |name, type|
+            "$#{name}: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_client/query/operations/mutation_operation.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Client
+    module Query
+      class MutationOperation < Operation
+        def operation_type
+          'mutation'
+        end
+
+        def resolver_type
+          schema.type(schema.mutation_root_name)
+        end
+      end
+    end
+  end
+end