graphql_rails 0.6.0 → 1.2.0

data/lib/graphql_rails/model/{graphql_input_type_builder.rb → build_graphql_input_type.rb}

@@ -3,7 +3,11 @@
 module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
-    class GraphqlInputTypeBuilder
+    class BuildGraphqlInputType
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
       def initialize(name:, description: nil, attributes:)
         @name = name
         @attributes = attributes
@@ -20,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,10 +1,11 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/attribute'
-require 'graphql_rails/model/graphql_type_builder'
+require 'graphql_rails/attributes'
+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
@@ -16,13 +17,28 @@ module GraphqlRails
         @model_class = model_class
       end
 
-      def attribute(attribute_name, type: nil, **attribute_options)
-        attributes[attribute_name.to_s] = \
-          Attribute.new(
-            attribute_name,
-            type,
-            attribute_options
-          )
+      def initialize_copy(other)
+        super
+        @connection_type = nil
+        @graphql_type = nil
+        @input = other.instance_variable_get(:@input)&.transform_values(&:dup)
+        @attributes = other.instance_variable_get(:@attributes)&.transform_values(&:dup)
+      end
+
+      def attribute(attribute_name, **attribute_options)
+        key = attribute_name.to_s
+
+        attributes[key] ||= Attributes::Attribute.new(attribute_name)
+
+        attributes[key].tap do |attribute|
+          attribute_options.each do |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?
+        end
       end
 
       def input(input_name = nil)
@@ -35,22 +51,21 @@ module GraphqlRails
         end
 
         @input.fetch(name) do
-          raise("GraphQL input with name #{input_name.inspect} is not defined for #{model_class}")
+          raise("GraphQL input with name #{input_name.inspect} is not defined for #{model_class.name}")
         end
       end
 
       def graphql_type
-        @graphql_type ||= GraphqlTypeBuilder.new(
-          name: name, description: description, attributes: attributes
-        ).call
+        @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

data/lib/graphql_rails/model/find_or_build_graphql_type_class.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Model
+    # Initializes class to define graphql type and fields.
+    class FindOrBuildGraphqlTypeClass
+      require 'graphql_rails/concerns/service'
+
+      include ::GraphqlRails::Service
+
+      def initialize(name:, type_name:, description: nil)
+        @name = name
+        @type_name = type_name
+        @description = description
+        @new_class = false
+      end
+
+      def klass
+        @klass ||= Object.const_defined?(type_name) && Object.const_get(type_name) || build_graphql_type_klass
+      end
+
+      def new_class?
+        new_class
+      end
+
+      private
+
+      attr_accessor :new_class
+      attr_reader :name, :type_name, :description
+
+      def build_graphql_type_klass
+        graphql_type_name = name
+        graphql_type_description = description
+
+        graphql_type_klass = Class.new(GraphQL::Schema::Object) do
+          graphql_name(graphql_type_name)
+          description(graphql_type_description)
+        end
+
+        self.new_class = true
+
+        Object.const_set(type_name, graphql_type_klass)
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/input.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/model/graphql_input_type_builder'
+require 'graphql_rails/model/build_graphql_input_type'
 require 'graphql_rails/model/configurable'
 
 module GraphqlRails
@@ -14,19 +14,23 @@ module GraphqlRails
         @input_name_suffix = input_name_suffix
       end
 
+      def initialize_copy(other)
+        super
+        @attributes = other.instance_variable_get(:@attributes)&.transform_values(&:dup)
+      end
+
       def graphql_input_type
-        @graphql_input_type ||= GraphqlInputTypeBuilder.new(
+        @graphql_input_type ||= BuildGraphqlInputType.call(
           name: name, description: description, attributes: attributes
-        ).call
+        )
       end
 
-      def attribute(attribute_name, type: nil, **attribute_options)
-        attributes[attribute_name.to_s] = \
-          InputAttribute.new(
-            attribute_name,
-            type,
-            attribute_options
-          )
+      def attribute(attribute_name, type: nil, enum: nil, **attribute_options)
+        input_type = attribute_type(attribute_name, type: type, enum: enum, **attribute_options)
+
+        attributes[attribute_name.to_s] = Attributes::InputAttribute.new(
+          attribute_name, type: input_type, **attribute_options
+        )
       end
 
       private
@@ -35,10 +39,20 @@ module GraphqlRails
 
       def default_name
         @default_name ||= begin
-          suffix = input_name_suffix ? input_name_suffix.to_s.tableize : ''
+          suffix = input_name_suffix ? input_name_suffix.to_s.camelize : ''
           "#{model_class.name.split('::').last}#{suffix}Input"
         end
       end
+
+      def attribute_type(attribute_name, type:, enum:, description: nil, **_other)
+        return type unless enum
+
+        BuildEnumType.call(
+          "#{name}_#{attribute_name}_enum",
+          allowed_values: enum,
+          description: description
+        )
+      end
     end
   end
 end

data/lib/graphql_rails/query_runner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # executes GraphQL queries and returns json
+  class QueryRunner
+    require 'graphql_rails/router'
+    require 'graphql_rails/concerns/service'
+
+    include ::GraphqlRails::Service
+
+    def initialize(group: nil, params:, schema: nil, router: nil, **schema_options)
+      @group = group
+      @graphql_schema = schema
+      @params = params
+      @schema_options = schema_options
+      @router = router
+    end
+
+    def call
+      graphql_schema.execute(
+        params[:query],
+        variables: variables,
+        operation_name: params[:operationName],
+        **schema_options
+      )
+    end
+
+    private
+
+    attr_reader :schema_options, :params, :group
+
+    def variables
+      ensure_hash(params[:variables])
+    end
+
+    def graphql_schema
+      @graphql_schema ||= router_schema
+    end
+
+    def router
+      @router ||= ::GraphqlRouter
+    end
+
+    def router_schema
+      router.graphql_schema(group)
+    end
+
+    def ensure_hash(ambiguous_param)
+      if ambiguous_param.blank?
+        {}
+      elsif ambiguous_param.is_a?(String)
+        ensure_hash(JSON.parse(ambiguous_param))
+      elsif kind_of_hash?(ambiguous_param)
+        ambiguous_param
+      else
+        raise ArgumentError, "Unexpected parameter: #{ambiguous_param.inspect}"
+      end
+    end
+
+    def kind_of_hash?(object)
+      return true if object.is_a?(Hash)
+
+      defined?(ActionController) &&
+        defined?(ActionController::Parameters) &&
+        object.is_a?(ActionController::Parameters)
+    end
+  end
+end

data/lib/graphql_rails/railtie.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # Used to load rake tasks in RoR app
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'graphql_rails/tasks/schema.rake'
+    end
+  end
+end