graphql-activerecord 0.10.0.pre.alpha2 → 0.10.0.pre.alpha3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1de65b95cb8f19cdca7643404e8dd55c072e2a3b
-  data.tar.gz: a21768845b286ae9f539725e2d7ab52002b6d3c0
+  metadata.gz: 51188ba9e6b78d0a5db797c4cba6501995c01b85
+  data.tar.gz: 1d38ee1f0b1b5ef17e8a38d9ef8e9cb06019631c
 SHA512:
-  metadata.gz: 97aa43f8f65466f9b069786fbba22f7552f775c42693b3d148fdc931cd7d41606e729c4af73e75f4708a23ea4af7397b11ddf202bac57e9a501d96d787371cce
-  data.tar.gz: 9b541a012f17e0b7cb6dbba60110d64fcc5df04fd34eec2624d2ee7f6c91990bac411e42860b4211b62416581d5fbdf6aae5cb008b536fd7dd6712cc41870bd3
+  metadata.gz: 3198879eb4d21bcc2f52098a8c0ae70a511e5e7700e2a16185abf65cdedfc5b95dc840e70a9a8393959aa5ed3e6c7f155342be177006d6d2b0cd4e54041aaaf2
+  data.tar.gz: cfe77dd4439bb6068a1d4283bd7d16297258b5637fa40d846b625a2f4e7005fc2a236accc23ab51840a10b2f26aff4c6e5f478ee88147ca8efac060dd73e02b2

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+# 0.10.0
+There are a few breaking changes:
+- Added automatic nullability checking for attributes. It’s enabled by default; see the README for more info.
+- The gem now assumes that the object types for your models are called "ModelNameType" instead of "ModelNameGraph",
+  to bring it more in line with common practice. You can get the old behavior by adding this to an initializer:
+  
+```ruby
+  GraphQL::Models.model_to_graphql_type -> (model_class) { "#{model_class.name}Graph".safe_constantize }
+```
+
+- Fixed a bug with the `has_many_connection` helper, which deserves some explanation. This helper constructs a
+  connection field that returns an ActiveRecord relation. There isn't an easy way to inject functionality into the resolvers
+  that are used by connections (to my knowledge) - eg, by using middleware - so this helper had some GoCo-specific code
+  baked into it, which probably caused odd errors about an undefined constant `GraphSupport` whenever it was used. I can’t
+  quite remove that functionality yet, but I did take it one step closer by having the code first check to see if the constant
+  was defined, and bypass it if it’s not.
+
 ## 0.9.0
 - Support for graphql version 1.2.1 and higher, but it no longer works with 0.x versions
 

data/README.md

@@ -1,13 +1,13 @@
 # GraphQL::Models
 
-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, Relay and PostgreSQL.
+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.
 
 It extends the `define` methods for GraphQL object types to provide a simple syntax for adding fields that access attributes
 on your model. It also makes it easy to "flatten" models together across associations, or to create fields that just access
 the association as a separate object type.
 
-In the process, this gem also converts `snake_case` attribute names into `camelCase` field names. When you go to build a mutation
-using this gem, it knows how to revert that process, even in cases where the conversion isn't symmetric.
+In the process, this gem also converts `snake_case` attribute names into `camelCase` field names. When you go to build a mutation using this gem, it knows how to revert that process, even in cases where the conversion isn't symmetric.
 
 Here's an example:
 ```ruby
@@ -31,7 +31,7 @@ EmployeeGraph = GraphQL::ObjectType.define do
 
       # You can also provide the association itself as an object field. In this example, a
       # Person has one Address. The gem assumes that the corresponding GraphQL object type
-      # is called "AddressGraph".
+      # is called "AddressType" (but you can override, see installation section below).
       has_one :address
     end
   end
@@ -129,19 +129,23 @@ GraphQL::Models.authorize = -> (context, action, model) {
   user = context['user']
   model.authorize_changes!(action, user)
 }
+
+# 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 }
 ```
 
 Finally, you need to set a few options on your schema:
 ```ruby
-Schema.query_execution_strategy = GraphQL::Batch::ExecutionStrategy
-Schema.mutation_execution_strategy = GraphQL::Batch::MutationExecutionStrategy
-Schema.middleware << GraphQL::Models::Middleware.new
-```
-
-## Other notes
+GraphQL::Schema.define do
+  # Set up the graphql-batch gem
+  lazy_resolve(Promise, :sync)
+  instrument(:query, GraphQL::Batch::Setup)
 
-The code in this gem was originally part of our main codebase, before we extracted it. So there are a few places where some of
-of our own conventions leak through. Eventually, I'd like to clean these up, but you'll have to live with them for now.
+  # This middleware should be somewhere near the top of your middleware chain
+  middleware GraphQL::Models::Middleware.new
+end
+```
 
 ### Database compatibility
 
@@ -149,58 +153,83 @@ This gem uses `graphql-batch` to optimize loading associated models in your grap
 queries. It tries to do that in a way that preserves things like scopes that change the order or filter the rows retrieved.
 
 Unfortunately, that means that it needs to build some custom SQL expressions, and they might not be compatible with every
-database engine. They should work correctly on PostgreSQL.
-
-### Naming of GraphQL types
-
-If your model is named `Something`, this gem assumes that the corresponding object type is called `SomethingGraph`, and it uses
-the Rails `String#constantize` method to find it. This is mainly needed when you're specifying associations on your object types.
+database engine. They should work correctly on PostgreSQL. For other databases, your mileage may vary.
 
 ### Global ID's
 
 When you use the `has_one` or `has_many_array` helpers to output associations, the gem will also include a field that only
-returns the global ID's of the models. To do that, it calls a method named `gid` on the model. You'll need to provide that method
-for those fields to work. We do that by defining it in a concern that we include into `ActiveRecord::Base`:
+returns the global ID's of the models. To do that, it calls a method named `gid` on the model. You'll need to provide that method for those fields to work. We do that by adding it to our `ApplicationRecord` base class:
 
 ```ruby
-module ActiveRecordExtensions
-  extend ActiveSupport::Concern
-
+class ApplicationRecord < ActiveRecord::Base
   def gid
-    NodeHelpers.encode_id(self.class.name, self.id)
+    # add code to return a global object ID here
   end
 end
-
-ActiveRecord::Base.send(:include, ActiveRecordExtensions)
 ```
 
 ## Usage
 
-### GraphQL Enum's
+Inside of your GraphQL object types, you use `backed_by_model` to create fields that are tied to your models (see
+example above). Inside of those blocks, you have some helper methods.
 
-Active Record allows you to define enum fields on your models. They're stored as integers, but treated as strings in your app.
-You can use a helper to automatically build GraphQL enum types for them:
+### Attribute helpers
 
+You use the `attr` method to add an ordinary attribute from your model to your schema:
 ```ruby
-class MyModel < ActiveRecord::Base
-  enum status: [:active, :inactive]
-  graphql_enum :status
+backed_by_model :employee do
+  attr :first_name
+  attr :last_name
 end
+```
 
-# You can access the auto-built type if you need to:
-MyModel.graphql_enum_types[:status]
+The gem knows how to handle basic attribute types: boolean, int, float, and string. For other types, you need
+to tell it what GraphQL type to use:
 
-# When you use it inside of your GraphQL schema, it'll know to use the GraphQL enum type:
-MyModelGraph = GraphQL::ObjectType.define do
-  backed_by_model :my_model do
-    attr :status
-  end
+```ruby
+# config/initializers/graphql_activerecord.rb
+GraphQL::Models::DatabaseTypes.register(:decimal, DecimalType)
+
+# You can wrap the type in a proc, or use a string, so that you don't break code reloading:
+GraphQL::Models::DatabaseTypes.register(:decimal, -> { DecimalType })
+GraphQL::Models::DatabaseTypes.register(:decimal, "DecimalType")
+
+# If you're not using a scalar, you need to give it separate input/output types:
+GraphQL::Models::DatabaseTypes.register(:date, DateType, DateInputType)
+```
+
+#### Nullability of attributes
+The gem will mark a field as non-nullable if:
+- the database column is non-null
+- the attribute has an unconditional presence validator on it
+
+There are two ways you can override this behavior:
+- You can pass either `nullable: true` or `nullable: false` to the helper, and no automatic detection happens
+- You can disable null detection for the entire `backed_by_model` block
+
+Example:
+```ruby
+backed_by_model :employee do
+  # All fields created by the gem will be nullable
+  detect_nulls false
+
+  # Override it on a per-field basis
+  attr :first_name, nullable: false
 end
 ```
 
-You can also manually specify the type to use, if you just want the type mapping behavior:
+If you use a `proxy_to` block, the gem will automatically detect whether the associated model
+has a presence validator on it. If it doesn’t, all fields inside of the block are nullable:
+
 ```ruby
-  graphql_enum :status, type: StatusEnum
+backed_by_model :employee do
+
+  # If you have `validates :person, presence: true` in your model, then nullability
+  # on these fields is preserved. Otherwise, they will all be nullable.
+  proxy_to :person do
+    attr :birthday
+  end
+end
 ```
 
 ### Association helpers
@@ -210,6 +239,29 @@ There are three helpers that you can use to build fields for associated models:
 - `has_many_array` will return all of the associated models as a GraphQL list
 - `has_many_connection` will return a paged connection of the associated models
 
+#### Nullability of associations
+When you use the `has_one` helper, the gem follows the same rules for nullability as it does for attributes. Thus,
+it’ll check for a presence validator on the association itself:
+
+```ruby
+class MyModel < ApplicationRecord
+  belongs_to :some_other_model
+  validates :some_other_model, presence: true
+end
+```
+
+In addition, for `belongs_to` models, it’ll check the nullability of the foreign key:
+```ruby
+class MyModel < ApplicationRecord
+  belongs_to :some_other_model
+  validates :some_other_model_id, presence: true
+end
+```
+
+For `has_many` associations, it does not check for presence validators; rather, it assumes that an empty array
+will be returned if there are no associated models, so the field is always marked non-null (but subject to the same rules
+as attributes regarding proxy blocks).
+
 ### Fields inside of `proxy_to` blocks
 You can also define ordinary fields inside of `proxy_to` blocks. When you do that, your field will receive the associated model
 as the object, instead of the original model. This is meant to allow you to take advantage of the optimized association loading
@@ -227,6 +279,33 @@ backed_by_model :employee do
 end
 ```
 
+### GraphQL Enum's
+
+Active Record allows you to define enum fields on your models. They're stored as integers, but treated as strings in your app.
+You can use a helper to automatically build GraphQL enum types for them:
+
+```ruby
+class MyModel < ApplicationRecord
+  enum status: [:active, :inactive]
+  graphql_enum :status
+end
+
+# You can access the auto-built type if you need to:
+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
+  backed_by_model :my_model do
+    attr :status
+  end
+end
+```
+
+You can also manually specify the type to use, if you just want the type mapping behavior:
+```ruby
+  graphql_enum :status, type: StatusEnum
+```
+
 ### Defining Mutations
 
 When you define a mutation, there are a few parameters that you need to pass. Here's an example:
@@ -306,7 +385,6 @@ them. It will destroy extra models, or create missing models.
 - `object_to_model`
 - Retrieving field metadata (for building an authorization middleware)
 - Validation error exceptions
-- Why all fields on query types are nullable
 
 
 ## Development

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

@@ -226,20 +226,10 @@ module GraphQL
           object_to_base_model: object_to_model
         })
 
-        # 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
+        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

data/lib/graphql/models/hash_combiner.rb

@@ -3,7 +3,7 @@ module GraphQL::Models::HashCombiner
     # Takes a set of hashes that represent conditions, and combines them into the smallest number of hashes
     def combine(hashes)
       # Group the hashes by keys. If they are querying different columns, they can't be combined
-      by_keys = hashes.group_by { |h| h.keys }
+      by_keys = hashes.group_by { |h| h.keys.sort }
       by_keys.map { |keys, values| combine_core(values, keys) }.flatten
     end
 

data/lib/graphql/models/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Models
-    VERSION = "0.10.0-alpha2"
+    VERSION = "0.10.0-alpha3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-activerecord
 version: !ruby/object:Gem::Version
-  version: 0.10.0.pre.alpha2
+  version: 0.10.0.pre.alpha3
 platform: ruby
 authors:
 - Ryan Foster
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-02 00:00:00.000000000 Z
+date: 2017-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport