jason-rails 0.4.0 → 0.6.1

data/config/routes.rb

@@ -1,4 +1,8 @@
 Jason::Engine.routes.draw do
-  get '/api/schema', to: 'api#schema'
+  get '/api/config', to: 'api#configuration'
   post '/api/action', to: 'api#action'
+  post '/api/create_subscription', to: 'api#create_subscription'
+  post '/api/remove_subscription', to: 'api#remove_subscription'
+  post '/api/get_payload', to: 'api#get_payload'
+  post '/api/pusher/auth', to: 'api/pusher#auth'
 end

data/jason-rails.gemspec

@@ -27,4 +27,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "connection_pool", ">= 2.2.3"
   spec.add_dependency "redis", ">= 4"
   spec.add_dependency "jsondiff"
+
+  spec.add_development_dependency "rspec-rails"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry"
 end

data/lib/jason.rb

@@ -7,10 +7,70 @@ require 'jason/api_model'
 require 'jason/channel'
 require 'jason/publisher'
 require 'jason/subscription'
+require 'jason/broadcaster'
 require 'jason/engine'
+require 'jason/lua_generator'
+require 'jason/includes_helper'
+require 'jason/graph_helper'
 
 module Jason
   class Error < StandardError; end
 
-  $redis_jason = ::ConnectionPool::Wrapper.new(size: 5, timeout: 3) { ::Redis.new(url: ENV['REDIS_URL']) }
+  self.mattr_accessor :schema
+  self.mattr_accessor :transport_service
+  self.mattr_accessor :redis
+  self.mattr_accessor :pusher
+  self.mattr_accessor :pusher_key
+  self.mattr_accessor :pusher_region
+  self.mattr_accessor :pusher_channel_prefix
+  self.mattr_accessor :authorization_service
+
+  self.schema = {}
+  self.transport_service = :action_cable
+  self.pusher_region = 'eu'
+  self.pusher_channel_prefix = 'jason'
+
+  def self.init
+    # Check if the schema has changed since last time app was started. If so, do some work to ensure cache contains the correct data
+    got_lock = $redis_jason.set('jason:schema:lock', nx: true, ex: 3600) # Basic lock mechanism for multi-process environments
+    return if !got_lock
+
+    previous_schema = JSON.parse($redis_jason.get('jason:last_schema') || '{}')
+    current_schema = Jason.schema.deep_stringify_keys.deep_transform_values { |v| v.is_a?(Symbol) ? v.to_s : v }
+    pp current_schema
+    current_schema.each do |model, config|
+      if config != previous_schema[model]
+        puts "Config changed for #{model}"
+        puts "Old config was #{previous_schema[model]}"
+        puts "New config is #{config}"
+        puts "Rebuilding cache for #{model}"
+        model.classify.constantize.cache_all
+        puts "Done"
+      end
+    end
+
+    $redis_jason.set('jason:last_schema', current_schema.to_json)
+  ensure
+    $redis_jason.del('jason:schema:lock')
+
+    previous_config = 'test'
+  end
+
+
+  # this function maps the vars from your app into your engine
+  def self.setup(&block)
+    yield self
+
+    $redis_jason = self.redis || ::ConnectionPool::Wrapper.new(size: 5, timeout: 3) { ::Redis.new(url: ENV['REDIS_URL']) }
+
+    if ![:action_cable, :pusher].include?(self.transport_service)
+      raise "Unknown transport service '#{self.transport_service}' specified"
+    end
+
+    if self.transport_service == :pusher && self.pusher.blank?
+      raise "Pusher specified as transport service but no Pusher client provided. Please configure with config.pusher = Pusher::Client.new(...)"
+    end
+
+    init
+  end
 end

data/lib/jason/api_model.rb

@@ -8,7 +8,7 @@ class Jason::ApiModel
 
   def initialize(name)
     @name = name
-    @model = OpenStruct.new(JASON_API_MODEL[name.to_sym])
+    @model = OpenStruct.new(Jason.schema[name.to_sym])
   end
 
   def allowed_params
@@ -19,10 +19,6 @@ class Jason::ApiModel
     model.allowed_object_params || []
   end
 
-  def include_models
-    model.include_models || []
-  end
-
   def include_methods
     model.include_methods || []
   end
@@ -52,12 +48,6 @@ class Jason::ApiModel
   end
 
   def as_json_config
-    include_configs = include_models.map do |assoc|
-      reflection = name.classify.constantize.reflect_on_association(assoc.to_sym)
-      api_model = Jason::ApiModel.new(reflection.klass.name.underscore)
-      { assoc => { only: api_model.subscribed_fields, methods: api_model.include_methods } }
-    end
-
-    { only: subscribed_fields, include: include_configs, methods: include_methods }
+    { only: subscribed_fields, methods: include_methods }
   end
 end

data/lib/jason/broadcaster.rb

@@ -0,0 +1,19 @@
+class Jason::Broadcaster
+  attr_reader :channel
+
+  def initialize(channel)
+    @channel = channel
+  end
+
+  def pusher_channel_name
+    "private-#{Jason.pusher_channel_prefix}-#{channel}"
+  end
+
+  def broadcast(message)
+    if Jason.transport_service == :action_cable
+      ActionCable.server.broadcast(channel, message)
+    elsif Jason.transport_service == :pusher
+      Jason.pusher.trigger(pusher_channel_name, 'changed', message)
+    end
+  end
+end

data/lib/jason/channel.rb

@@ -1,32 +1,27 @@
 class Jason::Channel < ActionCable::Channel::Base
   attr_accessor :subscriptions
 
+  def subscribe
+    stream_from 'jason'
+  end
+
   def receive(message)
-    subscriptions ||= []
+    handle_message(message)
+  end
+
+  private
+
+  def handle_message(message)
+    pp message['createSubscription']
+    @subscriptions ||= []
 
     begin # ActionCable swallows errors in this message - ensure they're output to logs.
       if (config = message['createSubscription'])
-        subscription = Jason::Subscription.new(config: config)
-        subscriptions.push(subscription)
-        subscription.add_consumer(identifier)
-        config.keys.each do |model|
-          transmit(subscription.get(model.to_s.underscore))
-        end
-        stream_from subscription.channel
+        create_subscription(config['model'], config['conditions'], config['includes'])
       elsif (config = message['removeSubscription'])
-        subscription = Jason::Subscription.new(config: config)
-        subscriptions.reject! { |s| s.id == subscription.id }
-        subscription.remove_consumer(identifier)
-
-        # Rails for some reason removed stop_stream_from, so we need to stop all and then restart the other streams
-        # stop_all_streams
-        # subscriptions.each do |s|
-        #   stream_from s.channel
-        # end
-      elsif (data = message['getPayload'])
-        config = data['config']
-        model = data['model']
-        Jason::Subscription.new(config: config).get(model.to_s.underscore)
+        remove_subscription(config)
+      elsif (config = message['getPayload'])
+        get_payload(config, message['forceRefresh'])
       end
     rescue => e
       puts e.message
@@ -34,4 +29,38 @@ class Jason::Channel < ActionCable::Channel::Base
       raise e
     end
   end
+
+  def create_subscription(model, conditions, includes)
+    subscription = Jason::Subscription.upsert_by_config(model, conditions: conditions || {}, includes: includes || nil)
+
+    return if !subscription.user_can_access?(current_user)
+    stream_from subscription.channel
+
+    subscriptions.push(subscription)
+    subscription.add_consumer(identifier)
+    subscription.get.each do |payload|
+      pp payload
+      transmit(payload) if payload.present?
+    end
+  end
+
+  def remove_subscription(config)
+    subscription = Jason::Subscription.upsert_by_config(config['model'], conditions: config['conditions'], includes: config['includes'])
+    subscriptions.reject! { |s| s.id == subscription.id }
+    subscription.remove_consumer(identifier)
+
+    # TODO Stop streams
+  end
+
+  def get_payload(config, force_refresh = false)
+    subscription = Jason::Subscription.upsert_by_config(config['model'], conditions: config['conditions'], includes: config['includes'])
+
+    return if !subscription.user_can_access?(current_user)
+    if force_refresh
+      subscription.set_ids_for_sub_models
+    end
+    subscription.get.each do |model_name, payload|
+      transmit(payload) if payload.present?
+    end
+  end
 end

data/lib/jason/graph_helper.rb

@@ -0,0 +1,165 @@
+class Jason::GraphHelper
+  attr_reader :id, :includes_helper
+
+  def initialize(id, includes_helper)
+    @id = id
+    @includes_helper = includes_helper
+  end
+
+  def add_edge(parent_model, parent_id, child_model, child_id)
+    edge = "#{parent_model}:#{parent_id}/#{child_model}:#{child_id}"
+    $redis_jason.sadd("jason:subscriptions:#{id}:graph", edge)
+  end
+
+  def remove_edge(parent_model, parent_id, child_model, child_id)
+    edge = "#{parent_model}:#{parent_id}/#{child_model}:#{child_id}"
+    $redis_jason.srem("jason:subscriptions:#{id}:graph", edge)
+  end
+
+  def add_edges(all_models, instance_ids)
+    edges = build_edges(all_models, instance_ids)
+    $redis_jason.sadd("jason:subscriptions:#{id}:graph", edges)
+  end
+
+  def remove_edges(all_models, instance_ids)
+    edges = build_edges(all_models, instance_ids)
+    $redis_jason.srem("jason:subscriptions:#{id}:graph", edges)
+  end
+
+  def apply_remove_node(node)
+    edges = $redis_jason.smembers("jason:subscriptions:#{id}:graph")
+    edges = find_edges_with_node(edges, node)
+    diff_edges_from_graph(remove_edges: edges)
+  end
+
+  # Add and remove edges, return graph before and after
+  def apply_update(add: nil, remove: nil)
+    add_edges = []
+    remove_edges = []
+
+    if add.present?
+      add.each do |edge_set|
+        add_edges += build_edges(edge_set[:model_names], edge_set[:instance_ids])
+      end
+    end
+
+    if remove.present?
+      remove.each do |edge_set|
+        remove_edges += build_edges(edge_set[:model_names], edge_set[:instance_ids], include_root: false)
+      end
+    end
+    diff_edges_from_graph(add_edges: add_edges, remove_edges: remove_edges)
+  end
+
+  def diff_edges_from_graph(add_edges: [], remove_edges: [])
+    old_edges, new_edges = Jason::LuaGenerator.new.update_set_with_diff("jason:subscriptions:#{id}:graph", add_edges.flatten, remove_edges.flatten)
+
+    old_graph = build_graph_from_edges(old_edges)
+    new_graph = build_graph_from_edges(new_edges)
+
+    old_nodes = (old_graph.values + old_graph.keys).flatten.uniq - ['root']
+    new_nodes = (new_graph.values + new_graph.keys).flatten.uniq - ['root']
+    orphan_nodes = find_orphans_in_graph(new_graph)
+
+    added_nodes = new_nodes - old_nodes - orphan_nodes
+    removed_nodes = old_nodes - new_nodes + orphan_nodes
+
+    orphaned_edges = orphan_nodes.map do |node|
+      find_edges_with_node(new_edges, node)
+    end.flatten
+
+    if orphaned_edges.present?
+      $redis_jason.srem("jason:subscriptions:#{id}:graph", orphaned_edges)
+    end
+
+    ids_to_add = {}
+    ids_to_remove = {}
+
+    added_nodes.each do |node|
+      model_name, instance_id = node.split(':')
+      ids_to_add[model_name] ||= []
+      ids_to_add[model_name].push(instance_id)
+    end
+
+    removed_nodes.each do |node|
+      model_name, instance_id = node.split(':')
+      ids_to_remove[model_name] ||= []
+      ids_to_remove[model_name].push(instance_id)
+    end
+
+    { ids_to_remove: ids_to_remove, ids_to_add: ids_to_add }
+  end
+
+  def find_edges_with_node(edges, node)
+    edges.select do |edge|
+      parent, child = edge.split('/')
+      parent == node || child == node
+    end
+  end
+
+  def find_orphans
+    edges = $redis_jason.smembers("jason:subscriptions:#{id}:graph")
+    graph = build_graph_from_edges(edges)
+    find_orphans_in_graph(graph)
+  end
+
+  def find_orphans_in_graph(graph)
+    reachable_nodes = get_reachable_nodes(graph)
+    all_nodes = (graph.values + graph.keys).flatten.uniq - ['root']
+    all_nodes - reachable_nodes
+  end
+
+  def get_reachable_nodes(graph, parent = 'root')
+    reached_nodes = graph[parent] || []
+    reached_nodes.each do |child|
+      reached_nodes += get_reachable_nodes(graph, child)
+    end
+    reached_nodes
+  end
+
+  def build_graph_from_edges(edges)
+    graph = {}
+    edges.each do |edge|
+      parent, child = edge.split('/')
+      graph[parent] ||= []
+      graph[parent].push(child)
+    end
+    graph
+  end
+
+  private
+
+  def build_edges(all_models, instance_ids, include_root: true)
+    # Build the tree
+    # Find parent -> child model relationships
+    edges = []
+
+    all_models.each_with_index do |parent_model, parent_idx|
+      all_models.each_with_index do |child_model, child_idx|
+        next if parent_model == child_model
+        next if !includes_helper.in_sub(parent_model, child_model)
+
+        pairs = instance_ids.map { |row| [row[parent_idx], row[child_idx]] }
+          .uniq
+          .reject{ |pair| pair[0].blank? || pair[1].blank? }
+
+        edges += pairs.map.each do |pair|
+          "#{parent_model}:#{pair[0]}/#{child_model}:#{pair[1]}"
+        end
+      end
+    end
+
+    root_model = includes_helper.root_model
+
+    if include_root && all_models.include?(root_model)
+      root_idx = all_models.find_index(root_model)
+      root_ids = instance_ids.map { |row| row[root_idx] }.uniq.compact
+
+      edges += root_ids.map do |id|
+        "root/#{root_model}:#{id}"
+      end
+    end
+
+    edges
+  end
+end

data/lib/jason/includes_helper.rb

@@ -0,0 +1,108 @@
+# Helper to provide other modules with information about the includes of a subscription
+
+class Jason::IncludesHelper
+  attr_accessor :main_tree
+
+  def initialize(main_tree)
+    raise "Root must be hash" if !main_tree.is_a?(Hash)
+    raise "Only one root key allowed" if main_tree.keys.size != 1
+    @main_tree = main_tree
+  end
+
+  def all_models_recursive(tree)
+    sub_models = if tree.is_a?(Hash)
+      tree.map do |k,v|
+        [k, all_models_recursive(v)]
+      end
+    elsif tree.is_a?(Array)
+      tree.map do |v|
+        all_models_recursive(v)
+      end
+    else
+      tree
+    end
+  end
+
+  def all_models(model_name = nil)
+    model_name = model_name.presence || root_model
+    assoc_name = get_assoc_name(model_name)
+    tree = get_tree_for(assoc_name)
+    [model_name, all_models_recursive(tree)].flatten.uniq.map(&:to_s).map(&:singularize)
+  end
+
+  def root_model
+    main_tree.keys[0]
+  end
+
+  # assoc could be plural or not, so need to scan both.
+  def get_assoc_name(model_name, haystack = main_tree)
+    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 |element|
+        if element.is_a?(String)
+          if model_name.pluralize == element.pluralize
+            return element
+          end
+        else
+          found_assoc = get_assoc_name(model_name, element)
+          return found_assoc if found_assoc
+        end
+      end
+    else
+      if model_name.pluralize == haystack.to_s.pluralize
+        return haystack
+      end
+    end
+
+    return nil
+  end
+
+  def get_tree_for(needle, assoc_name = nil, haystack = main_tree)
+    return haystack if needle.to_s.pluralize == assoc_name.to_s.pluralize
+
+    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.present?
+      end
+    elsif haystack.is_a?(Array)
+      haystack.each do |includes_tree|
+        found_haystack = get_tree_for(needle, nil, includes_tree)
+        return found_haystack if found_haystack.present?
+      end
+    elsif haystack.is_a?(String)
+      found_haystack = get_tree_for(needle, haystack, nil)
+      return found_haystack if found_haystack.present?
+    end
+
+    return []
+  end
+
+  def in_sub(parent_model, child_model)
+    tree = get_tree_for(parent_model)
+
+    if tree.is_a?(Hash)
+      return tree.keys.map(&:singularize).include?(child_model)
+    elsif tree.is_a?(Array)
+      tree.each do |element|
+        if element.is_a?(String)
+          return true if element.singularize == child_model
+        elsif element.is_a?(Hash)
+          return true if element.keys.map(&:singularize).include?(child_model)
+        end
+      end
+    elsif tree.is_a?(String)
+      return tree.singularize == child_model
+    end
+
+    return false
+  end
+end