jason-rails 0.3.0 → 0.6.0

data/config/routes.rb

@@ -0,0 +1,8 @@
+Jason::Engine.routes.draw do
+  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

@@ -22,4 +22,13 @@ Gem::Specification.new do |spec|
   end
   spec.executables   = []
   spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails", ">= 5"
+  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

@@ -1,10 +1,49 @@
+require 'connection_pool'
+require 'redis'
+require 'jsondiff'
+
 require "jason/version"
 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
-  # Your code goes here...
+
+  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'
+
+  # add default values of more config vars here
+
+  # this function maps the vars from your app into your engine
+  def self.setup(&block)
+    yield self
+  end
+
+  $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
 end

data/lib/jason/api_model.rb

@@ -8,15 +8,15 @@ 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
     model.allowed_params || []
   end
 
-  def include_models
-    model.include_models || []
+  def allowed_object_params
+    model.allowed_object_params || []
   end
 
   def include_methods
@@ -35,13 +35,19 @@ class Jason::ApiModel
     model.scope
   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 } }
+  def permit(params)
+    pp self
+    pp params
+    params = params.require(:payload).permit(allowed_params).tap do |allowed|
+      pp "ALLOWED"
+      pp allowed
+      allowed_object_params.each do |key|
+        allowed[key] = params[:payload][key].to_unsafe_h if params[:payload][key]
+      end
     end
+  end
 
-    { only: subscribed_fields, include: include_configs, methods: include_methods }
+  def as_json_config
+    { 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/engine.rb

@@ -0,0 +1,5 @@
+module Jason
+  class Engine < ::Rails::Engine
+    isolate_namespace Jason
+  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