json_api_model 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0dcc8c7cf054ebbc3e13ff7f11e526703d8763fd
-  data.tar.gz: d11d0c76be9f5f0e7ff0b9545731e0534c66485c
+  metadata.gz: 61778944ededa50685c1d990d6f6a66c78254d4f
+  data.tar.gz: bd95c987db432e21b75457dddd973e3bcb3394eb
 SHA512:
-  metadata.gz: 6d6330ad95f23f9e0e3d97945f00d26f37c0a9d6f79598fba478b901a477718ce1c771121fe96b54c21d7510b8092a98cd0f817bddda3b527bae518449c9c38a
-  data.tar.gz: 55d212fb0693ae234aebc7cfd51c0e7e4f85d7cafd6a860261be22f2c26e8e1ca1f286aa733d03eeaae36c9974de4149c6ffdeae6f82aad55ae40b6ab46f552d
+  metadata.gz: f98a1388dee293f467b2af6b75134e8523ffc1c785a874e9a369b0b01a18139b75a20b9c6f804ab34bc07342f0bc0df2761e3234efa467d8a459e8c21202beff
+  data.tar.gz: 9d78a9616a2c80e2b67ae51f47951d641e690e7cc412bdad82377e624b30efdf2a3dd581a03e8c019e8e3b0bd296350bea11cc1d1479dc70c8cbd0ee3b57c7fb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    json_api_model (0.4.0)
+    json_api_model (0.5.0)
       activesupport
       json_api_client
 

data/README.md

@@ -184,6 +184,58 @@ class MyModelInRussianConroller < ApplicationController
 end
 ```
 
+### Preloading
+
+If you have a model that you need to bulk load along with its associations, in `ActiveRecord`, you can do `MyModel.where( args ).preload( :association, other_association: :nested association )`. Well, you can do that here as well.
+
+__NOTE__(1): consider the complexity, especially for remote models
+
+__NOTE__(2): for remote models, the preloader does not currently autopage
+
+#### Example
+
+Let's say you have a mixed environemnt of local and remote models, like so:
+
+```ruby
+module Example
+  class User < JsonApiModel::Model
+    wraps Example::Client::User
+
+    # remote model
+    belongs_to :org, class_name: "Example::Org"
+
+    # local model
+    has_one :profile
+  end
+
+  class Org < JsonApiModel::Model
+    wraps Example::Client::Org
+  end
+end
+
+class Profile < ActiveRecord::Base
+  belongs_to :user
+end
+```
+
+You can bulk prefetch associations for a block of `User`s
+
+```ruby
+Example::User.where( name: [ "Greg", "Mike" ] ).preload( :org, :profile )
+```
+
+Will make 3 calls:
+
+* `User` to fetch `.where( name: [ "Greg", "Mike" ])`
+* `Org` to fetch the orgs associated with those users, as returned in their relationship blocks
+* `Profile` to fetch `where( user_id: users.map( &:id ) )`
+
+Or if you already have your `users` loaded, you can call
+
+```ruby
+JsonApiModel::Associations::Preloader.preload( users, :org, :profile )
+```
+and that'll do the same thing, minus the `User` call
 
 ### Configuration
 

data/lib/json_api_model/associatable.rb

@@ -57,12 +57,15 @@ module JsonApiModel
             self.__cached_associations ||= {}
 
             unless self.__cached_associations.has_key? association.name
-              result = association.fetch( self )
-              
-              self.__cached_associations[association.name] = result
+              self.send( "#{association.name}=", association.fetch( self ) )
             end
             self.__cached_associations[association.name]
           end
+
+          define_method "#{association.name}=" do | value |
+            self.__cached_associations ||= {}
+            self.__cached_associations[association.name] = value
+          end
         end
       end
     end

data/lib/json_api_model/associations.rb

@@ -6,5 +6,7 @@ module JsonApiModel
     autoload :Has,        'json_api_model/associations/has'
     autoload :HasMany,    'json_api_model/associations/has_many'
     autoload :HasOne,     'json_api_model/associations/has_one'
+    autoload :Preloader,  'json_api_model/associations/preloader'
+    autoload :Preloaders, 'json_api_model/associations/preloaders'
   end
 end

data/lib/json_api_model/associations/base.rb

@@ -2,41 +2,46 @@ module JsonApiModel
   module Associations
     class Base
 
-      attr_accessor :name, :opts, :key
+      attr_accessor :name, :opts, :key, :base_class
+      delegate :preload, to: :preloader
 
       def initialize( base_class, name, opts = {} )
-        self.name = name
-        self.opts = opts
-        self.key  = idify( base_class )
+        self.name       = name
+        self.opts       = opts
+        self.key        = idify( base_class )
+        self.base_class = base_class
 
-        sanitize_opts( base_class )
+        validate_opts!
       end
 
       def fetch( instance )
-        process klass.send( action, query( instance ) )
+        process association_class.send( action, query( instance ) )
       end
 
-      protected
-
-      def klass
-        @klass ||= association_class( name, opts )
+      def json_relationship?
+        association_class < JsonApiModel::Model
       end
 
-      def association_class( name, opts = {} )
-        a_class       = opts[:class]                   if opts.has_key? :class
-        a_class_name  = opts[:class_name].constantize  if opts.has_key? :class_name
-
-        a_class || a_class_name || derived_class_for( name )
+      def association_class
+        @associated_class ||= opts[:class] ||
+                              opts[:class_name]&.constantize ||
+                              derived_class
       end
 
-      def derived_class_for( name )
-        name.to_s.singularize.classify.constantize
+      def process( results )
+        results
       end
 
+      protected
+
       def idify( class_name )
         "#{class_name.to_s.demodulize.underscore}_id"
       end
 
+      def derived_class
+        name.to_s.singularize.classify.constantize
+      end
+
       def supported_options
         [ :class, :class_name ] + additional_options
       end
@@ -45,21 +50,14 @@ module JsonApiModel
         []
       end
 
-      def sanitize_opts( base_class )
+      def validate_opts!
         if name.to_s == "object"
           raise "#{base_class}: 'object_id' is a reserved keyword in ruby and cannot be overridden"
         end
-        invalid_options = (opts.keys - supported_options)
-        if invalid_options.present?
-          list = invalid_options.map{|o|"'#{o}'"}.to_sentence
-          plural = invalid_options.count > 1
-          raise "#{base_class}: #{list} #{plural ? "are" : "is"} not supported."
+        (opts.keys - supported_options).each do | opt |
+          raise "#{base_class}: #{opt} is not supported."
         end
       end
-
-      def process( results )
-        results
-      end
     end
   end
 end

data/lib/json_api_model/associations/belongs_to.rb

@@ -11,13 +11,17 @@ module JsonApiModel
         "#{name}_id"
       end
 
-      def query( instance )
-        if instance.has_relationship_ids? name
+      def ids( instance )
+        if json_relationship?
           instance.relationship_ids( name ).first
         else
           instance.send key
         end
       end
+
+      def query( instance )
+        ids( instance )
+      end
     end
   end
 end

data/lib/json_api_model/associations/has.rb

@@ -6,20 +6,32 @@ module JsonApiModel
         :where
       end
 
-      def query( instance )
-        if instance.has_relationship_ids? name
-          { id: instance.relationship_ids( name ) }
-        elsif through?
-          { id: target_ids( instance ) }
+      def additional_options
+        [ :as, :through ]
+      end
+
+      def key
+        if json_relationship? || through?
+          :id
         elsif as?
-            { "#{as}_id" => instance.id }
+          "#{as}_id"
         else
-          { key => instance.id }
+          idify( base_class )
         end
       end
 
-      def additional_options
-        [ :as, :through ]
+      def ids( instance )
+        if json_relationship?
+          instance.relationship_ids( name )
+        elsif through?
+          target_ids( instance )
+        else
+          instance.id
+        end
+      end
+
+      def query( instance )
+        { key => ids( instance ) }
       end
 
       protected
@@ -41,15 +53,15 @@ module JsonApiModel
       end
 
       def target_ids( instance )
-        intermadiates = Array(instance.send( through ) )
-        
-        intermadiates.map do | intermediate | 
+        intermediates = Array(instance.send( through ) )
+
+        intermediates.map do | intermediate |
           intermediate.send( through_key )
         end
       end
       
       def through_key
-        idify klass
+        idify association_class
       end
     end
   end

data/lib/json_api_model/associations/preloader.rb

@@ -0,0 +1,59 @@
+module JsonApiModel
+  module Associations
+    class Preloader
+
+      class << self
+        def preload( objects, *preloads )
+          new( objects, preloads ).preload
+        end
+      end
+
+      attr_accessor :objects, :preloads
+
+      def initialize( objects, preloads )
+        @objects  = Array( objects ).compact
+        @preloads = preloads
+
+        validate_homogenity!
+      end
+
+      def preload
+        @preloads.each do | preload |
+          case preload
+          when Hash
+            preload.each do | preload, subpreloads |
+              preloader = Preloaders.preloader_for( @objects, preload )
+
+              subobjects = preloader.load
+              preloader.assign subobjects
+
+              subobjects.preload( subpreloads )
+            end
+          else
+            Preloaders.preloader_for( @objects, preload ).fetch
+          end
+        end
+
+        @objects
+      end
+
+      private
+
+      def validate_homogenity!
+        unless homogeneous?
+          raise "JsonApiModel::Associations::Preloader.preload called with a heterogeneous array of objects."
+        end
+      end
+
+      def object_class
+        @object_class ||= @objects.first.class
+      end
+
+      def homogeneous?
+        @objects.all? do |obj|
+          obj.is_a?(object_class)
+        end
+      end
+    end
+  end
+end

data/lib/json_api_model/associations/preloaders.rb

@@ -0,0 +1,32 @@
+module JsonApiModel
+  module Associations
+    module Preloaders
+      autoload :Base,       'json_api_model/associations/preloaders/base'
+      autoload :BelongsTo,  'json_api_model/associations/preloaders/belongs_to'
+      autoload :Has,        'json_api_model/associations/preloaders/has'
+
+      class << self
+        def preloader_for( objects, preload )
+          klass = object_class( objects )
+          association = klass.__associations.fetch preload
+
+          PREOLOADERS[ association.class ].new( objects, association )
+        rescue KeyError
+          raise "#{klass}##{preload.to_s} is not a valid association"
+        end
+
+        private 
+
+        def object_class( objects )
+          objects.first.class
+        end
+      end
+
+      PREOLOADERS = {
+                      JsonApiModel::Associations::BelongsTo => JsonApiModel::Associations::Preloaders::BelongsTo,
+                      JsonApiModel::Associations::HasOne    => JsonApiModel::Associations::Preloaders::Has,
+                      JsonApiModel::Associations::HasMany   => JsonApiModel::Associations::Preloaders::Has
+                    }
+    end
+  end
+end

data/lib/json_api_model/associations/preloaders/base.rb

@@ -0,0 +1,46 @@
+module JsonApiModel
+  module Associations
+    module Preloaders
+      class Base
+
+        attr_accessor :association
+        delegate :key, :name, :association_class, :action, :process, :ids, :base_class, to: :association
+
+        def initialize( objects, association )
+          @objects     = Array( objects )
+          @association = association
+        end
+
+        def fetch
+          assign load
+        end
+
+        def load
+          association_class.send( action, query( @objects ) )
+        end
+
+        def assign( results )
+          validate_assignability!( results )
+          @objects.each do | object |
+
+            associated_objects = results.to_a.select do |r|
+              associated_key( r ).in? Array( ids( object ) )
+            end
+
+            object.send( "#{name}=", process( associated_objects ) )
+          end
+        end
+
+        protected
+
+        def validate_assignability!( results )
+          results.each do | object |
+            unless associated_key( object )
+              raise "Preloading #{association_class}.#{lookup} failed: results don't identify an association."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api_model/associations/preloaders/belongs_to.rb

@@ -0,0 +1,23 @@
+module JsonApiModel
+  module Associations
+    module Preloaders
+      class BelongsTo < Base
+        def associated_key( object )
+          object.id
+        rescue => e
+          nil
+        end
+
+        def lookup
+          :id
+        end
+
+        def query( instances )
+          instances.map do | instance |
+            ids( instance )
+          end.uniq
+        end
+      end
+    end
+  end
+end

data/lib/json_api_model/associations/preloaders/has.rb

@@ -0,0 +1,26 @@
+module JsonApiModel
+  module Associations
+    module Preloaders
+      class Has < Base
+        def associated_key( object )
+          object.respond_to?( key ) ? object.send( key ) : object.id
+        rescue => e
+          nil
+        end
+
+        def query( instances )
+          instances.each_with_object( { key => [] } ) do | instance, query |
+            query[ key ] += Array( ids( instance ) )
+            query[ key ].uniq!
+          end
+        end
+
+        protected
+
+        def lookup
+          base_class.to_s.demodulize.underscore
+        end
+      end
+    end
+  end
+end

data/lib/json_api_model/model.rb

@@ -1,7 +1,7 @@
 module JsonApiModel
   class Model
     class << self
-      delegate :where, :order, :includes, :select, :all, :paginate, :page, :with_params, :first, :find, :last, to: :__new_scope
+      delegate :where, :order, :includes, :select, :all, :paginate, :page, :with_params, :first, :find, :last, :preload, to: :__new_scope
 
       attr_reader :client_class
       def wraps( client_class )

data/lib/json_api_model/result_set.rb

@@ -17,6 +17,10 @@ module JsonApiModel
       end
     end
 
+    def preload( *args )
+      JsonApiModel::Associations::Preloader.preload( self, *args )
+    end
+
     def meta
       @set.meta.attributes
     end

data/lib/json_api_model/version.rb

@@ -1,3 +1,3 @@
 module JsonApiModel
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: json_api_model
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Greg Orlov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-27 00:00:00.000000000 Z
+date: 2018-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -135,6 +135,11 @@ files:
 - lib/json_api_model/associations/has.rb
 - lib/json_api_model/associations/has_many.rb
 - lib/json_api_model/associations/has_one.rb
+- lib/json_api_model/associations/preloader.rb
+- lib/json_api_model/associations/preloaders.rb
+- lib/json_api_model/associations/preloaders/base.rb
+- lib/json_api_model/associations/preloaders/belongs_to.rb
+- lib/json_api_model/associations/preloaders/has.rb
 - lib/json_api_model/instrumenter.rb
 - lib/json_api_model/instrumenter/null_instrumenter.rb
 - lib/json_api_model/model.rb