live_record 0.2.8 → 0.3.0

data/app/channels/live_record/base_channel.rb

@@ -1,30 +1,5 @@
 class LiveRecord::BaseChannel < ActionCable::Channel::Base
 
-  module Helpers
-    def self.whitelisted_attributes(record, current_user)
-      whitelisted_attributes = record.class.live_record_whitelisted_attributes(record, current_user)
-
-      unless whitelisted_attributes.is_a? Array
-        raise "#{record.class}.live_record_whitelisted_attributes should return an array"
-      end
-
-      whitelisted_attributes = whitelisted_attributes.map(&:to_s)
-
-      if !whitelisted_attributes.empty? && !whitelisted_attributes.include?('id')
-        raise "#{record.class}.live_record_whitelisted_attributes should return an array that also includes the :id attribute, as you are authorizing at least one other attribute along with it."
-      end
-
-      whitelisted_attributes.to_set
-    end
-
-    def self.queryable_attributes(model_class, current_user)
-      queryable_attributes = model_class.live_record_queryable_attributes(current_user)
-      raise "#{model_class}.live_record_queryable_attributes should return an array" unless queryable_attributes.is_a? Array
-      queryable_attributes = queryable_attributes.map(&:to_s)
-      queryable_attributes.to_set
-    end
-  end
-
   protected
 
   def filtered_message(message, filters)

data/app/channels/live_record/base_channel/helpers.rb

@@ -0,0 +1,27 @@
+class LiveRecord::BaseChannel
+  
+  module Helpers
+    def self.whitelisted_attributes(record, current_user)
+      whitelisted_attributes = record.class.live_record_whitelisted_attributes(record, current_user)
+
+      unless whitelisted_attributes.is_a? Array
+        raise "#{record.class}.live_record_whitelisted_attributes should return an array"
+      end
+
+      whitelisted_attributes = whitelisted_attributes.map(&:to_s)
+
+      if !whitelisted_attributes.empty? && !whitelisted_attributes.include?('id')
+        raise "#{record.class}.live_record_whitelisted_attributes should return an array that also includes the :id attribute, as you are authorizing at least one other attribute along with it."
+      end
+
+      whitelisted_attributes.to_set
+    end
+
+    def self.queryable_attributes(model_class, current_user)
+      queryable_attributes = model_class.live_record_queryable_attributes(current_user)
+      raise "#{model_class}.live_record_queryable_attributes should return an array" unless queryable_attributes.is_a? Array
+      queryable_attributes = queryable_attributes.map(&:to_s)
+      queryable_attributes.to_set
+    end
+  end
+end

data/app/channels/live_record/{publications_channel → base_channel}/search_adapters.rb

@@ -1,4 +1,4 @@
-class LiveRecord::PublicationsChannel
+class LiveRecord::BaseChannel
 
   module SearchAdapters
     def self.mapped_active_record_relation(**args)

data/app/channels/live_record/changes_channel.rb

@@ -5,7 +5,7 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
 
   def subscribed
     find_record_from_params(params) do |record|
-      whitelisted_attributes = Helpers.whitelisted_attributes(record, current_user)
+      whitelisted_attributes = LiveRecord::BaseChannel::Helpers.whitelisted_attributes(record, current_user)
 
       if whitelisted_attributes.present?
         stream_for record, coder: ActiveSupport::JSON do |message|
@@ -14,7 +14,7 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
           rescue ActiveRecord::RecordNotFound
           end
 
-          whitelisted_attributes = Helpers.whitelisted_attributes(record, current_user)
+          whitelisted_attributes = LiveRecord::BaseChannel::Helpers.whitelisted_attributes(record, current_user)
 
           if whitelisted_attributes.size > 0
             response = filtered_message(message, whitelisted_attributes)
@@ -35,7 +35,7 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
     params = data.symbolize_keys
 
     find_record_from_params(params) do |record|
-      whitelisted_attributes = Helpers.whitelisted_attributes(record, current_user)
+      whitelisted_attributes = LiveRecord::BaseChannel::Helpers.whitelisted_attributes(record, current_user)
 
       if whitelisted_attributes.size > 0
         live_record_updates = nil

data/app/channels/live_record/publications_channel.rb

@@ -14,7 +14,7 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
       reject_subscription
     end
 
-    if !(model_class && Helpers.queryable_attributes(model_class, current_user).present?)
+    if !(model_class && LiveRecord::BaseChannel::Helpers.queryable_attributes(model_class, current_user).present?)
       respond_with_error(:forbidden, 'You do not have privileges to query')
       reject_subscription
     end
@@ -22,14 +22,14 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
     stream_from "live_record:publications:#{params[:model_name].underscore}", coder: ActiveSupport::JSON do |message|
       newly_created_record = model_class.find(message['attributes']['id'])
 
-      active_record_relation = SearchAdapters.mapped_active_record_relation(
+      active_record_relation = LiveRecord::BaseChannel::SearchAdapters.mapped_active_record_relation(
         model_class: model_class,
         conditions_hash: params[:where].to_h,
         current_user: current_user
       )
 
       if active_record_relation.exists?(id: newly_created_record.id)
-        whitelisted_attributes = Helpers.whitelisted_attributes(newly_created_record, current_user)
+        whitelisted_attributes = LiveRecord::BaseChannel::Helpers.whitelisted_attributes(newly_created_record, current_user)
 
         if whitelisted_attributes.size > 0
           message = { 'action' => 'create', 'attributes' => message['attributes'] }
@@ -46,7 +46,7 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
 
     if model_class && model_class < ApplicationRecord
 
-      active_record_relation = SearchAdapters.mapped_active_record_relation(
+      active_record_relation = LiveRecord::BaseChannel::SearchAdapters.mapped_active_record_relation(
         model_class: model_class,
         conditions_hash: params[:where].to_h,
         current_user: current_user,
@@ -61,7 +61,7 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
       # we `transmmit` a message back to client for each matching record
       active_record_relation.find_each do |record|
         # but first, check for the authorised attributes, if exists
-        whitelisted_attributes = Helpers.whitelisted_attributes(record, current_user)
+        whitelisted_attributes = LiveRecord::BaseChannel::Helpers.whitelisted_attributes(record, current_user)
 
         if whitelisted_attributes.size > 0
           message = { 'action' => 'create', 'attributes' => record.attributes }

data/config/puma.rb

@@ -0,0 +1,2 @@
+workers 3
+preload_app!

data/lib/live_record/model/callbacks.rb

@@ -4,10 +4,12 @@ module LiveRecord
       extend ActiveSupport::Concern
 
       included do
+        after_update_commit :__live_record_dereference_changed_attributes__
         before_update :__live_record_reference_changed_attributes__
         after_update_commit :__live_record_broadcast_record_update__
         after_destroy_commit :__live_record_broadcast_record_destroy__
         after_create_commit :__live_record_broadcast_record_create__
+        after_commit :__live_record_broadcast_record_autoload__,  on: [:update, :create]
 
         def self.live_record_whitelisted_attributes(record, current_user)
           []
@@ -19,9 +21,12 @@ module LiveRecord
           @_live_record_changed_attributes = changed
         end
 
+        def __live_record_dereference_changed_attributes__
+          @_live_record_changed_attributes = nil
+        end
+
         def __live_record_broadcast_record_update__
           included_attributes = attributes.slice(*@_live_record_changed_attributes)
-          @_live_record_changed_attributes = nil
           message_data = { 'action' => 'update', 'attributes' => included_attributes }
           LiveRecord::ChangesChannel.broadcast_to(self, message_data)
           LiveRecordUpdate.create!(recordable_type: self.class, recordable_id: self.id, created_at: DateTime.now)
@@ -36,7 +41,29 @@ module LiveRecord
           message_data = { 'action' => 'create', 'attributes' => attributes }
           ActionCable.server.broadcast "live_record:publications:#{self.class.name.underscore}", message_data
         end
+
+        def __live_record_broadcast_record_autoload__
+          included_attributes = nil
+
+          changed_attributes = attributes.slice(*@_live_record_changed_attributes)
+
+          # if after_update
+          if changed_attributes.present?
+            included_attributes = changed_attributes
+          # else if after_create_commit
+          else
+            included_attributes = attributes
+          end
+
+          message_data = {
+            'action' => 'create_or_update',
+            'model_name' => self.class.to_s,
+            'record_id' => id,
+            'attributes' => included_attributes
+          }
+          ActionCable.server.broadcast 'live_record:autoloads', message_data
+        end
       end
     end
   end
-end
+end

data/lib/live_record/version.rb

@@ -1,3 +1,3 @@
 module LiveRecord
-  VERSION = '0.2.8'.freeze
+  VERSION = '0.3.0'.freeze
 end

data/live_record.gemspec

@@ -17,19 +17,23 @@ Gem::Specification.new do |s|
   s.add_dependency 'rails', '>= 5.0.0', '< 5.2'
 
   s.add_development_dependency 'rails', '~> 5.1'
+  s.add_development_dependency 'puma', '~> 3.10'
   s.add_development_dependency 'bundler', '~> 1.3'
-  s.add_development_dependency 'rspec-rails', '~> 3.6'
-  s.add_development_dependency 'combustion', '~> 0.7'
   s.add_development_dependency 'byebug', '~> 9.0'
-  s.add_development_dependency 'sqlite3', '~> 1.3'
-  s.add_development_dependency 'redis', '~> 3.3'
-  s.add_development_dependency 'puma', '~> 3.10'
-  s.add_development_dependency 'jquery-rails', '~> 4.3'
+
   s.add_development_dependency 'sprockets-rails', '~> 3.2'
   s.add_development_dependency 'coffee-rails', '~> 4.2'
+  s.add_development_dependency 'jquery-rails', '~> 4.3'
   s.add_development_dependency 'jbuilder', '~> 2.7'
+
+  s.add_development_dependency 'sqlite3', '~> 1.3'
+  s.add_development_dependency 'redis', '~> 3.3'
+
+  s.add_development_dependency 'rspec-rails', '~> 3.6'
+  s.add_development_dependency 'combustion', '~> 0.7'
   s.add_development_dependency 'chromedriver-helper', '~> 1.1'
   s.add_development_dependency 'selenium-webdriver', '~> 3.5'
   s.add_development_dependency 'faker', '~> 1.8'
   s.add_development_dependency 'database_cleaner', '~> 1.6'
+  s.add_development_dependency 'timecop', '0.9.1'
 end

data/spec/features/live_record_syncing_spec.rb

@@ -9,9 +9,15 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   let!(:users) { [user1, user2] }
   let!(:posts) { [post1, post2, post3] }
 
+  # LiveRecord.helpers.loadRecords({ modelName: 'Post' });
+  # LiveRecord.helpers.loadRecords({ modelName: 'User', url: '<%= j users_path %>' });
+  # LiveRecord.Model.all.Post.subscribe({ where: { is_enabled_eq: true, content_eq: 'somecontent' }});
+
   scenario 'User sees live changes (updates) of post records', js: true do
     visit '/posts'
 
+    execute_script("LiveRecord.helpers.loadRecords({ modelName: 'Post' });")
+
     post1_title_td = find('td', text: post1.title, wait: 10)
     post2_title_td = find('td', text: post2.title, wait: 10)
     post3_title_td = find('td', text: post3.title, wait: 10)
@@ -27,6 +33,8 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   scenario 'User sees live changes (destroy) of post records', js: true do
     visit '/posts'
 
+    execute_script("LiveRecord.helpers.loadRecords({ modelName: 'Post' });")
+
     expect{find('td', text: post1.title, wait: 10)}.to_not raise_error
     expect{find('td', text: post2.title, wait: 10)}.to_not raise_error
     expect{find('td', text: post3.title, wait: 10)}.to_not raise_error
@@ -43,6 +51,8 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   scenario 'User sees live changes (updates) of post records, but only changes from whitelisted authorised attributes', js: true do
     visit '/posts'
 
+    execute_script("LiveRecord.helpers.loadRecords({ modelName: 'Post' });")
+
     post1_title_td = find('td', text: post1.title, wait: 10)
     post1_content_td = find('td', text: post1.content, wait: 10)
     post2_title_td = find('td', text: post2.title, wait: 10)
@@ -65,6 +75,13 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   scenario 'JS-Client can access Model associations record objects in its current store', js: true do
     visit '/posts'
 
+    execute_script(
+      <<-eos
+      LiveRecord.helpers.loadRecords({ modelName: 'Post' });
+      LiveRecord.helpers.loadRecords({ modelName: 'User', url: '#{users_path}' });
+      eos
+    )
+
     # let's wait for all records first before checking correct associations
     wait before: -> { evaluate_script('Object.keys( LiveRecord.Model.all.User.all ).length') }, becomes: -> (value) { value == users.size }, duration: 10.seconds
     expect(evaluate_script('Object.keys( LiveRecord.Model.all.User.all ).length')).to eq users.size
@@ -94,35 +111,35 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
     expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post3.id}].user()")).to eq nil
   end
 
-  # see spec/internal/app/views/posts/index.html.erb to see the subscribe "conditions"
   scenario 'JS-Client receives live new (create) post records where specified "conditions" matched', js: true do
     visit '/posts'
 
-    # wait first for all posts to be loaded
-    wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
-    expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
+    execute_script("LiveRecord.Model.all.Post.subscribe({ where: { is_enabled_eq: true }});")
 
-    post4 = create(:post, id: 98, is_enabled: true)
-    post5 = create(:post, id: 99, is_enabled: false)
+    sleep(1)
+
+    post4 = create(:post, is_enabled: true)
+    post5 = create(:post, is_enabled: false)
+    post6 = create(:post, is_enabled: true)
 
     wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}] == undefined") }, becomes: -> (value) { value == false }
     expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}] == undefined")).to be false
 
     wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post5.id}] == undefined") }, becomes: -> (value) { value == true }
     expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post5.id}] == undefined")).to be true
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post6.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post6.id}] == undefined")).to be false
   end
 
-  # see spec/internal/app/views/posts/index.html.erb to see the subscribe "conditions"
   scenario 'JS-Client receives live new (create) post records where only considered "conditions" are the whitelisted authorised attributes', js: true do
     visit '/posts'
 
-    # wait first for all posts to be loaded
-    wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
-    expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
+    execute_script("LiveRecord.Model.all.Post.subscribe({ where: { is_enabled_eq: true, content_eq: 'somecontent' }});")
 
-    # in index.html.erb:
-    # LiveRecord.Model.all.Post.subscribe({ where: { is_enabled: true, content: 'somecontent' }});
-    # because `content` is not whitelisted, therefore the `content` condition above is disregarded
+    sleep(1)
+
+    # because `content` is not whitelisted in models/post.rb, therefore the `content` condition is disregarded from above
     post4 = create(:post, is_enabled: true, content: 'somecontent')
     post5 = create(:post, is_enabled: true, content: 'contentisnotwhitelistedthereforewontbeconsidered')
 
@@ -137,20 +154,105 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   scenario 'JS-Client receives live new (create) post records having only the whitelisted authorised attributes', js: true do
     visit '/posts'
 
-    # wait first for all posts to be loaded
-    wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
-    expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
+    execute_script("LiveRecord.Model.all.Post.subscribe();")
+
+    sleep(1)
 
     post4 = create(:post, is_enabled: true, title: 'sometitle', content: 'somecontent')
 
     wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}] == undefined")).to be false
     expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}].title()")).to eq post4.title
-    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}].content()")).to eq nil
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post4.id}].attributes.content")).to eq nil
+  end
+
+  scenario 'JS-Client receives live autoloaded (create or update) post records where specified "conditions" matched', js: true do
+    visit '/posts'
+
+    # prepopulate
+    disabled_post_that_will_be_enabled = create(:post, is_enabled: false)
+
+    execute_script("LiveRecord.Model.all.Post.autoload({ where: { is_enabled_eq: true }});")
+
+    sleep(1)
+
+    disabled_post = create(:post, is_enabled: false)
+    enabled_post = create(:post, is_enabled: true)
+
+    sleep(5)
+
+    disabled_post_that_will_be_enabled.update!(is_enabled: true)
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{disabled_post.id}] == undefined") }, becomes: -> (value) { value == true }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{disabled_post.id}] == undefined")).to be true
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{enabled_post.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{enabled_post.id}] == undefined")).to be false
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{disabled_post_that_will_be_enabled.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{disabled_post_that_will_be_enabled.id}] == undefined")).to be false
+  end
+
+  scenario 'JS-Client receives live autoloaded (create or update) post records where only considered "conditions" are the whitelisted authorised attributes', js: true do
+    visit '/posts'
+
+    # prepopulate
+    updated_post1 = create(:post, is_enabled: false, content: 'somecontent')
+    updated_post2 = create(:post, is_enabled: false, content: 'contentisnotwhitelistedthereforewontbeconsidered')
+
+    execute_script("LiveRecord.Model.all.Post.autoload({ where: { is_enabled_eq: true, content_eq: 'somecontent' }});")
+
+    sleep(1)
+
+    # because `content` is not whitelisted in models/post.rb, therefore the `content` condition is disregarded from above
+    created_post1 = create(:post, is_enabled: true, content: 'somecontent')
+    created_post2 = create(:post, is_enabled: true, content: 'contentisnotwhitelistedthereforewontbeconsidered')
+    updated_post1.update!(is_enabled: true)
+    updated_post2.update!(is_enabled: true)
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{created_post1.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{created_post1.id}] == undefined")).to be false
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{created_post2.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{created_post2.id}] == undefined")).to be false
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post1.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post1.id}] == undefined")).to be false
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post2.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post2.id}] == undefined")).to be false
+  end
+
+  # see spec/internal/app/models/post.rb to view specified whitelisted attributes
+  scenario 'JS-Client receives live autoloaded (create or update) post records having only the whitelisted authorised attributes', js: true do
+    visit '/posts'
+
+    # prepopulate
+    updated_post = create(:post, is_enabled: true, title: 'sometitle', content: 'somecontent')
+
+    execute_script("LiveRecord.Model.all.Post.autoload();")
+
+    sleep(1)
+
+    created_post = create(:post, is_enabled: true, title: 'sometitle', content: 'somecontent')
+    updated_post = create(:post, is_enabled: false, title: 'sometitle', content: 'somecontent')
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{created_post.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{created_post.id}] == undefined")).to be false
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{created_post.id}].title()")).to eq created_post.title
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{created_post.id}].attributes.content")).to eq nil
+
+    wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post.id}] == undefined") }, becomes: -> (value) { value == false }
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post.id}] == undefined")).to be false
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post.id}].title()")).to eq updated_post.title
+    expect(evaluate_script("LiveRecord.Model.all.Post.all[#{updated_post.id}].attributes.content")).to eq nil
   end
 
   scenario 'JS-Client should not have shared callbacks for those callbacks defined only for a particular post record', js: true do
     visit '/posts'
 
+    execute_script("LiveRecord.helpers.loadRecords({ modelName: 'Post' });")
+
     # wait first for all posts to be loaded
     wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
     expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
@@ -169,9 +271,7 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
   scenario 'JS-Client should receive response :forbidden error when using `subscribe()` but that the current_user is forbidden to do so', js: true do
     visit '/posts'
 
-    # wait first for all posts to be loaded
-    wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
-    expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
+    execute_script("LiveRecord.Model.all.Post.subscribe();")
 
     expect_any_instance_of(LiveRecord::BaseChannel).to(
       receive(:respond_with_error).with(:forbidden, 'You do not have privileges to query').once
@@ -194,12 +294,17 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
 
       visit '/posts'
 
+      execute_script(
+        <<-eos
+        LiveRecord.helpers.loadRecords({ modelName: 'Post' });
+        LiveRecord.Model.all.Post.subscribe();
+        eos
+      )
+
       # wait first for all posts to be loaded
       wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
       expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
 
-      disconnection_time = 10 # seconds
-
       Thread.new do
         sleep(2)
 
@@ -213,7 +318,7 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
         post_that_will_be_updated_while_disconnected_2.update!(title: 'newtitle')
       end
 
-      # LiveRecord.stop_all_streams
+      disconnection_time = 10
       sleep(disconnection_time)
 
       wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_that_will_be_updated_while_disconnected_1.id}] == undefined") }, becomes: -> (value) { value == false }, duration: 10.seconds
@@ -223,18 +328,22 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
       expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_that_will_be_updated_while_disconnected_2.id}].title()")).to eq 'newtitle'
     end
 
-    scenario 'JS-Client receives all post records created during the time it got disconnected', js: true do
+    scenario 'JS-Client receives all post records created (matching the conditions) during the time it got disconnected', js: true do
       visit '/posts'
 
-      # wait first for all posts to be loaded
-      wait before: -> { evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length") }, becomes: -> (value) { value == Post.all.count }, duration: 10.seconds
-      expect(evaluate_script("Object.keys( LiveRecord.Model.all.Post.all ).length")).to be Post.all.count
-
-      disconnection_time = 10 # seconds
-
       post_created_before_disconnection = nil
       post_created_while_disconnected_1 = nil
       post_created_while_disconnected_2 = nil
+      post_created_while_disconnected_but_does_not_match = nil
+
+      # this needs to be before execute_script, otherwise it gets loaded by the subscription
+      Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) - 30.seconds) do
+        post_created_before_disconnection = create(:post, is_enabled: true)
+      end
+
+      execute_script("LiveRecord.Model.all.Post.subscribe({where: {is_enabled_eq: true}});")
+
+      sleep(1)
 
       Thread.new do
         sleep(2)
@@ -245,13 +354,85 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
         end
 
         # then we create records while disconnected
-        post_created_while_disconnected_1 = create(:post, is_enabled: true, created_at: (DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 30.seconds)
-        post_created_while_disconnected_2 = create(:post, is_enabled: true, created_at: (DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours)
-        # we need to create this here, otherwise it will be loaded on the Page immediately by the .loadRecords() in JS
-        post_created_before_disconnection = create(:post, is_enabled: true, created_at: (DateTime.now - LiveRecord.configuration.sync_record_buffer_time) - 30.seconds)
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 30.seconds) do
+          post_created_while_disconnected_1 = create(:post, is_enabled: true)
+        end
+
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours) do
+          post_created_while_disconnected_2 = create(:post, is_enabled: true)
+        end
+
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours) do
+          post_created_while_disconnected_but_does_not_match = create(:post, is_enabled: false)
+        end
+      end
+
+      disconnection_time = 10
+      sleep(disconnection_time)
+
+      wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_1.id}] == undefined") }, becomes: -> (value) { value == false }, duration: 10.seconds
+      expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_1.id}] == undefined")).to be false
+
+      wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_2.id}] == undefined") }, becomes: -> (value) { value == false }
+      expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_2.id}] == undefined")).to be false
+
+      wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_but_does_not_match.id}] == undefined") }, becomes: -> (value) { value == true }
+      expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_but_does_not_match.id}] == undefined")).to be true
+
+      wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_before_disconnection.id}] == undefined") }, becomes: -> (value) { value == false }
+      expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_before_disconnection.id}] == undefined")).to be true
+    end
+
+    scenario 'JS-Client receives all post records created/updated (matching the conditions), during the time it got disconnected', js: true do
+      post_created_before_disconnection = nil
+      post_created_while_disconnected_1 = nil
+      post_created_while_disconnected_2 = nil
+      post_created_while_disconnected_but_does_not_match = nil
+
+      # prepopulate before loading of page/script
+      post_updated_before_disconnection = create(:post, is_enabled: false)
+      post_updated_while_disconnected_1 = create(:post, is_enabled: false)
+      post_updated_while_disconnected_2 = create(:post, is_enabled: false)
+      post_updated_while_disconnected_but_does_not_match = create(:post, is_enabled: true)
+
+      # this needs to be before execute_script, otherwise it gets loaded by the subscription
+      Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) - 30.seconds) do
+        post_created_before_disconnection = create(:post, is_enabled: true)
+        post_updated_before_disconnection.update!(is_enabled: true)
+      end
+
+      visit '/posts'
+
+      execute_script("LiveRecord.Model.all.Post.autoload({where: {is_enabled_eq: true}});")
+
+      sleep(1)
+
+      Thread.new do
+        sleep(2)
+
+        # temporarily stop all current autoloads_channel connections
+        ObjectSpace.each_object(LiveRecord::AutoloadsChannel) do |autoloads_channel|
+          autoloads_channel.connection.close
+        end
+
+        # then we create/update records while disconnected
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 30.seconds) do
+          post_created_while_disconnected_1 = create(:post, is_enabled: true)
+          post_updated_while_disconnected_1.update!(is_enabled: true)
+        end
+
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours) do
+          post_created_while_disconnected_2 = create(:post, is_enabled: true)
+          post_updated_while_disconnected_2.update!(is_enabled: true)
+        end
+
+        Timecop.freeze((DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours) do
+          post_created_while_disconnected_but_does_not_match = create(:post, is_enabled: false, created_at: (DateTime.now - LiveRecord.configuration.sync_record_buffer_time) + 99.hours)
+          post_updated_while_disconnected_but_does_not_match.update!(is_enabled: false)
+        end
       end
 
-      # LiveRecord.stop_all_streams
+      disconnection_time = 10
       sleep(disconnection_time)
 
       wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_1.id}] == undefined") }, becomes: -> (value) { value == false }, duration: 10.seconds
@@ -260,6 +441,9 @@ RSpec.feature 'LiveRecord Syncing', type: :feature do
       wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_2.id}] == undefined") }, becomes: -> (value) { value == false }
       expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_2.id}] == undefined")).to be false
 
+      wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_but_does_not_match.id}] == undefined") }, becomes: -> (value) { value == true }
+      expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_while_disconnected_but_does_not_match.id}] == undefined")).to be true
+
       wait before: -> { evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_before_disconnection.id}] == undefined") }, becomes: -> (value) { value == false }
       expect(evaluate_script("LiveRecord.Model.all.Post.all[#{post_created_before_disconnection.id}] == undefined")).to be true
     end