graphql_rails 1.2.4 → 2.2.0

data/lib/graphql_rails/model/configurable.rb

@@ -2,25 +2,47 @@
 
 module GraphqlRails
   module Model
-    # contains methods which are shared between various configurations
-    # expects `default_name` to be defined
+    # Contains methods which are shared between various configurations.
+    #
+    # Expects `default_name` to be defined.
+    # Expects `build_attribute(attr_name)` method to be defined.
     module Configurable
+      require 'active_support/concern'
+      require 'graphql_rails/concerns/chainable_options'
+
+      extend ActiveSupport::Concern
+
+      included do
+        include GraphqlRails::ChainableOptions
+
+        chainable_option :description
+      end
+
+      def initialize_copy(other)
+        super
+        @type_name = nil
+        @attributes = other.attributes.transform_values(&:dup)
+      end
+
       def attributes
         @attributes ||= {}
       end
 
-      def name(graphql_name = nil)
-        @name = graphql_name if graphql_name
-        @name || default_name
+      def name(*args)
+        get_or_set_chainable_option(:name, *args) || 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
+      def attribute(attribute_name, **attribute_options)
+        key = attribute_name.to_s
+
+        attributes[key] ||= build_attribute(attribute_name).tap do |new_attribute|
+          new_attribute.with(**attribute_options) unless attribute_options.empty?
+          yield(new_attribute) if block_given?
+        end
       end
     end
   end

data/lib/graphql_rails/model/configuration.rb

@@ -2,7 +2,6 @@
 
 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/build_connection_type'
@@ -11,6 +10,7 @@ module GraphqlRails
   module Model
     # stores information about model specific config, like attributes and types
     class Configuration
+      include ChainableOptions
       include Configurable
 
       def initialize(model_class)
@@ -22,22 +22,14 @@ module GraphqlRails
         @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?
+        attributes[key] ||= build_attribute(attribute_name).tap do |new_attribute|
+          new_attribute.with(**attribute_options)
+          yield(new_attribute) if block_given?
         end
       end
 
@@ -80,6 +72,10 @@ module GraphqlRails
 
       attr_reader :model_class
 
+      def build_attribute(attribute_name)
+        Attributes::Attribute.new(attribute_name)
+      end
+
       def default_name
         @default_name ||= model_class.name.split('::').last
       end

data/lib/graphql_rails/model/find_or_build_graphql_type.rb

@@ -37,28 +37,25 @@ module GraphqlRails
       end
 
       def add_fields_to_graphql_type
-        AddFieldsToGraphqlType.call(klass: klass, attributes: attributes.values.select(&:scalar_type?))
+        scalar_attributes, dynamic_attributes = attributes.values.partition(&: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
+        AddFieldsToGraphqlType.call(klass: klass, attributes: scalar_attributes)
+        dynamic_attributes.each { |attribute| find_or_build_dynamic_type(attribute) }
+        AddFieldsToGraphqlType.call(klass: klass, attributes: dynamic_attributes)
       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
+      def find_or_build_dynamic_type(attribute)
+        graphql_model = attribute.graphql_model
+        find_or_build_graphql_model_type(graphql_model) if graphql_model
+      end
+
+      def find_or_build_graphql_model_type(graphql_model)
+        self.class.call(
+          name: graphql_model.graphql.name,
+          description: graphql_model.graphql.description,
+          attributes: graphql_model.graphql.attributes,
+          type_name: graphql_model.graphql.type_name
+        )
       end
     end
   end

data/lib/graphql_rails/model/find_or_build_graphql_type_class.rb

@@ -5,6 +5,7 @@ module GraphqlRails
     # Initializes class to define graphql type and fields.
     class FindOrBuildGraphqlTypeClass
       require 'graphql_rails/concerns/service'
+      require 'graphql_rails/types/object_type'
 
       include ::GraphqlRails::Service
 
@@ -32,7 +33,7 @@ module GraphqlRails
         graphql_type_name = name
         graphql_type_description = description
 
-        graphql_type_klass = Class.new(GraphQL::Schema::Object) do
+        graphql_type_klass = Class.new(GraphqlRails::Types::ObjectType) do
           graphql_name(graphql_type_name)
           description(graphql_type_description)
         end

data/lib/graphql_rails/model/input.rb

@@ -1,58 +1,42 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/model/build_graphql_input_type'
-require 'graphql_rails/model/configurable'
-
 module GraphqlRails
   module Model
     # stores information about model input specific config, like attributes and types
     class Input
+      require 'graphql_rails/concerns/chainable_options'
+      require 'graphql_rails/model/configurable'
+      require 'graphql_rails/model/build_graphql_input_type'
+
       include Configurable
 
+      chainable_option :enum
+
       def initialize(model_class, input_name_suffix)
         @model_class = model_class
         @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
         )
       end
 
-      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
 
       attr_reader :input_name_suffix, :model_class
 
+      def build_attribute(attribute_name)
+        Attributes::InputAttribute.new(attribute_name, config: self)
+      end
+
       def default_name
         @default_name ||= begin
           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

@@ -8,12 +8,13 @@ module GraphqlRails
 
     include ::GraphqlRails::Service
 
-    def initialize(group: nil, params:, schema: nil, router: nil, **schema_options)
+    def initialize(params:, context: {}, schema: nil, router: nil, group: nil, **schema_options) # rubocop:disable Metrics/ParameterLists
       @group = group
       @graphql_schema = schema
       @params = params
-      @schema_options = schema_options
       @router = router
+      @initial_context = context
+      @schema_options = schema_options
     end
 
     def call
@@ -21,13 +22,18 @@ module GraphqlRails
         params[:query],
         variables: variables,
         operation_name: params[:operationName],
+        context: context,
         **schema_options
       )
     end
 
     private
 
-    attr_reader :schema_options, :params, :group
+    attr_reader :schema_options, :params, :group, :initial_context
+
+    def context
+      initial_context.merge(graphql_group: group)
+    end
 
     def variables
       ensure_hash(params[:variables])

data/lib/graphql_rails/router/mutation_route.rb

@@ -13,6 +13,10 @@ module GraphqlRails
       def mutation?
         true
       end
+
+      def subscription?
+        false
+      end
     end
   end
 end

data/lib/graphql_rails/router/query_route.rb

@@ -13,6 +13,10 @@ module GraphqlRails
       def mutation?
         false
       end
+
+      def subscription?
+        false
+      end
     end
   end
 end

data/lib/graphql_rails/router/resource_routes_builder.rb

@@ -28,6 +28,10 @@ module GraphqlRails
         routes << build_mutation(*args, **kwargs)
       end
 
+      def subscription(*args, **kwargs)
+        routes << build_subscription(*args, **kwargs)
+      end
+
       private
 
       attr_reader :autogenerated_action_names, :name, :options
@@ -62,6 +66,10 @@ module GraphqlRails
         build_route(QueryRoute, *args, **kwargs)
       end
 
+      def build_subscription(*args, **kwargs)
+        build_route(SubscriptionRoute, *args, **kwargs)
+      end
+
       # rubocop:disable Metrics/ParameterLists
       def build_route(builder, action, prefix: action, suffix: false, on: :member, **custom_options)
         if suffix == true

data/lib/graphql_rails/router/route.rb

@@ -6,7 +6,7 @@ module GraphqlRails
   class Router
     # Generic class for any type graphql action. Should not be used directly
     class Route
-      attr_reader :name, :module_name, :on, :relative_path
+      attr_reader :name, :module_name, :on, :relative_path, :groups
 
       def initialize(name, to: '', on:, groups: nil, **options)
         @name = name.to_s.camelize(:lower)
@@ -43,7 +43,7 @@ module GraphqlRails
 
       private
 
-      attr_reader :function, :groups
+      attr_reader :function
 
       def resolver
         @resolver ||= Controller::BuildControllerActionResolver.call(route: self)

data/lib/graphql_rails/router/schema_builder.rb

@@ -6,11 +6,12 @@ module GraphqlRails
     class SchemaBuilder
       require_relative './plain_cursor_encoder'
 
-      attr_reader :queries, :mutations, :raw_actions
+      attr_reader :queries, :mutations, :subscriptions, :raw_actions
 
-      def initialize(queries:, mutations:, raw_actions:, group: nil)
+      def initialize(queries:, mutations:, subscriptions:, raw_actions:, group: nil)
         @queries = queries
         @mutations = mutations
+        @subscriptions = subscriptions
         @raw_actions = raw_actions
         @group = group
       end
@@ -18,6 +19,7 @@ module GraphqlRails
       def call
         query_type = build_group_type('Query', queries)
         mutation_type = build_group_type('Mutation', mutations)
+        subscription_type = build_group_type('Subscription', subscriptions)
         raw = raw_actions
 
         Class.new(GraphQL::Schema) do
@@ -30,6 +32,7 @@ module GraphqlRails
 
           query(query_type) if query_type
           mutation(mutation_type) if mutation_type
+          subscription(subscription_type) if subscription_type
         end
       end
 
@@ -39,7 +42,13 @@ module GraphqlRails
 
       def build_group_type(type_name, routes)
         group_name = group
-        group_routes = routes.select { |route| route.show_in_group?(group_name) }
+        group_routes =
+          routes
+          .select { |route| route.show_in_group?(group_name) }
+          .reverse
+          .uniq(&:name)
+          .reverse
+
         return if group_routes.empty?
 
         build_type(type_name, group_routes)

data/lib/graphql_rails/router/subscription_route.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'route'
+
+module GraphqlRails
+  class Router
+    # stores subscription type graphql action info
+    class SubscriptionRoute < Route
+      def query?
+        false
+      end
+
+      def mutation?
+        false
+      end
+
+      def subscription?
+        true
+      end
+    end
+  end
+end

data/lib/graphql_rails/router.rb

@@ -5,6 +5,7 @@ require 'active_support/core_ext/string/inflections'
 require 'graphql_rails/router/schema_builder'
 require 'graphql_rails/router/mutation_route'
 require 'graphql_rails/router/query_route'
+require 'graphql_rails/router/subscription_route'
 require 'graphql_rails/router/resource_routes_builder'
 
 module GraphqlRails
@@ -27,6 +28,7 @@ module GraphqlRails
       @group_names = group_names
       @routes ||= Set.new
       @raw_graphql_actions ||= []
+      @graphql_schema = {}
     end
 
     def group(*group_names, &block)
@@ -57,6 +59,10 @@ module GraphqlRails
       routes << build_route(MutationRoute, name, **options)
     end
 
+    def subscription(name, **options)
+      routes << build_route(SubscriptionRoute, name, **options)
+    end
+
     RAW_ACTION_NAMES.each do |action_name|
       define_method(action_name) do |*args, &block|
         add_raw_action(action_name, *args, &block)
@@ -64,17 +70,17 @@ module GraphqlRails
     end
 
     def graphql_schema(group = nil)
-      @graphql_schema ||= {}
       @graphql_schema[group&.to_sym] ||= SchemaBuilder.new(
         queries: routes.select(&:query?),
         mutations: routes.select(&:mutation?),
+        subscriptions: routes.select(&:subscription?),
         raw_actions: raw_graphql_actions,
         group: group
       ).call
     end
 
     def reload_schema
-      @graphql_schema = nil
+      @graphql_schema.clear
     end
 
     private

data/lib/graphql_rails/tasks/dump_graphql_schema.rb

@@ -7,51 +7,42 @@ module GraphqlRails
 
     class MissingGraphqlRouterError < GraphqlRails::Error; end
 
-    attr_reader :name
-
-    def self.call(*args)
-      new(*args).call
+    def self.call(**args)
+      new(**args).call
     end
 
-    def initialize(name:)
-      @name = name
+    def initialize(group:, router:, dump_dir: nil)
+      @group = group
+      @router = router
+      @dump_dir = dump_dir
     end
 
     def call
-      validate
-      File.write(schema_path, schema.to_definition)
+      File.write(schema_path, schema_dump)
     end
 
     private
 
-    def validate
-      return if router
-
-      error_message = \
-        'GraphqlRouter is missing. ' \
-        'Run `rails g graphql_rails:install` to build it'
-      raise MissingGraphqlRouterError, error_message
-    end
+    attr_reader :router, :group
 
-    def router
-      @router ||= '::GraphqlRouter'.safe_constantize
+    def schema_dump
+      context = { graphql_group: group }
+      schema.to_definition(context: context)
     end
 
     def schema
-      @schema ||= ::GraphqlRouter.graphql_schema(name.presence)
+      @schema ||= router.graphql_schema(group.presence)
     end
 
     def schema_path
-      ENV['GRAPHQL_SCHEMA_DUMP_PATH'] || default_schema_path
-    end
-
-    def default_schema_path
-      schema_folder_path = Rails.root.join('spec', 'fixtures')
+      FileUtils.mkdir_p(dump_dir)
+      file_name = group.present? ? "graphql_#{group}_schema.graphql" : 'graphql_schema.graphql'
 
-      FileUtils.mkdir_p(schema_folder_path)
-      file_name = name.present? ? "graphql_#{name}_schema.graphql" : 'graphql_schema.graphql'
+      "#{dump_dir}/#{file_name}"
+    end
 
-      schema_folder_path.join(file_name)
+    def dump_dir
+      @dump_dir ||= Rails.root.join('spec/fixtures').to_s
     end
   end
 end

data/lib/graphql_rails/tasks/dump_graphql_schemas.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/tasks/dump_graphql_schema'
+
+module GraphqlRails
+  # Generates graphql schema dump files
+  class DumpGraphqlSchemas
+    require 'graphql_rails/errors/error'
+
+    class MissingGraphqlRouterError < GraphqlRails::Error; end
+
+    def self.call(**args)
+      new(**args).call
+    end
+
+    def initialize(dump_dir:, groups: nil)
+      @groups = groups.presence
+      @dump_dir = dump_dir
+    end
+
+    def call
+      validate
+      return dump_default_schema if groups.empty?
+
+      groups.each { |group| dump_graphql_schema(group) }
+    end
+
+    private
+
+    attr_reader :dump_dir
+
+    def dump_default_schema
+      dump_graphql_schema('')
+    end
+
+    def dump_graphql_schema(group)
+      DumpGraphqlSchema.call(group: group, router: router, dump_dir: dump_dir)
+    end
+
+    def validate
+      return if router
+
+      error_message = \
+        'GraphqlRouter is missing. ' \
+        'Run `rails g graphql_rails:install` to build it'
+      raise MissingGraphqlRouterError, error_message
+    end
+
+    def router
+      @router ||= '::GraphqlRouter'.safe_constantize
+    end
+
+    def groups
+      @groups ||= router.routes.flat_map(&:groups).uniq
+    end
+  end
+end

data/lib/graphql_rails/tasks/schema.rake

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/tasks/dump_graphql_schema'
+require 'graphql_rails/tasks/dump_graphql_schemas'
 
 namespace :graphql_rails do
   namespace :schema do
     desc 'Dump GraphQL schema'
-    task(:dump, %i[name] => :environment) do |_, args|
-      default_name = ENV.fetch('SCHEMA_GROUP_NAME', '')
-      args.with_defaults(name: default_name)
-      GraphqlRails::DumpGraphqlSchema.call(name: args.name)
+    task(dump: :environment) do |_, args|
+      groups_from_args = args.extras
+      groups_from_env = ENV['SCHEMA_GROUP_NAME'].to_s.split(',').map(&:strip)
+      groups = groups_from_args + groups_from_env
+      dump_dir = ENV.fetch('GRAPHQL_SCHEMA_DUMP_DIR') { Rails.root.join('spec/fixtures').to_s }
+
+      GraphqlRails::DumpGraphqlSchemas.call(groups: groups, dump_dir: dump_dir)
     end
   end
 end

data/lib/graphql_rails/types/argument_type.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/types/hidable_by_group'
+
+module GraphqlRails
+  module Types
+    # Base argument type for all GraphqlRails inputs
+    class ArgumentType < GraphQL::Schema::Argument
+      include GraphqlRails::Types::HidableByGroup
+    end
+  end
+end

data/lib/graphql_rails/types/field_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/types/argument_type'
+require 'graphql_rails/types/hidable_by_group'
+
+module GraphqlRails
+  module Types
+    # Base field for all GraphqlRails model fields
+    class FieldType < GraphQL::Schema::Field
+      include GraphqlRails::Types::HidableByGroup
+      argument_class(GraphqlRails::Types::ArgumentType)
+    end
+  end
+end

data/lib/graphql_rails/types/hidable_by_group.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/types/argument_type'
+
+module GraphqlRails
+  module Types
+    # Add visibility option based on groups
+    module HidableByGroup
+      def initialize(*args, groups: [], **kwargs, &block)
+        super(*args, **kwargs, &block)
+
+        @groups = groups.map(&:to_s)
+      end
+
+      def visible?(context)
+        super && visible_in_context_group?(context)
+      end
+
+      private
+
+      def groups
+        @groups
+      end
+
+      def visible_in_context_group?(context)
+        group = context[:graphql_group] || context['graphql_group']
+
+        group.nil? || groups.empty? || groups.include?(group.to_s)
+      end
+    end
+  end
+end