graphql_lazy_load 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f712c10800162f814d8f7d170e10231adf25aa518aab8c08b5f7d6459a8b9efe
-  data.tar.gz: 98fd3434f3a11930cdd5e7e87be35e03054d7652108f45ecf837cffb7deba177
+  metadata.gz: 724af5e1b3fe1f2fbff97284fe54f2b20d9ddd9e3dddd3932c2f5b913c678873
+  data.tar.gz: adfcdb624948134a38390d7470898d8d038982dd917d76dda82eb898f3ffaadd
 SHA512:
-  metadata.gz: 70c960dc556b35794248ac96afcbb067067c8a2f07b1e72987d935afe3a9a7d4eb61bbd40024f3f9dffdb27c2e624caf023080c17ae8a2387fc1ee13db760fc5
-  data.tar.gz: 13f918ac5f4d57099d5543c4fa48749ae69179c0026a71ecfef973cdbbcb61673fcbf6fb24bfbe403f6d2df6cdeb0de0b0326f538d47e7e6949a28fd4b3d18cf
+  metadata.gz: 81e56ea916ed8ae3173bd6629b037960f56f0edcb5031b64d7ad12a6c38ea1a293d98bca839955311adee539f300b1a4a7ab20a8a07ea3cc7394aaa0e2005705
+  data.tar.gz: 6062acf99ebc505293eb69bd5d917048f89927aa5be346cb8d86440fd70c05dbe370b193c007f1d00f3c6ef1a78d393a63955c3d393402432074316c2c776310

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_lazy_load (0.1.0)
+    graphql_lazy_load (0.2.0)
       activerecord (>= 4.1.16)
       graphql (>= 1.3.0)
 
@@ -38,7 +38,7 @@ GEM
     concurrent-ruby (1.1.5)
     crass (1.0.4)
     erubi (1.8.0)
-    graphql (1.9.11)
+    graphql (1.9.12)
     i18n (1.6.0)
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.3)

data/README.md

@@ -6,7 +6,7 @@ Lazy executor for activerecord associations and graphql gem.
 
 GraphqlLazyLoad requires ActiveRecord >= 4.1.16 and Graphql >= 1.3.0. To use add this line to your application's Gemfile:
 ```ruby
-gem 'graphql_lazy_load'
+gem 'graphql_lazy_load', '~> 0.2.0'
 ```
 Then run `bundle install`.
 
@@ -15,6 +15,7 @@ Or install it yourself as:
     $ gem install graphql_lazy_load
 
 ## Usage
+### ActiveRecordRelation
 To use, first add the executor (`GraphqlLazyLoad::ActiveRecordRelation`) to graphqls schema:
 ```ruby
 class MySchema < GraphQL::Schema
@@ -32,11 +33,37 @@ def field_name
   GraphqlLazyLoad::ActiveRecordRelation.new(self, :association_name)
 end
 ```
+### Custom
+If you want to lazy load a non active record association you can use the `Custom` loader, first add the executor (`GraphqlLazyLoad::Custom`) to graphqls schema (both can be in the schema together):
+```ruby
+class MySchema < GraphQL::Schema
+  mutation(Types::MutationType)
+  query(Types::QueryType)
+
+  lazy_resolve(GraphqlLazyLoad::Custom, :result)
+end
+```
+
+Now you can start using it! Wherever you have a something to lazy load, the syntax is:
+```ruby
+field :field_name, Types::AssociationType, null: false
+def field_name
+  GraphqlLazyLoad::Custom.new(self, :association_name, object.id) do |ids|
+    # return a hash with key matching object.id
+    AssociationName.where(id: ids).reduce({}) do |acc, value|
+      acc[value.id] = value
+      acc
+    end
+  end
+end
+```
+Values passed to the `Custom` initializer are `self`, `unique_identifier`, `unique_id` (gets passed to block, and is used to retrieve the values), you can also pass an optional value `params` (gets passed as second argument to block). It is important to note that data is grouped by `unique_identifier` and `params`.
 ## Examples
-If you have two models `Team` which can have many `Players`. To lazy load players from teams do the following:
+If you have two models `Team` which can have many `Player`s. To lazy load players from teams do the following:
+### ActiveRecordRelation
 ```ruby
 module Types
-  class PlayerType < Types::BaseObject
+  class TeamType < Types::BaseObject
     ...
     field :players, [Types::PlayerType], null: false
     def players
@@ -48,7 +75,7 @@ end
 And to lazy load teams from players do the following:
 ```ruby
 module Types
-  class TeamType < Types::BaseObject
+  class PlayerType < Types::BaseObject
     ...
     field :team, Types::TeamType, null: false
     def team
@@ -57,8 +84,46 @@ module Types
   end
 end
 ```
+### Custom
+```ruby
+module Types
+  class TeamType < Types::BaseObject
+    ...
+    field :players, [Types::PlayerType], null: false
+    def players
+      GraphqlLazyLoad::Custom.new(self, :players, object.id) do |team_ids|
+        # return a hash with key matching object.id
+        Player.where(team_id: team_ids).reduce({}) do |acc, player|
+          (acc[player.team_id] ||= []).push(player)
+          acc
+        end
+      end
+    end
+  end
+end
+```
+And to lazy load teams from players do the following:
+```ruby
+module Types
+  class PlayerType < Types::BaseObject
+    ...
+    field :team, Types::TeamType, null: false
+    def team
+      GraphqlLazyLoad::Custom.new(self, :team, object.team_id) do |team_ids|
+        # return a hash with key matching object.team_id
+        Team.where(id: team_ids).reduce({}) do |acc, team|
+          acc[team.id] = team
+          acc
+        end
+      end
+    end
+  end
+end
+```
+
 ### Scoping
-The great thing about `GraphqlLazyLoad::ActiveRecordRelation` is it allows scopes to be passed! So for the example above if you want to allow sorting (or query, paging, etc) do the following.
+The great thing is you can pass scopes/params! So for the example above if you want to allow sorting (or query, paging, etc) do the following.
+### ActiveRecordRelation
 ```ruby
 module Types
   class PlayerType < Types::BaseObject
@@ -75,6 +140,27 @@ module Types
 end
 ```
 
+### Custom
+```ruby
+module Types
+  class PlayerType < Types::BaseObject
+    ...
+    field :players, [Types::PlayerType], null: false do
+      argument :order, String, required: false
+    end
+    def players(order: nil)
+      GraphqlLazyLoad::Custom.new(self, :players, object.id, {order: order}) do |team_ids, params|
+        query = Player.where(team_id: team_ids)
+        query = query.order(params[:order].underscore) if params[:order]
+        query.reduce({}) do |acc, player|
+          (acc[player.team_id] ||= []).push(player)
+          acc
+        end
+      end
+    end
+  end
+end
+```
 To test this out try the example app at [graph_test](https://github.com/jonathongardner/graph_test)
 
 ## Contributing

data/lib/graphql_lazy_load/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphqlLazyLoad
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/graphql_lazy_load.rb

@@ -4,6 +4,72 @@ require "graphql_lazy_load/version"
 require "active_record"
 
 module GraphqlLazyLoad
+  class Custom
+    def initialize(type, unique_identifier, value, **params, &block)
+      @unique_identifier = unique_identifier
+      @params = params
+      @block = block
+      @value = value
+      # Initialize the loading state for this query,
+      # or get the previously-initiated state
+      # scope cant be used as a hash key because when .hash is called on diff
+      # for ~same~ scopes its diff every time but scope == scope will return true if ~same~
+      @lazy = type.context[context_key] ||= {
+        values_to_load: Set.new,
+        ids: Set.new,
+        results: {}
+      }
+      # Register this to be loaded later unless we've already queued or loaded it
+      return if already_loaded_or_queued?
+      lazy_values.add(value)
+      lazy_ids.add(value)
+    end
+
+    # Return the loaded record, hitting the database if needed
+    def result
+      if !already_loaded? && any_to_load?
+        lazy_results.merge!(block_results)
+        lazy_values.clear
+      end
+      lazy_results[value]
+    end
+
+    private
+      attr_reader :unique_identifier, :params, :value
+
+      def block_results
+        @block.call(lazy_values, params)
+      end
+
+      def context_key
+        [unique_identifier, params]
+      end
+
+      def already_loaded_or_queued?
+        lazy_ids.include?(object_id)
+      end
+
+      def already_loaded?
+        lazy_results.key?(object_id)
+      end
+
+      def any_to_load?
+        lazy_values.any?
+      end
+
+      def lazy_ids
+        @lazy[:ids]
+      end
+
+      def lazy_values
+        @lazy[:values_to_load]
+      end
+
+      def lazy_results
+        @lazy[:results]
+      end
+  end
+
   class ActiveRecordRelation
     def initialize(type, association, scope: nil)
       @object_class = type.object.class
@@ -19,8 +85,7 @@ module GraphqlLazyLoad
         @lazy = {
           objects_to_load: Set.new,
           ids: Set.new,
-          results: {},
-          scope: scope
+          results: {}
         }
         type.context[context_key].push(@lazy)
       end
@@ -52,7 +117,7 @@ module GraphqlLazyLoad
       end
 
       def already_loaded_or_queued?
-        lazy_objects.include?(object_id)
+        lazy_ids.include?(object_id)
       end
 
       def already_loaded?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_lazy_load
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jonathon Gardner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-31 00:00:00.000000000 Z
+date: 2019-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -140,6 +140,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- gems/graphql_lazy_load-0.1.0.gem
 - graphql_lazy_load.gemspec
 - lib/graphql_lazy_load.rb
 - lib/graphql_lazy_load/version.rb