rails-graphql 0.1.0

data/lib/rails/graphql/helpers/with_fields.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold fields during the
+      # definition process. Works very similar to Arguments, but it's more
+      # flexible, since the type of the fields can be dynamic defined by the
+      # class that extends this module.
+      #
+      # Fields, different from arguments, has extended types, which is somewhat
+      # related to the base type, but it's closer associated with the strategy
+      # used to handle them.
+      module WithFields
+        module ClassMethods # :nodoc: all
+          def inherited(subclass)
+            super if defined? super
+            return unless defined?(@fields)
+            fields.each_value(&subclass.method(:proxy_field))
+          end
+        end
+
+        def self.extended(other) # :nodoc:
+          other.extend(WithFields::ClassMethods)
+          other.define_singleton_method(:fields) { @fields ||= Concurrent::Map.new }
+          other.class_attribute(:field_type, instance_writer: false)
+          other.class_attribute(:valid_field_types, instance_writer: false, default: [])
+        end
+
+        # Check if the field is already defined before actually creating it
+        def safe_field(*args, of_type: nil, **xargs, &block)
+          method_name = of_type.nil? ? :field : "#{of_type}_field"
+          public_send(method_name, *args, **xargs, &block)
+        rescue DuplicatedError
+          # Do not do anything if it is duplicated
+        end
+
+        # See {Field}[rdoc-ref:Rails::GraphQL::Field] class.
+        def field(name, *args, **xargs, &block)
+          xargs[:owner] = self
+          object = field_type.new(name, *args, **xargs, &block)
+
+          raise DuplicatedError, <<~MSG.squish if field?(object.name)
+            The #{name.inspect} field is already defined and can't be redefined.
+          MSG
+
+          fields[object.name] = object
+        rescue DefinitionError => e
+          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+        end
+
+        # Add a new field to the list but use a proxy instead of a hard copy of
+        # a given +field+
+        def proxy_field(field, *args, **xargs, &block)
+          raise ArgumentError, <<~MSG.squish unless field.is_a?(GraphQL::Field)
+            The #{field.class.name} is not a valid field.
+          MSG
+
+          xargs[:owner] = self
+          object = field.to_proxy(*args, **xargs, &block)
+          raise DuplicatedError, <<~MSG.squish if field?(object.name)
+            The #{field.name.inspect} field is already defined and can't be replaced.
+          MSG
+
+          fields[object.name] = object
+        end
+
+        # Overwrite attributes of a given field named as +name+, it also allows
+        # a +block+ which will then further configure the field
+        def change_field(object, **xargs, &block)
+          find_field!(object).apply_changes(**xargs, &block)
+        end
+
+        alias overwrite_field change_field
+
+        # Perform extra configurations on a given +field+
+        def configure_field(object, &block)
+          find_field!(object).configure(&block)
+        end
+
+        # Disable a list of given +fields+
+        def disable_fields(*list)
+          list.flatten.map { |item| self[item]&.disable! }
+        end
+
+        # Enable a list of given +fields+
+        def enable_fields(*list)
+          list.flatten.map { |item| self[item]&.enable! }
+        end
+
+        # Check wheter a given field +object+ is defined in the list of fields
+        def field?(object)
+          object = object.name if object.is_a?(GraphQL::Field)
+          fields.key?(object.is_a?(String) ? object.underscore.to_sym : object)
+        end
+
+        # Allow accessing fields using the hash notation
+        def [](object)
+          object = object.name if object.is_a?(GraphQL::Field)
+          fields[object.is_a?(String) ? object.underscore.to_sym : object]
+        end
+
+        alias find_field []
+
+        # If the field is not found it will raise an exception
+        def find_field!(object)
+          find_field(object) || raise(::ArgumentError, <<~MSG.squish)
+            The #{object.inspect} field is not defined yet.
+          MSG
+        end
+
+        # Get the list of GraphQL names of all the fields difined
+        def field_names(enabled_only = true)
+          (enabled_only ? enabled_fields : fields.each_value).map(&:gql_name).compact
+        end
+
+        # Return a lazy enumerator for enabled fields
+        def enabled_fields
+          fields.values.select(&:enabled?)
+        end
+
+        # Validate all the fields to make sure the definition is valid
+        def validate!(*)
+          super if defined? super
+
+          # TODO: Maybe find a way to freeze the fields, since after validation
+          # the best thing to do is block changes
+          fields.each_value(&:validate!)
+        end
+
+        protected
+
+          # A little helper to define arguments using the :arguments key
+          def arg(*args, **xargs, &block)
+            xargs[:owner] = self
+            GraphQL::Argument.new(*args, **xargs, &block)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_namespace.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold namespaces. It can
+      # either work as an extension of the superclass using +add_namespace+ or
+      # it can be reset then set using +namespace+.
+      module WithNamespace
+        # Returns the list of defined namespaces
+        def namespaces
+          return @namespaces if defined?(@namespaces)
+          superclass.try(:namespaces) || Set.new
+        end
+
+        # Set or overwrite the list of namespaces
+        def set_namespace(*list)
+          @namespaces = normalize_namespaces(list).to_set
+        end
+
+        alias set_namespaces set_namespace
+
+        # Add more namespaces to the list already defined. If the super class
+        # has already defined namespaces, the extend that list.
+        def namespace(*list)
+          @namespaces = (superclass.try(:namespaces)&.dup || Set.new) \
+            unless defined?(@namespaces)
+
+          @namespaces.merge(normalize_namespaces(list))
+        end
+
+        private
+
+          def normalize_namespaces(list)
+            list.map { |item| item.to_s.underscore.to_sym }
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_owner.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold an +assigned_to+ object
+      module WithOwner
+        def self.included(other)
+          other.class_attribute(:owner, instance_writer: false)
+        end
+
+        private
+
+          def respond_to_missing?(*args) # :nodoc:
+            owner_respond_to?(*args) || super
+          end
+
+          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+            return super unless owner_respond_to?(method_name)
+            event.on_instance(owner) do |obj|
+              obj.public_send(method_name, *args, **xargs, &block)
+            end
+          end
+
+          # Since owners are classes, this checks for the instance methods of
+          # it, since this is a instance method
+          def owner_respond_to?(method_name, include_private = false)
+            (include_private ? %i[public protected private] : %i[public]).any? do |type|
+              owner.send("#{type}_instance_methods").include?(method_name)
+            end unless owner.nil?
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_schema_fields.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module that allows other objects to hold schema fields (query,
+      # mutation, and subscription fields). Works very similar to fields, but
+      # they are placed in different places regarding their type.
+      module WithSchemaFields
+        SCHEMA_FIELD_TYPES = %i[query mutation subscription].map do |key|
+          [key, "_#{key.to_s.classify}"]
+        end.to_h.freeze
+
+        TYPE_FIELD_CLASS = {
+          query:        'OutputField',
+          mutation:     'MutationField',
+          subscription: 'OutputField',
+        }.freeze
+
+        module ClassMethods # :nodoc: all
+          def inherited(subclass)
+            super if defined? super
+
+            SCHEMA_FIELD_TYPES.each_key do |kind|
+              fields = instance_variable_defined?("@#{kind}_fields")
+              fields = fields ? instance_variable_get("@#{kind}_fields") : {}
+              fields.each_value { |field| subclass.add_proxy_field(kind, field) }
+            end
+          end
+        end
+
+        ScopedConfig = Struct.new(:source, :type) do # :nodoc: all
+          def arg(*args, **xargs, &block)
+            xargs[:owner] ||= source
+            GraphQL::Argument.new(*args, **xargs, &block)
+          end
+
+          private
+
+            def respond_to_missing?(method_name, include_private = false)
+              schema_methods.key?(method_name) ||
+                source.respond_to?(method_name, include_private) || super
+            end
+
+            def method_missing(method_name, *args, **xargs, &block)
+              schema_method = schema_methods[method_name]
+              args.unshift(type) unless schema_method.nil?
+              source.send(schema_method || method_name, *args, **xargs, &block)
+            end
+
+            def schema_methods
+              @@schema_methods ||= begin
+                typed_methods = WithSchemaFields.public_instance_methods
+                typed_methods = typed_methods.zip(typed_methods).to_h
+                typed_methods.merge(
+                  fields:      :fields_for,
+                  safe_field:  :safe_add_field,
+                  field:       :add_field,
+                  proxy_field: :add_proxy_field,
+                  field?:      :has_field?,
+                )
+              end
+            end
+        end
+
+        def self.extended(other) # :nodoc:
+          other.extend(WithSchemaFields::ClassMethods)
+        end
+
+        # A little helper for getting the list of fields of a given type
+        def fields_for(type)
+          public_send("#{type}_fields")
+        end
+
+        # Return the object name for a given +type+ of list of fields
+        def type_name_for(type)
+          SCHEMA_FIELD_TYPES[type]
+        end
+
+        # Only add the field if it is not already defined
+        def safe_add_field(*args, of_type: nil, **xargs, &block)
+          method_name = of_type.nil? ? :add_field : "add_#{of_type}_field"
+          public_send(method_name, *args, **xargs, &block)
+        rescue DuplicatedError
+          # Do not do anything if it is duplicated
+        end
+
+        # Add a new field of the give +type+
+        # See {OutputField}[rdoc-ref:Rails::GraphQL::OutputField] class.
+        def add_field(type, *args, **xargs, &block)
+          xargs[:owner] = self
+          klass = Field.const_get(TYPE_FIELD_CLASS[type])
+          object = klass.new(*args, **xargs, &block)
+
+          raise DuplicatedError, <<~MSG.squish if has_field?(type, object.name)
+            The "#{object.name}" field is already defined on #{type} fields and
+            cannot be redefined.
+          MSG
+
+          fields_for(type)[object.name] = object
+        rescue DefinitionError => e
+          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+        end
+
+        # Add a new field to the list but use a proxy instead of a hard copy of
+        # a given +field+
+        def add_proxy_field(type, field, *args, **xargs, &block)
+          klass = Field.const_get(TYPE_FIELD_CLASS[type])
+          raise ArgumentError, <<~MSG.squish unless field.is_a?(klass)
+            The #{field.class.name} is not a valid field for #{type} fields.
+          MSG
+
+          xargs[:owner] = self
+          object = field.to_proxy(*args, **xargs, &block)
+          raise DuplicatedError, <<~MSG.squish if has_field?(type, object.name)
+            The #{field.name.inspect} field is already defined on #{type} fields
+            and cannot be replaced.
+          MSG
+
+          fields_for(type)[object.name] = object
+        end
+
+        # Find a field and then change some flexible attributes of it
+        def change_field(type, object, **xargs, &block)
+          find_field!(type, object).apply_changes(**xargs, &block)
+        end
+
+        alias overwrite_field change_field
+
+        # Run a configuration block for the given field of a given +type+
+        def configure_field(type, object, &block)
+          find_field!(type, object).configure(&block)
+        end
+
+        # Disable a list of given +fields+ from a given +type+
+        def disable_fields(type, *list)
+          list.flatten.map { |item| find_field(type, item)&.disable! }
+        end
+
+        # Enable a list of given +fields+ from a given +type+
+        def enable_fields(type, *list)
+          list.flatten.map { |item| find_field(type, item)&.enable! }
+        end
+
+        # Check if a field of the given +type+ exists. The +object+ can be the
+        # +gql_name+, +name+, or an actual field.
+        def has_field?(type, object)
+          object = object.name if object.is_a?(GraphQL::Field)
+          fields_for(type).key?(object.is_a?(String) ? object.underscore.to_sym : object)
+        end
+
+        # Find a specific field on the given +type+ list. The +object+ can be
+        # the +gql_name+, +name+, or an actual field.
+        def find_field(type, object)
+          object = object.name if object.is_a?(GraphQL::Field)
+          fields_for(type)[object.is_a?(String) ? object.underscore.to_sym : object]
+        end
+
+        # If the field is not found it will raise an exception
+        def find_field!(type, object)
+          find_field(type, object) || raise(::ArgumentError, <<~MSG.squish)
+            The #{object.inspect} field on #{type} is not defined yet.
+          MSG
+        end
+
+        # Get the list of GraphQL names of all the fields difined
+        def field_names_for(type, enabled_only = true)
+          (enabled_only ? fields_for(type).select(&:enabled?) : fields_for(type))
+            .map(&:gql_name).compact
+        end
+
+        # Run a configuration block for the given +type+
+        def configure_fields(type, &block)
+          schema_scoped_config(self, type).instance_exec(&block)
+        end
+
+        # Validate all the fields to make sure the definition is valid
+        def validate!(*)
+          super if defined? super
+
+          # TODO: Maybe find a way to freeze the fields, since after validation
+          # the best thing to do is block changes
+          SCHEMA_FIELD_TYPES.each_key do |kind|
+            next unless instance_variable_defined?("@#{kind}_fields")
+            instance_variable_get("@#{kind}_fields")&.each_value(&:validate!)
+          end
+        end
+
+        SCHEMA_FIELD_TYPES.each do |kind, type_name|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{kind}_field?(name)
+              field?(:#{kind}, name)
+            end
+
+            def #{kind}_fields(&block)
+              return @#{kind}_fields ||= Concurrent::Map.new if block.nil?
+              configure_fields(:#{kind}, &block)
+              @#{kind}_fields
+            end
+
+            def #{kind}_type_name
+              '#{type_name}'
+            end
+
+            def #{kind}_type
+              OpenStruct.new(
+                kind: :object,
+                object?: true,
+                kind_enum: 'OBJECT',
+                fields: defined?(@#{kind}_fields) ? @#{kind}_fields : nil,
+                gql_name: '#{type_name}',
+                interfaces: nil,
+                description: nil,
+                interfaces?: false,
+                internal?: false,
+              ).freeze
+            end
+          RUBY
+        end
+
+        protected
+
+          # Create a new instace of the +ScopedConfig+ class
+          def schema_scoped_config(*args)
+            WithSchemaFields::ScopedConfig.new(*args)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/helpers/with_validator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper that contains the main exceptions and validation process for a
+      # value against a type
+      module WithValidator
+        delegate :ordinalize, to: 'ActiveSupport::Inflector'
+
+        protected
+
+          # Run the validation process with +value+ against +type+
+          def validate_output!(value, type, checker: :null?, array: true)
+            result = validate_null(value, checker)
+            result ||= array? && array \
+              ? validate_array(value) \
+              : validate_type(value) \
+              unless value.nil?
+
+            return if result.blank?
+            message, idx = result
+
+            base_error = idx.present? \
+              ? "#{ordinalize(idx + 1)} value of the #{gql_name} #{type}" \
+              : "#{gql_name} #{type} value"
+
+            raise InvalidValueError, "The #{base_error} #{message}."
+          end
+
+        private
+
+          def validate_array(value) # :nodoc:
+            return 'is not an array' unless value.is_a?(Enumerable)
+
+            value.each_with_index do |val, idx|
+              err = validate_null(val, :nullable?) || validate_type(val)
+              return err, idx unless err.nil?
+            end
+          end
+
+          def validate_null(value, checker = :null?) # :nodoc:
+            'can not be null' if value.nil? && !send(checker)
+          end
+
+          def validate_type(value) # :nodoc:
+            'is invalid' if leaf_type? && !type_klass.valid_output?(value)
+          end
+      end
+    end
+  end
+end