graphql_rails 0.8.0 → 1.0.0

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
@@ -26,6 +26,10 @@ module GraphqlRails
           type_attributes.each_value do |type_attribute|
             argument(*type_attribute.input_argument_args)
           end
+
+          def self.inspect
+            "#{GraphQL::Schema::InputObject}(#{graphql_name})"
+          end
         end
       end
 

data/lib/graphql_rails/model/build_graphql_type.rb

@@ -4,9 +4,12 @@ module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
     class BuildGraphqlType
-      def self.call(*args)
-        new(*args).call
-      end
+      require 'graphql_rails/concerns/service'
+      require 'graphql_rails/model/call_graphql_model_method'
+
+      include ::GraphqlRails::Service
+
+      PAGINATION_KEYS = %i[before after first last].freeze
 
       def initialize(name:, description: nil, attributes:)
         @name = name
@@ -19,19 +22,32 @@ module GraphqlRails
         type_description = description
         type_attributes = attributes
 
-        GraphQL::ObjectType.define do
-          name(type_name)
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name(type_name)
           description(type_description)
 
           type_attributes.each_value do |attribute|
-            field(*attribute.field_args)
+            field(*attribute.field_args) do
+              attribute.attributes.values.each do |arg_attribute|
+                argument(*arg_attribute.input_argument_args)
+              end
+            end
+
+            define_method attribute.property do |**kwargs|
+              CallGraphqlModelMethod.call(
+                model: object,
+                attribute_config: attribute,
+                method_keyword_arguments: kwargs,
+                graphql_context: context
+              )
+            end
           end
         end
       end
 
       private
 
-      attr_reader :model_configuration, :attributes, :name, :description
+      attr_reader :attributes, :name, :description
     end
   end
 end

data/lib/graphql_rails/model/call_graphql_model_method.rb

@@ -0,0 +1,59 @@
+# 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
+          model.send(method_name, **custom_keyword_arguments)
+        end
+      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/configuration.rb

@@ -5,7 +5,7 @@ require 'graphql_rails/model/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
@@ -60,11 +60,7 @@ module GraphqlRails
       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/input.rb

@@ -14,6 +14,11 @@ 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 ||= BuildGraphqlInputType.call(
           name: name, description: description, attributes: attributes
@@ -21,12 +26,11 @@ module GraphqlRails
       end
 
       def attribute(attribute_name, type: nil, enum: nil, **attribute_options)
-        attributes[attribute_name.to_s] = \
-          GraphqlRails::Attributes::InputAttribute.new(
-            attribute_name,
-            attribute_type(attribute_name, type: type, enum: enum, **attribute_options),
-            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

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

data/lib/graphql_rails/router.rb

@@ -11,32 +11,39 @@ module GraphqlRails
   # graphql router that mimics Rails.application.routes
   class Router
     RAW_ACTION_NAMES = %i[
-      rescue_from query_analyzer instrument cursor_encoder default_max_page_size
+      use rescue_from query_analyzer instrument cursor_encoder default_max_page_size
     ].freeze
 
     def self.draw(&block)
-      router = new
-      router.instance_eval(&block)
-      router.graphql_schema
+      new.tap do |router|
+        router.instance_eval(&block)
+      end
     end
 
     attr_reader :routes, :namespace_name, :raw_graphql_actions
 
-    def initialize(module_name: '')
+    def initialize(module_name: '', group_names: [])
       @module_name = module_name
+      @group_names = group_names
       @routes ||= Set.new
       @raw_graphql_actions ||= []
     end
 
+    def group(*group_names, &block)
+      scoped_router = router_with(group_names: group_names)
+      scoped_router.instance_eval(&block)
+      routes.merge(scoped_router.routes)
+    end
+
     def scope(**options, &block)
       full_module_name = [module_name, options[:module]].reject(&:empty?).join('/')
-      scoped_router = self.class.new(module_name: full_module_name)
+      scoped_router = router_with(module_name: full_module_name)
       scoped_router.instance_eval(&block)
       routes.merge(scoped_router.routes)
     end
 
     def resources(name, **options, &block)
-      builder_options = default_route_options.merge(options)
+      builder_options = full_route_options(options)
       routes_builder = ResourceRoutesBuilder.new(name, **builder_options)
       routes_builder.instance_eval(&block) if block
       routes.merge(routes_builder.routes)
@@ -56,25 +63,45 @@ module GraphqlRails
       end
     end
 
-    def graphql_schema
-      SchemaBuilder.new(
+    def graphql_schema(group = nil)
+      @graphql_schema ||= {}
+      @graphql_schema[group&.to_sym] ||= SchemaBuilder.new(
         queries: routes.select(&:query?),
         mutations: routes.select(&:mutation?),
-        raw_actions: raw_graphql_actions
+        raw_actions: raw_graphql_actions,
+        group: group
       ).call
     end
 
+    def reload_schema
+      @graphql_schema = nil
+    end
+
     private
 
-    attr_reader :module_name
+    attr_reader :module_name, :group_names
+
+    def router_with(new_router_options = {})
+      default_options = { module_name: module_name, group_names: group_names }
+      full_options = default_options.merge(new_router_options)
+
+      self.class.new(full_options)
+    end
 
     def add_raw_action(name, *args, &block)
       raw_graphql_actions << { name: name, args: args, block: block }
     end
 
     def build_route(route_builder, name, **options)
-      route_options = default_route_options.merge(options)
-      route_builder.new(name, route_options)
+      route_builder.new(name, full_route_options(options))
+    end
+
+    def full_route_options(extra_options)
+      extra_groups = Array(extra_options[:group]) + Array(extra_options[:groups])
+      extra_options = extra_options.except(:group, :groups)
+      groups = (group_names + extra_groups).uniq
+
+      default_route_options.merge(extra_options).merge(groups: groups)
     end
 
     def default_route_options

data/lib/graphql_rails/router/resource_routes_builder.rb

@@ -70,8 +70,9 @@ module GraphqlRails
         end
 
         action_options = options.merge(custom_options).merge(on: on)
+        controller_method_name = action.to_s.underscore
         action_name = [prefix, resource_name(on), suffix_name].map(&:to_s).reject(&:empty?).join('_')
-        builder.new(action_name, to: "#{name}##{action}", **action_options)
+        builder.new(action_name, to: "#{name}##{controller_method_name}", **action_options)
       end
       # rubocop:enable Metrics/ParameterLists
 

data/lib/graphql_rails/router/route.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../controller/controller_function'
+require_relative '../controller/build_controller_action_resolver'
 
 module GraphqlRails
   class Router
@@ -8,10 +8,11 @@ module GraphqlRails
     class Route
       attr_reader :name, :module_name, :on, :relative_path
 
-      def initialize(name, to: '', on:, **options)
+      def initialize(name, to: '', on:, groups: nil, **options)
         @name = name.to_s.camelize(:lower)
         @module_name = options[:module].to_s
         @function = options[:function]
+        @groups = groups
         @relative_path = to
         @on = on.to_sym
       end
@@ -26,12 +27,30 @@ module GraphqlRails
         on == :collection
       end
 
-      def member?
-        on == :member
+      def show_in_group?(group_name)
+        return true if groups.nil? || groups.empty?
+
+        groups.include?(group_name&.to_sym)
       end
 
-      def function
-        @function ||= Controller::ControllerFunction.from_route(self)
+      def field_args
+        options = {}
+
+        if function
+          options[:function] = function
+        else
+          options[:resolver] = resolver
+        end
+
+        [name, options]
+      end
+
+      private
+
+      attr_reader :function, :groups
+
+      def resolver
+        @resolver ||= Controller::BuildControllerActionResolver.call(route: self)
       end
     end
   end

data/lib/graphql_rails/router/schema_builder.rb

@@ -8,34 +8,49 @@ module GraphqlRails
 
       attr_reader :queries, :mutations, :raw_actions
 
-      def initialize(queries:, mutations:, raw_actions:)
+      def initialize(queries:, mutations:, raw_actions:, group: nil)
         @queries = queries
         @mutations = mutations
         @raw_actions = raw_actions
+        @group = group
       end
 
       def call
-        query_type = build_type('Query', queries)
-        mutation_type = build_type('Mutation', mutations)
+        query_type = build_group_type('Query', queries)
+        mutation_type = build_group_type('Mutation', mutations)
         raw = raw_actions
 
-        GraphQL::Schema.define do
+        Class.new(GraphQL::Schema) do
           cursor_encoder(Router::PlainCursorEncoder)
           raw.each { |action| send(action[:name], *action[:args], &action[:block]) }
 
-          query(query_type)
-          mutation(mutation_type)
+          query(query_type) if query_type
+          mutation(mutation_type) if mutation_type
         end
       end
 
       private
 
-      def build_type(type_name, routes)
-        GraphQL::ObjectType.define do
-          name type_name
+      attr_reader :group
 
-          routes.each do |route|
-            field route.name, function: route.function
+      def build_group_type(type_name, routes)
+        group_name = group
+        group_routes = routes.select { |route| route.show_in_group?(group_name) }
+        return if group_routes.empty?
+
+        build_type(type_name, group_routes)
+      end
+
+      def build_type(type_name, group_routes)
+        Class.new(GraphQL::Schema::Object) do
+          graphql_name(type_name)
+
+          group_routes.each do |route|
+            field(*route.field_args)
+          end
+
+          def self.inspect
+            "#{GraphQL::Schema::Object}(#{graphql_name})"
           end
         end
       end