live_record 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4cb6c6112e8dc95504592f04bbcc692184625232
-  data.tar.gz: 8fc5c877c5bc1b14f84c7e4d835880cf057c62e8
+  metadata.gz: cd7810b1566eda128b77c0d451fedf5056c006b1
+  data.tar.gz: ac200f664f84fb987e563a6dbbed7b186fdcf5f1
 SHA512:
-  metadata.gz: f4f90c7c3dcd0be1ab798a484d87af59d0fda7383c22f1568c5cf9ec0bae8c6cef13d915fa3884ed72d13e30c85128bcb978e4f1c57cd423551087a042a8f944
-  data.tar.gz: 6fbb76854c2369cb1432b4f5dd1989e4880d16cc41707233be861999c5fbf1838cc4c23cf2d3791aca74cfe05424d773056aeafbb2e7fccb82f5e864055294a6
+  metadata.gz: 181ef9c74581d40fb9e4cd9f9992f25dc798370467fc93c67b6934e305c02a463390fc505210b04dc68c1a2efd2a92f32e5586d828978af897ae1eaf958ac0f5
+  data.tar.gz: d6c549d59bad9e84abc80d734abc39c093dd62fd673886abe8c98953ade0c5d66d327c8dc75aecd9b371573bb3f81ae0d1321232d86176f14912678d8e5fbc32

data/README.md

@@ -32,10 +32,13 @@
 
 ### Subscribing to Record Creation
   ```js
-  // subscribe, and auto-receive newly created Book records from the Rails server
+  // subscribe and auto-receive newly created Book records from the Rails server
   LiveRecord.Model.all.Book.subscribe()
 
-  // ...or only those which are enabled
+  // ... or also load all Book records as well (not just the new ones)
+  // LiveRecord.Model.all.Book.subscribe({reload: true})
+
+  // ...or only those which are enabled (you can also combine this with `reload: true`)
   // LiveRecord.Model.all.Book.subscribe({where: {is_enabled_eq: true}})
 
   // now, we can just simply add a "create" callback, to apply our own logic whenever a new Book record is streamed from the backend
@@ -114,7 +117,7 @@
 1. Add the following to your `Gemfile`:
 
     ```ruby
-    gem 'live_record', '~> 0.2.3'
+    gem 'live_record', '~> 0.2.4'
     ```
 
 2. Run:
@@ -345,16 +348,22 @@
     })
     ```
 
-9. To automatically receive new Book records, you may subscribe:
+9. To automatically receive new Book records, and/or also load the old ones, you may subscribe:
 
     ```js
-    // subscribe
+    // subscribe and auto-fetches newly created Book records from the backend
     var subscription = LiveRecord.Model.all.Book.subscribe();
 
+    // ...or also load all Book records (not just the new ones).
+    // useful for populating records at the start, and therefore you may skip using `LiveRecord.helpers.loadRecords()` already
+    // subscription = LiveRecord.Model.all.Book.subscribe({reload: true});
+
     // ...or subscribe only to certain conditions (i.e. when `is_enabled` attribute value is `true`)
     // For the list of supported operators (like `..._eq`), see JS API `MODEL.subscribe(CONFIG)` below
     // subscription = LiveRecord.Model.all.Book.subscribe({where: {is_enabled_eq: true}});
 
+    // you may choose to combine both `where` and `reload` arguments described above
+
     // now, we can just simply add a "create" callback, to apply our own logic whenever a new Book record is streamed from the backend
     LiveRecord.Model.all.Book.addCallback('after:create', function() {
       // let's say you have a code here that adds this new Book on the page
@@ -490,6 +499,7 @@
 
 ### `MODEL.subscribe(CONFIG)`
   * `CONFIG` (Object, Optional)
+    * `reload`: (Boolean, Default: false)
     * `where`: (Object)
       * `ATTRIBUTENAME_OPERATOR`: (Any Type)
     * `callbacks`: (Object)
@@ -498,6 +508,7 @@
       * `before:create`: (function Object)
       * `after:create`: (function Object)
   * subscribes to the `LiveRecord::PublicationsChannel`, which then automatically receives new records from the backend.
+  * when `reload: true`, all records (subject to `where` condition above) are immediately loaded, and not just the new ones.
   * you can also pass in `callbacks` (see above). These callbacks are only applicable to this subscription, and is independent of the Model and Instance callbacks.
   * `ATTRIBUTENAME_OPERATOR` means something like (for example): `is_enabled_eq`, where `is_enabled` is the `ATTRIBUTENAME` and `eq` is the `OPERATOR`.
     * you can have as many `ATTRIBUTENAME_OPERATOR` as you like, but keep in mind that the logic applied to them is "AND", and not "OR". For "OR" conditions, use `ransack`
@@ -536,8 +547,11 @@
   * if association is "belongs to", then returns the record (if exists in current store)
   * (i.e. `bookInstance.user()`, `bookInstance.reviews()`)
 
-### `MODELINSTANCE.subscribe()`
+### `MODELINSTANCE.subscribe(config)`
+  * `CONFIG` (Object, Optional)
+    * `reload`: (Boolean, Default: false)
   * subscribes to the `LiveRecord::ChangesChannel`. This instance should already be subscribed by default after being stored, unless there is a `on:response_error` or manually `unsubscribed()` which then you should manually call this `subscribe()` function after correctly handling the response error, or whenever desired.
+  * when `reload: true`, the record is forced reloaded to make sure all attributes are in-sync
   * returns the `subscription` object (the ActionCable subscription object itself)
 
 ### `MODELINSTANCE.unsubscribe()`
@@ -550,7 +564,7 @@
   * the `subscription` object (the ActionCable subscription object itself)
 
 ### `MODELINSTANCE.create()`
-  * stores the instance to the store, and then `subscribe()` to the `LiveRecord::ChangesChannel` for syncing
+  * stores the instance to the store, and then `subscribe({reload: true})` to the `LiveRecord::ChangesChannel` for syncing
   * returns the instance
 
 ### `MODELINSTANCE.update(ATTRIBUTES)`
@@ -596,6 +610,10 @@
 * MIT
 
 ## Changelog
+* 0.2.4
+  * you can now pass in `{reload: true}` to `subscribe()` like the folowing:
+    * `MODEL.subscribe({reload: true})` to immediately load all records from backend, and not just the new ones
+    * `MODELINSTANCE.subscribe({reload: true})` to immediately reload the record and make sure it's in-sync
 * 0.2.3
   * IMPORTANT! renamed callback from `on:response_error` to `on:responseError` for conformity. So please update your code accordingly.
   * added [associations](#example-2---model--callbacks--associations):

data/app/assets/javascripts/live_record/model/create.coffee

@@ -5,12 +5,12 @@ LiveRecord.Model.create = (config) ->
 
   # NEW
   Model = (attributes) ->
-    this.attributes = attributes
+    @attributes = attributes
 
-    Object.keys(this.attributes).forEach (attribute_key) ->
+    Object.keys(@attributes).forEach (attribute_key) ->
       if Model.prototype[attribute_key] == undefined
         Model.prototype[attribute_key] = ->
-          this.attributes[attribute_key]
+          @attributes[attribute_key]
     this
 
   Model.modelName = config.modelName
@@ -49,9 +49,9 @@ LiveRecord.Model.create = (config) ->
 
   Model.subscriptions = []
 
-  Model.subscribe = (config) ->
-    config ||= {}
+  Model.subscribe = (config = {}) ->
     config.callbacks ||= {}
+    config.reload ||= false
 
     subscription = App.cable.subscriptions.create(
       {
@@ -61,13 +61,18 @@ LiveRecord.Model.create = (config) ->
       },
 
       connected: ->
-        if this.liveRecord._staleSince != undefined
+        # if forced reload of all records after subscribing, reload only once at the very start of connection, and no longer when reconnecting
+        if config.reload
+          config.reload = false
+          @syncRecords()
+
+        if @liveRecord._staleSince != undefined
           @syncRecords()
 
         config.callbacks['on:connect'].call(this) if config.callbacks['on:connect']
 
       disconnected: ->
-        this.liveRecord._staleSince = (new Date()).toISOString() unless this.liveRecord._staleSince
+        @liveRecord._staleSince = (new Date()).toISOString() unless @liveRecord._staleSince
         config.callbacks['on:disconnect'].call(this) if config.callbacks['on:disconnect']
 
       received: (data) ->
@@ -85,9 +90,9 @@ LiveRecord.Model.create = (config) ->
           'sync_records',
           model_name: Model.modelName,
           where: config.where,
-          stale_since: this.liveRecord._staleSince
+          stale_since: @liveRecord._staleSince
         )
-        this.liveRecord._staleSince = undefined
+        @liveRecord._staleSince = undefined
     )
 
     subscription.liveRecord = {}
@@ -95,36 +100,43 @@ LiveRecord.Model.create = (config) ->
     subscription.liveRecord.where = config.where
     subscription.liveRecord.callbacks = config.callbacks
 
-    this.subscriptions.push(subscription)
+    @subscriptions.push(subscription)
     subscription
 
   Model.unsubscribe = (subscription) ->
-    index = this.subscriptions.indexOf(subscription)
-    throw new Error('`subscription` argument does not exist in ' + this.modelName + ' subscriptions list') if index == -1
+    index = @subscriptions.indexOf(subscription)
+    throw new Error('`subscription` argument does not exist in ' + @modelName + ' subscriptions list') if index == -1
 
     App.cable.subscriptions.remove(subscription)
 
-    this.subscriptions.splice(index, 1)
+    @subscriptions.splice(index, 1)
     subscription
 
-  Model.prototype.subscribe = ->
-    return this.subscription if this.subscription != undefined
+  Model.prototype.subscribe = (config = {}) ->
+    return @subscription if @subscription != undefined
+
+    config.reload ||= false
 
     # listen for record changes (update / destroy)
-    subscription = App['live_record_' + this.modelName() + '_' + this.id()] = App.cable.subscriptions.create(
+    subscription = App['live_record_' + @modelName() + '_' + @id()] = App.cable.subscriptions.create(
       {
         channel: 'LiveRecord::ChangesChannel'
-        model_name: this.modelName()
-        record_id: this.id()
+        model_name: @modelName()
+        record_id: @id()
       },
 
       record: ->
         return @_record if @_record
-        identifier = JSON.parse(this.identifier)
+        identifier = JSON.parse(@identifier)
         @_record = Model.all[identifier.record_id]
 
       # on: connect
       connected: ->
+        # if forced reload of this record after subscribing, reload only once at the very start of connection, and no longer when reconnecting
+        if config.reload
+          config.reload = false
+          @syncRecord(@record())
+
         if @record()._staleSince != undefined
           @syncRecord(@record())
 
@@ -173,7 +185,7 @@ LiveRecord.Model.create = (config) ->
         @record()._staleSince = undefined
     )
 
-    this.subscription = subscription
+    @subscription = subscription
 
   Model.prototype.model = ->
     Model
@@ -182,45 +194,44 @@ LiveRecord.Model.create = (config) ->
     Model.modelName
 
   Model.prototype.unsubscribe = ->
-    return if this.subscription == undefined
-    App.cable.subscriptions.remove(this.subscription)
+    return if @subscription == undefined
+    App.cable.subscriptions.remove(@subscription)
     delete this['subscription']
 
   Model.prototype.isSubscribed = ->
-    this.subscription != undefined
+    @subscription != undefined
 
   # CREATE
   Model.prototype.create = (options) ->
-    throw new Error(Model.modelName+'('+this.id()+') is already in the store') if Model.all[this.attributes.id]
-    this._callCallbacks('before:create', undefined)
+    throw new Error(Model.modelName+'('+@id()+') is already in the store') if Model.all[@attributes.id]
+    @_callCallbacks('before:create', undefined)
 
-    Model.all[this.attributes.id] = this
-    # because we do not know if this newly created object is statle, then we just set it to very long time ago, before we subscribe()
-    this._staleSince = (new Date(1900, 0, 1)).toISOString()
-    this.subscribe()
+    Model.all[@attributes.id] = this
+    # because we do not know if this newly created object is stale upon creation, then we force reload it
+    @subscribe({reload: true})
 
-    this._callCallbacks('after:create', undefined)
+    @_callCallbacks('after:create', undefined)
     this
 
   # UPDATE
   Model.prototype.update = (attributes) ->
-    this._callCallbacks('before:update', undefined)
+    @_callCallbacks('before:update', undefined)
 
     self = this
     Object.keys(attributes).forEach (attribute_key) ->
       self.attributes[attribute_key] = attributes[attribute_key]
 
-    this._callCallbacks('after:update', undefined)
+    @_callCallbacks('after:update', undefined)
     true
 
   # DESTROY
   Model.prototype.destroy = ->
-    this._callCallbacks('before:destroy', undefined)
+    @_callCallbacks('before:destroy', undefined)
 
-    this.unsubscribe()
-    delete Model.all[this.attributes.id]
+    @unsubscribe()
+    delete Model.all[@attributes.id]
 
-    this._callCallbacks('after:destroy', undefined)
+    @_callCallbacks('after:destroy', undefined)
     this
 
   # CALLBACKS
@@ -251,16 +262,16 @@ LiveRecord.Model.create = (config) ->
 
   # adding new callbackd to the list
   Model.prototype.addCallback = Model.addCallback = (callbackKey, callbackFunction) ->
-    index = this._callbacks[callbackKey].indexOf(callbackFunction)
+    index = @_callbacks[callbackKey].indexOf(callbackFunction)
     if index == -1
-      this._callbacks[callbackKey].push(callbackFunction)
+      @_callbacks[callbackKey].push(callbackFunction)
       return callbackFunction
 
   # removing a callback from the list
   Model.prototype.removeCallback = Model.removeCallback = (callbackKey, callbackFunction) ->
-    index = this._callbacks[callbackKey].indexOf(callbackFunction)
+    index = @_callbacks[callbackKey].indexOf(callbackFunction)
     if index != -1
-      this._callbacks[callbackKey].splice(index, 1)
+      @_callbacks[callbackKey].splice(index, 1)
       return callbackFunction
 
   Model.prototype._callCallbacks = (callbackKey, args) ->
@@ -269,15 +280,15 @@ LiveRecord.Model.create = (config) ->
       callback.apply(this, args)
 
     # call instance callbacks
-    for callback in this._callbacks[callbackKey]
+    for callback in @_callbacks[callbackKey]
       callback.apply(this, args)
 
   Model.prototype._setChangesFrom = (attributes) ->
-    this.changes = {}
+    @changes = {}
 
     for attributeName, attributeValue of attributes
-      unless this.attributes[attributeName] && this.attributes[attributeName] == attributeValue
-        this.changes[attributeName] = [this.attributes[attributeName], attributeValue]
+      unless @attributes[attributeName] && @attributes[attributeName] == attributeValue
+        @changes[attributeName] = [@attributes[attributeName], attributeValue]
 
   Model.prototype._unsetChanges = () ->
     delete this['changes']

data/app/channels/live_record/changes_channel.rb

@@ -13,7 +13,7 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
             record.reload
           rescue ActiveRecord::RecordNotFound
           end
-          
+
           authorised_attributes = authorised_attributes(record, current_user)
 
           # if not just :id
@@ -33,19 +33,27 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
   end
 
   def sync_record(data)
-    find_record_from_params(data.symbolize_keys) do |record|
+    params = data.symbolize_keys
+
+    find_record_from_params(params) do |record|
       authorised_attributes = authorised_attributes(record, current_user)
 
       # if not just :id
       if authorised_attributes.size > 1
-        live_record_update = LiveRecordUpdate.where(
-          recordable_type: record.class.name,
-          recordable_id: record.id
-        ).where(
-          'created_at >= ?', DateTime.parse(data['stale_since']) - LiveRecord.configuration.sync_record_buffer_time
-        ).order(id: :asc)
-        
-        if live_record_update.exists?
+        live_record_updates = nil
+
+        if params[:stale_since].present?
+          live_record_updates = LiveRecordUpdate.where(
+            recordable_type: record.class.name,
+            recordable_id: record.id
+          ).where(
+            'created_at >= ?', DateTime.parse(params[:stale_since]) - LiveRecord.configuration.sync_record_buffer_time
+          )
+        end
+
+        # if stale_since is unknown, or there is a live_record_update that has happened while disconnected,
+        # then we update the record in the client-side
+        if params[:stale_since].blank? || live_record_updates.exists?
           message = { 'action' => 'update', 'attributes' => record.attributes }
           response = filtered_message(message, authorised_attributes)
           transmit response if response.present?
@@ -56,4 +64,4 @@ class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
       end
     end
   end
-end
+end

data/app/channels/live_record/publications_channel.rb

@@ -18,7 +18,7 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
       newly_created_record = model_class.find(message['attributes']['id'])
 
       @authorised_attributes ||= authorised_attributes(newly_created_record, current_user)
-      
+
       active_record_relation = SearchAdapters.mapped_active_record_relation(
         model_class: model_class,
         conditions_hash: params[:where].to_h,
@@ -42,10 +42,13 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
     model_class = params[:model_name].safe_constantize
 
     if model_class && model_class < ApplicationRecord
+      records = model_class.all
 
-      records = model_class.where(
-        'created_at >= ?', DateTime.parse(params[:stale_since]) - LiveRecord.configuration.sync_record_buffer_time
-      )
+      if params[:stale_since].present?
+        records = records.where(
+          'created_at >= ?', DateTime.parse(params[:stale_since]) - LiveRecord.configuration.sync_record_buffer_time
+        )
+      end
 
       # we `transmmit` a message back to client for each matching record
       records.find_each do |record|
@@ -131,4 +134,4 @@ class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
       end
     end
   end
-end
+end

data/lib/live_record/version.rb

@@ -1,3 +1,3 @@
 module LiveRecord
-  VERSION = '0.2.3'.freeze
+  VERSION = '0.2.4'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: live_record
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Jules Roman B. Polidario