rails-graphql 1.0.0.beta → 1.0.0.rc2

data/lib/rails/graphql/subscription/store/base.rb

@@ -65,6 +65,11 @@ module Rails
             raise NotImplementedError, +"#{self.class.name} does not implement remove"
           end
 
+          # Marks that a subscription has received an update
+          def update!(item)
+            raise NotImplementedError, +"#{self.class.name} does not implement update!"
+          end
+
           # Check if a given sid or instance is stored
           def has?(item)
             raise NotImplementedError, +"#{self.class.name} does not implement has?"
@@ -123,21 +128,12 @@ module Rails
             def hash_for(value, klass = nil)
               if !klass.nil?
                 klass.hash ^ value.hash
-              elsif extract_class_from?(value)
-                value.class.hash ^ value.id.hash
               elsif value.is_a?(Numeric)
                 value
               else
                 value.hash
               end
             end
-
-            # Check if ActiveRecord::Base is available and then if the object
-            # provided is an instance of it, so that the serialize can work
-            # correctly
-            def extract_class_from?(value)
-              defined?(ActiveRecord) && value.is_a?(ActiveRecord::Base)
-            end
         end
       end
     end

data/lib/rails/graphql/subscription/store/memory.rb

@@ -49,6 +49,11 @@ module Rails
               raise ::ArgumentError, +"SID #{subscription.sid} is already taken."
             end
 
+            # Rewrite the scope, to save memory
+            scope = possible_scopes(subscription.scope)&.first
+            subscription.instance_variable_set(:@scope, scope)
+
+            # Save to the list and to the index
             list[subscription.sid] = subscription
             index_set = subscription_to_index(subscription).reduce(index, &:[])
             index_set << subscription.sid
@@ -56,13 +61,13 @@ module Rails
           end
 
           def fetch(*sids)
-            if sids.none?
-              nil
-            elsif sids.one?
-              list[sids.first]
-            else
-              sids.map(&list.method(:[]))
+            return if sids.none?
+
+            items = sids.map do |item|
+              instance?(item) ? item : list[item]
             end
+
+            items.one? ? items.first : items
           end
 
           def remove(item)
@@ -82,6 +87,10 @@ module Rails
             index.delete(path[0]) if f_level.empty?
           end
 
+          def update!(item)
+            (instance?(item) ? item : fetch(item)).update!
+          end
+
           def has?(item)
             list.key?(instance?(item) ? item.sid : item)
           end
@@ -115,9 +124,9 @@ module Rails
             # Turn the request subscription into into the path of the index
             def subscription_to_index(subscription)
               [
-                hash_for(subscription.field),
-                possible_scopes(subscription.scope)&.first,
-                hash_for(subscription.args),
+                subscription.field.hash,
+                subscription.scope,
+                subscription.args.hash,
               ]
             end
         end

data/lib/rails/graphql/type/creator.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Type
+      # = GraphQL Type Creator
+      #
+      # This class helps to dynamically create types using a large set of
+      # settings that are provided through the named arguments. There are
+      # setting that are general to all types, and some are specific per base
+      # type of the superclass
+      class Creator
+        NESTED_MODULE = :NestedTypes
+        SUPPORTED_KINDS = %i[scalar object interface union enum input_object source].freeze
+
+        attr_reader :name, :superclass, :klass, :settings
+
+        delegate :type_map, to: '::Rails::GraphQL'
+        delegate :kind, to: :superclass
+
+        # Simply instantiate the creator and run the process
+        def self.create!(*args, **xargs, &block)
+          new(*args, **xargs).create!(&block)
+        end
+
+        def initialize(from, name_or_object, superclass, **settings)
+          @from = from
+          @settings = settings
+          @object = name_or_object if name_or_object.is_a?(Class)
+
+          @superclass = sanitize_superclass(superclass)
+          @name = sanitize_name(name_or_object)
+        end
+
+        # Go over the create process
+        def create!(&block)
+          @klass = find_or_create_class
+          klass.instance_variable_set(:@gql_name, gql_name)
+
+          apply_general_settings
+          after_block = apply_specific_settings
+
+          klass.module_exec(&block) if block.present?
+          after_block.call if after_block.is_a?(Proc)
+          klass
+        end
+
+        protected
+
+          # Use the type map to look for a type from the same namespace
+          def find_type!(value)
+            type_map.fetch!(value, namespaces: namespaces, base_class: :Type)
+          end
+
+          # Same as above, but mapping the list
+          def find_all_types!(*list)
+            list.map { |item| item.is_a?(Class) ? item : find_type!(item) }
+          end
+
+          # Apply settings that is common for any possible type created
+          def apply_general_settings
+            klass.abstract = settings[:abstract] if settings.key?(:abstract)
+            klass.set_namespace(*namespaces)
+
+            klass.use(*settings[:directives]) if settings.key?(:directives) &&
+              klass.is_a?(Helpers::WithDirectives)
+
+            if klass.is_a?(Helpers::WithAssignment)
+              assignment = settings.fetch(:assigned_to, @object)
+              klass.assigned_to = assignment unless assignment.nil?
+            end
+
+            if settings.key?(:owner)
+              klass.include(Helpers::WithOwner) unless klass.is_a?(Helpers::WithOwner)
+              klass.owner = settings[:owner] == true ? @from : settings[:owner]
+            end
+          end
+
+          # Using the kind, call of a specific method to further configure the
+          # created class
+          def apply_specific_settings
+            method_name = +"apply_#{kind}_settings"
+            send(method_name) if respond_to?(method_name, true)
+          end
+
+          # Specific settings when creating an enum
+          def apply_enum_settings
+            klass.indexed! if settings[:indexed]
+            return if (values = settings[:values]).nil?
+            GraphQL.enumerate(values).each(&klass.method(:add))
+          end
+
+          # Specific settings when creating an union
+          def apply_union_settings
+            types = settings[:of_types]
+            klass.append(*find_all_types!(*types)) unless types.nil?
+          end
+
+          # Specific settings when creating a source
+          def apply_source_settings
+            build = settings[:build]
+
+            -> do
+              return klass.build_all if build == true
+              GraphQL.enumerate(build).each do |step|
+                klass.public_send(+"build_#{step}")
+              end
+            end if build
+          end
+
+        private
+
+          # Either get the gql name from settings or properly resolve one from
+          # the name
+          def gql_name
+            settings[:gql_name].presence || begin
+              gql_name = name.dup
+              gql_name = gql_name.chomp(name_suffix) unless kind == :input_object
+              gql_name.tr('_', '')
+            end
+          end
+
+          # Add the nested module to the source of the creating and create the
+          # class. If any of those exist, return the constant instead
+          def find_or_create_class
+            base = base_module
+
+            # Create the class under the nested module
+            return base.const_set(name, Class.new(superclass)) \
+              unless base.const_defined?(name, false)
+
+            # Get the existing class and check for the once setting
+            klass = base.const_get(name, false)
+            return klass unless !once? && klass < superclass
+
+            # Created once or not from the same superclass
+            raise DuplicatedError, (+<<~MSG).squish
+              A type named "#{name}" already exists for the "#{base.name}" module.
+            MSG
+          end
+
+          # Make sure to properly get the superclass
+          def sanitize_superclass(value)
+            value = Type.const_get(value.to_s.classify, false) unless value.is_a?(Class)
+
+            valid_class = value.is_a?(Class) && value.respond_to?(:kind)
+            valid_class &= SUPPORTED_KINDS.include?(value.kind)
+            return value if valid_class
+
+            raise ::ArgumentError, +"The \"#{value.inspect}\" is not a valid superclass."
+          rescue ::NameError
+            raise ::ArgumentError, +"Unable to find a \"#{value}\" superclass."
+          end
+
+          # Let's clean up the name
+          def sanitize_name(name_or_object)
+            name = name_or_object.is_a?(Module) ? name_or_object.name : name_or_object.to_s
+            name = name.classify.delete_prefix('GraphQL::').gsub(/::/, '_')
+            name.end_with?(name_suffix) ? name : name + name_suffix
+          end
+
+          # Figure out the suffix that is supposed to be used for the name
+          def name_suffix
+            @name_suffix ||= @settings[:suffix] || begin
+              if kind == :input_object
+                GraphQL.config.auto_suffix_input_objects
+              else
+                superclass.kind.to_s.classify
+              end
+            end
+          end
+
+          # Get or set the base module using the from argument
+          def base_module
+            base = @from.is_a?(Module) ? @from : @from.class
+            if base.const_defined?(NESTED_MODULE, false)
+              base.const_get(NESTED_MODULE, false)
+            else
+              base.const_set(NESTED_MODULE, Module.new).tap do
+                base.private_constant(NESTED_MODULE)
+              end
+            end
+          end
+
+          # Get the namespaces from the settings or from the source
+          def namespaces
+            @namespaces ||= settings[:namespace] || settings[:namespaces] || @from.namespace
+          end
+
+          # Check if the type should be create only once, meaning that returning
+          # an existing one is not an option
+          def once?
+            settings.fetch(:once, true)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/enum.rb

@@ -75,6 +75,7 @@ module Rails
           # ==== Options
           #
           # * <tt>:desc</tt> - The description of the enum value (defaults to nil).
+          # * <tt>:description</tt> - Alias to the above.
           # * <tt>:directives</tt> - The list of directives associated with the value
           #   (defaults to nil).
           # * <tt>:deprecated</tt> - A shortcut that auto-attach a @deprecated
@@ -82,9 +83,9 @@ module Rails
           #   but provide a string so it can be used as the reason of the deprecation.
           #   See {DeprecatedDirective}[rdoc-ref:Rails::GraphQL::Directive::DeprecatedDirective]
           #   (defaults to false).
-          def add(value, desc: nil, directives: nil, deprecated: false)
+          def add(value, desc: nil, description: nil, directives: nil, deprecated: false)
             value = value&.to_s
-            raise ArgumentError, (+<<~MSG).squish unless value.is_a?(String) && value.present?
+            raise ArgumentError, (+<<~MSG).squish unless value.is_a?(String) && !value.empty?
               The "#{value}" is invalid.
             MSG
 
@@ -103,6 +104,8 @@ module Rails
               source: self,
             )
 
+            desc = description if desc.nil?
+
             values << value
             value_description[value] = desc unless desc.nil?
             value_directives[value] = directives if directives
@@ -130,10 +133,12 @@ module Rails
 
           def inspect
             return super if self.eql?(Type::Enum)
+
+            values = all_values.to_a
             (+<<~INFO).squish << '>'
               #<GraphQL::Enum #{gql_name}
-              (#{all_values.size})
-              {#{all_values.to_a.join(' | ')}}
+              (#{values.size})
+              {#{values.to_a.join(' | ')}}
               #{inspect_directives}
             INFO
           end
@@ -143,6 +148,8 @@ module Rails
 
         delegate :to_s, :inspect, to: :@value
 
+        # TODO: Maybe add delegate missing
+
         def initialize(value)
           @value = value
         end
@@ -165,13 +172,15 @@ module Rails
         # Gets all the description of the current value
         def description
           return unless @value
-          @description ||= all_value_description.try(:[], @value)
+          return @description if defined?(@description)
+          @description = all_value_description.try(:[], @value)
         end
 
         # Gets all the directives associated with the current value
         def directives
           return unless @value
-          @directives ||= all_value_directives.try(:[], @value)
+          return @directives if defined?(@directives)
+          @directives = all_value_directives.try(:[], @value)
         end
 
         # Checks if the current value is marked as deprecated
@@ -181,10 +190,9 @@ module Rails
 
         # Return the deprecated reason
         def deprecated_reason
-          return unless deprecated?
-          directives.find do |dir|
+          directives&.find do |dir|
             dir.is_a?(Directive::DeprecatedDirective)
-          end.args.reason
+          end&.args&.reason
         end
       end
     end

data/lib/rails/graphql/type/input.rb

@@ -105,7 +105,7 @@ module Rails
             end
         end
 
-        attr_reader :args
+        attr_reader :args, :assignment_error
         attr_writer :resource
 
         delegate :fields, to: :class
@@ -114,7 +114,7 @@ module Rails
         delegate_missing_to :resource
 
         def initialize(args = nil, **xargs)
-          @args = args || OpenStruct.new(xargs.transform_keys { |key| key.to_s.underscore })
+          @args = args || build_ostruct(xargs)
           @args.freeze
 
           validate! if args.nil?
@@ -124,7 +124,10 @@ module Rails
         # received arguments. It also accepts extra arguments for inheritance
         # purposes
         def resource(*args, **xargs, &block)
-          @resource ||= (klass = safe_assigned_class).nil? ? nil : begin
+          return @resource if defined?(@resource)
+          return if (klass = safe_assigned_class).nil?
+
+          @resource = begin
             xargs = xargs.reverse_merge(params)
             klass.new(*args, **xargs, &block)
           end
@@ -132,21 +135,25 @@ module Rails
 
         # Just return the arguments as an hash
         def params
-          parametrize(self)
+          parametrize(@args.to_h)
         end
 
-        # Corretly turn all the arguments into their +as_json+ version and
+        # Correctly turn all the arguments into their +as_json+ version and
         # return a hash of them
         def args_as_json
           self.class.as_json(@args.to_h)
         end
 
-        # Corretly turn all the arguments into their +to_json+ version and
+        alias as_json args_as_json
+
+        # Correctly turn all the arguments into their +to_json+ version and
         # return a hash of them
         def args_to_json
           self.class.to_json(@args.to_h)
         end
 
+        alias to_json args_to_json
+
         # Checks if all the values provided to the input instance are valid
         def validate!(*)
           errors = []
@@ -162,18 +169,34 @@ module Rails
           MSG
         end
 
+        # Override this method to save any errors that could happen with loading
+        # the assigned class
+        def safe_assigned_class
+          assigned_class
+        rescue ::ArgumentError, ::NameError => error
+          @assignment_error = error
+          nil
+        end
+
         %i[to_global_id to_gid to_gid_param].each do |method_name|
           define_method(method_name) do
             self.class.public_send(method_name, args_as_json.compact)
           end
         end
 
+        protected
+
+          # A helper to turn a hash into a proper Open Struct instance
+          def build_ostruct(hash)
+            OpenStruct.new(hash.transform_keys { |key| key.to_s.underscore })
+          end
+
         private
 
           # Make sure to turn inputs into params
           def parametrize(input)
             case input
-            when Type::Input then parametrize(input.args.to_h)
+            when Type::Input then input.params
             when Array       then input.map(&method(:parametrize))
             when Hash        then input.transform_values(&method(:parametrize))
             else input

data/lib/rails/graphql/type/interface.rb

@@ -26,6 +26,11 @@ module Rails
         inherited_collection :types, instance_reader: false
 
         class << self
+          # Figure out which one of the types is compatible with the provided +value+
+          def type_for(value, *)
+            all_types&.reverse_each&.find { |t| t.valid_member?(value) }
+          end
+
           # Check if the other type is equivalent, by checking if the other is
           # an object and the object implements this interface
           def =~(other)
@@ -35,16 +40,22 @@ module Rails
           # When attaching an interface to an object, copy the fields and add to
           # the list of types. Pre-existing same-named fields with are not
           # equivalent produces an exception.
-          def implemented(object)
+          def implemented(object, import_fields: true)
+            import_fields = false if abstract?
+
             fields.each do |name, field|
-              defined = object.field?(name)
-              invalid = defined && object.fields[name] !~ field
+              defined = object[field.name]
+              raise ArgumentError, (+<<~MSG).squish unless defined || import_fields
+                The "#{object.gql_name}" object must have a "#{field.gql_name}" field.
+              MSG
+
+              invalid = defined && defined !~ field
               raise ArgumentError, (+<<~MSG).squish if invalid
                 The "#{object.gql_name}" object already has a "#{field.gql_name}" field and it
                 is not equivalent to the one defined on the "#{gql_name}" interface.
               MSG
 
-              object.proxy_field(field) unless defined
+              object.proxy_field(field) if import_fields && !defined
             end
 
             types << object

data/lib/rails/graphql/type/object/directive_object.rb

@@ -20,13 +20,14 @@ module Rails
           additional information to the executor.
         DESC
 
-        field :name,        :string,               null: false, method_name: :gql_name
-        field :description, :string
-        field :locations,   '__DirectiveLocation', full: true
-        field :args,        '__InputValue',        full: true
+        field :name,          :string,               null: false, method_name: :gql_name
+        field :description,   :string
+        field :locations,     '__DirectiveLocation', full: true
+        field :args,          '__InputValue',        full: true
+        field :is_repeatable, :boolean,              null: false, method_name: :repeatable?
 
         def args
-          all_arguments.values
+          all_arguments.each_value
         end
       end
     end

data/lib/rails/graphql/type/object/input_value_object.rb

@@ -17,10 +17,9 @@ module Rails
         rename! '__InputValue'
 
         desc <<~DESC
-          Alongside with scalars and enums, input value objects allow the user
-          to provide values to arguments on fields and directives. Different
-          from those, input values accepts a list of keyed values, instead of
-          a single value.
+          Arguments provided to Fields or Directives and the input fields of an
+          InputObject are represented as Input Values which describe their type
+          and optionally a default value.
         DESC
 
         field :name,          :string,  null: false, method_name: :gql_name

data/lib/rails/graphql/type/object/type_object.rb

@@ -12,15 +12,19 @@ module Rails
             kind: :list,
             kind_enum: 'LIST',
             name: 'List',
+            gql_name: nil,
             object?: true,
             description: nil,
+            of_type: nil,
           },
           non_null: {
             kind: :non_null,
             kind_enum: 'NON_NULL',
             name: 'Non-Null',
+            gql_name: nil,
             object?: true,
             description: nil,
+            of_type: nil,
           },
         }.freeze
 
@@ -32,7 +36,7 @@ module Rails
         end
 
         def self.fake_type_object(type, subtype)
-          OpenStruct.new(**FAKE_TYPES[type].merge(of_type: subtype))
+          FAKE_TYPES[type].merge(of_type: subtype)
         end
 
         rename! '__Type'
@@ -59,13 +63,15 @@ module Rails
           the schema to define exactly what data is expected.
         DESC
 
-        field :kind,           '__TypeKind',   null: false,
+        field :kind,             '__TypeKind',   null: false,
           method_name: :kind_enum
 
-        field :name,           :string,
+        field :name,             :string,
           method_name: :gql_name
 
-        field :description,    :string
+        field :description,      :string
+
+        field :specified_by_url, :string
 
         field :fields,         '__Field',      array: true, nullable: false do
           desc 'OBJECT and INTERFACE only'
@@ -89,8 +95,16 @@ module Rails
         field :of_type,        '__Type',
           desc: 'NON_NULL and LIST only'
 
+        def specified_by_url
+          return if fake_type? || !current.scalar?
+
+          current.all_directives&.find do |dir|
+            dir.is_a?(Directive::SpecifiedByDirective)
+          end&.args&.url
+        end
+
         def fields(include_deprecated:)
-          return EMPTY_ARRAY unless current.object? || current.interface?
+          return if fake_type? || !(current.object? || current.interface?)
 
           list =
             if current.respond_to?(:enabled_fields)
@@ -109,7 +123,7 @@ module Rails
         end
 
         def enum_values(include_deprecated:)
-          return EMPTY_ARRAY unless current.enum?
+          return if fake_type? || !current.enum?
 
           descriptions = all_value_description
           deprecated = all_deprecated_values
@@ -119,26 +133,39 @@ module Rails
             unless include_deprecated || deprecated.nil?
 
           list.map do |value|
-            OpenStruct.new(
+            {
               name: value,
-              description: descriptions[value],
+              description: descriptions.try(:[], value),
               is_deprecated: (deprecated.nil? ? false : deprecated.key?(value)),
               deprecation_reason: deprecated.try(:[], value),
-            )
+            }
           end
         end
 
         def interfaces
-          (current.object? && current.all_interfaces) || EMPTY_ARRAY
+          return if fake_type? || !current.object?
+          current.all_interfaces || EMPTY_ARRAY
         end
 
         def possible_types
-          (current.interface? && current.all_types) ||
-            (current.union? && current.all_members) || EMPTY_ARRAY
+          return if fake_type?
+
+          if current.interface?
+            current.all_types || EMPTY_ARRAY
+          elsif current.union?
+            current.all_members || EMPTY_ARRAY
+          end
         end
 
         def input_fields
-          (current.input? && current.enabled_fields) || EMPTY_ARRAY
+          return if fake_type? || !current.input?
+          current.enabled_fields || EMPTY_ARRAY
+        end
+
+        private
+
+        def fake_type?
+          Hash === current
         end
       end
     end