jason-rails 0.6.4 → 0.7.0

data/client/src/transportAdapters/pusherAdapter.ts

@@ -1,11 +1,10 @@
 import Pusher from 'pusher-js'
-import { createConsumer } from "@rails/actioncable"
 import restClient from '../restClient'
 import { v4 as uuidv4 } from 'uuid'
 import _ from 'lodash'
 
 export default function pusherAdapter(jasonConfig, handlePayload, dispatch) {
-  let consumerId = uuidv4()
+  const consumerId = uuidv4()
 
   const { pusherKey, pusherRegion, pusherChannelPrefix } = jasonConfig
   const pusher = new Pusher(pusherKey, {

data/client/src/useDraft.ts

@@ -0,0 +1,17 @@
+import _ from 'lodash'
+import { useSelector } from 'react-redux'
+import addRelations from './addRelations'
+
+/* Can be called as
+useDraft() => draft object for making updates
+useDraft('entity', id) => returns [draft, object]
+useDraft('entity', id, relations) => returns [draft, objectWithEmbeddedRelations]
+*/
+
+export default function useDraft(entity, id, relations = []) {
+  // const entityDraft =`${entity}Draft`
+  // const object = { ...s[entityDraft].entities[String(id)] }
+
+  // return useSelector(s => addRelations(s, object, entity, relations, 'Draft'), _.isEqual)
+}
+

data/client/src/useEager.ts

@@ -1,9 +1,12 @@
-import JasonContext from './JasonContext'
-import { useContext } from 'react'
+import _ from 'lodash'
+import { useSelector } from 'react-redux'
+import addRelations from './addRelations'
 
-export default function useEager(entity, id = null, relations = []) {
-  const { eager } = useContext(JasonContext)
-
-  return eager(entity, id, relations)
+export default function useEager(entity: string, id = '', relations = [] as any) {
+  if (id) {
+    return useSelector(s => addRelations(s, { ...s[entity].entities[String(id)] }, entity, relations), _.isEqual)
+  } else {
+    return useSelector(s => addRelations(s, _.values(s[entity].entities), entity, relations), _.isEqual)
+  }
 }
 

data/client/src/useJason.ts

@@ -9,7 +9,6 @@ import createTransportAdapater from './createTransportAdapter'
 
 import { createEntityAdapter, createSlice, createReducer, configureStore } from '@reduxjs/toolkit'
 
-import makeEager from './makeEager'
 import { camelizeKeys } from 'humps'
 import md5 from 'blueimp-md5'
 import _ from 'lodash'
@@ -41,7 +40,6 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
 
       const optDis = createOptDis(schema, dispatch, restClient, serverActionQueue)
       const actions = createActions(schema, store, restClient, optDis, extraActions)
-      const eager = makeEager(schema)
 
       let payloadHandlers = {}
       let configs = {}
@@ -90,7 +88,7 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       function removeSubscription(config) {
         transportAdapter.removeSubscription(config)
         const md5Hash = md5(JSON.stringify(config))
-        payloadHandlers[md5Hash].tearDown()
+        payloadHandlers[md5Hash]?.tearDown() // Race condition where component mounts then unmounts quickly
         delete payloadHandlers[md5Hash]
         delete configs[md5Hash]
         delete subOptions[md5Hash]
@@ -99,7 +97,6 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       setValue({
         actions: actions,
         subscribe: createSubscription,
-        eager,
         handlePayload
       })
       setStore(store)

data/config/routes.rb

@@ -1,8 +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'
+  get '/api/config', to: 'jason#configuration'
+  post '/api/action', to: 'jason#action'
+  post '/api/create_subscription', to: 'jason#create_subscription'
+  post '/api/remove_subscription', to: 'jason#remove_subscription'
+  post '/api/get_payload', to: 'jason#get_payload'
+  post '/api/pusher/auth', to: 'pusher#auth'
 end

data/jason-rails.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency "sidekiq"
 end

data/lib/jason.rb

@@ -12,6 +12,8 @@ require 'jason/engine'
 require 'jason/lua_generator'
 require 'jason/includes_helper'
 require 'jason/graph_helper'
+require 'jason/conditions_matcher'
+require 'jason/consistency_checker'
 
 module Jason
   class Error < StandardError; end
@@ -24,20 +26,24 @@ module Jason
   self.mattr_accessor :pusher_region
   self.mattr_accessor :pusher_channel_prefix
   self.mattr_accessor :authorization_service
+  self.mattr_accessor :sidekiq_queue
 
   self.schema = {}
   self.transport_service = :action_cable
   self.pusher_region = 'eu'
   self.pusher_channel_prefix = 'jason'
+  self.sidekiq_queue = 'default'
 
   def self.init
+    # Don't run in AR migration / generator etc.
+    return if $PROGRAM_NAME == '-e' || ActiveRecord::Base.connection.migration_context.needs_migration?
+
     # 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}"
@@ -52,8 +58,6 @@ module Jason
     $redis_jason.set('jason:last_schema', current_schema.to_json)
   ensure
     $redis_jason.del('jason:schema:lock')
-
-    previous_config = 'test'
   end
 
 

data/lib/jason/api_model.rb

@@ -36,11 +36,7 @@ class Jason::ApiModel
   end
 
   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

data/lib/jason/broadcaster.rb

@@ -13,7 +13,8 @@ class Jason::Broadcaster
     if Jason.transport_service == :action_cable
       ActionCable.server.broadcast(channel, message)
     elsif Jason.transport_service == :pusher
-      Jason.pusher.trigger(pusher_channel_name, 'changed', message)
+      $redis_jason.rpush("jason:outbound_message_queue", { channel: pusher_channel_name, name: 'changed', data: message }.to_json)
+      Jason::OutboundMessageQueueWorker.perform_async
     end
   end
 end

data/lib/jason/channel.rb

@@ -12,7 +12,6 @@ class Jason::Channel < ActionCable::Channel::Base
   private
 
   def handle_message(message)
-    pp message['createSubscription']
     @subscriptions ||= []
 
     begin # ActionCable swallows errors in this message - ensure they're output to logs.
@@ -38,18 +37,12 @@ class Jason::Channel < ActionCable::Channel::Base
 
     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)

data/lib/jason/conditions_matcher.rb

@@ -0,0 +1,88 @@
+class Jason::ConditionsMatcher
+  attr_reader :klass
+
+  def initialize(klass)
+    @klass = klass
+  end
+
+  # key, rules = 'post_id', 123
+  # key, rules = 'post_id', { 'value': [123,C456], 'type': 'between' }
+  # key, rules = 'post_id', { 'value': [123,456], 'type': 'between', 'not': true }
+  # key, rules = 'post_id', { 'value': 123, 'type': 'equals', 'not': true }
+  def test_match(key, rules, previous_changes)
+    return nil if !previous_changes.keys.include?(key)
+
+    if rules.is_a?(Hash)
+      matches = false
+      value = convert_to_datatype(key, rules['value'])
+
+      if rules['type'] == 'equals'
+        matches = previous_changes[key][1] == value
+      elsif rules['type'] == 'between'
+        matches = (value[0]..value[1]).cover?(previous_changes[key][1])
+      else
+        raise "Unrecognized rule type #{rules['type']}"
+      end
+
+      if rules['not']
+        return !matches
+      else
+        return matches
+      end
+
+    elsif rules.is_a?(Array)
+      value = convert_to_datatype(key, rules)
+      return previous_changes[key][1].includes?(value)
+    else
+      value = convert_to_datatype(key, rules)
+      return previous_changes[key][1] == value
+    end
+  end
+
+  # conditions = { 'post_id' => 123, 'created_at' => { 'type' => 'between', 'value' => ['2020-01-01', '2020-01-02'] } }
+  def apply_conditions(relation, conditions)
+    conditions.each do |key, rules|
+      relation = apply_condition(relation, key, rules)
+    end
+
+    relation
+  end
+
+  private
+
+  def apply_condition(relation, key, rules)
+    if rules.is_a?(Hash)
+      value = convert_to_datatype(key, rules['value'])
+
+      if rules['type'] == 'equals'
+        arg = { key => value }
+      elsif rules['type'] == 'between'
+        arg = { key => value[0]..value[1] }
+      else
+        raise "Unrecognized rule type #{rules['type']}"
+      end
+
+      if rules['not']
+        return relation.where.not(arg)
+      else
+        return relation.where(arg)
+      end
+    else
+      value = convert_to_datatype(key, rules)
+      return relation.where({ key => value })
+    end
+  end
+
+  def convert_to_datatype(key, value)
+    datatype = klass.type_for_attribute(key).type
+    if datatype == :datetime || datatype == :date
+      if value.is_a?(Array)
+        value.map { |v| v&.to_datetime }
+      else
+        value&.to_datetime
+      end
+    else
+      value
+    end
+  end
+end

data/lib/jason/consistency_checker.rb

@@ -0,0 +1,61 @@
+class Jason::ConsistencyChecker
+  attr_reader :subscription
+  attr_reader :inconsistent
+
+  def self.check_all(fix: false)
+    Jason::Subscription.all.each do |sub|
+      next if sub.consumer_count == 0
+      checker = Jason::ConsistencyChecker.new(sub)
+      result = checker.check
+      if checker.inconsistent?
+        pp sub.config
+        pp result
+        if fix
+          sub.reset!(hard: true)
+        end
+      end
+    end
+  end
+
+  def self.fix_all
+    check_all(fix: true)
+  end
+
+  def initialize(subscription)
+    @subscription = subscription
+    @inconsistent = false
+  end
+
+  def inconsistent?
+    inconsistent
+  end
+
+  # Take a subscription, get the current cached payload, and compare it to the data retrieved from the database
+  def check
+    cached_payload = subscription.get
+    edge_set = subscription.load_ids_for_sub_models(subscription.model, nil)
+
+    result = cached_payload.map do |model_name, data|
+      cached_payload_instance_ids = data[:payload].map { |row| row['id'] }
+
+      model_idx = edge_set[:model_names].index(model_name)
+      if model_idx.present?
+        edge_set_instance_ids = edge_set[:instance_ids].map { |row| row[model_idx] }
+      else
+        next
+      end
+
+      missing = edge_set_instance_ids - cached_payload_instance_ids
+      intruding = cached_payload_instance_ids - edge_set_instance_ids
+
+      if missing.present? || intruding.present?
+        @inconsistent = true
+      end
+
+      [model_name, {
+        'missing' => missing,
+        'intruding' => intruding
+      }]
+    end.compact.to_h
+  end
+end

data/lib/jason/graph_helper.rb

@@ -26,6 +26,10 @@ class Jason::GraphHelper
     $redis_jason.srem("jason:subscriptions:#{id}:graph", edges)
   end
 
+  def apply_add_node_at_root(node)
+    diff_edges_from_graph(add_edges: ["root/#{node}"])
+  end
+
   def apply_remove_node(node)
     edges = $redis_jason.smembers("jason:subscriptions:#{id}:graph")
     edges = find_edges_with_node(edges, node)
@@ -33,7 +37,8 @@ class Jason::GraphHelper
   end
 
   # Add and remove edges, return graph before and after
-  def apply_update(add: nil, remove: nil)
+  # Enforce means make the graph contain only the add_edges
+  def apply_update(add: nil, remove: nil, enforce: false)
     add_edges = []
     remove_edges = []
 
@@ -48,11 +53,21 @@ class Jason::GraphHelper
         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)
+
+    diff_edges_from_graph(add_edges: add_edges, remove_edges: remove_edges, enforce: enforce)
   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)
+  def diff_edges_from_graph(add_edges: [], remove_edges: [], enforce: false)
+    if enforce
+      old_edges = $redis_jason.multi do |r|
+        r.smembers("jason:subscriptions:#{id}:graph")
+        r.del("jason:subscriptions:#{id}:graph")
+        r.sadd("jason:subscriptions:#{id}:graph", add_edges) if add_edges.present?
+      end[0]
+      new_edges = add_edges
+    else
+      old_edges, new_edges = Jason::LuaGenerator.new.update_set_with_diff("jason:subscriptions:#{id}:graph", add_edges.flatten, remove_edges.flatten)
+    end
 
     old_graph = build_graph_from_edges(old_edges)
     new_graph = build_graph_from_edges(new_edges)

data/lib/jason/publisher.rb

@@ -5,6 +5,7 @@ module Jason::Publisher
   def self.cache_all
     Rails.application.eager_load!
     ActiveRecord::Base.descendants.each do |klass|
+      $redis_jason.del("jason:cache:#{klass.name.underscore}")
       klass.cache_all if klass.respond_to?(:cache_all)
     end
   end
@@ -42,7 +43,9 @@ module Jason::Publisher
     # - TODO: The value of an instance changes so that it enters/leaves a subscription
 
     # TODO: Optimize this, by caching associations rather than checking each time instance is saved
-    jason_assocs = self.class.reflect_on_all_associations(:belongs_to).select { |assoc| assoc.klass.respond_to?(:has_jason?) }
+    jason_assocs = self.class.reflect_on_all_associations(:belongs_to)
+      .reject { |assoc| assoc.polymorphic? } # Can't get the class name of a polymorphic association, by
+      .select { |assoc| assoc.klass.respond_to?(:has_jason?) }
     jason_assocs.each do |assoc|
       if previous_changes[assoc.foreign_key].present?
         Jason::Subscription.update_ids(
@@ -70,13 +73,38 @@ module Jason::Publisher
        )
     end
 
-    # - An instance is created where it belongs_to an _all_ subscription
-    if previous_changes['id'].present?
-      Jason::Subscription.add_id(self.class.name.underscore, id)
-    end
-
     if persisted?
+      applied_sub_ids = []
+
+      jason_conditions.each do |row|
+        matches = row['conditions'].map do |key, rules|
+          Jason::ConditionsMatcher.new(self.class).test_match(key, rules, previous_changes)
+        end
+        next if matches.all? { |m| m.nil? } # None of the keys were in previous changes - therefore this condition does not apply
+        in_sub = matches.all? { |m| m }
+
+        if in_sub
+          row['subscription_ids'].each do |sub_id|
+            Jason::Subscription.find_by_id(sub_id).add_id(self.class.name.underscore, self.id)
+            applied_sub_ids.push(sub_id)
+          end
+        else
+          row['subscription_ids'].each do |sub_id|
+            jason_subscriptions.each do |already_sub_id|
+              # If this sub ID already has this instance, remove it
+              if already_sub_id == sub_id
+                sub = Jason::Subscription.find_by_id(already_sub_id)
+                sub.remove_id(self.class.name.underscore, self.id)
+                applied_sub_ids.push(already_sub_id)
+              end
+            end
+          end
+        end
+      end
+
       jason_subscriptions.each do |sub_id|
+        next if applied_sub_ids.include?(sub_id)
+
         Jason::Subscription.new(id: sub_id).update(self.class.name.underscore, id, payload, gidx)
       end
     end
@@ -91,6 +119,10 @@ module Jason::Publisher
     Jason::Subscription.for_instance(self.class.name.underscore, id)
   end
 
+  def jason_conditions
+    Jason::Subscription.conditions_for_model(self.class.name.underscore)
+  end
+
   def jason_cached_value
     JSON.parse($redis_jason.hget("jason:cache:#{self.class.name.underscore}", id) || '{}')
   end
@@ -115,7 +147,8 @@ module Jason::Publisher
       self.after_initialize -> {
         @api_model = Jason::ApiModel.new(self.class.name.underscore)
       }
-      self.after_commit :publish_json_if_changed
+      self.after_commit :force_publish_json, on: [:create, :destroy]
+      self.after_commit :publish_json_if_changed, on: [:update]
     end
 
     def find_or_create_by_id(params)