graphql_rails 0.8.0 → 1.2.2

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/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

data/lib/graphql_rails/model/call_graphql_model_method.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Model
+    # Executes model method and adds additional meta data if needed
+    class CallGraphqlModelMethod
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
+      PAGINATION_KEYS = %i[before after first last].freeze
+
+      def initialize(model:, method_keyword_arguments:, graphql_context:, attribute_config:)
+        @model = model
+        @method_keyword_arguments = method_keyword_arguments
+        @graphql_context = graphql_context
+        @attribute_config = attribute_config
+      end
+
+      def call
+        with_graphql_context do
+          run_method
+        end
+      end
+
+      private
+
+      attr_reader :model, :attribute_config, :graphql_context, :method_keyword_arguments
+
+      def run_method
+        if custom_keyword_arguments.empty?
+          model.send(method_name)
+        else
+          formatted_arguments = formatted_method_input(custom_keyword_arguments)
+          model.send(method_name, **formatted_arguments)
+        end
+      end
+
+      def formatted_method_input(keyword_arguments)
+        keyword_arguments.transform_values do |input_argument|
+          formatted_method_input_argument(input_argument)
+        end
+      end
+
+      def formatted_method_input_argument(argument)
+        return argument.to_h if argument.is_a?(GraphQL::Schema::InputObject)
+
+        argument
+      end
+
+      def method_name
+        attribute_config.property
+      end
+
+      def paginated?
+        attribute_config.paginated?
+      end
+
+      def custom_keyword_arguments
+        return method_keyword_arguments unless paginated?
+
+        method_keyword_arguments.except(*PAGINATION_KEYS)
+      end
+
+      def with_graphql_context
+        return yield unless model.respond_to?(:with_graphql_context)
+
+        model.with_graphql_context(graphql_context) { yield }
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/configurable.rb

@@ -9,11 +9,15 @@ module GraphqlRails
         @attributes ||= {}
       end
 
-      def name(type_name = nil)
-        @name = type_name if type_name
+      def name(graphql_name = nil)
+        @name = graphql_name if graphql_name
         @name || default_name
       end
 
+      def type_name
+        @type_name ||= "#{name.camelize}Type#{SecureRandom.hex}"
+      end
+
       def description(new_description = nil)
         @description = new_description if new_description
         @description

data/lib/graphql_rails/model/configuration.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'graphql_rails/attributes'
-require 'graphql_rails/model/build_graphql_type'
+require 'graphql_rails/model/find_or_build_graphql_type'
 require 'graphql_rails/model/build_enum_type'
 require 'graphql_rails/model/input'
 require 'graphql_rails/model/configurable'
-require 'graphql_rails/model/configuration/count_items'
+require 'graphql_rails/model/build_connection_type'
 
 module GraphqlRails
   module Model
@@ -32,7 +32,9 @@ module GraphqlRails
 
         attributes[key].tap do |attribute|
           attribute_options.each do |method_name, args|
-            attribute.public_send(method_name, args)
+            send_args = [method_name]
+            send_args << args if attribute.method(method_name).parameters.present?
+            attribute.public_send(*send_args)
           end
 
           yield(attribute) if block_given?
@@ -54,17 +56,16 @@ module GraphqlRails
       end
 
       def graphql_type
-        @graphql_type ||= BuildGraphqlType.call(
-          name: name, description: description, attributes: attributes
+        @graphql_type ||= FindOrBuildGraphqlType.call(
+          name: name,
+          description: description,
+          attributes: attributes,
+          type_name: type_name
         )
       end
 
       def connection_type
-        @connection_type ||= begin
-          graphql_type.define_connection do
-            field :total, types.Int, resolve: CountItems
-          end
-        end
+        @connection_type ||= BuildConnectionType.call(graphql_type)
       end
 
       private

data/lib/graphql_rails/model/find_or_build_graphql_type.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Model
+    # stores information about model specific config, like attributes and types
+    class FindOrBuildGraphqlType
+      require 'graphql_rails/concerns/service'
+      require 'graphql_rails/model/find_or_build_graphql_type_class'
+      require 'graphql_rails/model/add_fields_to_graphql_type'
+
+      include ::GraphqlRails::Service
+
+      def initialize(name:, description:, attributes:, type_name:)
+        @name = name
+        @description = description
+        @attributes = attributes
+        @type_name = type_name
+      end
+
+      def call
+        klass.tap { add_fields_to_graphql_type if new_class? }
+      end
+
+      private
+
+      attr_reader :name, :description, :attributes, :type_name
+
+      delegate :klass, :new_class?, to: :type_class_finder
+
+      def type_class_finder
+        @type_class_finder ||= FindOrBuildGraphqlTypeClass.new(
+          name: name,
+          type_name: type_name,
+          description: description
+        )
+      end
+
+      def add_fields_to_graphql_type
+        AddFieldsToGraphqlType.call(klass: klass, attributes: attributes.values.select(&:scalar_type?))
+
+        attributes.values.reject(&:scalar_type?).tap do |dynamic_attributes|
+          find_or_build_dynamic_graphql_types(dynamic_attributes) do |name, description, attributes, type_name|
+            self.class.call(
+              name: name, description: description,
+              attributes: attributes, type_name: type_name
+            )
+          end
+          AddFieldsToGraphqlType.call(klass: klass, attributes: dynamic_attributes)
+        end
+      end
+
+      def find_or_build_dynamic_graphql_types(dynamic_attributes)
+        dynamic_attributes.each do |attribute|
+          yield(
+            attribute.graphql_model.graphql.name,
+            attribute.graphql_model.graphql.description,
+            attribute.graphql_model.graphql.attributes,
+            attribute.graphql_model.graphql.type_name
+          )
+        end
+      end
+    end
+  end
+end