graphql_rails 0.7.0 → 1.2.1

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/integrations.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # allows to enable various integrations
+  module Integrations
+    def self.enable(*integrations)
+      @enabled_integrations ||= []
+
+      to_be_enabled_integrations = integrations.map(&:to_s) - @enabled_integrations
+
+      to_be_enabled_integrations.each do |integration|
+        require_relative "./integrations/#{integration}"
+        Integrations.const_get(integration.classify).enable
+      end
+
+      @enabled_integrations += to_be_enabled_integrations
+    end
+  end
+end

data/lib/graphql_rails/integrations/lograge.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Integrations
+    # lograge integration
+    #
+    # usage:
+    # add `GraphqlRails::Integrations::Lograge.enable` in your initializers
+    module Lograge
+      require 'lograge'
+
+      # lograge subscriber for graphql_rails controller events
+      class GraphqlActionControllerSubscriber < ::Lograge::LogSubscribers::Base
+        def process_action(event)
+          process_main_event(event)
+        end
+
+        private
+
+        def initial_data(payload)
+          {
+            controller: payload[:controller],
+            action: payload[:action]
+          }
+        end
+      end
+
+      def self.enable
+        return unless active?
+
+        GraphqlActionControllerSubscriber.attach_to :graphql_action_controller
+      end
+
+      def self.active?
+        !defined?(Rails) || Rails.configuration&.lograge&.enabled
+      end
+    end
+  end
+end

data/lib/graphql_rails/integrations/sentry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Integrations
+    # sentry integration
+    module Sentry
+      require 'active_support/concern'
+
+      # controller extension which logs errors to sentry
+      module SentryLogger
+        extend ActiveSupport::Concern
+
+        included do
+          around_action :log_to_sentry
+
+          protected
+
+          def log_to_sentry
+            Raven.context.transaction.pop
+            Raven.context.transaction.push "#{self.class}##{action_name}"
+            yield
+          rescue Exception => error # rubocop:disable Lint/RescueException
+            Raven.capture_exception(error) unless error.is_a?(GraphQL::ExecutionError)
+            raise error
+          end
+        end
+      end
+
+      def self.enable
+        GraphqlRails::Controller.include(SentryLogger)
+      end
+    end
+  end
+end

data/lib/graphql_rails/model.rb

@@ -17,17 +17,39 @@ 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)
+        super
+        subclass.instance_variable_set(:@graphql, graphql.dup)
+        subclass.graphql.instance_variable_set(:@model_class, self)
+        subclass.graphql.instance_variable_set(:@graphql_type, nil)
+      end
+
       def graphql
         @graphql ||= Model::Configuration.new(self)
         yield(@graphql) if block_given?
         @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/add_fields_to_graphql_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Model
+    # Adds graphql attributes as graphql fields to given graphql schema object.
+    class AddFieldsToGraphqlType
+      require 'graphql_rails/concerns/service'
+      require 'graphql_rails/model/call_graphql_model_method'
+
+      include ::GraphqlRails::Service
+
+      def initialize(klass:, attributes:)
+        @klass = klass
+        @attributes = attributes
+      end
+
+      def call
+        attributes.each { |attribute| define_graphql_field(attribute) }
+      end
+
+      private
+
+      attr_reader :attributes, :klass
+
+      def define_graphql_field(attribute) # rubocop:disable Metrics/MethodLength)
+        klass.class_eval do
+          field(*attribute.field_args, **attribute.field_options) do
+            attribute.attributes.values.each do |arg_attribute|
+              argument(*arg_attribute.input_argument_args, **arg_attribute.input_argument_options)
+            end
+          end
+
+          define_method(attribute.field_name) do |**kwargs|
+            CallGraphqlModelMethod.call(
+              model: object,
+              attribute_config: attribute,
+              method_keyword_arguments: kwargs,
+              graphql_context: context
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/build_connection_type.rb

@@ -0,0 +1,52 @@
+# 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
+
+          def total
+            CountItems.call(self)
+          end
+        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,15 +2,15 @@
 
 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)
+        def initialize(graphql_object)
           @graphql_object = graphql_object
         end
 

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

data/lib/graphql_rails/model/build_graphql_input_type.rb

@@ -4,9 +4,9 @@ module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
     class BuildGraphqlInputType
-      def self.call(*args)
-        new(*args).call
-      end
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
 
       def initialize(name:, description: nil, attributes:)
         @name = name
@@ -24,7 +24,11 @@ module GraphqlRails
           description(type_description)
 
           type_attributes.each_value do |type_attribute|
-            argument(*type_attribute.input_argument_args)
+            argument(*type_attribute.input_argument_args, **type_attribute.input_argument_options)
+          end
+
+          def self.inspect
+            "#{GraphQL::Schema::InputObject}(#{graphql_name})"
           end
         end
       end