graphql-activerecord 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef1f87b7695a19936a0776a5a9d1fe43364bbfe7
-  data.tar.gz: c3aece35fd294936549655ea4d7a6282356803d9
+  metadata.gz: f66ba2bd587b9ec556a33c6c53be9feb2f0897d3
+  data.tar.gz: 30b46efe06e881c0237d5f624cd7376873e0b253
 SHA512:
-  metadata.gz: 54edee615092c39ef2000be4519345706da498d4742d050b074a399b7ff8512b8e83846d2bb88ed51c3763e805b41ad32cf21a1b545b11a0fb42483d093661b8
-  data.tar.gz: 8516a38b326591d06b28f94748f411b6c7c2d471efb4e9495fb88fd510e8b8523eaef3752a5bfc5d084850e5c15ce657c7dcb5e9ada387657c63428510d6e600
+  metadata.gz: 70e55f628ca3ce4d4c385bfdf090eca6905867b698a917cefacfbc172fe8f0778de945d99fbab8579007d3d1da573e47b4f23dcb7728e9ddfe11f4911084711a
+  data.tar.gz: b7d96cfc3e4a0bdbbb732ca49fc99e264b4589406f05894c450a62a5279df33204c3e063d6a672904304215f63260837f620f1c3ef015ce9d01580baa25aab4b

data/lib/graphql/activerecord.rb

@@ -17,16 +17,23 @@ 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/mutation_helpers/print_input_fields'
+require 'graphql/models/mutation_helpers/apply_changes'
+require 'graphql/models/mutation_helpers/authorization'
+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
+      attr_accessor :node_interface_proc, :model_from_id, :authorize
     end
 
     # Returns a promise that will traverse the associations and resolve to the model at the end of the path.
@@ -50,5 +57,16 @@ module GraphQL
 
       meta[field_name]
     end
+
+    def self.authorize!(context, model, action)
+      authorize.call(context, model, action)
+    end
+
+    def self.define_mutator(definer, model_type, null_behavior:, &block)
+      mutator_definition = MutatorDefinition.new(model_type, null_behavior: null_behavior)
+      mutator_definition.field_map.instance_exec(&block)
+      MutationHelpers.print_input_fields(mutator_definition.field_map, definer, model_type.name)
+      mutator_definition
+    end
   end
 end

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

@@ -27,7 +27,7 @@ module GraphQL
 
       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
+        return nil unless col
 
         if model_type.graphql_enum_types.include?(name)
           graphql_type = model_type.graphql_enum_types[name]
@@ -42,10 +42,17 @@ module GraphQL
         return OpenStruct.new({
           is_range: /range\z/ === col.type.to_s,
           camel_name: name.to_s.camelize(:lower).to_sym,
-          graphql_type: graphql_type
+          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
 
@@ -63,7 +70,7 @@ module GraphQL
       # @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)
+        column = get_column!(model_type, attribute)
         field_name = options[:name] || column.camel_name
 
         DefinitionHelpers.register_field_metadata(graph_type, field_name, {
@@ -84,7 +91,7 @@ module GraphQL
 
           resolve -> (model, args, context) do
             return nil unless model
-            
+
             if column.is_range
               DefinitionHelpers.range_to_graphql(model.public_send(attribute))
             else

data/lib/graphql/models/definition_helpers.rb

@@ -103,6 +103,21 @@ module GraphQL
         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

@@ -0,0 +1,155 @@
+module GraphQL::Models
+  class MutationFieldMap
+    attr_accessor :model_type, :find_by, :null_behavior, :fields, :nested_maps
+
+    # These are used when this is a proxy_to or a nested field map
+    attr_accessor :name, :association, :has_many, :required, :path
+
+    def initialize(model_type, find_by:, null_behavior:)
+      fail ArgumentError.new("model_type must be a model") if model_type && !(model_type <= ActiveRecord::Base)
+      fail ArgumentError.new("null_behavior must be :set_null or :leave_unchanged") unless [:set_null, :leave_unchanged].include?(null_behavior)
+
+      @fields = []
+      @nested_maps = []
+      @path = []
+      @model_type = model_type
+      @find_by = Array.wrap(find_by)
+      @null_behavior = null_behavior
+
+      @find_by.each { |f| attr(f) }
+    end
+
+    def types
+      GraphQL::Define::TypeDefiner.instance
+    end
+
+    def attr(attribute, type: nil, name: nil, required: false)
+      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 column
+          type ||= begin
+            if attribute == :id || foreign_keys.include?(attribute)
+              type = types.ID
+            else
+              type = column.graphql_type
+            end
+          end
+
+          required = DefinitionHelpers.detect_is_required(model_type, attribute)
+        end
+      end
+
+      name ||= attribute.to_s.camelize(:lower)
+      name = name.to_s
+
+      detect_field_conflict(name)
+
+      fields.push({
+        name: name,
+        attribute: attribute,
+        type: type,
+        required: required
+      })
+    end
+
+    def proxy_to(association, &block)
+      association = association.to_sym if association.is_a?(String)
+
+      reflection = model_type&.reflect_on_association(association)
+
+      if reflection
+        unless [:belongs_to, :has_one].include?(reflection.macro)
+          fail ArgumentError.new("Cannot proxy to #{reflection.macro} association #{association} from #{model_type.name}")
+        end
+
+        klass = reflection.polymorphic? ? nil : reflection.klass
+      else
+        klass = nil
+      end
+
+      proxy = MutationFieldMap.new(klass, find_by: nil, null_behavior: null_behavior)
+      proxy.association = association
+      proxy.instance_exec(&block)
+
+      proxy.fields.each { |f| detect_field_conflict(f[:name]) }
+      proxy.nested_maps.each { |m| detect_field_conflict(m.name) }
+
+      proxy.fields.each do |field|
+        fields.push({
+          name: field[:name],
+          attribute: field[:attribute],
+          type: field[:type],
+          required: field[:required],
+          path: [association] + Array.wrap(field[:path])
+        })
+      end
+
+      proxy.nested_maps.each do |m|
+        m.path.unshift(association)
+        nested_maps.push(m)
+      end
+    end
+
+    def nested(association, find_by: nil, null_behavior:, name: nil, has_many: false, &block)
+      unless model_type
+        fail ArgumentError.new("Cannot use `nested` unless the model type is known at build time.")
+      end
+
+      association = association.to_sym if association.is_a?(String)
+      reflection = model_type.reflect_on_association(association)
+
+      unless reflection
+        fail ArgumentError.new("Could not find association #{association} on #{model_type.name}")
+      end
+
+      if reflection.polymorphic?
+        fail ArgumentError.new("Cannot used `nested` with polymorphic association #{association} on #{model_type.name}")
+      end
+
+      has_many = reflection.macro == :has_many
+      required = DefinitionHelpers.detect_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)
+      map.association = association.to_s
+      map.has_many = has_many
+      map.required = required
+
+      detect_field_conflict(map.name)
+
+      map.instance_exec(&block)
+
+      nested_maps.push(map)
+    end
+
+    def leave_null_unchanged?
+      null_behavior == :leave_unchanged
+    end
+
+    private
+
+    def detect_field_conflict(name)
+      if fields.any? { |f| f[name] == name } || nested_maps.any? { |n| n.name == name }
+        fail ArgumentError.new("The field #{name} is defined more than once.")
+      end
+    end
+
+    def foreign_keys
+      @foreign_keys ||= model_type.reflections.values
+        .select { |r| r.macro == :belongs_to }
+        .map(&:foreign_key)
+        .map(&:to_sym)
+    end
+  end
+end

data/lib/graphql/models/mutation_helpers/apply_changes.rb

@@ -0,0 +1,229 @@
+module GraphQL::Models
+  module MutationHelpers
+    def self.apply_changes(field_map, model, inputs, context)
+      # This will hold a flattened list of attributes/models that we actually changed
+      changes = []
+
+      # Values will now contain the list of inputs that we should actually act on. Any null values should actually
+      # be set to null, and missing fields should be skipped.
+      values = field_map.leave_null_unchanged? ? prep_leave_unchanged(inputs) : prep_set_null(field_map, inputs)
+
+      values.each do |name, value|
+        field_def = field_map.fields.detect { |f| f[:name] == name }
+
+        # Skip this value unless it's a field on the model. Nested fields are handled later.
+        next unless field_def
+
+        # Advance to the model that we actually need to change
+        change_model = model_to_change(model, field_def[:path], changes, create_if_missing: !value.nil?)
+        next if change_model.nil?
+
+        # Apply the change to this model
+        apply_field_value(change_model, field_def, value, context, changes)
+      end
+
+      # Handle the value nested fields now.
+      field_map.nested_maps.each do |child_map|
+        next if inputs[child_map.name].nil? && field_map.leave_null_unchanged?
+
+        # Advance to the model that contains the nested fields
+        change_model = model_to_change(model, child_map.path, changes, create_if_missing: !inputs[child_map.name].nil?)
+        next if change_model.nil?
+
+        # Apply the changes to the nested models
+        child_changes = handle_nested_map(field_map, change_model, inputs, context, child_map)
+
+        # Merge the changes with the parent, but prepend the input field path
+        child_changes.each do |cc|
+          cc[:input_path] = [child_map.name] + Array.wrap(cc[:input_path]) if cc[:input_path]
+          changes.push(cc)
+        end
+      end
+
+      return changes
+    end
+
+    def self.handle_nested_map(parent_map, parent_model, inputs, context, child_map)
+      next_inputs = inputs[child_map.name]
+
+      # Don't do anything if the value is null, and we leave null fields unchanged
+      return [] if next_inputs.nil? && parent_map.leave_null_unchanged?
+
+      changes = []
+      matches = match_inputs_to_models(parent_model, child_map, next_inputs, changes)
+
+      matches.each do |match|
+        child_changes = apply_changes(child_map, match[:child_model], match[:child_inputs], context)
+
+        if match[:input_path]
+          child_changes.select { |cc| cc[:input_path] }.each do |cc|
+            cc[:input_path] = [match[:input_path]] + Array.wrap(cc[:input_path])
+          end
+        end
+
+        changes.concat(child_changes)
+      end
+
+      return changes
+    end
+
+    def self.match_inputs_to_models(model, child_map, next_inputs, changes)
+      if !child_map.has_many
+        child_model = model.public_send(child_map.association)
+
+        unless child_model
+          child_model = model.public_send("build_#{child_map.association}")
+          changes.push({ model_instance: child_model, action: :create })
+        end
+
+        return [{ child_model: child_model, child_inputs: next_inputs }]
+      else
+        next_inputs = [] if next_inputs.nil?
+
+        # Match up each of the elements in next_inputs with one of the models, based on the `find_by` value.
+        associated_models = model.public_send(child_map.association)
+        find_by = Array.wrap(child_map.find_by).map(&:to_s)
+
+        if find_by.empty?
+          return match_inputs_by_position(model, child_map, next_inputs, changes, associated_models, find_by)
+        else
+          return match_inputs_by_fields(model, child_map, next_inputs, changes, associated_models, find_by)
+        end
+      end
+    end
+
+    def self.match_inputs_by_position(model, child_map, next_inputs, changes, associated_models, find_by)
+      count = [associated_models.length, next_inputs.length].max
+
+      matches = []
+
+      # This will give us an array of [number, model, inputs].
+      # Either the model or the inputs could be nil, but not both.
+      count.times.zip(associated_models.to_a, next_inputs) do |(idx, child_model, inputs)|
+        if child_model.nil?
+          child_model = associated_models.build
+          changes.push({ model_instance: child_model, action: :create })
+        end
+
+        if inputs.nil?
+          child_model.mark_for_destruction
+          changes.push({ model_instance: child_model, action: :destroy })
+          next
+        end
+
+        matches.push({ child_model: child_model, child_inputs: inputs, input_path: idx })
+      end
+
+      return matches
+    end
+
+    def self.match_inputs_by_fields(model, child_map, next_inputs, changes, associated_models, find_by)
+      grouped_models = associated_models.group_by { |m| m.attributes.slice(*find_by) }
+      grouped_inputs = next_inputs.group_by { |ni| ni.to_h.slice(*find_by) }
+
+      # Match each model to its input. If there is no input for it, mark that the model should be destroyed.
+      matches = []
+
+      # TODO: Support for finding by an ID field, that needs to be untranslated from a Relay ID into a model ID
+
+      grouped_models.each do |key_attrs, vals|
+        child_model = vals[0]
+
+        inputs = grouped_inputs[key_attrs][0]
+
+        if inputs.nil?
+          child_model.mark_for_destruction
+          changes.push({ model_instance: child_model, action: :destroy })
+        else
+          matches.push({ child_model: child_model, child_inputs: inputs, input_path: next_inputs.index(inputs) })
+        end
+      end
+
+      # Build a new model for each input that doesn't have a model
+      grouped_inputs.each do |key_attrs, vals|
+        inputs = vals[0]
+
+        next if grouped_models.include?(key_attrs)
+        child_model = associated_models.build
+        changes.push({ model_instance: child_model, action: :create })
+        matches.push({ child_model: child_model, child_inputs: inputs, input_path: next_inputs.index(inputs) })
+      end
+
+      return matches
+    end
+
+    # Returns the instance of the model that will be changed for this field. If new models are created along the way,
+    # they are added to the list of changes.
+    def self.model_to_change(starting_model, path, changes, create_if_missing: true)
+      model_to_change = starting_model
+
+      Array.wrap(path).each do |ps|
+        next_model = model_to_change.public_send(ps)
+
+        return nil if next_model.nil? && !create_if_missing
+
+        unless next_model
+          next_model = model_to_change.public_send("build_#{ps}")
+          # Even though we may not be changing anything on this model, record it as a change, since it's a new model.
+          changes.push({ model_instance: next_model, action: :create })
+        end
+
+        model_to_change = next_model
+      end
+
+      return model_to_change
+    end
+
+    def self.apply_field_value(model, field_def, value, context, changes)
+      # Special case: If this is an ID field, get the ID from the target model
+      if value.present? && field_def[:type].unwrap == GraphQL::ID_TYPE
+        target_model = GraphQL::Models.model_from_id.call(value, context)
+
+        unless target_model
+          fail GraphQL::ExecutionError.new("The value provided for #{field_def[:name]} does not refer to a valid model.")
+        end
+
+        value = target_model.id
+      end
+
+      unless model.public_send(field_def[:attribute]) == value
+        model.public_send("#{field_def[:attribute]}=", value)
+
+        changes.push({
+          model_instance: model,
+          input_path: field_def[:name],
+          attribute: field_def[:attribute],
+          action: model.new_record? ? :create : :update
+        })
+      end
+    end
+
+    # If the field map has the option leave_null_unchanged, there's an `unsetFields` string array that contains the
+    # name of inputs that should be treated as if they are null. We handle that by removing null inputs, and then
+    # adding back any unsetFields with null values.
+    def self.prep_leave_unchanged(inputs)
+      # String key hash
+      values = inputs.to_h.compact
+
+      unset = Array.wrap(values['unsetFields'])
+      values.delete('unsetFields')
+
+      unset.each do |name|
+        values[name] = nil
+      end
+
+      values
+    end
+
+    # Field map has the option to set_null. Any field that has the value null, or is missing, will be set to null.
+    def self.prep_set_null(field_map, inputs)
+      values = inputs.to_h.compact
+
+      field_map.fields.each { |f| values[f[:name]] ||= nil }
+      field_map.nested_maps.each { |m| values[m.name] ||= nil }
+
+      values
+    end
+
+  end
+end

data/lib/graphql/models/mutation_helpers/authorization.rb

@@ -0,0 +1,13 @@
+module GraphQL::Models
+  module MutationHelpers
+    def self.authorize_changes(context, all_changes)
+      changed_models = all_changes.group_by { |c| c[:model_instance] }
+
+      changed_models.each do |model, changes|
+        changes.map { |c| c[:action] }.uniq.each do |action|
+          GraphQL::Models.authorize!(context, action, model)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/models/mutation_helpers/print_input_fields.rb

@@ -0,0 +1,45 @@
+module GraphQL::Models
+  module MutationHelpers
+    def self.print_input_fields(field_map, definer, map_name_prefix)
+      definer.instance_exec do
+        field_map.fields.each do |f|
+          field_type = f[:type]
+
+          if f[:required] && !field_map.leave_null_unchanged?
+            field_type = field_type.to_non_null_type
+          end
+
+          input_field(f[:name], field_type)
+        end
+
+        if field_map.leave_null_unchanged?
+          input_field('unsetFields', types[!types.String])
+        end
+      end
+
+      # Build the input types for the nested input maps
+      field_map.nested_maps.each do |child_map|
+        type = build_input_type(child_map, "#{map_name_prefix}#{child_map.name.to_s.classify}")
+
+        if child_map.has_many
+          type = type.to_non_null_type.to_list_type
+        end
+
+        if child_map.required && !field_map.leave_null_unchanged?
+          type = type.to_non_null_type
+        end
+
+        definer.instance_exec do
+          input_field(child_map.name, type)
+        end
+      end
+    end
+
+    def self.build_input_type(field_map, name)
+      type = GraphQL::InputObjectType.define do
+        name(name)
+        GraphQL::Models::MutationHelpers.print_input_fields(field_map, self, name)
+      end
+    end
+  end
+end

data/lib/graphql/models/mutation_helpers/validation.rb

@@ -0,0 +1,95 @@
+module GraphQL::Models
+  module MutationHelpers
+    def self.validate_changes(inputs, field_map, root_model, context, all_changes)
+      invalid_fields = {}
+      unknown_errors = []
+
+      changed_models = all_changes.group_by { |c| c[:model_instance] }
+
+      changed_models.reject { |m, v| m.valid? }.each do |model, changes|
+        attrs_to_field = changes
+          .select { |c| c[:attribute] && c[:input_path] }
+          .map { |c| [c[:attribute], c[:input_path]] }
+          .to_h
+
+        model.errors.each do |attribute, message|
+          attribute = attribute.to_sym if attribute.is_a?(String)
+
+          # Cheap check, see if this is a field that the user provided a value for...
+          if attrs_to_field.include?(attribute)
+            add_error(attribute, message, attrs_to_field[attribute], invalid_fields)
+          else
+            # Didn't provide a value, expensive check... trace down the input field
+            path = detect_input_path_for_attribute(model, attribute, inputs, field_map, root_model)
+
+            if path
+              add_error(attribute, message, path, invalid_fields)
+            else
+              unknown_errors.push({
+                modelType: model.class.name,
+                modelRid: model.id,
+                attribute: attribute,
+                message: message
+              })
+            end
+          end
+        end
+      end
+
+      unless invalid_fields.empty? && unknown_errors.empty?
+        fail ValidationError.new(invalid_fields, unknown_errors)
+      end
+    end
+
+    def self.add_error(attribute, message, path, invalid_fields)
+      path = Array.wrap(path)
+
+      current = invalid_fields
+      path[0..-2].each do |ps|
+        current = current[ps] ||= {}
+      end
+
+      current[path[-1]] = message
+    end
+
+    # Given a model and an attribute, returns the path of the input field that would modify that attribute
+    def self.detect_input_path_for_attribute(target_model, attribute, inputs, field_map, starting_model)
+      # Case 1: The input field is inside of this field map.
+      candidate_fields = field_map.fields.select { |f| f[:attribute] == attribute }
+
+      candidate_fields.each do |field|
+        # Walk to this field. If the model we get is the same as the target model, we found a match.
+        candidate_model = model_to_change(starting_model, field[:path], [], create_if_missing: false)
+        return Array.wrap(field[:name]) if candidate_model == target_model
+      end
+
+      # Case 2: The input field is somewhere inside of a nested field map.
+      field_map.nested_maps.each do |child_map|
+        # If we don't have the values for this map, it can't be the right one.
+        next if inputs[child_map.name].blank?
+
+        # Walk to the model that contains the nested field
+        candidate_model = model_to_change(starting_model, child_map.path, [], create_if_missing: false)
+
+        # If the model for this map doesn't exist, it can't be the one we need, because the target_model does exist.
+        next if candidate_model.nil?
+
+        # Match up the inputs with the models, and then check each of them.
+        candidate_matches = match_inputs_to_models(candidate_model, child_map, inputs[child_map.name], [])
+
+        candidate_matches.each do |m|
+          result = detect_input_path_for_attribute(target_model, attribute, m[:child_inputs], child_map, m[:child_model])
+          next if result.nil?
+
+          path = Array.wrap(result)
+          path.unshift(m[:input_path]) if m[:input_path]
+          return path
+        end
+      end
+
+      return nil
+    end
+
+
+  end
+end

data/lib/graphql/models/mutation_helpers/validation_error.rb

@@ -0,0 +1,36 @@
+module GraphQL::Models
+  module MutationHelpers
+    class ValidationError < GraphQL::ExecutionError
+      attr_accessor :invalid_arguments, :unknown_errors
+
+      def initialize(invalid_arguments, unknown_errors)
+        @invalid_arguments = invalid_arguments
+        @unknown_errors = unknown_errors
+      end
+
+      def to_h
+        values = {
+          'message' => "Some of your changes could not be saved.",
+          'kind' => "INVALID_ARGUMENTS",
+          'invalidArguments' => invalid_arguments,
+          'unknownErrors' => unknown_errors
+        }
+
+        if ast_node
+          values.merge!({
+            'locations' => [{
+              "line" => ast_node.line,
+              "column" => ast_node.col,
+            }]
+          })
+        end
+
+        values
+      end
+
+      def to_s
+        "Some of your changes could not be saved."
+      end
+    end
+  end
+end

data/lib/graphql/models/mutator.rb

@@ -0,0 +1,50 @@
+module GraphQL::Models
+  class Mutator
+    attr_accessor :field_map, :root_model, :inputs, :context
+
+    def initialize(field_map, root_model, inputs, context)
+      @field_map = field_map
+      @root_model = root_model
+      @inputs = inputs
+      @context = context
+    end
+
+    def apply_changes
+      fail StandardError.new("Called apply_changes twice for the same mutator") if @all_changes
+      @all_changes = MutationHelpers.apply_changes(field_map, root_model, inputs, context)
+      changed_models
+    end
+
+    def changed_models
+      fail StandardError.new("Need to call apply_changes before #{__method__}") unless @all_changes
+      @all_changes.map { |c| c[:model_instance] }.uniq
+    end
+
+    def validate!
+      fail StandardError.new("Need to call apply_changes before #{__method__}") unless @all_changes
+      MutationHelpers.validate_changes(inputs, field_map, root_model, context, @all_changes)
+    end
+
+    def authorize!
+      fail StandardError.new("Need to call apply_changes before #{__method__}") unless @all_changes
+      MutationHelpers.authorize_changes(context, @all_changes)
+    end
+
+    def save!
+      fail StandardError.new("Need to call apply_changes before #{__method__}") unless @all_changes
+      changed_models.each(&:save!).each(&:reload)
+    end
+  end
+
+  class MutatorDefinition
+    attr_accessor :field_map
+
+    def initialize(model_type, null_behavior:)
+      @field_map = MutationFieldMap.new(model_type, find_by: nil, null_behavior: null_behavior)
+    end
+
+    def mutator(root_model, inputs, context)
+      Mutator.new(field_map, root_model, inputs, context)
+    end
+  end
+end

data/lib/graphql/models/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Ryan Foster
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-05 00:00:00.000000000 Z
+date: 2016-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -57,6 +57,13 @@ files:
 - 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/mutation_field_map.rb
+- lib/graphql/models/mutation_helpers/apply_changes.rb
+- lib/graphql/models/mutation_helpers/authorization.rb
+- lib/graphql/models/mutation_helpers/print_input_fields.rb
+- 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
@@ -83,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: ActiveRecord helpers for GraphQL + Relay