rails-graphql 0.1.0

data/lib/rails/graphql/source/active_record_source.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Source Active Record
+    #
+    # This source allows the translation of active record objects into a new
+    # source object, creating:
+    # 1. 1 Object
+    # 2. 1 Input
+    # 3. 2 Query fields (ingular and plural)
+    # 4. 3 Mutation fields (create, update, destroy)
+    class Source::ActiveRecordSource < Source
+      include Source::ScopedArguments
+
+      require_relative 'active_record/builders'
+      extend Builders
+
+      validate_assignment('ActiveRecord::Base') do |value|
+        "The \"#{value.name}\" is not a valid Active Record model"
+      end
+
+      # The name of the class (or the class itself) to be used as superclass for
+      # the generate GraphQL interface type of this source
+      class_attribute :interface_class, instance_writer: false
+      alias interface interface_class
+
+      %i[object interface input].each do |type|
+        settings = { abstract: true, with_owner: true }
+        send("#{type}_class=", create_type(type, **settings))
+      end
+
+      self.abstract = true
+
+      delegate :primary_key, :singular, :plural, :model, to: :class
+
+      skip_on :input, :created_at, :updated_at
+
+      on :start do
+        GraphQL.enable_ar_adapter(adapter_name)
+        build_enum_types
+      end
+
+      on :object do
+        build_attribute_fields(self)
+        build_reflection_fields(self)
+      end
+
+      on :input do
+        extra = { primary_key => { null: true } }
+        build_attribute_fields(self, **extra)
+        build_reflection_inputs(self)
+
+        safe_field(model.inheritance_column, :string, null: false) if object.interface?
+        safe_field(:_delete, :boolean, default: false)
+
+        reference = model.new
+        model.columns_hash.each_value do |column|
+          change_field(column.name, default: reference[column.name]) \
+            if column.default.present? && field?(column.name)
+        end
+      end
+
+      on :query do
+        safe_field(plural, object, full: true) do
+          before_resolve :load_records
+        end
+
+        safe_field(singular, object, null: false) do
+          argument primary_key, :id, null: false
+          before_resolve :load_record
+        end
+      end
+
+      on :mutation do
+        safe_field("create_#{singular}", object, null: false) do
+          argument singular, input, null: false
+          perform :create_record
+        end
+
+        safe_field("update_#{singular}", object, null: false) do
+          argument primary_key, :id, null: false
+          argument singular, input, null: false
+          before_resolve :load_record
+          perform :update_record
+        end
+
+        safe_field("delete_#{singular}", :boolean, null: false) do
+          argument primary_key, :id, null: false
+          before_resolve :load_record
+          perform :destroy_record
+        end
+      end
+
+      on :finish do
+        attach_fields!
+        attach_scoped_arguments_to(query_fields.values)
+        attach_scoped_arguments_to(mutation_fields.values)
+
+        next if model.base_class == model
+
+        # TODO: Allow nested inheritance for setting up implementation
+        type_map_after_register(model.base_class.name) do |type|
+          object.implements(type) if type.interface?
+        end
+      end
+
+      class << self
+        delegate :primary_key, :model_name, to: :model
+        delegate :singular, :plural, :param_key, to: :model_name
+        delegate :adapter_name, to: 'model.connection'
+
+        alias model assigned_class
+        alias model= assigned_to=
+
+        # Set the assignemnt to a model with a similar name as the source
+        def assigned_to
+          @assigned_to ||= name.delete_prefix('GraphQL::')[0..-7]
+        end
+
+        # Stores columns associated with enums so that the fields can have a
+        # correctly assigned type
+        def enums
+          @enums ||= model.defined_enums.dup
+        end
+
+        protected
+
+          # Check if a given +attr_name+ is associated with a presence validator
+          # but ignores when there is a default value
+          def attr_required?(attr_name)
+            return true if attr_name.eql?(primary_key)
+            return false if model.columns_hash[attr_name]&.default.present?
+            return false unless model._validators.key?(attr_name.to_sym)
+            model._validators[attr_name.to_sym].any?(presence_validator)
+          rescue ::ActiveRecord::StatementInvalid
+            false
+          end
+
+        private
+
+          def presence_validator # :nodoc:
+            ::ActiveRecord::Validations::PresenceValidator
+          end
+      end
+
+      # Prepare to load multiple records from the underlying table
+      def load_records
+        inject_scopes(model.all, :relation)
+      end
+
+      # Prepare to load a single record from the underlying table
+      def load_record
+        load_records.find(event.argument(primary_key))
+      end
+
+      # Get the chain result and preload the records with thre resulting scope
+      def preload_association(association, scope = nil)
+        event.stop(preload(association, scope || event.last_result), layer: :object)
+      end
+
+      # Collect a scope for filters applied to a given association
+      def build_association_scope(association)
+        scope = model._reflect_on_association(association).klass.unscoped
+
+        # Apply proxied injected scopes
+        proxied = event.field.try(:proxied_owner)
+        scope = event.on_instance(proxied) do |instance|
+          instance.inject_scopes(scope, :relation)
+        end if proxied.present? && proxied <= Source::ActiveRecordSource
+
+        # Apply self defined injected scopes
+        inject_scopes(scope, :relation)
+      end
+
+      # Once the records are pre-loaded due to +preload_association+, use the
+      # parent value and the preloader result to get the records
+      def parent_owned_records(collection_result = false)
+        data = event.data[:prepared]
+        return collection_result ? [] : nil unless data
+
+        result = data.records_by_owner[current_value] || []
+        collection_result ? result : result.first
+      end
+
+      # The perform step for the +create+ based mutation
+      def create_record
+        input_argument.resource.tap(&:save!)
+      end
+
+      # The perform step for the +update+ based mutation
+      def update_record
+        current_value.tap { |record| record.update!(**input_argument.params) }
+      end
+
+      # The perform step for the +delete+ based mutation
+      def destroy_record
+        !!current_value.destroy!
+      end
+
+      protected
+
+        # Basically get the argument associated to the input
+        def input_argument
+          event.argument(singular)
+        end
+
+        # Preload the records for a given +association+ using the current value.
+        # It can be further specified with a given +scope+
+        def preload(association, scope = nil)
+          reflection = model._reflect_on_association(association)
+          records = current_value.is_a?(preloader_association) \
+            ? current_value.preloaded_records \
+            : Array.wrap(current_value.itself).compact
+
+          ar_preloader.send(:preloaders_for_reflection, reflection, records, scope).first
+        end
+
+        # Get the cached instance of active record prelaoder
+        def ar_preloader
+          event.request.cache(:ar_preloader) { ::ActiveRecord::Associations::Preloader.new }
+        end
+
+      private
+
+        def preloader_association # :nodoc:
+          ActiveRecord::Associations::Preloader::Association
+        end
+    end
+  end
+end

data/lib/rails/graphql/source/scoped_arguments.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # This is a helper class that allows sources to have scoped-based arguments,
+    # meaning that when an argument is present, it triggers the underlying block
+    # on the fields where the argument was attached to
+    #
+    # TODO: Easy the usage of scoped arguments with AR, to map model scopes as
+    # arguments using the abilities here provided
+    module Source::ScopedArguments
+      def self.included(other)
+        other.extend(ClassMethods)
+      end
+
+      # Extended argument class to be the instance of the scoped
+      class Argument < GraphQL::Argument
+        attr_reader :block, :fields
+
+        def initialize(*args, on: nil, **xargs, &block)
+          super(*args, **xargs)
+
+          @block = block
+          @fields = Array.wrap(on).presence
+        end
+
+        # Check if the argument should be attached to the given +field+
+        def attach_to?(field)
+          return true if fields.nil?
+
+          fields.any? do |item|
+            (item.is_a?(Symbol) && field.name.eql?(item)) || field.gql_name.eql?(item)
+          end
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        # Return the list of scoped params defined
+        def scoped_arguments
+          defined?(@scoped_arguments) ? @scoped_arguments : {}
+        end
+
+        protected
+
+          # Add a new scoped param to the list
+          def scoped_argument(param, type = :string, proc_method = nil, **settings, &block)
+            block = proc_method if proc_method.present? && block.nil?
+            argument = Argument.new(param, type, **settings.merge(owner: self), &block)
+            (@scoped_arguments ||= {})[argument.name] = argument
+          end
+
+          alias scoped_arg scoped_arguments
+
+          # Helper method to attach the scoped arguments to a given +field+
+          def attach_scoped_arguments_to(*fields, safe: true)
+            fields = fields.flatten.compact
+            return if fields.blank?
+
+            scoped_arguments.each_value do |argument|
+              fields.each do |item|
+                item.ref_argument(argument) if argument.attach_to?(item)
+              rescue DuplicatedError
+                raise unless safe
+              end
+            end
+          end
+      end
+
+      # Find all the executable arguments attached to the running field and
+      # call them with the given object
+      def inject_scopes(object, assigned_to = nil)
+        return object if event.field.nil? || (args_source = event.send(:args_source)).nil?
+
+        event.data[assigned_to] ||= object unless assigned_to.nil?
+        event.field.all_arguments.each_value.inject(object) do |result, argument|
+          next result unless argument.respond_to?(:block) && args_source.key?(argument.name)
+          send_args = argument.block.arity.eql?(1) ? [args_source[argument.name]] : []
+
+          value = result.instance_exec(*send_args, &argument.block)
+          value = value.nil? ? result : value
+
+          assigned_to.nil? ? value : event.data[assigned_to] = value
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/to_gql.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+require 'arel/visitors/visitor'
+
+# rubocop:disable Naming/MethodParameterName, Naming/MethodName
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL ToGQL
+    #
+    # This class can turn any class related to GraphQL into its GraphQL string
+    # representation. It was developed more for testing purposes, but it can
+    # also used by describing purposes or generating API description pages.
+    class ToGQL < Arel::Visitors::Visitor
+      DESCRIBE_TYPES = %i[scalar enum input_object interface union object].freeze
+
+      # Trigger a new compile process
+      def self.compile(node, **xargs)
+        new.compile(node, **xargs)
+      end
+
+      # Trigger a new describe process
+      def self.describe(schema, **xargs)
+        new.describe(schema, **xargs)
+      end
+
+      # Describe the given +node+ as GraphQL
+      def compile(node, collector = nil, with_descriptions: true)
+        collector ||= Collectors::IdentedCollector.new
+        @with_descriptions = with_descriptions
+        accept(node, collector).value
+      end
+
+      # Describe the given +schema+ as GraphQL, with all types and directives
+      def describe(schema, collector = nil, with_descriptions: true, with_spec: nil)
+        collector ||= Collectors::IdentedCollector.new
+        @with_descriptions = with_descriptions
+        @with_spec = with_spec.nil? ? schema.introspection? : with_spec
+
+        accept(schema, collector).eol
+
+        GraphQL.type_map.each_from(schema.namespace, base_class: :Type)
+          .group_by(&:kind).values_at(*DESCRIBE_TYPES)
+          .each do |items|
+            items&.sort_by(&:gql_name)&.each do |item|
+              next if !@with_spec && item.internal?
+
+              next visit_Rails_GraphQL_Type_Object(item, collector).eol \
+                if item.is_a?(::OpenStruct) && item.object?
+
+              accept(item, collector).eol
+            end
+          end
+
+        GraphQL.type_map.each_from(schema.namespace, base_class: :Directive)
+          .sort_by(&:gql_name).each do |item|
+            next if !@with_spec && item.spec_object
+            accept(item, collector).eol
+          end
+
+        collector.value.chomp
+      end
+
+      # Keep visitors in an alphabetical order, but leave instances at the end
+      protected
+
+        def visit_Rails_GraphQL_Directive(o, collector)
+          return visit_Rails_GraphQL_Directive_Instance(o, collector) \
+            unless o.is_a?(Module)
+
+          visit_description(o, collector)
+          collector << 'directive @' << o.gql_name
+          visit_arguments(o.arguments, collector)
+          collector << ' on '
+          collector << o.locations.map { |l| l.to_s.upcase }.join(' | ')
+          collector.eol
+        end
+
+        def visit_Rails_GraphQL_Field(o, collector)
+          return if o.disabled?
+
+          visit_description(o, collector)
+          collector << o.gql_name
+
+          visit_arguments(o.all_arguments, collector) \
+            if o.respond_to?(:all_arguments)
+
+          collector << ': '
+
+          visit_typed_object(o, collector)
+          visit_directives(o.directives, collector)
+          collector.eol if @with_descriptions
+          collector.eol
+        end
+
+        def visit_Rails_GraphQL_Mutation(o, collector)
+          visit_description(o, collector)
+          collector << o.gql_name
+
+          visit_arguments(o.arguments, collector)
+          collector << ': '
+
+          visit_typed_object(o, collector)
+          collector.eol
+        end
+
+        def visit_Rails_GraphQL_Schema(o, collector)
+          visit_description(o, collector)
+          collector << 'schema'
+          visit_directives(o.directives, collector)
+
+          collector.indented(' {', '}') do
+            Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.each do |key, name|
+              next unless key.eql?(:query) || o.fields_for(key).present?
+
+              collector << key.to_s
+              collector << ': '
+              collector << name
+              collector.eol
+            end
+          end
+        end
+
+        def visit_Rails_GraphQL_Field_AssociationField(o, collector)
+          return if o.disabled?
+
+          if @with_descriptions
+            field = o.instance_variable_get(:@field)
+            collector << '# Association of '
+            collector << field.owner.name
+            collector << '["'
+            collector << field.gql_name
+            collector << '"]'
+            collector.eol
+          end
+
+          visit_Rails_GraphQL_Field(o, collector)
+        end
+
+        def visit_Rails_GraphQL_Field_ProxyField(o, collector)
+          return if o.disabled?
+
+          if @with_descriptions
+            field = o.instance_variable_get(:@field)
+            collector << '# Proxy of '
+            collector << field.owner.name
+            collector << '["'
+            collector << field.gql_name
+            collector << '"]'
+            collector.eol
+          end
+
+          visit_Rails_GraphQL_Field(o, collector)
+        end
+
+        def visit_Rails_GraphQL_Field_OutputField(o, collector)
+          visit_Rails_GraphQL_Field(o, collector)
+        end
+
+        def visit_Rails_GraphQL_Field_InputField(o, collector)
+          visit_Rails_GraphQL_Field(o, collector)
+        end
+
+        def visit_Rails_GraphQL_Type_Enum(o, collector)
+          visit_description(o, collector)
+          collector << 'enum '
+          collector << o.gql_name
+          visit_directives(o.directives, collector)
+
+          collector.indented(' {', '}') do
+            o.values.each { |x| visit_enum_value(o, x, collector) }
+          end
+        end
+
+        def visit_Rails_GraphQL_Type_Input(o, collector)
+          visit_description(o, collector)
+          visit_assignment(o, collector)
+          collector << 'input '
+          collector << o.gql_name
+          visit_directives(o.directives, collector)
+
+          collector.indented(' {', '}') do
+            o.fields.each_value { |x| visit(x, collector) }
+          end
+        end
+
+        def visit_Rails_GraphQL_Type_Interface(o, collector)
+          visit_description(o, collector)
+          visit_assignment(o, collector)
+          collector << 'interface '
+          collector << o.gql_name
+          visit_directives(o.directives, collector)
+
+          collector.indented(' {', '}') do
+            o.fields.each_value { |x| visit(x, collector) }
+          end
+        end
+
+        def visit_Rails_GraphQL_Type_Object(o, collector)
+          visit_description(o, collector)
+          visit_assignment(o, collector)
+          collector << 'type '
+          collector << o.gql_name
+
+          if o.interfaces?
+            collector << ' implements '
+            o.all_interfaces.each_with_index do |x, i|
+              collector << ' & ' if i.positive?
+              collector << x.gql_name
+            end
+          end
+
+          visit_directives(o.directives, collector)
+
+          collector.indented(' {', '}') do
+            o.fields.each_value { |x| visit(x, collector) }
+          end
+        end
+
+        def visit_Rails_GraphQL_Type_Scalar(o, collector)
+          visit_description(o, collector)
+          collector << 'scalar '
+          collector << o.gql_name
+          visit_directives(o.directives, collector)
+
+          collector.eol
+        end
+
+        def visit_Rails_GraphQL_Type_Union(o, collector)
+          visit_description(o, collector)
+          collector << 'union '
+          collector << o.gql_name
+          visit_directives(o.directives, collector)
+
+          collector << ' = '
+          collector << o.members.map(&:gql_name).join(' | ')
+          collector.eol
+        end
+
+        def visit_Rails_GraphQL_Directive_Instance(o, collector)
+          collector << '@' << o.gql_name
+          return unless o.args.to_h.values.any?
+
+          collector << '('
+          o.arguments.values.each_with_index do |x, i|
+            value = o.args[x.gql_name]
+            value = o.args[x.name] if value.nil?
+            next if value.nil?
+
+            collector << ', ' if i.positive?
+            collector << x.gql_name
+            collector << ': '
+            collector << x.as_json(value).inspect
+          end
+          collector << ')'
+        end
+
+        def visit_Rails_GraphQL_Argument_Instance(o, collector)
+          visit_description(o, collector)
+          collector << o.gql_name << ': '
+          visit_typed_object(o, collector)
+        end
+
+        def visit_arguments(list, collector)
+          return if list.empty?
+
+          indented = @with_descriptions && list.values.any?(&:description?)
+
+          collector << '('
+          collector.eol.indent if indented
+
+          list.each_value.with_index do |x, i|
+            if i.positive?
+              collector << ', '
+              collector.eol if indented
+              collector.eol if @with_descriptions && x.description?
+            end
+
+            visit_Rails_GraphQL_Argument_Instance(x, collector)
+          end
+
+          collector.eol.unindent if indented
+          collector << ')'
+        end
+
+        def visit_assignment(o, collector)
+          return unless @with_descriptions && o.assigned?
+
+          collector << '# Assigned to '
+          collector << o.assigned_to
+          collector << ' class'
+          collector.eol
+        end
+
+        def visit_description(o, collector)
+          return unless @with_descriptions && o.description?
+
+          if o.description.lines.size === 1
+            collector << o.description.inspect
+          else
+            collector << '"""'
+            collector.eol
+
+            collector << o.description
+            collector.eol
+
+            collector << '"""'
+          end
+
+          collector.eol
+        end
+
+        def visit_directives(list, collector)
+          list&.each do |x|
+            collector << ' '
+            visit_Rails_GraphQL_Directive_Instance(x, collector)
+          end
+        end
+
+        def visit_enum_value(o, value, collector)
+          description = o.value_description[value]
+          directives = o.value_directives[value]
+
+          unless !@with_descriptions || description.nil?
+            collector << description.inspect
+            collector.eol
+          end
+
+          collector << value
+          visit_directives(directives, collector)
+          collector.eol if @with_descriptions
+          collector.eol
+        end
+
+        def visit_typed_object(o, collector)
+          collector << '[' if o.array?
+          collector << o.type_klass.gql_name
+
+          if o.array?
+            collector << '!' unless o.nullable?
+            collector << ']'
+          end
+
+          collector << '!' unless o.null?
+          collector << ' = ' << o.to_json(o.default) if o.try(:default_value?)
+        end
+
+        def visit(object, collector = nil) # :nodoc:
+          object_class = object.is_a?(Module) ? object : object.class
+          dispatch_method = dispatch[object_class]
+          if collector
+            send dispatch_method, object, collector
+          else
+            send dispatch_method, object
+          end
+        rescue ::NoMethodError => e
+          raise e if respond_to?(dispatch_method, true)
+          superklass = object_class.ancestors.find do |klass|
+            respond_to?(dispatch[klass], true)
+          end
+
+          raise(::TypeError, "Cannot visit #{object_class}") unless superklass
+          dispatch[object_class] = dispatch[superklass]
+          retry
+        end
+    end
+  end
+end
+# rubocop:enable Naming/MethodParameterName, Naming/MethodName