graphql-activerecord 0.12.6 → 0.13.0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+# 0.13.0
+Changed the way that null values are handled inside of mutators. Take a look at [(#49)](https://github.com/goco-inc/graphql-activerecord/pull/49)
+for details. If you need to get back to the old behavior (ie, `unsetFields`), you can either:
+- Add the `legacy_nulls: true` option when defining your mutator, or
+- Set `GraphQL::Models.legacy_nulls = true` in an initializer
+
 # 0.12.6
 - Fixed a bug when you used a `nested` mutator, and provided a symbol for the `:name` kwarg
 - Fixed a bug where the `context` parameter was not being passed to `MutationHelpers::match_inputs_to_models`

data/Gemfile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in graphql-activerecord.gemspec

data/README.md

@@ -1,5 +1,23 @@
 # GraphQL::Models
 
+## WARNING!
+This gem was designed as a helper for building GraphQL schema's based on the [`graphql`](https://github.com/rmosolgo/graphql-ruby) gem. Primarily, it was meant to reduce redundancy when your object types were virtually identical to the attributes on your models in a few ways:
+1. It uses some clever tricks to automatically infer field types based on the data types of your database columns
+2. It automatically camelizes your attributes names
+3. It has some helpers to optimize association loading
+
+But in the time since I originally wrote this gem, a lot has transpired in the GraphQL world:
+- For #2: The 1.8 release of the graphql gem solves field camelization
+- For #3: Better solutions for association loading, that aren't quite as heavy as this library, have surfaced. One example is outlined in a [gist](https://gist.github.com/theorygeek/a1a59a2bf9c59e4b3706ac68d12c8434) that I wrote on Association Loading. That gist has proven to be more popular than this library 😁
+
+I don't know if there's a good solution out there for #1, but it was probably the least important problem to solve.
+
+We use GraphQL extensively at GoCo. Our schema has thousands of types. We'll be rethinking our implementation soon, and taking a closer look at the patterns that we use to DRY up our schema definition, to see if there are better patterns in the 1.8+ world.
+
+This gem may evolve into something better, or we may eventually deprecate it. But as of right now, I can't recommend that you build any major projects on top of it, since its future is a bit uncertain. I apologize if that makes more work for you :( but I want to be honest about the state of the project.
+
+## Overview
+
 This gem is designed to help you map Active Record models to GraphQL types, both for queries and mutations, using the [`graphql`](https://github.com/rmosolgo/graphql-ruby)
 gem. It assumes that you're using Rails and have `graphql-batch` set up.
 
@@ -11,7 +29,7 @@ In the process, this gem also converts `snake_case` attribute names into `camelC
 
 Here's an example:
 ```ruby
-EmployeeGraph = GraphQL::ObjectType.define do
+EmployeeType = GraphQL::ObjectType.define do
   name "Employee"
 
   # Looks for an Active Record model called "Employee"
@@ -38,6 +56,22 @@ EmployeeGraph = GraphQL::ObjectType.define do
 end
 ```
 
+Then in your query file:
+```ruby
+QueryType = GraphQL::ObjectType.define do
+  name "Query"
+
+  field :employees, types[EmployeeType] do
+    resolve -> (_obj, _args, _ctx) { Employee.all }
+  end
+
+  field :employee, EmployeeType do
+    argument :id, !types.ID
+    resolve -> (obj, args, ctx) { Employee.find(args[:id])}
+  end
+end
+```
+
 You can also build a corresponding mutation, using a very similar syntax. Mutations are more complicated, since they involve
 not just changing the data, but also validating it. Here's an example:
 ```ruby
@@ -49,7 +83,7 @@ UpdateEmployeeMutation = GraphQL::Relay::Mutation.define do
   # For mutations, you create a mutator definition. This will add the input fields to your
   # mutation, and also return an object that you'll use in the resolver to perform the mutation.
   # The parameters you pass are explained below.
-  mutator_definition = GraphQL::Models.define_mutator(self, Employee, null_behavior: :leave_unchanged) do
+  mutator_definition = GraphQL::Models.define_mutator(self, Employee) do
     attr :title
     attr :salary
 
@@ -60,7 +94,7 @@ UpdateEmployeeMutation = GraphQL::Relay::Mutation.define do
 
       # You can use nested input object types to allow making changes across associations with a single mutation.
       # Unlike querying, you need to be explicit about what fields on associated objects can be changed.
-      nested :address, null_behavior: :set_null do
+      nested :address do
         attr :line_1
         attr :line_2
         attr :city
@@ -70,7 +104,7 @@ UpdateEmployeeMutation = GraphQL::Relay::Mutation.define do
     end
   end
 
-  return_field :employee, EmployeeGraph
+  return_field :employee, EmployeeType
 
   resolve -> (inputs, context) {
     # Fetch (or create) the model that the mutation should change
@@ -96,6 +130,15 @@ UpdateEmployeeMutation = GraphQL::Relay::Mutation.define do
 end
 ```
 
+In your mutation file:
+```ruby
+MutationType = GraphQL::ObjectType.define do
+  name "Mutation"
+  
+  field :updateEmployee, UpdateEmployeeMutation.field
+end
+```
+
 ## Installation
 
 To get started, you should add this line to your application's Gemfile:
@@ -132,15 +175,14 @@ GraphQL::Models.authorize = -> (context, action, model) {
 
 # The gem assumes that if your model is called `MyModel`, the corresponding type is `MyModelType`.
 # You can override that convention. Return `nil` if the model doesn't have a GraphQL type:
-GraphQL::Models.model_to_graphql_type = -> (model_class) { "#{model_class.name}Graph".safe_constantize }
+GraphQL::Models.model_to_graphql_type = -> (model_class) { "#{model_class.name}Type".safe_constantize }
 ```
 
 Finally, you need to set a few options on your schema:
 ```ruby
 GraphQL::Schema.define do
   # Set up the graphql-batch gem
-  lazy_resolve(Promise, :sync)
-  instrument(:query, GraphQL::Batch::Setup)
+  use GraphQL::Batch
 
   # Set up the graphql-activerecord gem
   instrument(:field, GraphQL::Models::Instrumentation.new)
@@ -309,7 +351,7 @@ end
 MyModel.graphql_enum_types[:status]
 
 # When you use it inside of your GraphQL schema, it'll know to use the GraphQL enum type:
-MyModelGraph = GraphQL::ObjectType.define do
+MyModelType = GraphQL::ObjectType.define do
   backed_by_model :my_model do
     attr :status
   end
@@ -326,13 +368,12 @@ You can also manually specify the type to use, if you just want the type mapping
 When you define a mutation, there are a few parameters that you need to pass. Here's an example:
 
 ```ruby
-mutator_definition = GraphQL::Models.define_mutator(self, Employee, null_behavior: :leave_unchanged)
+mutator_definition = GraphQL::Models.define_mutator(self, Employee)
 ```
 
 The parameters are:
 - The definer object: it needs this so that it can create the input fields. You should always pass `self` for this parameter.
 - The model class that the mutator is changing: it needs this so that it can map attributes to the correct input types.
-- `null_behavior`: this lets you choose how null values are treated. It's explained below.
 
 #### Virtual Attributes
 In your mutator, you can specify virtual attributes on your model, you just need to provide the type:
@@ -340,39 +381,30 @@ In your mutator, you can specify virtual attributes on your model, you just need
 attr :some_fake_attribute, type: types.String
 ```
 
-#### null_behavior
-
-When you build a mutation, you have two options that control how null values are treated. They are meant to allow you
-to choose behavior similar to HTTP PATCH or HTTP POST, where you may want to update just part of a model without having to supply
-values for every field.
-
-You specify which option you'd like using the `null_behavior` parameter when defining the mutation:
-- `leave_unchanged` means that if the input field contains a null value, it is ignored
-- `set_null` means that if the input field contains a null value, the attribute will actually be set to `nil`
+#### Implicit Null Values
 
-##### set_null
-The `set_null` option is the simpler of the two, and you should probably default to using that option. When you pick this option,
-null values behave as you would expect: they cause the attribute to be set to `nil`.
+By default, input fields that are not supplied to a mutation (ie, they are left blank when the mutation is executed) will
+be ignored. You must explicitly provide a value (including `null`) for the attribute to be updated.
 
-But another important side-effect is that the input fields on the mutation will be marked as non-nullable if the underlying
-database column is not nullable, or if there is an unconditional presence validator on that field.
+You can override this behavior by using the `null_behavior: :set_null` option. This will cause two side-effects:
+- The input fields on your mutation will be marked non-null if they are required in your model
+- If any input field is not supplied, it will be treated as if the value `null` was actually supplied.
 
-##### leave_unchanged
-If you select this option, any input fields that contain null values will be ignored. Instead, if you really do want to set a
-field to null, the gem adds a field called `unsetFields`. It takes an array of field names, and it will set all of those fields
-to null.
-
-If the field is not nullable in the database, or it has an unconditional presence validator, you cannot pass it to `unsetFields`.
-Also, if _all_ of the fields meet this criteria, the gem does not even create the `unsetFields` field.
-
-The important side-effect here is that `leave_unchanged` causes all of the input fields on the mutation to be nullable.
+Example:
+```ruby
+nested :emergency_contacts, null_behavior: :set_null do
+  attr :first_name
+  attr :last_name
+  attr :phone
+end
+```
 
 ### Mutations and has_many associations
 You can create mutations that update models across a `has_many` association, by using a `nested` block just like you would for
 `has_one` or `belongs_to` associations:
 
 ```ruby
-nested :emergency_contacts, null_behavior: :set_null do
+nested :emergency_contacts do
   attr :first_name
   attr :last_name
   attr :phone
@@ -382,7 +414,7 @@ end
 By default, inputs are matched to associated models by position (ie, the first input to the first model, etc). However, if you
 have an attribute that should instead be used to match them, you can specify it:
 ```ruby
-nested :emergency_contacts, find_by: :priority, null_behavior: :set_null do
+nested :emergency_contacts, find_by: :priority do
   attr :first_name
   attr :last_name
   attr :phone
@@ -392,8 +424,8 @@ end
 This causes the gem to automatically include `priority` as an input field. You could also manually specify the
 `priority` field if you wanted to override its name or type.
 
-Also, an important note is that the gem assumes that you are passing up _all_ of the associated models, and not just some of
-them. It will destroy extra models, or create missing models.
+Also, an important note is that the gem assumes that your input is providing values for _all_ of the associated models, and not just
+some of them. It will destroy extra models, or create missing models.
 
 ### Other things that need to be documented
 - Custom scalar types

data/Rakefile

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 

data/bin/bundle

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+    module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1 || ">= 0.a"
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||= begin
+      env_var_version || cli_arg_version ||
+        lockfile_version || "#{Gem::Requirement.default}.a"
+    end
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    # must dup string for RG < 1.8 compatibility
+    activate_bundler(bundler_version.dup)
+  end
+
+  def activate_bundler(bundler_version)
+    if Gem::Version.correct?(bundler_version) && Gem::Version.new(bundler_version).release < Gem::Version.new("2.0")
+      bundler_version = "< 2"
+    end
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_version
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_version).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_version}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_version}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/bin/coderay

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"
 

data/bin/htmldiff

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"
 

data/bin/ldiff

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"
 

data/bin/pry

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"
 

data/bin/rake

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+
 #
 # This file was generated by Bundler.
 #
@@ -11,6 +12,17 @@ require "pathname"
 ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
   Pathname.new(__FILE__).realpath)
 
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
 require "rubygems"
 require "bundler/setup"