graphql-dsl 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'graphql_dsl'
+require 'bundler/gem_tasks'
+
+Rake.add_rakelib 'tasks/readme'

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'graphql_dsl'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle config set --local path 'vendor/bundle'
+bundle install

data/graphql-dsl.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'lib/graphql/dsl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'graphql-dsl'
+  spec.version       = GraphQL::DSL::VERSION
+  spec.authors       = ['Maxim Dobryakov']
+  spec.email         = ['maxim.dobryakov@gmail.com']
+
+  spec.summary       = 'GraphQL DSL'
+  spec.description   = 'Ruby DSL for GraphQL'
+  spec.homepage      = 'https://github.com/maxd/graphql-dsl'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
+  # spec.metadata['allowed_push_host'] = "Set to 'http://mygemserver.com'"
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/maxd/graphql-dsl'
+  spec.metadata['changelog_uri'] = 'https://github.com/maxd/graphql-dsl/releases'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.10'
+  spec.add_development_dependency 'rubocop', '~> 1.18'
+  spec.add_development_dependency 'rubocop-rake', '~> 0.6'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.4'
+  spec.add_development_dependency 'yard', '~> 0.9'
+end

data/lib/graphql/dsl/constants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    ##
+    # Help to mark default parameter as undefined
+    UNDEFINED = Object.new
+  end
+end

data/lib/graphql/dsl/error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    ##
+    # GraphQL DSL error
+    class Error < StandardError
+      ##
+      # @return [Hash] additional error arguments
+      attr_reader :arguments
+
+      ##
+      # Create GraphQL error
+      #
+      # @param msg [String] error message
+      # @param arguments [Hash] additional error arguments
+      def initialize(msg = nil, **arguments)
+        super(msg)
+
+        @arguments = arguments
+      end
+
+      ##
+      # Error message
+      #
+      # @return [String] error message
+      def message
+        super + (arguments ? "\nArguments: #{arguments}" : '')
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/arguments.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format arguments as string
+      #
+      # @param arguments [Hash] arguments
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of arguments as string
+      def format_arguments(arguments, is_const)
+        return nil if arguments.empty?
+
+        result = arguments.map do |name, value|
+          "#{name}: #{format_value(value, is_const)}"
+        end
+
+        "(#{result.join(', ')})"
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/directives.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format directives to string
+      #
+      # @param directives [Array] directives
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of directives as string
+      def format_directives(directives, is_const)
+        return nil if directives.empty?
+
+        result = directives.map do |directive|
+          format_directive(directive, is_const)
+        end
+
+        result.join(' ')
+      end
+
+      ##
+      # Format directive to string
+      #
+      # @param directive [] directive
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of directive as string
+      def format_directive(directive, is_const)
+        result = []
+
+        result << format_directive_name(directive.name)
+        result << format_arguments(directive.arguments, is_const) unless directive.arguments.empty?
+
+        result.compact.join
+      end
+
+      ##
+      # Format directive name to string
+      #
+      # @param name [String] directive name
+      #
+      # @return [String] representation of directive name as string
+      def format_directive_name(name)
+        name.start_with?('@') ? name.to_s : "@#{name}"
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/executable_document.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format executable document as string
+      #
+      # @param executable_document [ExecutableDocument] executable document node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of executable document as string
+      def format_executable_document(executable_document, level)
+        result = []
+        result += executable_document.__nodes.map { |node| format_node(node, level) }
+        result.join("\n\n")
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/field.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format field as string
+      #
+      # @param field [Field] field node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of field as string
+      def format_field(field, level)
+        result = []
+        result << indent(level) + format_field_signature(field)
+
+        unless field.__nodes.empty?
+          result << "#{indent(level)}{"
+          result += field.__nodes.map { |node| format_node(node, level + 1) }
+          result << "#{indent(level)}}"
+        end
+
+        result.join("\n")
+      end
+
+      ##
+      # Format field signature as string
+      #
+      # @param field [Field] field node
+      #
+      # @return [String] representation of field signature as string
+      def format_field_signature(field)
+        field_alias = field.__alias ? "#{field.__alias}: " : ''
+        field_name = field.__name.to_s
+        field_arguments = field.__arguments.empty? ? '' : format_arguments(field.__arguments, false)
+        field_directives = field.__directives.empty? ? '' : " #{format_directives(field.__directives, false)}"
+
+        [
+          field_alias,
+          field_name,
+          field_arguments,
+          field_directives,
+        ].join
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/formatter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    ##
+    # Format nodes to GraphQL
+    class Formatter
+      ##
+      # Format node to GraphQL
+      #
+      # @param node [Node] node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of node as GraphQL string
+      def format_node(node, level)
+        case node
+        when ExecutableDocument then format_executable_document(node, level)
+        when Operation then format_operation(node, level)
+        when FragmentOperation then format_fragment_operation(node, level)
+        when Field then format_field(node, level)
+        when FragmentSpread then format_fragment_spread(node, level)
+        when InlineFragment then format_inline_fragment(node, level)
+        else
+          raise Error.new('Unknown node', class: node.class.name, node: node)
+        end
+      end
+
+      private
+
+      ##
+      # Generate indent for formatting
+      #
+      # @param level [Integer] indent level
+      #
+      # @return [String] string for indent
+      def indent(level)
+        '  ' * level
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/fragment_operation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format fragment operation as string
+      #
+      # @param fragment_operation [FragmentOperation] fragment operation node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of fragment operation as string
+      def format_fragment_operation(fragment_operation, level)
+        result = []
+
+        result << indent(level) + format_fragment_operation_signature(fragment_operation)
+        result << "#{indent(level)}{"
+        result += fragment_operation.__nodes.map { |node| format_node(node, level + 1) }
+        result << "#{indent(level)}}"
+
+        result.join("\n")
+      end
+
+      ##
+      # Format fragment operation signature as string
+      #
+      # @param fragment_operator [FragmentOperation] fragment operation node
+      #
+      # @return [String] representation of fragment operation signature as string
+      def format_fragment_operation_signature(fragment_operator)
+        [
+          "fragment #{fragment_operator.__name}",
+          "on #{fragment_operator.__type}",
+          format_directives(fragment_operator.__directives, false),
+        ].compact.join(' ')
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/fragment_spread.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format fragment spread as string
+      #
+      # @param fragment_spread [FragmentSpread] fragment spread node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of fragment spread as string
+      def format_fragment_spread(fragment_spread, level)
+        fragment_spread_signature = [
+          fragment_spread.__name,
+          format_directives(fragment_spread.__directives, false),
+        ].compact.join(' ')
+
+        indent(level) + "...#{fragment_spread_signature}"
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/inline_fragment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format inline fragment as string
+      #
+      # @param inline_fragment [InlineFragment] inline fragment node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of inline fragment as string
+      def format_inline_fragment(inline_fragment, level)
+        result = []
+        result << indent(level) + format_inline_fragment_signature(inline_fragment)
+
+        unless inline_fragment.__nodes.empty?
+          result << "#{indent(level)}{"
+          result += inline_fragment.__nodes.map { |node| format_node(node, level + 1) }
+          result << "#{indent(level)}}"
+        end
+
+        result.join("\n")
+      end
+
+      ##
+      # Format inline fragment signature as string
+      #
+      # @param inline_fragment [InlineFragment] inline fragment node
+      #
+      # @return [String] representation of inline fragment signature as string
+      def format_inline_fragment_signature(inline_fragment)
+        [
+          '...',
+          (inline_fragment.__type ? "on #{inline_fragment.__type}" : nil),
+          format_directives(inline_fragment.__directives, false),
+        ].compact.join(' ')
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/operation.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format operation as string
+      #
+      # @param operation [FragmentOperation] operation node
+      # @param level [Integer] indent level
+      #
+      # @return [String] representation of operation as string
+      def format_operation(operation, level)
+        result = []
+
+        operation_signature = format_operation_signature(operation)
+
+        result << indent(level) + operation_signature if operation_signature
+        result << "#{indent(level)}{"
+        result += operation.__nodes.map { |node| format_node(node, level + 1) }
+        result << "#{indent(level)}}"
+
+        result.join("\n")
+      end
+
+      ##
+      # Format operation signature
+      #
+      # @return [String, nil] representation of operation signature as string
+      def format_operation_signature(operation)
+        operation_name_and_variables = [
+          operation.__name,
+          format_variable_definitions(operation.__variable_definitions),
+        ].compact
+
+        operation_signature = [
+          format_operation_type(operation),
+          (operation_name_and_variables.join unless operation_name_and_variables.empty?),
+          format_directives(operation.__directives, false),
+        ].compact
+
+        operation_signature.empty? ? nil : operation_signature.join(' ')
+      end
+
+      ##
+      # Format operation type
+      #
+      # @return [String, nil] representation of operation type as string
+      def format_operation_type(operation)
+        return unless operation.__operation_type != :query ||
+                      operation.__name ||
+                      !operation.__variable_definitions.empty?
+
+        operation.__operation_type.to_s
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/values.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format value to string
+      #
+      # @param value [] value
+      # @param is_const [Boolean] allow to use variables or not i.e. value is constant or not
+      #
+      # @return [String] representation of value as string
+      def format_value(value, is_const) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+        case value
+        when Integer
+          format_value_to_integer(value)
+        when Float
+          format_value_to_float(value)
+        when String
+          format_value_to_string(value)
+        when TrueClass, FalseClass
+          format_value_to_boolean(value)
+        when NilClass
+          format_value_to_null(value)
+        when Symbol
+          if value.start_with?('$')
+            format_value_to_variable(value, is_const)
+          else
+            format_value_to_enum(value)
+          end
+        when Array
+          format_value_to_list(value, is_const)
+        when Hash
+          format_value_to_object(value, is_const)
+        else
+          raise Error.new('Unsupported value type', class: value.class.name, value: value)
+        end
+      end
+
+      ##
+      # Format value to integer value
+      #
+      # @param value [Integer] value
+      #
+      # @return [String] representation of value as integer value
+      def format_value_to_integer(value)
+        value.to_s
+      end
+
+      ##
+      # Format value to float value
+      #
+      # @param value [Float] value
+      #
+      # @return [String] representation of value as float value
+      def format_value_to_float(value)
+        value.to_s
+      end
+
+      ##
+      # Format value to string value
+      #
+      # @param value [String] value
+      #
+      # @return [String] representation of value as string value
+      def format_value_to_string(value)
+        value.dump
+      end
+
+      ##
+      # Format value to boolean value
+      #
+      # @param value [TrueClass, FalseClass] value
+      #
+      # @return [String] representation of value as boolean value
+      def format_value_to_boolean(value)
+        value.to_s
+      end
+
+      ##
+      # Format value to null value
+      #
+      # @param _value [NilClass] value
+      #
+      # @return [String] representation of value as null value
+      def format_value_to_null(_value)
+        'null'
+      end
+
+      ##
+      # Format value to variable value
+      #
+      # @param value [Symbol] value
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of value as variable value
+      def format_value_to_variable(value, is_const)
+        raise Error.new('Value must be constant', value: value) if is_const
+
+        value.to_s
+      end
+
+      ##
+      # Format value to enum value
+      #
+      # @param value [Symbol] value
+      #
+      # @return [String] representation of value as enum value
+      def format_value_to_enum(value)
+        value.to_s
+      end
+
+      ##
+      # Format value to list value
+      #
+      # @param value [Array] value
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of value as list value
+      def format_value_to_list(value, is_const)
+        result = value.map do |element|
+          format_value(element, is_const)
+        end.join(', ')
+
+        "[#{result}]"
+      end
+
+      ##
+      # Format value to object value
+      #
+      # @param value [Hash] value
+      # @param is_const [Boolean] allow to use variables or not
+      #
+      # @return [String] representation of value as object value
+      def format_value_to_object(value, is_const)
+        result = value.map do |n, v|
+          "#{n}: #{format_value(v, is_const)}"
+        end.join(', ')
+
+        "{#{result}}"
+      end
+    end
+  end
+end

data/lib/graphql/dsl/formatter/variable_definitions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module DSL
+    class Formatter # rubocop:disable Style/Documentation
+      private
+
+      ##
+      # Format variable definitions to string
+      #
+      # @param variable_definitions [Hash] variable definitions
+      #
+      # @return [String] representation of variable definitions as string
+      def format_variable_definitions(variable_definitions)
+        return nil if variable_definitions.empty?
+
+        result = variable_definitions.map do |variable_name, variable_definition|
+          format_variable_definition(variable_name, variable_definition)
+        end
+
+        "(#{result.join(', ')})"
+      end
+
+      ##
+      # Format variable definition to string
+      #
+      # @param variable_name [Symbol, String] variable name
+      # @param variable_definition [] variable definition
+      #
+      # @return [String] representation of variable definition as string
+      def format_variable_definition(variable_name, variable_definition)
+        result = []
+
+        result << "$#{variable_name}:"
+        result << variable_definition.type
+        result << "= #{format_value(variable_definition.default, true)}" if variable_definition.default != UNDEFINED
+        result << format_directives(variable_definition.directives, true) unless variable_definition.directives.empty?
+
+        result.compact.join(' ')
+      end
+    end
+  end
+end