graphql-activerecord 0.9.1 → 0.10.0.pre.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b747cb0c89283eb53f5bed955aba5ac63c67e403
-  data.tar.gz: 6fc9db07f08a93526bc4d2d6cae816efd4ecf0d5
+  metadata.gz: 492bdd93511565f485130b3faa32d9af36eed176
+  data.tar.gz: bafa803ca1452a1f7ceefe66362cf4c063e06a49
 SHA512:
-  metadata.gz: c9724e12c8b19c2361183aaf25e2823e19c262c0a36ff27d038bc4d7a8972fb63ccfc1104a5e7c3eac450bf1e4a680e0d57daa1718c52ecbaef6b5b71ddb11fa
-  data.tar.gz: 32d5a9dbfed54b57b8e201299294a5413c6958f623c1f83ec8782f6668f26b5967876194097699b7a144d3d0ee88aa8959ef99addcc5aaf2eb0e14533babf1a2
+  metadata.gz: 3e5652bd12e1b46d9bb1834aa8eebe149f5e484d79d29fa7d25297121e626f0962729199dc135e532d348344f4105ca35b3f2b6be5d5c3c02aaca938f0b37edf
+  data.tar.gz: ada3b96ec9bcdbfbdf0dee07ed79ccce4b603a7ac353a99f0b2acc65cec877f081d496e4e39a688f6d1e2a27bec5696424fd1ae6eb25efca36fefc1157c895a5

data/lib/graphql/activerecord.rb

@@ -19,7 +19,8 @@ require 'graphql/models/relation_loader'
 # Order matters...
 require 'graphql/models/promise_relation_connection'
 require 'graphql/models/relation_load_request'
-require 'graphql/models/scalar_types'
+require 'graphql/models/database_types'
+require 'graphql/models/reflection'
 require 'graphql/models/definition_helpers'
 require 'graphql/models/definition_helpers/associations'
 require 'graphql/models/definition_helpers/attributes'
@@ -30,16 +31,14 @@ require 'graphql/models/mutation_helpers/validation_error'
 require 'graphql/models/mutation_helpers/validation'
 require 'graphql/models/mutation_field_map'
 
-require 'graphql/models/proxy_block'
 require 'graphql/models/backed_by_model'
-require 'graphql/models/object_type'
 require 'graphql/models/mutator'
 
 
 module GraphQL
   module Models
     class << self
-      attr_accessor :node_interface_proc, :model_from_id, :authorize, :id_for_model
+      attr_accessor :model_from_id, :authorize, :id_for_model, :model_to_graphql_type
     end
 
     # Returns a promise that will traverse the associations and resolve to the model at the end of the path.
@@ -82,5 +81,30 @@ module GraphQL
       MutationHelpers.print_input_fields(mutator_definition.field_map, definer, "#{prefix}Input")
       mutator_definition
     end
+
+    def self.get_graphql_type(model_class)
+      model_class = model_class.constantize if model_class.is_a?(String)
+
+      if model_to_graphql_type
+        model_to_graphql_type[model_class]
+      else
+        "#{model_class.name}Type".safe_constantize
+      end
+    end
+
+    def self.get_graphql_type!(model_class)
+      type = get_graphql_type(model_class)
+      fail RuntimeError, "Could not locate GraphQL type for model #{model_class}" if type.nil?
+      type
+    end
   end
 end
+
+GraphQL::ObjectType.accepts_definitions(
+  backed_by_model: -> (graph_type, model_type, &block) do
+    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
+)

data/lib/graphql/models/active_record_extension.rb

@@ -41,7 +41,7 @@ module GraphQL
           if defined_enums.include?(attribute.to_s)
             values = defined_enums[attribute.to_s].keys
           else
-            values = DefinitionHelpers.detect_inclusion_values(self, attribute)
+            values = Reflection.possible_values(self, attribute)
           end
 
           if values.nil?

data/lib/graphql/models/backed_by_model.rb

@@ -1,14 +1,18 @@
 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)
+      def initialize(graph_type, model_type, base_model_type: model_type, path: [], object_to_model: DEFAULT_OBJECT_TO_MODEL, detect_nulls: true)
+        model_type = model_type.to_s.classify.constantize unless model_type.is_a?(Class)
+        base_model_type = base_model_type.to_s.classify.constantize unless model_type.is_a?(Class)
+
         @graph_type = graph_type
         @model_type = model_type
-        @object_to_model = DEFAULT_OBJECT_TO_MODEL
+        @object_to_model = object_to_model
+        @base_model_type = base_model_type
+        @path = path
+        @detect_nulls = detect_nulls
       end
 
       def types
@@ -20,36 +24,90 @@ module GraphQL
         @object_to_model
       end
 
-      def attr(name, **options, &block)
-        DefinitionHelpers.define_attribute(graph_type, model_type, model_type, [], name, object_to_model, options, &block)
+      # Allows you to overide the automatic nullability detection. By default, nulls are detected. However, attributes inside
+      # of a proxy_to block are assumed to be nullable, unless the association itself has a presence validator.
+      def detect_nulls(value = nil)
+        @detect_nulls = value if !value.nil?
+        @detect_nulls
       end
 
+      # Adds a field to the graph type that is resolved to an attribute on the model.
+      # @param attribute Symbol with the name of the attribute on the model
+      # @param description Description for the field
+      # @param name Name of the field to use. By default, the attribute name is camelized.
+      # @param nullable Set to false to force the field to be non-null. By default, nullability is automatically detected.
+      # @param deprecation_reason Sets the deprecation reason on the field.
+      def attr(attribute, name: attribute.to_s.camelize(:lower), nullable: nil, description: nil, deprecation_reason: nil, &block)
+        name = name.to_sym unless name.is_a?(Symbol)
+
+        options = {
+          name: name,
+          nullable: nullable,
+          description: description,
+          deprecation_reason: deprecation_reason
+        }
+
+        DefinitionHelpers.define_attribute(@graph_type, @base_model_type, @model_type, @path, attribute, @object_to_model, options, nullable, &block)
+      end
+
+      # Flattens an associated model into the graph type, allowing to you adds its attributes as if they existed on the parent model.
+      # @param association Name of the association to use. Polymorphic belongs_to associations are not supported.
       def proxy_to(association, &block)
-        DefinitionHelpers.define_proxy(graph_type, model_type, model_type, [], association, object_to_model, &block)
+        DefinitionHelpers.define_proxy(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, @detect_nulls, &block)
       end
 
-      def has_one(association, **options)
-        DefinitionHelpers.define_has_one(graph_type, model_type, model_type, [], association, object_to_model, options)
+      def has_one(association, name: association.to_s.camelize(:lower), nullable: nil, description: nil, deprecation_reason: nil)
+        name = name.to_sym unless name.is_a?(Symbol)
+
+        options = {
+          name: name,
+          nullable: nullable,
+          description: description,
+          deprecation_reason: deprecation_reason
+        }
+
+        DefinitionHelpers.define_has_one(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options, @detect_nulls)
       end
 
-      def has_many_connection(association, **options)
-        DefinitionHelpers.define_has_many_connection(graph_type, model_type, model_type, [], association, object_to_model, options)
+      def has_many_connection(association, name: association.to_s.camelize(:lower), nullable: nil, description: nil, deprecation_reason: nil, **goco_options)
+        name = name.to_sym unless name.is_a?(Symbol)
+
+        options = goco_options.merge({
+          name: name,
+          nullable: nullable,
+          description: description,
+          deprecation_reason: deprecation_reason
+        })
+
+        DefinitionHelpers.define_has_many_connection(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options, @detect_nulls)
       end
 
-      def has_many_array(association, **options)
-        DefinitionHelpers.define_has_many_array(graph_type, model_type, model_type, [], association, object_to_model, options)
+      def has_many_array(association, name: association.to_s.camelize(:lower), nullable: nil, description: nil, deprecation_reason: nil, type: nil)
+        name = name.to_sym unless name.is_a?(Symbol)
+
+        options = {
+          name: name,
+          type: type,
+          nullable: nullable,
+          description: description,
+          deprecation_reason: deprecation_reason
+        }
+
+        DefinitionHelpers.define_has_many_array(@graph_type, @base_model_type, @model_type, @path, association, @object_to_model, options, @detect_nulls)
       end
 
       def field(*args, &block)
-        defined_field = GraphQL::Define::AssignObjectField.call(graph_type, *args, &block)
+        defined_field = GraphQL::Define::AssignObjectField.call(@graph_type, *args, &block)
+        name = defined_field.name
+        name = name.to_sym unless name.is_a?(Symbol)
 
-        DefinitionHelpers.register_field_metadata(graph_type, defined_field.name, {
+        DefinitionHelpers.register_field_metadata(@graph_type, 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
+          path: @path,
+          base_model_type: @base_model_type,
+          model_type: @model_type,
+          object_to_base_model: @object_to_model
         })
 
         defined_field

data/lib/graphql/models/database_types.rb

@@ -0,0 +1,39 @@
+module GraphQL
+  module Models
+    module DatabaseTypes
+      TypeStruct = Struct.new(:input, :output)
+
+      def self.registered_type(database_type)
+        @registered_types ||= {}.with_indifferent_access
+
+        result = @registered_types[database_type]
+        return nil if result.nil?
+
+        if !result.input.is_a?(GraphQL::BaseType) || !result.output.is_a?(GraphQL::BaseType)
+          input = result.input
+          output = result.output
+
+          input = input.call if input.is_a?(Proc)
+          output = output.call if output.is_a?(Proc)
+
+          input = input.constantize if input.is_a?(String)
+          output = output.constantize if output.is_a?(String)
+
+          TypeStruct.new(input, output)
+        else
+          result
+        end
+      end
+
+      def self.register(database_type, output_type, input_type = output_type)
+        @registered_types ||= {}.with_indifferent_access
+        @registered_types[database_type] = TypeStruct.new(input_type, output_type)
+      end
+    end
+
+    DatabaseTypes.register(:boolean, GraphQL::BOOLEAN_TYPE)
+    DatabaseTypes.register(:integer, GraphQL::INT_TYPE)
+    DatabaseTypes.register(:float, GraphQL::FLOAT_TYPE)
+    DatabaseTypes.register(:string, GraphQL::STRING_TYPE)
+  end
+end

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

@@ -1,7 +1,7 @@
 module GraphQL
   module Models
     module DefinitionHelpers
-      def self.define_proxy(graph_type, base_model_type, model_type, path, association, object_to_model, &block)
+      def self.define_proxy(graph_type, base_model_type, model_type, path, association, object_to_model, detect_nulls, &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?
@@ -9,7 +9,15 @@ module GraphQL
 
         return unless block_given?
 
-        proxy = ProxyBlock.new(graph_type, base_model_type, reflection.klass, [*path, association], object_to_model)
+        proxy = BackedByModel.new(
+          graph_type,
+          reflection.klass,
+          base_model_type: base_model_type,
+          path: [*path, association],
+          object_to_model: object_to_model,
+          detect_nulls: detect_nulls && Reflection.is_required(model_type, association)
+        )
+
         proxy.instance_exec(&block)
       end
 
@@ -18,36 +26,32 @@ module GraphQL
         ## 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.
+        if reflection.polymorphic?
+          # 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)
+          model_type = reflection.active_record
+          valid_types = Reflection.possible_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
+          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
+          graph_types = valid_types.map { |t| GraphQL::Models.get_graphql_type(t) }.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
+        else
+          GraphQL::Models.get_graphql_type!(reflection.klass)
         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)
+      def self.define_has_one(graph_type, base_model_type, model_type, path, association, object_to_model, options, detect_nulls)
         reflection = model_type.reflect_on_association(association)
 
         fail ArgumentError.new("Association #{association} wasn't found on model #{model_type.name}") unless reflection
@@ -55,10 +59,9 @@ module GraphQL
 
         # Define the field for the association itself
 
-        camel_name = options[:name] || association.to_s.camelize(:lower)
-        camel_name = camel_name.to_sym if camel_name.is_a?(String)
-
-        type_lambda = resolve_has_one_type(reflection)
+        camel_name = options[:name]
+        association_graphql_type = resolve_has_one_type(reflection)
+        association_graphql_type = resolve_nullability(association_graphql_type, model_type, association, detect_nulls, options)
 
         DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
           macro: :has_one,
@@ -72,7 +75,7 @@ module GraphQL
 
         graph_type.fields[camel_name.to_s] = GraphQL::Field.define do
           name camel_name.to_s
-          type type_lambda
+          type association_graphql_type
           description options[:description] if options.include?(:description)
           deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
 
@@ -84,6 +87,7 @@ module GraphQL
 
         # Define the field for the associated model's ID
         id_field_name = :"#{camel_name}Id"
+        id_field_type = resolve_nullability(GraphQL::ID_TYPE, model_type, association, detect_nulls, options)
 
         DefinitionHelpers.register_field_metadata(graph_type, id_field_name, {
           macro: :has_one,
@@ -103,7 +107,7 @@ module GraphQL
 
         graph_type.fields[id_field_name.to_s] = GraphQL::Field.define do
           name id_field_name.to_s
-          type types.ID
+          type id_field_type
           deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
 
           resolve -> (model, args, context) do
@@ -123,14 +127,29 @@ module GraphQL
         end
       end
 
-      def self.define_has_many_array(graph_type, base_model_type, model_type, path, association, object_to_model, options)
+      def self.define_has_many_array(graph_type, base_model_type, model_type, path, association, object_to_model, options, detect_nulls)
         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
+        association_type = options[:type] || GraphQL::Models.get_graphql_type!(reflection.klass)
+
+        if !association_type.is_a?(GraphQL::ListType)
+          association_type = association_type.to_non_null_type.to_list_type
+        end
+
+        id_field_type = GraphQL::ID_TYPE.to_non_null_type.to_list_type
+
+        # The has_many associations are a little special. Instead of checking for a presence validator, we instead assume
+        # that the outer type should be non-null, unless detect_nulls is false. In other words, we prefer an empty
+        # array for the association, rather than null.
+        if (options[:nullable] == nil && detect_nulls) || options[:nullable] == false
+          association_type = association_type.to_non_null_type
+          id_field_type = id_field_type.to_non_null_type
+        end
+
+        camel_name = options[:name]
 
         DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
           macro: :has_many_array,
@@ -144,7 +163,7 @@ module GraphQL
 
         graph_type.fields[camel_name.to_s] = GraphQL::Field.define do
           name camel_name.to_s
-          type type_lambda
+          type association_type
           description options[:description] if options.include?(:description)
           deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
 
@@ -171,7 +190,7 @@ module GraphQL
 
         graph_type.fields[id_field_name.to_s] = GraphQL::Field.define do
           name id_field_name.to_s
-          type types[!types.ID]
+          type id_field_type
           deprecation_reason options[:deprecation_reason] if options.include?(:deprecation_reason)
 
           resolve -> (model, args, context) do
@@ -183,14 +202,19 @@ module GraphQL
         end
       end
 
-      def self.define_has_many_connection(graph_type, base_model_type, model_type, path, association, object_to_model, options)
+      def self.define_has_many_connection(graph_type, base_model_type, model_type, path, association, object_to_model, options, detect_nulls)
         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
+        connection_type = GraphQL::Models.get_graphql_type!(reflection.klass).connection_type
+
+        if (options[:nullable] == nil && detect_nulls) || options[:nullable] == false
+          connection_type = connection_type.to_non_null_type
+        end
+
+        camel_name = options[:name]
 
         DefinitionHelpers.register_field_metadata(graph_type, camel_name, {
           macro: :has_many_connection,
@@ -202,12 +226,20 @@ module GraphQL
           object_to_base_model: object_to_model
         })
 
-        GraphQL::Define::AssignConnection.call(graph_type, camel_name, type_lambda) do
-          resolve -> (model, args, context) do
-            return nil unless model
-
-            # TODO: Figure out a way to remove this from the gem. It's only applicable to GoCo's codebase.
-            GraphSupport.secure(model.public_send(association), context, permission: options[:permission] || :read)
+        # TODO: Figure out a way to remove this from the gem. It's only applicable to GoCo's codebase.
+        if Object.const_defined?('GraphSupport') && GraphSupport.respond_to?(:secure)
+          GraphQL::Define::AssignConnection.call(graph_type, camel_name, connection_type) do
+            resolve -> (model, args, context) do
+              return nil unless model
+              GraphSupport.secure(model.public_send(association), context, permission: options[:permission] || :read)
+            end
+          end
+        else
+          GraphQL::Define::AssignConnection.call(graph_type, camel_name, connection_type) do
+            resolve -> (model, args, context) do
+              return nil unless model
+              model.public_send(association)
+            end
           end
         end
       end

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

@@ -1,104 +1,50 @@
 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
+      def self.resolve_nullability(graphql_type, model_class, attribute_or_association, detect_nulls, options)
+        # If detect_nulls is true, it means that everything on the path (ie, between base_model_class and model_class) is non null.
+        # So for example, if we're five levels deep inside of proxy_to blocks, but every single association along the way has
+        # a presence validator, then `detect_nulls` is false. Thus, we can take it one step further and enforce nullability on the
+        # attribute itself.
+        nullable = options[:nullable]
+
+        if nullable == nil
+          nullable = !(detect_nulls && Reflection.is_required(model_class, attribute_or_association))
         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]
+        if nullable == false
+          graphql_type = graphql_type.to_non_null_type
         else
-          types.String
+          graphql_type
         end
       end
 
-      def self.get_column(model_type, name)
-        col = model_type.columns.detect { |c| c.name == name.to_s }
-        return nil unless col
+      def self.define_attribute(graph_type, base_model_class, model_class, path, attribute, object_to_model, options, detect_nulls, &block)
+        attribute_graphql_type = Reflection.attribute_graphql_type(model_class, attribute).output
+        attribute_graphql_type = resolve_nullability(attribute_graphql_type, model_class, attribute, detect_nulls, options)
 
-        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,
-          nullable: col.null
-        })
-      end
-
-      def self.get_column!(model_type, name)
-        col = get_column(model_type, name)
-        raise ArgumentError.new("The attribute #{name} wasn't found on model #{model_type.name}.") unless col
-        col
-      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, &block)
-        column = get_column!(model_type, attribute)
-        field_name = options[:name] || column.camel_name
+        field_name = options[: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,
+          base_model_class: base_model_class,
+          model_class: model_class,
           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
+          type attribute_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
-              model.public_send(attribute)
-            end
+            model&.public_send(attribute)
           end
-          
+
           instance_exec(&block) if block
         end
       end

data/lib/graphql/models/definition_helpers.rb

@@ -117,32 +117,6 @@ module GraphQL
         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
-
-      def self.detect_is_required(model_type, attr_or_assoc)
-        col = model_type.columns.detect { |c| c.name == attr_or_assoc.to_s }
-        return true if col && !col.null
-
-        validators = model_type.validators_on(attr_or_assoc)
-          .select { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
-          .reject { |v| v.options.include?(:if) || v.options.include?(:unless) }
-
-        return true if validators.any?
-
-        # The column is nullable, and there are no unconditional presence validators,
-        # so it's at least sometimes optional
-        false
-      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)

data/lib/graphql/models/mutation_field_map.rb

@@ -23,31 +23,23 @@ module GraphQL::Models
       GraphQL::Define::TypeDefiner.instance
     end
 
-    def attr(attribute, type: nil, name: nil, required: false)
+    def attr(attribute, type: nil, name: nil, required: nil)
       attribute = attribute.to_sym if attribute.is_a?(String)
 
       if type.nil? && !model_type
         fail ArgumentError.new("You must specify a type for attribute #{name}, because its model type is not known until runtime.")
       end
 
-      if model_type
-        column = DefinitionHelpers.get_column(model_type, attribute)
-
-        if column.nil? && type.nil?
-          fail ArgumentError.new("You must specify a type for attribute #{name}, because it's not a column on #{model_type}.")
-        end
+      if type.nil? && (attribute == :id || foreign_keys.include?(attribute))
+        type = types.ID
+      end
 
-        if column
-          type ||= begin
-            if attribute == :id || foreign_keys.include?(attribute)
-              type = types.ID
-            else
-              type = column.graphql_type
-            end
-          end
+      if type.nil? && model_type
+        type = Reflection.attribute_graphql_type(model_type, attribute).input
+      end
 
-          required = DefinitionHelpers.detect_is_required(model_type, attribute)
-        end
+      if required.nil?
+        required = model_type ? Reflection.is_required(model_type, attribute) : false
       end
 
       name ||= attribute.to_s.camelize(:lower)
@@ -118,7 +110,7 @@ module GraphQL::Models
       end
 
       has_many = reflection.macro == :has_many
-      required = DefinitionHelpers.detect_is_required(model_type, association)
+      required = Reflection.is_required(model_type, association)
 
       map = MutationFieldMap.new(reflection.klass, find_by: find_by, null_behavior: null_behavior)
       map.name = name || association.to_s.camelize(:lower)

data/lib/graphql/models/reflection.rb

@@ -0,0 +1,57 @@
+# Exposes utility methods for getting metadata out of active record models
+module GraphQL::Models
+  module Reflection
+    class << self
+      # Returns the possible values for an attribute on a model by examining inclusion validators
+      def possible_values(model_class, attribute)
+        # Get all of the inclusion validators
+        validators = model_class.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
+
+      # Determines if the attribute (or association) is required by examining presence validators
+      # and the nullability of the column in the database
+      def is_required(model_class, attr_or_assoc)
+        return true if model_class.columns_hash[attr_or_assoc.to_s]&.null == false
+
+        model_class.validators_on(attr_or_assoc)
+          .select { |v| v.is_a?(ActiveModel::Validations::PresenceValidator) }
+          .reject { |v| v.options.include?(:if) || v.options.include?(:unless) }
+          .any?
+      end
+
+      # Returns a struct that tells you the input and output GraphQL types for an attribute
+      def attribute_graphql_type(model_class, attribute)
+        # See if it's an enum
+        if model_class.graphql_enum_types.include?(attribute)
+          type = model_class.graphql_enum_types[attribute]
+          DatabaseTypes::TypeStruct.new(type, type)
+        else
+          # See if it's a registered scalar type
+          active_record_type = model_class.type_for_attribute(attribute.to_s)
+
+          if active_record_type.type.nil?
+            fail ArgumentError, "The type for attribute #{attribute} wasn't found on #{model_class.name}"
+          end
+
+          result = DatabaseTypes.registered_type(active_record_type.type)
+
+          if !result
+            fail RuntimeError, "The type #{active_record_type} is not registered with DatabaseTypes (attribute #{attribute} on #{model_class.name})"
+          end
+
+          # Arrays: Rails doesn't have a generalized way to detect arrays, so we use this method to do it:
+          if active_record_type.class.name.ends_with?('Array')
+            DatabaseTypes::TypeStruct.new(result.input.to_list_type, result.output.to_list_type)
+          else
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/models/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Models
-    VERSION = "0.9.1"
+    VERSION = "0.10.0-alpha1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0.pre.alpha1
 platform: ruby
 authors:
 - Ryan Foster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -176,6 +176,7 @@ files:
 - lib/graphql/models/association_load_request.rb
 - lib/graphql/models/attribute_loader.rb
 - lib/graphql/models/backed_by_model.rb
+- lib/graphql/models/database_types.rb
 - lib/graphql/models/definer.rb
 - lib/graphql/models/definition_helpers.rb
 - lib/graphql/models/definition_helpers/associations.rb
@@ -191,12 +192,10 @@ files:
 - lib/graphql/models/mutation_helpers/validation.rb
 - lib/graphql/models/mutation_helpers/validation_error.rb
 - lib/graphql/models/mutator.rb
-- lib/graphql/models/object_type.rb
 - lib/graphql/models/promise_relation_connection.rb
-- lib/graphql/models/proxy_block.rb
+- lib/graphql/models/reflection.rb
 - lib/graphql/models/relation_load_request.rb
 - lib/graphql/models/relation_loader.rb
-- lib/graphql/models/scalar_types.rb
 - lib/graphql/models/version.rb
 homepage: http://github.com/goco-inc/graphql-activerecord
 licenses:
@@ -213,9 +212,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.8

data/lib/graphql/models/object_type.rb

@@ -1,120 +0,0 @@
-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, &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_attribute(graph_type, resolve_model_type(graph_type), resolve_model_type(graph_type), [], name, object_to_model, options, &block)
-        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/proxy_block.rb

@@ -1,52 +0,0 @@
-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, &block)
-        DefinitionHelpers.define_attribute(@graph_type, @base_model_type, @model_type, @path, name, @object_to_model, options, &block)
-      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/scalar_types.rb

@@ -1,15 +0,0 @@
-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