live_record 0.1.2 → 0.2.0

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task default: :spec

data/app/assets/javascripts/live_record.coffee

@@ -0,0 +1,4 @@
+#= require_self
+#= require_directory ./live_record/
+
+this.LiveRecord ||= {}

data/app/assets/javascripts/live_record/helpers.coffee

@@ -0,0 +1,4 @@
+#= require_self
+#= require_directory ./helpers/
+
+LiveRecord.helpers ||= {}

data/app/assets/javascripts/live_record/helpers/load_records.coffee

@@ -8,23 +8,29 @@ LiveRecord.helpers.loadRecords = (args) ->
     args['url']
   ).done(
     (data) -> 
+      record_or_records = undefined
+
       # Array JSON
       if $.isArray(data)
-        records_attributes = data;
+        records_attributes = data
         records = []
 
         for record_attributes in records_attributes
-          record = new LiveRecord.Model.all[args['modelName']](record_attributes);
-          record.create();
-          records << record
+          record = new LiveRecord.Model.all[args['modelName']](record_attributes)
+          record.create()
+          records.push(record)
+
+        record_or_records = records
 
       # Single-Record JSON
       else
         record_attributes = data
-        record = new LiveRecord.Model.all[args['modelName']](record_attributes);
-        record.create();
+        record = new LiveRecord.Model.all[args['modelName']](record_attributes)
+        record.create()
+
+        record_or_records = record
 
-      args['onLoad'].call(this, records) if args['onLoad']
+      args['onLoad'].call(this, record_or_records) if args['onLoad']
   ).fail(
     (jqxhr, textStatus, error) ->
       args['onError'].call(this, jqxhr, textStatus, error) if args['onError']

data/app/assets/javascripts/live_record/helpers/spaceship.coffee

@@ -0,0 +1,13 @@
+# ref: https://stackoverflow.com/questions/34852855/combined-comparison-spaceship-operator-in-javascript
+
+LiveRecord.helpers.spaceship = (val1, val2) ->
+  if val1 == null or val2 == null or typeof val1 != typeof val2
+    return null
+  if typeof val1 == 'string'
+    val1.localeCompare val2
+  else
+    if val1 > val2
+      return 1
+    else if val1 < val2
+      return -1
+    0

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

@@ -0,0 +1,4 @@
+#= require_self
+#= require_directory ./model/
+
+LiveRecord.Model ||= {}

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

@@ -6,18 +6,6 @@ LiveRecord.Model.create = (config) ->
   # NEW
   Model = (attributes) ->
     this.attributes = attributes
-    # instance callbacks
-    this._callbacks = {
-      'on:connect': [],
-      'on:disconnect': [],
-      'on:response_error': [],
-      'before:create': [],
-      'after:create': [],
-      'before:update': [],
-      'after:update': [],
-      'before:destroy': [],
-      'after:destroy': []
-    }
 
     Object.keys(this.attributes).forEach (attribute_key) ->
       if Model.prototype[attribute_key] == undefined
@@ -27,18 +15,81 @@ LiveRecord.Model.create = (config) ->
 
   Model.modelName = config.modelName
 
-  Model.prototype.modelName = ->
-    Model.modelName
+  Model.store = {}
+  
+  Model.all = {}
+
+  Model.subscriptions = []
+
+  Model.subscribe = (config) ->
+    config || (config = {})
+    config.callbacks || (config.callbacks = {})
+
+    subscription = App.cable.subscriptions.create(
+      {
+        channel: 'LiveRecord::PublicationsChannel'
+        model_name: Model.modelName
+        where: config.where
+      },
+
+      connected: ->
+        if this.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
+        config.callbacks['on:disconnect'].call(this) if config.callbacks['on:disconnect']
+
+      received: (data) ->
+        @onAction[data.action].call(this, data)
+
+      onAction:
+        create: (data) ->
+          config.callbacks['before:create'].call(this, data) if config.callbacks['before:create']
+          record = new Model(data.attributes)
+          record.create()
+          config.callbacks['after:create'].call(this, data) if config.callbacks['after:create']
+
+      syncRecords: ->
+        @perform(
+          'sync_records',
+          model_name: Model.modelName,
+          where: config.where,
+          stale_since: this.liveRecord._staleSince
+        )
+        this.liveRecord._staleSince = undefined
+    )
+
+    subscription.liveRecord = {}
+    subscription.liveRecord.modelName = config.modelName
+    subscription.liveRecord.where = config.where
+    subscription.liveRecord.callbacks = config.callbacks
+
+    this.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
+
+    App.cable.subscriptions.remove(subscription)
+
+    this.subscriptions.splice(index, 1)
+    subscription
 
   Model.prototype.subscribe = ->
     return this.subscription if this.subscription != undefined
 
     # listen for record changes (update / destroy)
-    subscription = App['live_record_' + this.modelName() + '_' + this.id()] = App.cable.subscriptions.create({
-      channel: 'LiveRecordChannel'
-      model_name: this.modelName()
-      record_id: this.id()
-    },
+    subscription = App['live_record_' + this.modelName() + '_' + this.id()] = App.cable.subscriptions.create(
+      {
+        channel: 'LiveRecord::ChangesChannel'
+        model_name: this.modelName()
+        record_id: this.id()
+      },
+
       record: ->
         return @_record if @_record
         identifier = JSON.parse(this.identifier)
@@ -94,6 +145,12 @@ LiveRecord.Model.create = (config) ->
 
     this.subscription = subscription
 
+  Model.prototype.model = ->
+    Model
+
+  Model.prototype.modelName = ->
+    Model.modelName
+
   Model.prototype.unsubscribe = ->
     return if this.subscription == undefined
     App.cable.subscriptions.remove(this.subscription)
@@ -102,14 +159,14 @@ LiveRecord.Model.create = (config) ->
   Model.prototype.isSubscribed = ->
     this.subscription != undefined
 
-  # ALL
-  Model.all = {}
-
   # CREATE
-  Model.prototype.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)
 
     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()
 
     this._callCallbacks('after:create', undefined)
@@ -138,7 +195,6 @@ LiveRecord.Model.create = (config) ->
 
   # CALLBACKS
 
-  ## class callbacks
   Model._callbacks = {
     'on:connect': [],
     'on:disconnect': [],
@@ -150,14 +206,28 @@ LiveRecord.Model.create = (config) ->
     'before:destroy': [],
     'after:destroy': []
   }
+  
+  Model.prototype._callbacks = {
+    'on:connect': [],
+    'on:disconnect': [],
+    'on:response_error': [],
+    'before:create': [],
+    'after:create': [],
+    'before:update': [],
+    'after:update': [],
+    'before:destroy': [],
+    'after:destroy': []
+  }
 
-  Model.addCallback = Model.prototype.addCallback = (callbackKey, callbackFunction) ->
+  # adding new callbackd to the list
+  Model.prototype.addCallback = Model.addCallback = (callbackKey, callbackFunction) ->
     index = this._callbacks[callbackKey].indexOf(callbackFunction)
     if index == -1
       this._callbacks[callbackKey].push(callbackFunction)
       return callbackFunction
 
-  Model.removeCallback = Model.prototype.removeCallback = (callbackKey, callbackFunction) ->
+  # removing a callback from the list
+  Model.prototype.removeCallback = Model.removeCallback = (callbackKey, callbackFunction) ->
     index = this._callbacks[callbackKey].indexOf(callbackFunction)
     if index != -1
       this._callbacks[callbackKey].splice(index, 1)
@@ -179,7 +249,6 @@ LiveRecord.Model.create = (config) ->
     for callbackFunction in callbackFunctions
       Model.addCallback(callbackKey, callbackFunction)
 
-
   # enable plugins from arguments
   for pluginKey, pluginValue of config.plugins
     if LiveRecord.plugins

data/app/assets/javascripts/live_record/plugins.coffee

@@ -0,0 +1,3 @@
+#= require_self
+
+LiveRecord.plugins ||= {}

data/app/assets/javascripts/live_record/plugins/live_dom.coffee

@@ -1,21 +1,7 @@
-this.LiveRecord.plugins.LiveDOM || (this.LiveRecord.plugins.LiveDOM = {});
+#= require_self
+#= require_directory ./live_dom/
 
-if window.jQuery == undefined
-  throw new Error('jQuery is not loaded yet, and is a dependency of LiveRecord')
-
-LiveRecord.plugins.LiveDOM.applyToModel = (Model, pluginValue) ->
-  return if pluginValue != true
-
-  # DOM callbacks
-
-  Model._updateDomCallback = ->
-    $updateableElements = $('[data-live-record-update-from]')
+LiveRecord.plugins.LiveDOM ||= {}
 
-    for key, value of this.attributes
-      $updateableElements.filter('[data-live-record-update-from="' + Model.modelName + '-' + this.id() + '-' + key + '"]').text(this[key]())
-
-  Model._destroyDomCallback = ->
-    $('[data-live-record-destroy-from="' + Model.modelName + '-' + this.id() + '"]').remove()
-
-  Model.addCallback('after:update', Model._updateDomCallback)
-  Model.addCallback('after:destroy', Model._destroyDomCallback)
+if window.jQuery == undefined 
+  throw new Error('jQuery is not loaded yet, and is a dependency of LiveRecord')

data/app/assets/javascripts/live_record/plugins/live_dom/apply_to_model.coffee

@@ -0,0 +1,17 @@
+LiveRecord.plugins.LiveDOM.applyToModel = (Model, pluginValue) ->
+  return if pluginValue != true
+
+  # DOM callbacks
+  Model._updateDomCallback = (domContext)->
+    domContext ||= $('body')
+
+    $updatableElements = domContext.find('[data-live-record-update-from]')
+
+    for key, value of this.attributes
+      $updatableElements.filter('[data-live-record-update-from="' + Model.modelName + '-' + this.id() + '-' + key + '"]').text(this[key]())
+
+  Model._destroyDomCallback = ->
+    $('[data-live-record-destroy-from="' + Model.modelName + '-' + this.id() + '"]').remove()
+  
+  Model.addCallback('after:update', Model._updateDomCallback)
+  Model.addCallback('after:destroy', Model._destroyDomCallback)

data/app/channels/live_record/base_channel.rb

@@ -0,0 +1,41 @@
+class LiveRecord::BaseChannel < ActionCable::Channel::Base
+
+  protected
+
+  def authorised_attributes(record, current_user)
+    whitelisted_attributes = record.class.live_record_whitelisted_attributes(record, current_user)
+    raise "#{record.model}.live_record_whitelisted_attributes should return an array" unless whitelisted_attributes.is_a? Array 
+    ([:id] + whitelisted_attributes).map(&:to_s).to_set
+  end
+
+  def filtered_message(message, filters)
+    message['attributes'].slice!(*filters) if message['attributes'].present?
+    message
+  end
+
+  def find_record_from_params(params)
+    model_class = params[:model_name].safe_constantize
+
+    if model_class && model_class < ApplicationRecord
+      record = model_class.find_by(id: params[:record_id])
+
+      if record.present?
+        yield record
+      else
+        transmit 'action' => 'destroy'
+      end
+    else
+      respond_with_error(:bad_request, 'Not a correct model name')
+      reject_subscription
+    end
+  end
+
+  def respond_with_error(type, message = nil)
+    case type
+    when :forbidden
+      transmit error: { 'code' => 'forbidden', 'message' => (message || 'You are not authorised') }
+    when :bad_request
+      transmit error: { 'code' => 'bad_request', 'message' => (message || 'Invalid request parameters') }
+    end
+  end
+end

data/app/channels/live_record/changes_channel.rb

@@ -0,0 +1,59 @@
+# This channel streams changes (update/destroy) from records to connected clients, through ActiveRecord callbacks
+# This also supports syncing (old changes) when a client somehow got disconnected (i.e. network problems),
+# through a separate cache `live_record_updates` table.
+class LiveRecord::ChangesChannel < LiveRecord::BaseChannel
+
+  def subscribed
+    find_record_from_params(params) do |record|
+      authorised_attributes = authorised_attributes(record, current_user)
+
+      if authorised_attributes.present?
+        stream_for record, coder: ActiveSupport::JSON do |message|
+          begin
+            record.reload
+          rescue ActiveRecord::RecordNotFound
+          end
+          
+          authorised_attributes = authorised_attributes(record, current_user)
+
+          # if not just :id
+          if authorised_attributes.size > 1
+            response = filtered_message(message, authorised_attributes)
+            transmit response if response.present?
+          else
+            respond_with_error(:forbidden)
+            reject_subscription
+          end
+        end
+      else
+        respond_with_error(:forbidden)
+        reject
+      end
+    end
+  end
+
+  def sync_record(data)
+    find_record_from_params(data.symbolize_keys) 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?
+          message = { 'action' => 'update', 'attributes' => record.attributes }
+          response = filtered_message(message, authorised_attributes)
+          transmit response if response.present?
+        end
+      else
+        respond_with_error(:forbidden)
+        reject_subscription
+      end
+    end
+  end
+end

data/app/channels/live_record/publications_channel.rb

@@ -0,0 +1,134 @@
+# This channel streams new records to connected clients whenever the "where" condition supplied by the client matches
+# This implementation can be quite inefficient because there's only one pub-sub queue used for each model, but because of
+# constraints ( see https://github.com/jrpolidario/live_record/issues/2 ) and because Users are authorised-validated anyway
+# in each stream, then there's already an overhead delay. I am prioritising development convenience (as Rails does), in order
+# to achieve a simpler API; in this example, it would be something like in JS:
+# `LiveRecord.Model.all.Book.subscribe({where: is_enabled: true})`
+class LiveRecord::PublicationsChannel < LiveRecord::BaseChannel
+
+  def subscribed
+    model_class = params[:model_name].safe_constantize
+
+    if !(model_class && model_class < ApplicationRecord)
+      respond_with_error(:bad_request, 'Not a correct model name')
+      reject_subscription
+    end
+
+    stream_from "live_record:publications:#{params[:model_name].underscore}", coder: ActiveSupport::JSON do |message|
+      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,
+        current_user: current_user,
+        authorised_attributes: @authorised_attributes
+      )
+
+      if active_record_relation.exists?(id: newly_created_record.id)
+        # if not just :id
+        if @authorised_attributes.size > 1
+          message = { 'action' => 'create', 'attributes' => message['attributes'] }
+          response = filtered_message(message, @authorised_attributes)
+          transmit response if response.present?
+        end
+      end
+    end
+  end
+
+  def sync_records(data)
+    params = data.symbolize_keys
+    model_class = params[:model_name].safe_constantize
+
+    if model_class && model_class < ApplicationRecord
+
+      records = model_class.where(
+        'created_at >= ?', DateTime.parse(params[:stale_since]) - LiveRecord.configuration.sync_record_buffer_time
+      )
+
+      # we `transmmit` a message back to client for each matching record
+      records.find_each do |record|
+        # now we check each record if it is part of the "where" condition
+        current_authorised_attributes = authorised_attributes(record, current_user)
+
+        active_record_relation = SearchAdapters.mapped_active_record_relation(
+          model_class: model_class,
+          conditions_hash: params[:where].to_h,
+          current_user: current_user,
+          authorised_attributes: current_authorised_attributes
+        )
+
+        if active_record_relation.exists?(id: record)
+          message = { 'action' => 'create', 'attributes' => record.attributes }
+          response = filtered_message(message, current_authorised_attributes)
+          transmit response if response.present?
+        end
+      end
+    else
+      respond_with_error(:bad_request, 'Not a correct model name')
+      reject_subscription
+    end
+  end
+
+  module SearchAdapters
+    def self.mapped_active_record_relation(**args)
+      # if ransack is loaded, use ransack
+      if Gem.loaded_specs.has_key? 'ransack'
+        active_record_relation = RansackAdapter.mapped_active_record_relation(args)
+      else
+        active_record_relation = ActiveRecordDefaultAdapter.mapped_active_record_relation(args)
+      end
+      active_record_relation
+    end
+
+    module RansackAdapter
+      def self.mapped_active_record_relation(**args)
+        model_class = args.fetch(:model_class)
+        conditions_hash = args.fetch(:conditions_hash)
+        current_user = args.fetch(:current_user)
+
+        model_class.ransack(conditions_hash, auth_object: current_user).result
+      end
+    end
+
+    module ActiveRecordDefaultAdapter
+      def self.mapped_active_record_relation(**args)
+        model_class = args.fetch(:model_class)
+        conditions_hash = args.fetch(:conditions_hash)
+        authorised_attributes = args.fetch(:authorised_attributes)
+
+        current_active_record_relation = model_class.all
+
+        conditions_hash.each do |key, value|
+          operator = key.split('_').last
+          # to get attribute_name, we subtract the end part of the string with size of operator substring; i.e.: created_at_lteq -> created_at
+          attribute_name = key[0..(-1 - operator.size - 1)]
+
+          if authorised_attributes == :all || authorised_attributes.include?(attribute_name)
+            case operator
+            when 'eq'
+              current_active_record_relation = current_active_record_relation.where(attribute_name => value)
+            when 'not_eq'
+              current_active_record_relation = current_active_record_relation.where.not(attribute_name => value)
+            when 'gt'
+              current_active_record_relation = current_active_record_relation.where(model_class.arel_table[attribute_name].gt(value))
+            when 'gteq'
+              current_active_record_relation = current_active_record_relation.where(model_class.arel_table[attribute_name].gteq(value))
+            when 'lt'
+              current_active_record_relation = current_active_record_relation.where(model_class.arel_table[attribute_name].lt(value))
+            when 'lteq'
+              current_active_record_relation = current_active_record_relation.where(model_class.arel_table[attribute_name].lteq(value))
+            when 'in'
+              current_active_record_relation = current_active_record_relation.where(attribute_name => Array.wrap(value))
+            when 'not_in'
+              current_active_record_relation = current_active_record_relation.where.not(attribute_name => Array.wrap(value))
+            end
+          end
+        end
+
+        current_active_record_relation
+      end
+    end
+  end
+end