graphql_rails 0.8.0 → 1.0.0

data/lib/graphql_rails/controller/log_controller_action.rb

@@ -6,13 +6,13 @@ module GraphqlRails
   class Controller
     # logs controller start and end times
     class LogControllerAction
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
       START_PROCESSING_KEY = 'start_processing.graphql_action_controller'
       PROCESS_ACTION_KEY = 'process_action.graphql_action_controller'
 
-      def self.call(**kwargs, &block)
-        new(**kwargs).call(&block)
-      end
-
       def initialize(controller_name:, action_name:, params:, graphql_request:)
         @controller_name = controller_name
         @action_name = action_name

data/lib/graphql_rails/controller/request.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/errors/execution_error'
-
 module GraphqlRails
   class Controller
     # Contains all info related with single request to controller
     class Request
+      require 'graphql_rails/controller/request/format_errors'
+
       attr_accessor :object_to_return
       attr_reader :errors, :context
 
@@ -16,12 +16,9 @@ module GraphqlRails
       end
 
       def errors=(new_errors)
-        @errors = new_errors
+        @errors = FormatErrors.call(new_errors)
 
-        new_errors.each do |error|
-          error_message = error.is_a?(String) ? error : error.message
-          context.add_error(ExecutionError.new(error_message))
-        end
+        @errors.each { |error| context.add_error(error) }
       end
 
       def no_object_to_return?
@@ -29,12 +26,36 @@ module GraphqlRails
       end
 
       def params
-        inputs.to_h
+        deep_transform_values(inputs.to_h) do |val|
+          graphql_object_to_hash(val)
+        end
       end
 
       private
 
       attr_reader :graphql_object, :inputs
+
+      def graphql_object_to_hash(object)
+        if object.is_a?(GraphQL::Dig)
+          object.to_h
+        elsif object.is_a?(Array)
+          object.map { |item| graphql_object_to_hash(item) }
+        else
+          object
+        end
+      end
+
+      def deep_transform_values(hash, &block)
+        return hash unless hash.is_a?(Hash)
+
+        hash.transform_values do |val|
+          if val.is_a?(Hash)
+            deep_transform_values(val, &block)
+          else
+            yield(val)
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql_rails/controller/request/format_errors.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/concerns/service'
+require 'graphql_rails/errors/execution_error'
+require 'graphql_rails/errors/validation_error'
+require 'graphql_rails/errors/custom_execution_error'
+
+module GraphqlRails
+  class Controller
+    class Request
+      # Converts user provided free-form errors in to meaningfull graphql error classes
+      class FormatErrors
+        include Service
+
+        def initialize(not_formatted_errors)
+          @not_formatted_errors = not_formatted_errors
+        end
+
+        def call
+          if validation_errors?
+            formatted_validation_errors
+          else
+            not_formatted_errors.map { |error| format_error(error) }
+          end
+        end
+
+        private
+
+        attr_reader :not_formatted_errors
+
+        def validation_errors?
+          defined?(ActiveModel) &&
+            defined?(ActiveModel::Errors) &&
+            not_formatted_errors.is_a?(ActiveModel::Errors)
+        end
+
+        def formatted_validation_errors
+          not_formatted_errors.map do |field, message|
+            ValidationError.new(message, field)
+          end
+        end
+
+        def format_error(error)
+          if error.is_a?(String)
+            ExecutionError.new(error)
+          elsif error.is_a?(GraphQL::ExecutionError)
+            error
+          elsif CustomExecutionError.accepts?(error)
+            message = error[:message] || error['message']
+            CustomExecutionError.new(message, error.except(:message, 'message'))
+          elsif error.respond_to?(:message)
+            ExecutionError.new(error.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/decorator/relation_decorator.rb

@@ -37,7 +37,7 @@ module GraphqlRails
       end
 
       def to_a
-        @to_a ||= relation.to_a.map { |it| decorator.new(it) }
+        @to_a ||= relation.to_a.map { |it| decorator.new(it, *decorator_args) }
       end
 
       private

data/lib/graphql_rails/errors/custom_execution_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  class CustomExecutionError < ExecutionError
+    attr_reader :extra_graphql_data
+
+    def self.accepts?(error)
+      error.is_a?(Hash) &&
+        (error.key?(:message) || error.key?('message'))
+    end
+
+    def initialize(message, extra_graphql_data = {})
+      super(message)
+      @extra_graphql_data = extra_graphql_data.stringify_keys
+    end
+
+    def to_h
+      super
+    end
+  end
+end

data/lib/graphql_rails/errors/execution_error.rb

@@ -6,15 +6,14 @@ module GraphqlRails
   # base class which is returned in case something bad happens. Contains all error rendering tructure
   class ExecutionError < GraphQL::ExecutionError
     def to_h
-      super.except('locations').merge('type' => type, 'http_status_code' => http_status_code)
+      super.merge(extra_graphql_data)
     end
 
-    def type
-      'system_error'
-    end
-
-    def http_status_code
-      500
+    def extra_graphql_data
+      {}.tap do |data|
+        data['type'] = type if respond_to?(:type) && type
+        data['code'] = type if respond_to?(:code) && code
+      end
     end
   end
 end

data/lib/graphql_rails/errors/system_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  class SystemError < ExecutionError
+    def to_h
+      super.except('locations')
+    end
+
+    def type
+      'system_error'
+    end
+  end
+end

data/lib/graphql_rails/errors/validation_error.rb

@@ -6,7 +6,7 @@ module GraphqlRails
     attr_reader :short_message, :field
 
     def initialize(short_message, field)
-      super([field.presence, short_message].compact.join(' '))
+      super([field.presence&.to_s&.humanize, short_message].compact.join(' '))
       @short_message = short_message
       @field = field
     end
@@ -15,10 +15,6 @@ module GraphqlRails
       'validation_error'
     end
 
-    def http_status_code
-      422
-    end
-
     def to_h
       super.merge('field' => field, 'short_message' => short_message)
     end

data/lib/graphql_rails/input_configurable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # contains configuration options related with inputs
+  module InputConfigurable
+    def permit(*no_type_attributes, **typed_attributes)
+      no_type_attributes.each { |attribute| permit_input(attribute) }
+      typed_attributes.each { |attribute, type| permit_input(attribute, type: type) }
+      self
+    end
+
+    def permit_input(name, **input_options)
+      field_name = name.to_s.remove(/!\Z/)
+
+      attributes[field_name] = build_input_attribute(name.to_s, **input_options)
+      self
+    end
+
+    def paginated(pagination_options = {})
+      pagination_options = {} if pagination_options == true
+      pagination_options = nil if pagination_options == false
+
+      @pagination_options = pagination_options
+      permit(:before, :after, first: :int, last: :int)
+    end
+
+    def paginated?
+      !pagination_options.nil?
+    end
+
+    def pagination_options
+      @pagination_options
+    end
+
+    def input_attribute_options
+      @input_attribute_options || {}
+    end
+
+    def build_input_attribute(name, options: {}, **other_options)
+      Attributes::InputAttribute.new(
+        name.to_s,
+        options: input_attribute_options.merge(options),
+        **other_options
+      )
+    end
+  end
+end

data/lib/graphql_rails/model.rb

@@ -17,10 +17,6 @@ module GraphqlRails
   #
   # YourModel.new.graphql_type # => type with [:id, :title] attributes
   module Model
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
     # static methods for GraphqlRails::Model
     module ClassMethods
       def inherited(subclass)
@@ -36,5 +32,24 @@ module GraphqlRails
         @graphql
       end
     end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def graphql_context
+      @graphql_context
+    end
+
+    def graphql_context=(value)
+      @graphql_context = value
+    end
+
+    def with_graphql_context(graphql_context)
+      self.graphql_context = graphql_context
+      yield(self)
+    ensure
+      self.graphql_context = nil
+    end
   end
 end

data/lib/graphql_rails/model/build_connection_type.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'graphql'
+require 'graphql_rails/model/build_connection_type/count_items'
+
+module GraphqlRails
+  module Model
+    # builds connection type from graphql type with some extra attributes
+    class BuildConnectionType
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
+      attr_reader :initial_type
+
+      def initialize(initial_type)
+        @initial_type = initial_type
+      end
+
+      def call
+        build_connection_type
+      end
+
+      private
+
+      def build_connection_type
+        edge_type = build_edge_type
+        type = initial_type
+        Class.new(GraphQL::Types::Relay::BaseConnection) do
+          graphql_name("#{type.graphql_name}Connection")
+          edge_type(edge_type)
+
+          field :total, Integer, null: false, resolve: CountItems
+        end
+      end
+
+      def build_edge_type
+        type = initial_type
+
+        Class.new(GraphQL::Types::Relay::BaseEdge) do
+          graphql_name("#{type.graphql_name}Edge")
+
+          node_type(type)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/{configuration → build_connection_type}/count_items.rb

@@ -2,13 +2,13 @@
 
 module GraphqlRails
   module Model
-    class Configuration
+    class BuildConnectionType
       # Used when generating ConnectionType.
       # It handles all the logic which is related with counting total items
       class CountItems
-        def self.call(*args)
-          new(*args).call
-        end
+        require 'graphql_rails/concerns/service'
+
+        include ::GraphqlRails::Service
 
         def initialize(graphql_object, _args, _ctx)
           @graphql_object = graphql_object

data/lib/graphql_rails/model/build_enum_type.rb

@@ -7,9 +7,10 @@ module GraphqlRails
   module Model
     # contains info about single graphql attribute
     class BuildEnumType
-      def self.call(*args)
-        new(*args).call
-      end
+      class InvalidEnum < GraphqlRails::Error; end
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
 
       def initialize(name, allowed_values:, description: nil)
         @name = name
@@ -18,22 +19,50 @@ module GraphqlRails
       end
 
       def call
-        allowed_values = self.allowed_values
-        enum_name = name.to_s.camelize
-        enum_description = description
+        validate
+        build_enum
+      end
+
+      protected
+
+      attr_reader :name, :allowed_values, :description
+
+      def validate
+        return if allowed_values.is_a?(Array) && !allowed_values.empty?
+
+        validate_enum_type
+        validate_enum_content
+      end
+
+      def validate_enum_type
+        return if allowed_values.is_a?(Array)
+
+        raise InvalidEnum, "Enum must be instance of Array, but instance of #{allowed_values.class} was given"
+      end
+
+      def validate_enum_content
+        return unless allowed_values.empty?
+
+        raise InvalidEnum, 'At lest one enum option must be given'
+      end
+
+      def formatted_name
+        name.to_s.camelize
+      end
 
+      def build_enum(allowed_values: self.allowed_values, enum_name: formatted_name, enum_description: description)
         Class.new(GraphQL::Schema::Enum) do
           allowed_values.each do |allowed_value|
             graphql_name(enum_name)
             description(enum_description) if enum_description
             value(allowed_value.to_s.underscore.upcase, value: allowed_value)
           end
+
+          def self.inspect
+            "#{GraphQL::Schema::Enum}(#{graphql_name})"
+          end
         end
       end
-
-      protected
-
-      attr_reader :name, :allowed_values, :description
     end
   end
 end