jason-rails 0.5.1 → 0.6.0

data/lib/jason/subscription.rb

@@ -1,17 +1,32 @@
 class Jason::Subscription
   attr_accessor :id, :config
+  attr_reader :includes_helper, :graph_helper
 
   def initialize(id: nil, config: nil)
     if id
       @id = id
       raw_config = $redis_jason.hgetall("jason:subscriptions:#{id}").map { |k,v| [k, JSON.parse(v)] }.to_h
+      raise "Subscription ID #{id} does not exist" if raw_config.blank?
       set_config(raw_config)
     else
       @id = Digest::MD5.hexdigest(config.sort_by { |key| key }.to_h.to_json)
-      pp config.sort_by { |key| key }.to_h.to_json
       configure(config)
     end
-    pp @id
+    @includes_helper = Jason::IncludesHelper.new({ model => self.config['includes'] })
+    @graph_helper = Jason::GraphHelper.new(self.id, @includes_helper)
+
+    check_for_missing_keys
+  end
+
+  def broadcaster
+    @broadcaster ||= Jason::Broadcaster.new(channel)
+  end
+
+  def check_for_missing_keys
+    missing_keys = includes_helper.all_models - Jason.schema.keys.map(&:to_s)
+    if missing_keys.present?
+      raise "#{missing_keys.inspect} are not in the schema. Only models in the Jason schema can be subscribed."
+    end
   end
 
   def self.upsert_by_config(model, conditions: {}, includes: {})
@@ -26,6 +41,13 @@ class Jason::Subscription
     self.new(id: id)
   end
 
+  def self.for_instance_with_child(model_name, id, child_model_name, include_all = true)
+    sub_ids = for_instance(model_name, id, include_all = true)
+    sub_ids.select do |sub_id|
+      find_by_id(sub_id).includes_helper.in_sub(model_name, child_model_name)
+    end
+  end
+
   def self.for_instance(model_name, id, include_all = true)
     subs = $redis_jason.smembers("jason:models:#{model_name}:#{id}:subscriptions")
     if include_all
@@ -41,37 +63,117 @@ class Jason::Subscription
 
   # Find and update subscriptions affected by a model changing foreign key
   # comment, comment_id, post, old_post_id, new_post_id
-  def self.update_ids(model_name, id, parent_model_name, old_foreign_id, new_foreign_id)
-    # Check if this change means it needs to be removed
-    # First find subscriptions that reference this model
-
-    if old_foreign_id
-      old_model_subscriptions = for_instance(parent_model_name, old_foreign_id, false)
-      new_model_subscriptions = for_instance(parent_model_name, new_foreign_id, false)
-    else
-      # If this is a new instance, we need to include _all_ subscriptions
-      old_model_subscriptions = []
-      new_model_subscriptions = for_instance(parent_model_name, new_foreign_id, true)
+  def self.update_ids(changed_model_name, changed_model_id, foreign_model_name, old_foreign_id, new_foreign_id)
+    # There are 4 cases to consider.
+    # changed_instance ---/--- foreign_instance
+    #                  \--+--- new_foreign_instance
+    #
+    # foreign instance can either be parent or child for a given subscription
+    # 1. Child swap/add: foreign is child
+    # 2. Stay in the family: foreign is parent + both old and new foreign instances are part of the sub
+    # 3. Join the family: foreign is parent + only new foreign instance are part of the sub
+    # 4. Leave the family: foreign is parent + only the old foreign instance is part of the sub
+
+    #########
+    # Subs where changed is parent
+    sub_ids = for_instance_with_child(changed_model_name, changed_model_id, foreign_model_name, true)
+    sub_ids.each do |sub_id|
+      subscription = find_by_id(sub_id)
+
+      # If foreign key has been nulled, nothing to add
+      add = new_foreign_id.present? ? [
+        {
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, new_foreign_id]]
+        },
+        # Add IDs of child models
+        subscription.load_ids_for_sub_models(foreign_model_name, new_foreign_id)
+      ] : nil
+
+      id_changeset = subscription.graph_helper.apply_update({
+        remove: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, old_foreign_id]]
+        }],
+        add: add
+      })
+
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
     end
 
-    # To add
-    (new_model_subscriptions - old_model_subscriptions).each do |sub_id|
-      # add the current ID to the subscription, then add the tree below it
-      find_by_id(sub_id).set_id(model_name, id)
+    old_sub_ids = for_instance_with_child(foreign_model_name, old_foreign_id, changed_model_name, true)
+    new_sub_ids = for_instance_with_child(foreign_model_name, new_foreign_id, changed_model_name, true)
+
+    #########
+    # Subs where changed is child
+    # + parent in both old + new
+    # this is simple, only the edges need to change - no IDs can be changed
+    (old_sub_ids & new_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      subscription.graph_helper.apply_update({
+        remove: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, old_foreign_id]]
+        }],
+        add: [{
+          model_names: [changed_model_name, foreign_model_name],
+          instance_ids: [[changed_model_id, new_foreign_id]]
+        }]
+      })
     end
 
-    # To remove
-    (old_model_subscriptions - new_model_subscriptions).each do |sub_id|
-      find_by_id(sub_id).remove_ids(model_name, [id])
+    #########
+    # Subs where changed is child
+    # + old parent wasn't in the sub, but new parent is
+    # IE the changed instance is joining the sub
+    # No edges are removed, just added
+    (new_sub_ids - old_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      id_changeset = subscription.graph_helper.apply_update({
+        add: [
+          {
+            model_names: [changed_model_name, foreign_model_name],
+            instance_ids: [[changed_model_id, new_foreign_id]]
+          },
+          # Add IDs of child models
+          subscription.load_ids_for_sub_models(changed_model_name, changed_model_id)
+        ]
+      })
+
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
     end
 
-    # TODO changes to sub models - e.g. post -> comment -> user
+    #########
+    # --> Leaving the family
+    # Subs where changed is child
+    # + old parent was in the sub, but new parent isn't
+    # Just need to remove the link, orphan detection will do the rest
+    (old_sub_ids - new_sub_ids).each do |sub_id|
+      subscription = find_by_id(sub_id)
+      id_changeset = subscription.graph_helper.apply_update({
+        remove: [
+          {
+            model_names: [changed_model_name, foreign_model_name],
+            instance_ids: [[changed_model_id, old_foreign_id]]
+          }
+        ]
+      })
+      subscription.apply_id_changeset(id_changeset)
+      subscription.broadcast_id_changeset(id_changeset)
+    end
   end
 
   def self.remove_ids(model_name, ids)
+    # td: finish this
     ids.each do |instance_id|
       for_instance(model_name, instance_id, false).each do |sub_id|
-        find_by_id(sub_id).remove_ids(model_name, [instance_id])
+        subscription = find_by_id(sub_id)
+
+        id_changeset = subscription.graph_helper.apply_remove_node("#{model_name}:#{instance_id}")
+        subscription.apply_id_changeset(id_changeset)
+        subscription.broadcast_id_changeset(id_changeset)
       end
     end
   end
@@ -82,93 +184,25 @@ class Jason::Subscription
   end
 
   def self.all
-    $redis_jason.keys('jason:subscriptions:*')
+    $redis_jason.smembers('jason:subscriptions').map { |id| Jason::Subscription.find_by_id(id) }
   end
 
   def set_config(raw_config)
-    @config =  raw_config.with_indifferent_access
-  end
-
-  # E.g. add comment#123, and then sub models
-  def set_id(model_name, id)
-    commit_ids(model_name, [id])
-    assoc_name = get_assoc_name(model_name)
-    set_ids_for_sub_models(assoc_name, [id])
+    @config =  raw_config.deep_stringify_keys.deep_transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
   end
 
   def clear_id(model_name, id, parent_model_name)
     remove_ids(model_name, [id])
   end
 
-  # Set the instance IDs for the subscription
-  # Add an entry to the subscription list for each instance
-  def set_ids(assoc_name = model, referrer_model_name = nil, referrer_ids = nil, enforce: false)
-    model_name = assoc_name.to_s.singularize
-
-    if referrer_model_name.blank? && conditions.blank?
-      $redis_jason.sadd("jason:models:#{model_name}:all:subscriptions", id)
-      ids = model_klass(model_name).all.pluck(:id)
-      set_ids_for_sub_models(assoc_name, ids, enforce: enforce)
-      return
-    end
-
-    if referrer_model_name.blank?
-      ids = model_klass(model_name).where(conditions).pluck(:id)
-    else
-      assoc = model_klass(referrer_model_name).reflect_on_association(assoc_name.to_sym)
-
-      if assoc.is_a?(ActiveRecord::Reflection::HasManyReflection)
-        ids = model_klass(model_name).where(assoc.foreign_key => referrer_ids).pluck(:id)
-      elsif assoc.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-        ids = model_klass(referrer_model_name).where(id: referrer_ids).pluck(assoc.foreign_key)
-      end
-    end
-    return if ids.blank?
-
-    enforce ? enforce_ids(model_name, ids) : commit_ids(model_name, ids)
-    set_ids_for_sub_models(assoc_name, ids, enforce: enforce)
-  end
-
-  def refresh_ids(assoc_name = model, referrer_model_name = nil, referrer_ids)
-
-  end
-
   # Add IDs that aren't present
   def commit_ids(model_name, ids)
-    pp 'COMMIT'
-    pp model_name
-    pp ids
     $redis_jason.sadd("jason:subscriptions:#{id}:ids:#{model_name}", ids)
     ids.each do |instance_id|
       $redis_jason.sadd("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
     end
   end
 
-  # Ensure IDs are _only_ the ones passed
-  def enforce_ids(model_name, ids)
-    old_ids = $redis_jason.smembers("jason:subscriptions:#{id}:ids:#{model_name}")
-
-    # Remove
-    ids_to_remove = old_ids - ids
-    if ids_to_remove.present?
-      $redis_jason.srem("jason:subscriptions:#{id}:ids:#{model_name}", ids_to_remove)
-    end
-
-    ids_to_remove.each do |instance_id|
-      $redis_jason.srem("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
-    end
-
-    # Add
-    ids_to_add = ids - old_ids
-    if ids_to_add.present?
-      $redis_jason.sadd("jason:subscriptions:#{id}:ids:#{model_name}", ids_to_add)
-    end
-
-    ids_to_add.each do |instance_id|
-      $redis_jason.sadd("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
-    end
-  end
-
   def remove_ids(model_name, ids)
     $redis_jason.srem("jason:subscriptions:#{id}:ids:#{model_name}", ids)
     ids.each do |instance_id|
@@ -176,108 +210,81 @@ class Jason::Subscription
     end
   end
 
-  # 'posts', [post#1, post#2,...]
-  def set_ids_for_sub_models(assoc_name, ids, enforce: false)
-    model_name = assoc_name.to_s.singularize
-    # Limitation: Same association can't appear twice
-    includes_tree = get_tree_for(assoc_name)
+  def apply_id_changeset(changeset)
+    changeset[:ids_to_add].each do |model_name, ids|
+      commit_ids(model_name, ids)
+    end
 
-    if includes_tree.is_a?(Hash)
-      includes_tree.each do |assoc_name, includes_tree|
-        set_ids(assoc_name, model_name, ids, enforce: enforce)
-      end
-    # [:likes, :user]
-    elsif includes_tree.is_a?(Array)
-      includes_tree.each do |assoc_name|
-        set_ids(assoc_name, model_name, ids, enforce: enforce)
-      end
-    elsif includes_tree.is_a?(String)
-      set_ids(includes_tree, model_name, ids, enforce: enforce)
+    changeset[:ids_to_remove].each do |model_name, ids|
+      remove_ids(model_name, ids)
     end
   end
 
-  # assoc could be plural or not, so need to scan both.
-  def get_assoc_name(model_name, haystack = includes)
-    return model_name if model_name == model
-
-    if haystack.is_a?(Hash)
-      haystack.each do |assoc_name, includes_tree|
-        if model_name.pluralize == assoc_name.to_s.pluralize
-          return assoc_name
-        else
-          found_assoc = get_assoc_name(model_name, includes_tree)
-          return found_assoc if found_assoc
-        end
-      end
-    elsif haystack.is_a?(Array)
-      haystack.each do |assoc_name|
-        if model_name.pluralize == assoc_name.to_s.pluralize
-          return assoc_name
-        end
-      end
-    else
-      if model_name.pluralize == haystack.to_s.pluralize
-        return haystack
-      end
+  def broadcast_id_changeset(changeset)
+    changeset[:ids_to_add].each do |model_name, ids|
+      ids.each { |id| add(model_name, id) }
     end
 
-    return nil
+    changeset[:ids_to_remove].each do |model_name, ids|
+      ids.each { |id| destroy(model_name, id) }
+    end
   end
 
-  def get_tree_for(needle, assoc_name = nil, haystack = includes)
-    return includes if needle == model
-    return haystack if needle.to_s == assoc_name.to_s
+  # Take a model name and IDs and return an edge set of all the models that appear and
+  # their instance IDs
+  def load_ids_for_sub_models(model_name, ids)
+    # Limitation: Same association can't appear twice
+    includes_tree = includes_helper.get_tree_for(model_name)
+    all_models = includes_helper.all_models(model_name)
+
+    relation = model_name.classify.constantize.all.eager_load(includes_tree)
 
-    if haystack.is_a?(Hash)
-      haystack.each do |assoc_name, includes_tree|
-        found_haystack = get_tree_for(needle, assoc_name, includes_tree)
-        return found_haystack if found_haystack
+    if model_name == model
+      if conditions.blank?
+        $redis_jason.sadd("jason:models:#{model_name}:all:subscriptions", id)
+        all_models -= [model_name]
+      else
+        relation = relation.where(conditions)
       end
+    else
+      raise "Must supply IDs for sub models" if ids.nil?
+      return if ids.blank?
+      relation = relation.where(id: ids)
     end
 
-    return nil
-  end
+    pluck_args = all_models.map { |m| "#{m.pluralize}.id" }
+    instance_ids = relation.pluck(*pluck_args)
 
-  def all_models(tree = includes)
-    sub_models = if tree.is_a?(Hash)
-      tree.map do |k,v|
-        [k, all_models(v)]
-      end
-    else
-      tree
+    # pluck returns only a 1D array if only 1 arg passed
+    if all_models.size == 1
+      instance_ids = [instance_ids]
     end
 
-    pp ([model] + [sub_models]).flatten.uniq.map(&:to_s).map(&:singularize)
-    ([model] + [sub_models]).flatten.uniq.map(&:to_s).map(&:singularize)
+    return { model_names: all_models, instance_ids: instance_ids }
   end
 
-  def clear_all_ids(assoc_name = model)
-    model_name = assoc_name.to_s.singularize
-    includes_tree = model_name == model ? includes : get_tree_for(assoc_name)
-
-    if model_name == model && conditions.blank?
-      $redis_jason.srem("jason:models:#{model_name}:all:subscriptions", id)
-    end
+  # 'posts', [post#1, post#2,...]
+  def set_ids_for_sub_models(model_name = model, ids = nil, enforce: false)
+    edge_set = load_ids_for_sub_models(model_name, ids)
 
-    ids = $redis_jason.smembers("jason:subscriptions:#{id}:ids:#{model_name}")
-    ids.each do |instance_id|
-      $redis_jason.srem("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
-    end
-    $redis_jason.del("jason:subscriptions:#{id}:ids:#{model_name}")
+    # Build the tree
+    id_changeset = graph_helper.apply_update({
+      add: [edge_set]
+    })
+    apply_id_changeset(id_changeset)
+  end
 
-    # Recursively clear IDs
-    # { comments: [:like] }
-    if includes_tree.is_a?(Hash)
-      includes_tree.each do |assoc_name, includes_tree|
-        clear_all_ids(assoc_name)
+  def clear_all_ids
+    includes_helper.all_models.each do |model_name|
+      if model_name == model && conditions.blank?
+        $redis_jason.srem("jason:models:#{model_name}:all:subscriptions", id)
       end
-    # [:likes, :user]
-    elsif includes_tree.is_a?(Array)
-      includes_tree.each do |assoc_name|
-        clear_all_ids(assoc_name)
+
+      ids = $redis_jason.smembers("jason:subscriptions:#{id}:ids:#{model_name}")
+      ids.each do |instance_id|
+        $redis_jason.srem("jason:models:#{model_name}:#{instance_id}:subscriptions", id)
       end
-    elsif includes_tree.is_a?(String)
-      clear_all_ids(includes_tree)
+      $redis_jason.del("jason:subscriptions:#{id}:ids:#{model_name}")
     end
   end
 
@@ -297,12 +304,9 @@ class Jason::Subscription
     @config['conditions']
   end
 
-  def includes
-    @config['includes']
-  end
-
   def configure(raw_config)
     set_config(raw_config)
+    $redis_jason.sadd("jason:subscriptions", id)
     $redis_jason.hmset("jason:subscriptions:#{id}", *config.map { |k,v| [k, v.to_json] }.flatten)
   end
 
@@ -316,7 +320,7 @@ class Jason::Subscription
     $redis_jason.hset("jason:consumers", consumer_id, Time.now.utc)
 
     if before_consumer_count == 0
-      set_ids
+      set_ids_for_sub_models
     end
   end
 
@@ -334,11 +338,17 @@ class Jason::Subscription
   end
 
   def channel
-    "jason:#{id}"
+    "jason-#{id}"
+  end
+
+  def user_can_access?(user)
+    # td: implement the authorization logic here
+    return true if Jason.authorization_service.blank?
+    Jason.authorization_service.call(user, model, conditions, includes_helper.all_models - [model])
   end
 
   def get
-    all_models.map { |model_name| get_for_model(model_name) }
+    includes_helper.all_models.map { |model_name| [model_name, get_for_model(model_name)] }.to_h
   end
 
   def get_for_model(model_name)
@@ -367,6 +377,21 @@ class Jason::Subscription
     }
   end
 
+  def add(model_name, instance_id)
+    idx = $redis_jason.incr("jason:subscription:#{id}:#{model_name}:idx")
+    payload = JSON.parse($redis_jason.hget("jason:cache:#{model_name}", instance_id) || '{}')
+
+    payload = {
+      id: instance_id,
+      model: model_name,
+      payload: payload,
+      md5Hash: id,
+      idx: idx.to_i
+    }
+
+    broadcaster.broadcast(payload)
+  end
+
   def update(model_name, instance_id, payload, gidx)
     idx = Jason::LuaGenerator.new.get_subscription(model_name, instance_id, id, gidx)
     return if idx.blank?
@@ -379,11 +404,11 @@ class Jason::Subscription
       idx: idx.to_i
     }
 
-    ActionCable.server.broadcast(channel, payload)
+    broadcaster.broadcast(payload)
   end
 
   def destroy(model_name, instance_id)
-    idx = $redis_jason.incr("jason:subscription:#{id}:#{model_name}idx")
+    idx = $redis_jason.incr("jason:subscription:#{id}:#{model_name}:idx")
 
     payload = {
       id: instance_id,
@@ -393,6 +418,6 @@ class Jason::Subscription
       idx: idx.to_i
     }
 
-    ActionCable.server.broadcast(channel, payload)
+    broadcaster.broadcast(payload)
   end
 end