graphql-activerecord 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ef1f87b7695a19936a0776a5a9d1fe43364bbfe7
+  data.tar.gz: c3aece35fd294936549655ea4d7a6282356803d9
+SHA512:
+  metadata.gz: 54edee615092c39ef2000be4519345706da498d4742d050b074a399b7ff8512b8e83846d2bb88ed51c3763e805b41ad32cf21a1b545b11a0fb42483d093661b8
+  data.tar.gz: 8516a38b326591d06b28f94748f411b6c7c2d471efb4e9495fb88fd510e8b8523eaef3752a5bfc5d084850e5c15ce657c7dcb5e9ada387657c63428510d6e600

data/lib/graphql/activerecord.rb

@@ -0,0 +1,54 @@
+require 'graphql'
+
+require 'graphql/models/monkey_patches/graphql_query_context'
+require 'graphql/models/monkey_patches/graphql_schema_middleware_chain'
+require 'graphql/models/active_record_extension'
+require 'graphql/models/middleware'
+
+# Helpers
+require 'graphql/models/definer'
+require 'graphql/models/association_load_request'
+require 'graphql/models/loader'
+
+# Order matters...
+require 'graphql/models/promise_relation_connection'
+require 'graphql/models/relation_load_request'
+require 'graphql/models/scalar_types'
+require 'graphql/models/definition_helpers'
+require 'graphql/models/definition_helpers/associations'
+require 'graphql/models/definition_helpers/attributes'
+
+require 'graphql/models/proxy_block'
+require 'graphql/models/backed_by_model'
+require 'graphql/models/object_type'
+
+
+module GraphQL
+  module Models
+    class << self
+      attr_accessor :node_interface_proc
+    end
+
+    # Returns a promise that will traverse the associations and resolve to the model at the end of the path.
+    # You can use this to access associated models inside custom field resolvers, without losing optimization
+    # benefits.
+    def self.load_association(starting_model, path, context)
+      path = Array.wrap(path)
+      GraphQL::Models::DefinitionHelpers.load_and_traverse(starting_model, path, context)
+    end
+
+    def self.load_relation(relation)
+      request = RelationLoadRequest.new(relation)
+      request.load
+    end
+
+    def self.field_info(graph_type, field_name)
+      field_name = field_name.to_s
+
+      meta = graph_type.instance_variable_get(:@field_metadata)
+      return nil unless meta
+
+      meta[field_name]
+    end
+  end
+end

data/lib/graphql/models/active_record_extension.rb

@@ -0,0 +1,63 @@
+module GraphQL
+  module Models
+    module ActiveRecordExtension
+      extend ActiveSupport::Concern
+
+      # Default options for graphql_enums
+      ENUM_OPTIONS = {
+        upcase: true
+      }
+
+      class_methods do
+        def graphql_enum_types
+          @_graphql_enum_types ||= {}.with_indifferent_access
+        end
+
+        # Defines a GraphQL enum type on the model
+        def graphql_enum(attribute, **options)
+          options = ENUM_OPTIONS.merge(options)
+          options[:name] ||= "#{self.name}#{attribute.to_s.classify}"
+          options[:description] ||= "#{attribute.to_s.titleize} field on #{self.name.titleize}"
+
+          if !options.include?(:values) && !options.include?(:type)
+            if defined_enums.include?(attribute.to_s)
+              options[:values] = defined_enums[attribute.to_s].keys.map { |ev| [options[:upcase] ? ev.upcase : ev, ev.titleize] }.to_h
+            else
+              fail ArgumentError.new("Could not auto-detect the values for enum #{attribute} on #{self.name}")
+            end
+          end
+
+          enum_type = graphql_enum_types[attribute]
+          unless enum_type
+            enum_type = options[:type] || GraphQL::EnumType.define do
+              name options[:name]
+              description options[:description]
+
+              options[:values].each do |value_name, desc|
+                value(value_name, desc)
+              end
+            end
+
+            graphql_enum_types[attribute] = enum_type
+          end
+
+          graphql_resolve(attribute) { send(attribute).try(:upcase) } if options[:upcase]
+          enum_type
+        end
+
+        def graphql_resolvers
+          @_graphql_resolvers ||= {}.with_indifferent_access
+        end
+
+        # Defines a custom method that is used to resolve this attribute's value when it is included
+        # on a GraphQL type.
+        def graphql_resolve(attribute, &block)
+          fail ArgumentError.new("#{__method__} requires a block") unless block_given?
+          graphql_resolvers[attribute] = block
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, GraphQL::Models::ActiveRecordExtension)

data/lib/graphql/models/association_load_request.rb

@@ -0,0 +1,97 @@
+module GraphQL
+  module Models
+    class AssociationLoadRequest
+      attr_reader :base_model, :association, :context
+
+      def initialize(base_model, association_name, context)
+        @base_model = base_model
+        @association = base_model.association(association_name)
+        @context = context
+      end
+
+      ####################################################################
+      # Public members that all load requests should implement
+      ####################################################################
+
+      def load_type
+        case reflection.macro
+        when :belongs_to
+          :id
+        else
+          :relation
+        end
+      end
+
+      def load_target
+        case reflection.macro
+        when :belongs_to
+          base_model.send(reflection.foreign_key)
+        when :has_many
+          base_model.send(association.reflection.name)
+        else
+          # has_one, need to construct our own relation, because accessing the relation will load the model
+          condition = { reflection.foreign_key => base_model.id }
+
+          if reflection.options.include?(:as)
+            condition[reflection.type] = base_model.class.name
+          end
+
+          target_class.where(condition)
+        end
+      end
+
+      # If the value should be an array, make sure it's an array. If it should be a single value, make sure it's single.
+      # Passed in result could be a single model or an array of models.
+      def ensure_cardinality(result)
+        case reflection.macro
+        when :has_many
+          Array.wrap(result)
+        else
+          result.is_a?(Array) ? result[0] : result
+        end
+      end
+
+      # When the request is fulfilled, this method is called so that it can do whatever caching, etc. is needed
+      def fulfilled(result)
+        association.loaded!
+
+        if reflection.macro == :has_many
+          association.target.concat(result)
+          result.each do |m|
+            association.set_inverse_instance(m)
+          end
+        else
+          association.target = result
+          association.set_inverse_instance(result) if result
+        end
+      end
+
+      def load
+        loader.load(self)
+      end
+
+      #################################################################
+      # Public members specific to an association load request
+      #################################################################
+
+      def target_class
+        case when reflection.polymorphic?
+          base_model.send(reflection.foreign_type).constantize
+        else
+          reflection.klass
+        end
+      end
+
+      private
+
+      def loader
+        @loader ||= Loader.for(target_class)
+      end
+
+      def reflection
+        association.reflection
+      end
+
+    end
+  end
+end

data/lib/graphql/models/backed_by_model.rb

@@ -0,0 +1,59 @@
+module GraphQL
+  module Models
+    class BackedByModel
+      attr_accessor :graph_type, :model_type, :object_to_model
+
+      DEFAULT_OBJECT_TO_MODEL = -> (obj) { obj }
+
+      def initialize(graph_type, model_type)
+        @graph_type = graph_type
+        @model_type = model_type
+        @object_to_model = DEFAULT_OBJECT_TO_MODEL
+      end
+
+      def types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
+      def object_to_model(value = nil)
+        @object_to_model = value if value
+        @object_to_model
+      end
+
+      def attr(name, **options)
+        DefinitionHelpers.define_attribute(graph_type, model_type, model_type, [], name, object_to_model, options)
+      end
+
+      def proxy_to(association, &block)
+        DefinitionHelpers.define_proxy(graph_type, model_type, model_type, [], association, object_to_model, &block)
+      end
+
+      def has_one(association, **options)
+        DefinitionHelpers.define_has_one(graph_type, model_type, model_type, [], association, object_to_model, options)
+      end
+
+      def has_many_connection(association, **options)
+        DefinitionHelpers.define_has_many_connection(graph_type, model_type, model_type, [], association, object_to_model, options)
+      end
+
+      def has_many_array(association, **options)
+        DefinitionHelpers.define_has_many_array(graph_type, model_type, model_type, [], association, object_to_model, options)
+      end
+
+      def field(*args, &block)
+        defined_field = GraphQL::Define::AssignObjectField.call(graph_type, *args, &block)
+
+        DefinitionHelpers.register_field_metadata(graph_type, defined_field.name, {
+          macro: :field,
+          macro_type: :custom,
+          path: [],
+          base_model_type: @model_type.to_s.classify.constantize,
+          model_type: @model_type.to_s.classify.constantize,
+          object_to_base_model: object_to_model
+        })
+
+        defined_field
+      end
+    end
+  end
+end

data/lib/graphql/models/definer.rb

@@ -0,0 +1,26 @@
+# This is a helper class. It lets you build simple DSL's. Methods called against the class are
+# converted into attributes in a hash.
+module GraphQL
+  module Models
+    class Definer
+      def initialize(*methods)
+        @values = {}
+        methods.each do |m|
+          define_singleton_method(m) do |*args|
+            if args.blank?
+              @values[m] = nil
+            elsif args.length == 1
+              @values[m] = args[0]
+            else
+              @values[m] = args
+            end
+          end
+        end
+      end
+
+      def defined_values
+        @values
+      end
+    end
+  end
+end

data/lib/graphql/models/definition_helpers/associations.rb

@@ -0,0 +1,144 @@
+module GraphQL
+  module Models
+    module DefinitionHelpers
+      def self.define_proxy(graph_type, base_model_type, model_type, path, association, object_to_model, &block)
+        reflection = model_type.reflect_on_association(association)
+        raise ArgumentError.new("Association #{association} wasn't found on model #{model_type.name}") unless reflection
+        raise ArgumentError.new("Cannot proxy to polymorphic association #{association} on model #{model_type.name}") if reflection.polymorphic?
+        raise ArgumentError.new("Cannot proxy to #{reflection.macro} association #{association} on model #{model_type.name}") unless [:has_one, :belongs_to].include?(reflection.macro)
+
+        return unless block_given?
+
+        proxy = ProxyBlock.new(graph_type, base_model_type, reflection.klass, [*path, association], object_to_model)
+        proxy.instance_exec(&block)
+      end
+
+      def self.resolve_has_one_type(reflection)
+        ############################################
+        ## Ordinary has_one/belongs_to associations
+        ############################################
+
+        return -> { "#{reflection.klass.name}Graph".constantize } if !reflection.polymorphic?
+
+        ############################################
+        ## Polymorphic associations
+        ############################################
+
+        # For polymorphic associations, we look for a validator that limits the types of entities that could be
+        # used, and use it to build a union. If we can't find one, raise an error.
+
+        model_type = reflection.active_record
+        valid_types = detect_inclusion_values(model_type, reflection.foreign_type)
+
+        if valid_types.blank?
+          fail ArgumentError.new("Cannot include polymorphic #{reflection.name} association on model #{model_type.name}, because it does not define an inclusion validator on #{reflection.foreign_type}")
+        end
+
+        return ->() do
+          graph_types = valid_types.map { |t| "#{t}Graph".safe_constantize }.compact
+
+          GraphQL::UnionType.define do
+            name "#{model_type.name}#{reflection.foreign_type.classify}"
+            description "Objects that can be used as #{reflection.foreign_type.titleize.downcase} on #{model_type.name.titleize.downcase}"
+            possible_types graph_types
+          end
+        end
+      end
+
+      # Adds a field to the graph type which is resolved by accessing a has_one association on the model. Traverses
+      # across has_one associations specified in the path. The resolver returns a promise.
+      def self.define_has_one(graph_type, base_model_type, model_type, path, association, object_to_model, options)
+        reflection = model_type.reflect_on_association(association)
+
+        fail ArgumentError.new("Association #{association} wasn't found on model #{model_type.name}") unless reflection
+        fail ArgumentError.new("Cannot include #{reflection.macro} association #{association} on model #{model_type.name} with has_one") unless [:has_one, :belongs_to].include?(reflection.macro)
+
+        camel_name = options[:name] || association.to_s.camelize(:lower).to_sym
+        type_lambda = resolve_has_one_type(reflection)
+
+        DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
+          macro: :has_one,
+          macro_type: :association,
+          path: path,
+          association: association,
+          base_model_type: base_model_type,
+          model_type: model_type,
+          object_to_base_model: object_to_model
+        })
+
+        graph_type.fields[camel_name.to_s] = GraphQL::Field.define do
+          name camel_name.to_s
+          type type_lambda
+          description options[:description] if options.include?(:description)
+          deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
+
+          resolve -> (model, args, context) do
+            return nil unless model
+            DefinitionHelpers.load_and_traverse(model, [association], context)
+          end
+        end
+      end
+
+      def self.define_has_many_array(graph_type, base_model_type, model_type, path, association, object_to_model, options)
+        reflection = model_type.reflect_on_association(association)
+
+        fail ArgumentError.new("Association #{association} wasn't found on model #{model_type.name}") unless reflection
+        fail ArgumentError.new("Cannot include #{reflection.macro} association #{association} on model #{model_type.name} with has_many_array") unless [:has_many].include?(reflection.macro)
+
+        type_lambda = options[:type] || -> { types[!"#{reflection.klass.name}Graph".constantize] }
+        camel_name = options[:name] || association.to_s.camelize(:lower).to_sym
+
+        DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
+          macro: :has_many_array,
+          macro_type: :association,
+          path: path,
+          association: association,
+          base_model_type: base_model_type,
+          model_type: model_type,
+          object_to_base_model: object_to_model
+        })
+
+        graph_type.fields[camel_name.to_s] = GraphQL::Field.define do
+          name camel_name.to_s
+          type type_lambda
+          description options[:description] if options.include?(:description)
+          deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
+
+          resolve -> (model, args, context) do
+            return nil unless model
+            DefinitionHelpers.load_and_traverse(model, [association], context).then do |result|
+              Array.wrap(result)
+            end
+          end
+        end
+      end
+
+      def self.define_has_many_connection(graph_type, base_model_type, model_type, path, association, object_to_model, options)
+        reflection = model_type.reflect_on_association(association)
+
+        fail ArgumentError.new("Association #{association} wasn't found on model #{model_type.name}") unless reflection
+        fail ArgumentError.new("Cannot include #{reflection.macro} association #{association} on model #{model_type.name} with has_many_connection") unless [:has_many].include?(reflection.macro)
+
+        type_lambda = -> { "#{reflection.klass.name}Graph".constantize.connection_type }
+        camel_name = options[:name] || association.to_s.camelize(:lower).to_sym
+
+        DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
+          macro: :has_many_connection,
+          macro_type: :association,
+          path: path,
+          association: association,
+          base_model_type: base_model_type,
+          model_type: model_type,
+          object_to_base_model: object_to_model
+        })
+
+        GraphQL::Relay::Define::AssignConnection.call(graph_type, camel_name, type_lambda) do
+          resolve -> (model, args, context) do
+            return nil unless model
+            return GraphSupport.secure(model.public_send(association), context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/models/definition_helpers/attributes.rb

@@ -0,0 +1,103 @@
+module GraphQL
+  module Models
+    module DefinitionHelpers
+      def self.type_to_graphql_type(type)
+        registered_type = ScalarTypes.registered_type(type)
+        if registered_type
+          return registered_type.is_a?(Proc) ? registered_type.call : registered_type
+        end
+
+        case type
+        when :boolean
+          types.Boolean
+        when :integer
+          types.Int
+        when :float
+          types.Float
+        when :daterange
+          inner_type = type_to_graphql_type(:date)
+          types[!inner_type]
+        when :tsrange
+          inner_type = type_to_graphql_type(:datetime)
+          types[!inner_type]
+        else
+          types.String
+        end
+      end
+
+      def self.get_column(model_type, name)
+        col = model_type.columns.detect { |c| c.name == name.to_s }
+        raise ArgumentError.new("The attribute #{name} wasn't found on model #{model_type.name}.") unless col
+
+        if model_type.graphql_enum_types.include?(name)
+          graphql_type = model_type.graphql_enum_types[name]
+        else
+          graphql_type = type_to_graphql_type(col.type)
+        end
+
+        if col.array
+          graphql_type = types[graphql_type]
+        end
+
+        return OpenStruct.new({
+          is_range: /range\z/ === col.type.to_s,
+          camel_name: name.to_s.camelize(:lower).to_sym,
+          graphql_type: graphql_type
+        })
+      end
+
+      def self.range_to_graphql(value)
+        return nil unless value
+
+        begin
+          [value.first, value.last_included]
+        rescue TypeError
+          [value.first, value.last]
+        end
+      end
+
+      # Adds a field to the graph type which is resolved by accessing an attribute on the model. Traverses
+      # across has_one associations specified in the path. The resolver returns a promise.
+      # @param graph_type The GraphQL::ObjectType that the field is being added to
+      # @param model_type The class object for the model that defines the attribute
+      # @param path The associations (in order) that need to be loaded, starting from the graph_type's model
+      # @param attribute The name of the attribute that is accessed on the target model_type
+      def self.define_attribute(graph_type, base_model_type, model_type, path, attribute, object_to_model, options)
+        column = get_column(model_type, attribute)
+        field_name = options[:name] || column.camel_name
+
+        DefinitionHelpers.register_field_metadata(graph_type, field_name, {
+          macro: :attr,
+          macro_type: :attribute,
+          path: path,
+          attribute: attribute,
+          base_model_type: base_model_type,
+          model_type: model_type,
+          object_to_base_model: object_to_model
+        })
+
+        graph_type.fields[field_name.to_s] = GraphQL::Field.define do
+          name field_name.to_s
+          type column.graphql_type
+          description options[:description] if options.include?(:description)
+          deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
+
+          resolve -> (model, args, context) do
+            return nil unless model
+            
+            if column.is_range
+              DefinitionHelpers.range_to_graphql(model.public_send(attribute))
+            else
+              if model_type.graphql_resolvers.include?(attribute)
+                resolve_proc = model_type.graphql_resolvers[attribute]
+                model.instance_exec(&resolve_proc)
+              else
+                model.public_send(attribute)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/models/definition_helpers.rb

@@ -0,0 +1,117 @@
+require 'ostruct'
+
+module GraphQL
+  module Models
+    module DefinitionHelpers
+      def self.types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
+      # Returns a promise that will eventually resolve to the model that is at the end of the path
+      def self.load_and_traverse(current_model, path, context)
+        cache_model(context, current_model)
+        return Promise.resolve(current_model) if path.length == 0 || current_model.nil?
+
+        association = current_model.association(path[0])
+
+        while path.length > 0 && (association.loaded? || attempt_cache_load(current_model, association, context))
+          current_model = association.target
+          path = path[1..-1]
+          cache_model(context, current_model)
+
+          return Promise.resolve(current_model) if path.length == 0 || current_model.nil?
+
+          association = current_model.association(path[0])
+        end
+
+        request = AssociationLoadRequest.new(current_model, path[0], context)
+        request.load.then do |next_model|
+          next next_model if next_model.blank?
+          cache_model(context, next_model)
+
+          if path.length == 1
+            sanity = next_model.is_a?(Array) ? next_model[0] : next_model
+            next next_model
+          else
+            DefinitionHelpers.load_and_traverse(next_model, path[1..-1], context)
+          end
+        end
+      end
+
+      # Attempts to retrieve the model from the query's cache. If it's found, the association is marked as
+      # loaded and the model is added. This only works for belongs_to and has_one associations.
+      def self.attempt_cache_load(model, association, context)
+        return false unless context
+
+        reflection = association.reflection
+        return false unless [:has_one, :belongs_to].include?(reflection.macro)
+
+        if reflection.macro == :belongs_to
+          target_id = model.send(reflection.foreign_key)
+
+          # If there isn't an associated model, mark the association loaded and return
+          mark_association_loaded(association, nil) and return true if target_id.nil?
+
+          # If the associated model isn't cached, return false
+          target = context.cached_models.detect { |m| m.is_a?(association.klass) && m.id == target_id }
+          return false unless target
+
+          # Found it!
+          mark_association_loaded(association, target)
+          return true
+        else
+          target = context.cached_models.detect do |m|
+            m.is_a?(association.klass) && m.send(reflection.foreign_key) == model.id && (!reflection.options.include?(:as) || m.send(reflection.type) == model.class.name)
+          end
+
+          return false unless target
+
+          mark_association_loaded(association, target)
+          return true
+        end
+      end
+
+      def self.cache_model(context, model)
+        return unless context
+        context.cached_models.merge(Array.wrap(model))
+      end
+
+      def self.mark_association_loaded(association, target)
+        association.loaded!
+        association.target = target
+        association.set_inverse_instance(target) unless target.nil?
+      end
+
+      def self.traverse_path(base_model, path, context)
+        model = base_model
+        path.each do |segment|
+          return nil unless model
+          model = model.public_send(segment)
+        end
+
+        return model
+      end
+
+      # Detects the values that are valid for an attribute by looking at the inclusion validators
+      def self.detect_inclusion_values(model_type, attribute)
+        # Get all of the inclusion validators
+        validators = model_type.validators_on(attribute).select { |v| v.is_a?(ActiveModel::Validations::InclusionValidator) }
+
+        # Ignore any inclusion validators that are using the 'if' or 'unless' options
+        validators = validators.reject { |v| v.options.include?(:if) || v.options.include?(:unless) || v.options[:in].blank? }
+        return nil unless validators.any?
+        return validators.map { |v| v.options[:in] }.reduce(:&)
+      end
+
+      # Stores metadata about GraphQL fields that are available on this model's GraphQL type.
+      # @param metadata Should be a hash that contains information about the field's definition, including :macro and :type
+      def self.register_field_metadata(graph_type, field_name, metadata)
+        field_name = field_name.to_s
+
+        field_meta = graph_type.instance_variable_get(:@field_metadata)
+        field_meta = graph_type.instance_variable_set(:@field_metadata, {}) unless field_meta
+        field_meta[field_name] = OpenStruct.new(metadata).freeze
+      end
+    end
+  end
+end

data/lib/graphql/models/loader.rb

@@ -0,0 +1,104 @@
+module GraphQL
+  module Models
+    class Loader < GraphQL::Batch::Loader
+      attr_reader :model_class
+
+      def initialize(model_class)
+        @model_class = model_class
+      end
+
+      def perform(load_requests)
+
+        # Group the requests to load by id into a single relation, and we'll fan it back out after
+        # we have the results
+
+        relations = []
+        id_requests = load_requests.select { |r| r.load_type == :id }
+        id_relation = model_class.where(id: id_requests.map(&:load_target))
+
+        relations.push(id_relation) if id_requests.any?
+        relations_to_requests = {}
+
+        # Gather up all of the requests to load a relation, and map the relations back to their requests
+        load_requests.select { |r| r.load_type == :relation }.each do |request|
+          relation = request.load_target
+          relations.push(relation) unless relations.detect { |r| r.object_id == relation.object_id }
+          relations_to_requests[relation.object_id] ||= []
+          relations_to_requests[relation.object_id].push(request)
+        end
+
+        # We need to build a query that will return all of the rows that match any of the relations.
+        # But in addition, we also need to know how that relation sorted them. So we pull any ordering
+        # information by adding RANK() columns to the query, and we determine whether that row belonged
+        # to the query by adding CASE columns.
+
+        # Map each relation to a SQL query that selects only the ID column for the rows that match it
+        selection_clauses = relations.map do |relation|
+          relation.unscope(:select).select(model_class.primary_key).to_sql
+        end
+
+        # Generate a CASE column that will tell us whether the row matches this particular relation
+        slicing_columns = relations.each_with_index.map do |relation, index|
+          %{ CASE WHEN "#{model_class.table_name}"."#{model_class.primary_key}" IN (#{selection_clauses[index]}) THEN 1 ELSE 0 END AS "in_relation_#{index}" }
+        end
+
+        # For relations that have sorting applied, generate a RANK() column that tells us how the rows are
+        # sorted within that relation
+        sorting_columns = relations.each_with_index.map do |relation, index|
+          arel = relation.arel
+          next nil unless arel.orders.any?
+
+          order_by = arel.orders.map do |expr|
+            if expr.is_a?(Arel::Nodes::SqlLiteral)
+              expr.to_s
+            else
+              expr.to_sql
+            end
+          end
+
+          %{ RANK() OVER (ORDER BY #{order_by.join(', ')}) AS "sort_relation_#{index}" }
+        end
+
+        sorting_columns.compact!
+
+        # Build the query that will select any of the rows that match the selection clauses
+        main_relation = model_class
+          .where("id in ((#{selection_clauses.join(") UNION (")}))")
+          .select(%{ "#{model_class.table_name}".* })
+
+        main_relation = slicing_columns.reduce(main_relation) { |relation, memo| relation.select(memo) }
+        main_relation = sorting_columns.reduce(main_relation) { |relation, memo| relation.select(memo) }
+
+        # Run the query
+        result = main_relation.to_a
+
+        # Now multiplex the results out to all of the relations that had asked for values
+        relations.each_with_index do |relation, index|
+          slice_col = "in_relation_#{index}"
+          sort_col = "sort_relation_#{index}"
+
+          matching_rows = result.select { |r| r[slice_col] == 1 }.sort_by { |r| r[sort_col] }
+
+          if relation.object_id == id_relation.object_id
+            pk = relation.klass.primary_key
+
+            id_requests.each do |request|
+              row = matching_rows.detect { |r| r[pk] == request.load_target }
+              fulfill(request, row)
+            end
+          else
+            relations_to_requests[relation.object_id].each do |request|
+              fulfill_request(request, matching_rows)
+            end
+          end
+        end
+      end
+
+      def fulfill_request(request, result)
+        result = request.ensure_cardinality(result)
+        request.fulfilled(result)
+        fulfill(request, result)
+      end
+    end
+  end
+end

data/lib/graphql/models/middleware.rb

@@ -0,0 +1,23 @@
+class GraphQL::Models::Middleware
+  attr_accessor :skip_nil_models
+
+  def initialize(skip_nil_models = true)
+    @skip_nil_models = skip_nil_models
+  end
+
+  def call(graphql_type, object, field_definition, args, context, next_middleware)
+    # If this field defines a path, load the associations in the path
+    field_info = GraphQL::Models.field_info(graphql_type, field_definition.name)
+    return next_middleware.call unless field_info
+
+    # Convert the core object into the model
+    base_model = field_info.object_to_base_model.call(object)
+
+    GraphQL::Models.load_association(base_model, field_info.path, context).then do |model|
+      next nil if model.nil? && @skip_nil_models
+
+      next_args = [graphql_type, model, field_definition, args, context]
+      next_middleware.call(next_args)
+    end
+  end
+end

data/lib/graphql/models/monkey_patches/graphql_query_context.rb

@@ -0,0 +1,5 @@
+class GraphQL::Query::Context
+  def cached_models
+    @cached_models ||= Set.new
+  end
+end

data/lib/graphql/models/monkey_patches/graphql_schema_middleware_chain.rb

@@ -0,0 +1,10 @@
+# Monkey patch... there will soon be a PR in graphql-ruby for this functionality,
+# Talked with the gem author (@rmosolgo) and he said it was a good feature, so likely to land soon
+class GraphQL::Schema::MiddlewareChain
+  def call(next_arguments = @arguments)
+    @arguments = next_arguments
+    next_step = steps.shift
+    next_middleware = self
+    next_step.call(*arguments, next_middleware)
+  end
+end

data/lib/graphql/models/object_type.rb

@@ -0,0 +1,120 @@
+module GraphQL
+  module Models
+    module ObjectType
+      class << self
+        DEFAULT_OBJECT_TO_MODEL = -> (object) { object }
+
+        def object_to_model(graph_type, model_proc)
+          graph_type.instance_variable_set(:@unscoped_object_to_model, model_proc)
+        end
+
+        def model_type(graph_type, model_type)
+          model_type = model_type.to_s.classify.constantize unless model_type.is_a?(Class)
+
+          object_to_model = -> (object) do
+            model_proc = graph_type.instance_variable_get(:@unscoped_object_to_model)
+            if model_proc
+              model_proc.call(object)
+            else
+              DEFAULT_OBJECT_TO_MODEL.call(object)
+            end
+          end
+
+          graph_type.instance_variable_set(:@unscoped_model_type, model_type)
+
+          graph_type.fields['id'] = GraphQL::Field.define do
+            name 'id'
+            type !types.ID
+            resolve -> (object, args, context) { object.gid }
+          end
+
+          if GraphQL::Models.node_interface_proc
+            node_interface = GraphQL::Models.node_interface_proc.call
+            graph_type.interfaces = [*graph_type.interfaces, node_interface].uniq
+          end
+
+          graph_type.fields['rid'] = GraphQL::Field.define do
+            name 'rid'
+            type !types.String
+            resolve -> (object, args, context) do
+              model = object_to_model.call(object)
+              model.id
+            end
+          end
+
+          graph_type.fields['rtype'] = GraphQL::Field.define do
+            name 'rtype'
+            type !types.String
+            resolve -> (object, args, context) do
+              model = object_to_model.call(object)
+              model.class.name
+            end
+          end
+
+          if model_type.columns.detect { |c| c.name == 'created_at'}
+            DefinitionHelpers.define_attribute(graph_type, model_type, model_type, [], :created_at, object_to_model, {})
+          end
+
+          if model_type.columns.detect { |c| c.name == 'updated_at'}
+            DefinitionHelpers.define_attribute(graph_type, model_type, model_type, [], :updated_at, object_to_model, {})
+          end
+        end
+
+        def proxy_to(graph_type, association, &block)
+          ensure_has_model_type(graph_type, __method__)
+          object_to_model = graph_type.instance_variable_get(:@unscoped_object_to_model) || DEFAULT_OBJECT_TO_MODEL
+          DefinitionHelpers.define_proxy(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], association, object_to_model, &block)
+        end
+
+        def attr(graph_type, name, **options)
+          ensure_has_model_type(graph_type, __method__)
+          object_to_model = graph_type.instance_variable_get(:@unscoped_object_to_model) || DEFAULT_OBJECT_TO_MODEL
+          DefinitionHelpers.define_attribute(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], name, object_to_model, options)
+        end
+
+        def has_one(graph_type, association, **options)
+          ensure_has_model_type(graph_type, __method__)
+          object_to_model = graph_type.instance_variable_get(:@unscoped_object_to_model) || DEFAULT_OBJECT_TO_MODEL
+          DefinitionHelpers.define_has_one(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], association, object_to_model, options)
+        end
+
+        def has_many_connection(graph_type, association, **options)
+          ensure_has_model_type(graph_type, __method__)
+          object_to_model = graph_type.instance_variable_get(:@unscoped_object_to_model) || DEFAULT_OBJECT_TO_MODEL
+          DefinitionHelpers.define_has_many_connection(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], association, object_to_model, options)
+        end
+
+        def has_many_array(graph_type, association, **options)
+          ensure_has_model_type(graph_type, __method__)
+          object_to_model = graph_type.instance_variable_get(:@unscoped_object_to_model) || DEFAULT_OBJECT_TO_MODEL
+          DefinitionHelpers.define_has_many_array(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], association, object_to_model, options)
+        end
+
+        def backed_by_model(graph_type, model_type, &block)
+          model_type = model_type.to_s.classify.constantize unless model_type.is_a?(Class)
+
+          backer = GraphQL::Models::BackedByModel.new(graph_type, model_type)
+          backer.instance_exec(&block)
+        end
+
+        private
+
+        def resolve_model_type(graph_type)
+          graph_type.instance_variable_get(:@unscoped_model_type)
+        end
+
+        def ensure_has_model_type(graph_type, method)
+          fail RuntimeError.new("You must call model_type before using the #{method} method.") unless graph_type.instance_variable_get(:@unscoped_model_type)
+        end
+      end
+
+      # Attach the methods to ObjectType
+      extensions = ObjectType.methods(false).reduce({}) do |memo, method|
+        memo[method] = ObjectType.method(method)
+        memo
+      end
+
+      GraphQL::ObjectType.accepts_definitions(extensions)
+    end
+  end
+end

data/lib/graphql/models/promise_relation_connection.rb

@@ -0,0 +1,22 @@
+module GraphQL
+  module Models
+    class PromiseRelationConnection < GraphQL::Relay::RelationConnection
+      def edges
+        # Can't do any optimization if the request is asking for the last X items, since there's
+        # no easy way to turn it into a generalized query.
+        return super if last
+
+        relation = sliced_nodes
+        limit = [first, last, max_page_size].compact.min
+        relation = relation.limit(limit) if first
+        request = RelationLoadRequest.new(relation)
+
+        request.load.then do |models|
+          models.map { |m| GraphQL::Relay::Edge.new(m, self) }
+        end
+      end
+    end
+
+    GraphQL::Relay::BaseConnection.register_connection_implementation(ActiveRecord::Relation, PromiseRelationConnection)
+  end
+end

data/lib/graphql/models/proxy_block.rb

@@ -0,0 +1,52 @@
+module GraphQL
+  module Models
+    class ProxyBlock
+      def initialize(graph_type, base_model_type, model_type, path, object_to_model)
+        @path = path
+        @base_model_type = base_model_type
+        @model_type = model_type
+        @graph_type = graph_type
+        @object_to_model = object_to_model
+      end
+
+      def types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
+      def attr(name, **options)
+        DefinitionHelpers.define_attribute(@graph_type, @base_model_type, @model_type, @path, name, @object_to_model, options)
+      end
+
+      def proxy_to(association, &block)
+        DefinitionHelpers.define_proxy(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, &block)
+      end
+
+      def has_one(association, **options)
+        DefinitionHelpers.define_has_one(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options)
+      end
+
+      def has_many_connection(association, **options)
+        DefinitionHelpers.define_has_many_connection(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options)
+      end
+
+      def has_many_array(association, **options)
+        DefinitionHelpers.define_has_many_array(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options)
+      end
+
+      def field(*args, &block)
+        defined_field = GraphQL::Define::AssignObjectField.call(@graph_type, *args, &block)
+
+        DefinitionHelpers.register_field_metadata(@graph_type, defined_field.name, {
+          macro: :field,
+          macro_type: :custom,
+          path: @path,
+          base_model_type: @base_model_type,
+          model_type: @model_type,
+          object_to_base_model: @object_to_model
+        })
+
+        defined_field
+      end
+    end
+  end
+end

data/lib/graphql/models/relation_load_request.rb

@@ -0,0 +1,52 @@
+module GraphQL
+  module Models
+    class RelationLoadRequest
+      attr_reader :relation
+
+      def initialize(relation)
+        @relation = relation
+      end
+
+      ####################################################################
+      # Public members that all load requests should implement
+      ####################################################################
+
+      def load_type
+        :relation
+      end
+
+      def load_target
+        relation
+      end
+
+      # If the value should be an array, make sure it's an array. If it should be a single value, make sure it's single.
+      # Passed in result could be a single model or an array of models.
+      def ensure_cardinality(result)
+        Array.wrap(result)
+      end
+
+      # When the request is fulfilled, this method is called so that it can do whatever caching, etc. is needed
+      def fulfilled(result)
+      end
+
+      def load
+        loader.load(self)
+      end
+
+      #################################################################
+      # Public members specific to a relation load request
+      #################################################################
+
+      def target_class
+        relation.klass
+      end
+
+      private
+      
+      def loader
+        @loader ||= Loader.for(target_class)
+      end
+
+    end
+  end
+end

data/lib/graphql/models/scalar_types.rb

@@ -0,0 +1,15 @@
+module GraphQL
+  module Models
+    module ScalarTypes
+      def self.registered_type(database_type)
+        @registered_types ||= {}.with_indifferent_access
+        @registered_types[database_type]
+      end
+
+      def self.register(database_type, graphql_type)
+        @registered_types ||= {}.with_indifferent_access
+        @registered_types[database_type] = graphql_type
+      end
+    end
+  end
+end

data/lib/graphql/models/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Models
+    VERSION = "0.3.1"
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: graphql-activerecord
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Ryan Foster
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: graphql-relay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: Build Relay-compatible GraphQL schemas based on ActiveRecord models
+email:
+- theorygeek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/graphql/activerecord.rb
+- lib/graphql/models/active_record_extension.rb
+- lib/graphql/models/association_load_request.rb
+- lib/graphql/models/backed_by_model.rb
+- lib/graphql/models/definer.rb
+- lib/graphql/models/definition_helpers.rb
+- lib/graphql/models/definition_helpers/associations.rb
+- lib/graphql/models/definition_helpers/attributes.rb
+- lib/graphql/models/loader.rb
+- lib/graphql/models/middleware.rb
+- lib/graphql/models/monkey_patches/graphql_query_context.rb
+- lib/graphql/models/monkey_patches/graphql_schema_middleware_chain.rb
+- lib/graphql/models/object_type.rb
+- lib/graphql/models/promise_relation_connection.rb
+- lib/graphql/models/proxy_block.rb
+- lib/graphql/models/relation_load_request.rb
+- lib/graphql/models/scalar_types.rb
+- lib/graphql/models/version.rb
+homepage: http://github.com/goco-inc/graphql-activerecord
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: ActiveRecord helpers for GraphQL + Relay
+test_files: []