graphql_lazy_load 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 724af5e1b3fe1f2fbff97284fe54f2b20d9ddd9e3dddd3932c2f5b913c678873
-  data.tar.gz: adfcdb624948134a38390d7470898d8d038982dd917d76dda82eb898f3ffaadd
+  metadata.gz: 30a2e056b22a38d09ee95c801c2b40b5ca5ca84b5fc6515dfa3561bf0e1457a8
+  data.tar.gz: 6ab1efe390d966b27dabe05b813c6fb3efcab08456fdcd2a7f699477e05ed53b
 SHA512:
-  metadata.gz: 81e56ea916ed8ae3173bd6629b037960f56f0edcb5031b64d7ad12a6c38ea1a293d98bca839955311adee539f300b1a4a7ab20a8a07ea3cc7394aaa0e2005705
-  data.tar.gz: 6062acf99ebc505293eb69bd5d917048f89927aa5be346cb8d86440fd70c05dbe370b193c007f1d00f3c6ef1a78d393a63955c3d393402432074316c2c776310
+  metadata.gz: f1af93639f764829f3f7b452865e6e3e8a37bc3197ae0f367349aa71dec04fa939ef7f71c6b31c775f07226766cdc26e9a35bcac0abf06e4d9a44bad4392fb84
+  data.tar.gz: 9d208fdccddd90fa56a273531f6d4c639eabf640ab8d84ab478f036cc84c69263f9ae6d69798c66812d67f7abdc2a4194d2c5e5a539fef861c183019677dee26

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_lazy_load (0.2.0)
+    graphql_lazy_load (0.3.0)
       activerecord (>= 4.1.16)
       graphql (>= 1.3.0)
 

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', '~> 0.2.0'
+gem 'graphql_lazy_load', '~> 0.3.0'
 ```
 Then run `bundle install`.
 
@@ -15,60 +15,57 @@ Or install it yourself as:
     $ gem install graphql_lazy_load
 
 ## Usage
-### ActiveRecordRelation
-To use, first add the executor (`GraphqlLazyLoad::ActiveRecordRelation`) to graphqls schema:
+To use, first add the executor (`GraphqlLazyLoad::ActiveRecordRelation` and/or `GraphqlLazyLoad::Custom`) to graphqls schema:
 ```ruby
 class MySchema < GraphQL::Schema
   mutation(Types::MutationType)
   query(Types::QueryType)
 
   lazy_resolve(GraphqlLazyLoad::ActiveRecordRelation, :result)
+  lazy_resolve(GraphqlLazyLoad::Custom, :result)
 end
 ```
 
-Now you can start using it! Wherever you have an association, the syntax is:
+Now you can start using it!
+
+The easiest thing to do is to extend the object helper method in the `Types::BaseObject` (or where you want to use the methods):
 ```ruby
-field :field_name, Types::AssociationType, null: false
-def field_name
-  GraphqlLazyLoad::ActiveRecordRelation.new(self, :association_name)
+module Types
+  class BaseObject < GraphQL::Schema::Object
+    extend GraphqlLazyLoad::ObjectHelper
+  end
 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
+### ActiveRecordRelation Syntax
+```ruby
+field :field_name, Types::AssociationType, null: false
+lazy_load_association(:field_name)
 ```
+If the association does not match the field name you can pass it `lazy_load_association(:field_name, association: :association_name)`
 
-Now you can start using it! Wherever you have a something to lazy load, the syntax is:
+### Custom Syntax
 ```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
+lazy_load_custom(:field_name, :id) do |field_name_ids|
+  # return hash of field_name_id => association_name, ...
+  AssociationName.where(id: ids).reduce({}) do |acc, value|
+    acc[value.id] = value
+    acc
   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 `Player`s. To lazy load players from teams do the following:
 ### ActiveRecordRelation
 ```ruby
 module Types
   class TeamType < Types::BaseObject
+    # extend GraphqlLazyLoad::ObjectHelper # uncomment if not extended in Types::BaseObject
     ...
     field :players, [Types::PlayerType], null: false
-    def players
-      GraphqlLazyLoad::ActiveRecordRelation.new(self, :players)
-    end
+    lazy_load_association(:players)
   end
 end
 ```
@@ -78,9 +75,7 @@ module Types
   class PlayerType < Types::BaseObject
     ...
     field :team, Types::TeamType, null: false
-    def team
-      GraphqlLazyLoad::ActiveRecordRelation.new(self, :team)
-    end
+    lazy_load_association(:team)
   end
 end
 ```
@@ -90,14 +85,9 @@ 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
+    lazy_load_custom(:players, :id) do |team_ids|
+      # return a hash with key team_id => [player,...]
+      Player.where(team_id: team_ids).group_by(&:team_id)
     end
   end
 end
@@ -108,13 +98,10 @@ 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
+    lazy_load_custom(:field_name, :team_id) do |team_ids|
+      # return a hash with key team_id => team
+      Team.where(id: team_ids).each_with_object({}) do |team, acc|
+        acc[team.id] = team
       end
     end
   end
@@ -122,7 +109,7 @@ end
 ```
 
 ### Scoping
-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.
+The great thing is you can pass params. So for the example above if you want to allow sorting (or query, paging, etc) on player do the following.
 ### ActiveRecordRelation
 ```ruby
 module Types
@@ -131,10 +118,10 @@ module Types
     field :players, [Types::PlayerType], null: false do
       argument :order, String, required: false
     end
-    def players(order: nil)
+    lazy_load_association(:players) do |order: nil|
       scope = Player.all
       scope = scope.sort(order.underscore) if order
-      GraphqlLazyLoad::ActiveRecordRelation.new(self, :players, scope: scope)
+      scope
     end
   end
 end
@@ -148,15 +135,11 @@ module Types
     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
+    lazy_load_custom(:players, :id) do |team_ids, order: nil|
+      # return a hash with key team_id => [player,...]
+      query = Player.where(team_id: team_ids)
+      query = query.order(params[:order].underscore) if params[:order]
+      query.group_by(&:team_id)
     end
   end
 end

data/lib/graphql_lazy_load/active_record_relation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module GraphqlLazyLoad
+    class ActiveRecordRelation
+      def initialize(type, association, **params, &block)
+        object_class = type.object.class
+        context_key = [type.class, object_class, association]
+        @object_id = type.object.id
+        @association = association
+
+        # Initialize the loading state for this query,
+        # or get the previously-initiated state
+        @lazy = type.context[context_key] ||= {
+          objects_to_load: Set.new,
+          ids: Set.new, # use ids cause cant compare objects
+          results: {},
+          params: params,
+          block: block,
+        }
+        # Register this to be loaded later unless we've already queued or loaded it
+        return if already_loaded_or_queued?
+        # use copy of object so it doesnt add preload to associations.
+        # this is so associations dont get loaded to object passed so different scopes get reloaded
+        lazy_objects.add(object_class.new(type.object.attributes))
+        lazy_ids.add(object_id)
+      end
+
+      # Return the loaded record, hitting the database if needed
+      def result
+        if !already_loaded? && any_to_load?
+          ActiveRecord::Associations::Preloader.new.preload(lazy_objects.to_a, association, scope)
+          lazy_objects.each do |object|
+            lazy_results[object.id] = object.send(association)
+          end
+          lazy_objects.clear
+        end
+        lazy_results[object_id]
+      end
+
+      private
+        attr_reader :object_id, :association
+
+        def scope
+          return nil unless lazy_block
+          lazy_block.call(lazy_params)
+        end
+
+        def lazy_params
+          @lazy[:params]
+        end
+
+        def lazy_block
+          @lazy[:block]
+        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_objects.any?
+        end
+
+        def lazy_ids
+          @lazy[:ids]
+        end
+
+        def lazy_objects
+          @lazy[:objects_to_load]
+        end
+
+        def lazy_results
+          @lazy[:results]
+        end
+    end
+end

data/lib/graphql_lazy_load/custom.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module GraphqlLazyLoad
+  class Custom
+    def initialize(type, unique_identifier, value, default_value: nil, **params, &block)
+      context_key = [type.class, unique_identifier, params]
+      @value = value
+      # Initialize the loading state for this query,
+      # or get the previously-initiated state
+      @lazy = type.context[context_key] ||= {
+        values: Set.new,
+        results: Hash.new(default_value),
+        params: params,
+        block: block,
+      }
+      # Register this to be loaded later unless we've already queued or loaded it
+      return if already_loaded_or_queued?
+      lazy_values.add(value)
+    end
+
+    # Return the loaded record, hitting the database if needed
+    def result
+      if not_already_loaded? && any_to_load?
+        lazy_results.merge!(block_results)
+        lazy_values.clear
+      end
+      lazy_results[value]
+    end
+
+    private
+      attr_reader :value
+
+      def block_results
+        lazy_block.call(lazy_values.to_a, lazy_params)
+      end
+
+      def lazy_params
+        @lazy[:params]
+      end
+
+      def lazy_block
+        @lazy[:block]
+      end
+
+      def already_loaded_or_queued?
+        lazy_values.include?(value) || lazy_results.key?(value)
+      end
+
+      def not_already_loaded?
+        !lazy_results.key?(value)
+      end
+
+      def any_to_load?
+        lazy_values.any?
+      end
+
+      def lazy_values_array
+        lazy_values.to_a
+      end
+
+      def lazy_values
+        @lazy[:values]
+      end
+
+      def lazy_results
+        @lazy[:results]
+      end
+  end
+end

data/lib/graphql_lazy_load/object_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphqlLazyLoad
+  module ObjectHelper
+    def lazy_load_custom(method, value, default_value: nil, &block)
+      define_method(method) do |**params|
+        Custom.new(self, method, object.send(value), params.merge(default_value: default_value)) do |*options|
+          instance_exec(*options, &block)
+        end
+      end
+    end
+
+    def lazy_load_association(method, association: method, &block)
+      define_method(method) do |**params|
+        return ActiveRecordRelation.new(self, association, **params) unless block
+        ActiveRecordRelation.new(self, association, **params) do |*options|
+          instance_exec(*options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_lazy_load/version.rb

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

data/lib/graphql_lazy_load.rb

@@ -1,143 +1,11 @@
 # frozen_string_literal: true
 
 require "graphql_lazy_load/version"
+require "graphql_lazy_load/object_helper"
+require "graphql_lazy_load/custom"
+require "graphql_lazy_load/active_record_relation"
 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
-      @object_id = type.object.id
-      @association = association
-      @scope = scope
-      # 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] ||= []).find { |c| c[:scope] == scope }
-      unless @lazy
-        @lazy = {
-          objects_to_load: Set.new,
-          ids: Set.new,
-          results: {}
-        }
-        type.context[context_key].push(@lazy)
-      end
-      # Register this to be loaded later unless we've already queued or loaded it
-      return if already_loaded_or_queued?
-      # use copy of object so it doesnt add preload to associations.
-      # this is so associations dont get loaded to object passed so different scopes get reloaded
-      lazy_objects.add(object_class.new(type.object.attributes))
-      lazy_ids.add(object_id)
-    end
-
-    # Return the loaded record, hitting the database if needed
-    def result
-      if !already_loaded? && any_to_load?
-        ActiveRecord::Associations::Preloader.new.preload(lazy_objects.to_a, association, scope)
-        lazy_objects.each do |object|
-          lazy_results[object.id] = object.send(association)
-        end
-        lazy_objects.clear
-      end
-      lazy_results[object_id]
-    end
-
-    private
-      attr_reader :object_class, :object_id, :association, :scope
-
-      def context_key
-        [object_class, association]
-      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_objects.any?
-      end
-
-      def lazy_ids
-        @lazy[:ids]
-      end
-
-      def lazy_objects
-        @lazy[:objects_to_load]
-      end
-
-      def lazy_results
-        @lazy[:results]
-      end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_lazy_load
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonathon Gardner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-14 00:00:00.000000000 Z
+date: 2019-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -141,8 +141,12 @@ files:
 - bin/console
 - bin/setup
 - gems/graphql_lazy_load-0.1.0.gem
+- gems/graphql_lazy_load-0.2.0.gem
 - graphql_lazy_load.gemspec
 - lib/graphql_lazy_load.rb
+- lib/graphql_lazy_load/active_record_relation.rb
+- lib/graphql_lazy_load/custom.rb
+- lib/graphql_lazy_load/object_helper.rb
 - lib/graphql_lazy_load/version.rb
 homepage: http://github.com/jonathongardner/graphql_lazy_load
 licenses: