jason-rails 0.6.7 → 0.7.3

data/client/src/index.ts

@@ -1,8 +1,10 @@
+import _JasonContext from './JasonContext'
 import _JasonProvider from './JasonProvider'
 import _useAct from './useAct'
 import _useSub from './useSub'
 import _useEager from './useEager'
 
+export const JasonContext = _JasonContext
 export const JasonProvider = _JasonProvider
 export const useAct = _useAct
 export const useSub = _useSub

data/client/src/transportAdapters/actionCableAdapter.ts

@@ -1,6 +1,11 @@
 import { createConsumer } from "@rails/actioncable"
+import restClient from '../restClient'
+import { v4 as uuidv4 } from 'uuid'
+import _ from 'lodash'
 
 export default function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
+  const consumerId = uuidv4()
+
   const consumer = createConsumer()
   const subscription = (consumer.subscriptions.create({
     channel: 'Jason::Channel'
@@ -22,16 +27,30 @@ export default function actionCableAdapter(jasonConfig, handlePayload, dispatch,
     }
   }));
 
-  function getPayload(config, options) {
-    subscription.send({ getPayload: config, ...options })
-  }
-
   function createSubscription(config) {
     subscription.send({ createSubscription: config })
   }
 
   function removeSubscription(config) {
-    subscription.send({ removeSubscription: config })
+    restClient.post('/jason/api/remove_subscription', { config, consumerId })
+    .catch(e => console.error(e))
+  }
+
+  function getPayload(config, options) {
+    restClient.post('/jason/api/get_payload', {
+      config,
+      options
+    })
+    .then(({ data }) => {
+      _.map(data, (payload, modelName) => {
+        handlePayload(payload)
+      })
+    })
+    .catch(e => console.error(e))
+  }
+
+  function fullChannelName(channelName) {
+    return channelName
   }
 
   return { getPayload, createSubscription, removeSubscription }

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,13 +9,12 @@ 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'
 import React, { useState, useEffect } from 'react'
 
-export default function useJason({ reducers, middleware = [], extraActions }: { reducers?: any, middleware?: any[], extraActions?: any }) {
+export default function useJason({ reducers, middleware = [], enhancers = [], extraActions }: { reducers?: any, middleware?: any[], enhancers?: any[], extraActions?: any }) {
   const [store, setStore] = useState(null as any)
   const [value, setValue] = useState(null as any)
 
@@ -36,12 +35,11 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
 
       console.debug({ allReducers })
 
-      const store = configureStore({ reducer: allReducers, middleware: [...middleware, pruneIdsMiddleware(schema)] })
+      const store = configureStore({ reducer: allReducers, middleware: [...middleware, pruneIdsMiddleware(schema)], enhancers })
       const dispatch = store.dispatch
 
       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/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
@@ -23,7 +25,8 @@ module Jason
   self.mattr_accessor :pusher_key
   self.mattr_accessor :pusher_region
   self.mattr_accessor :pusher_channel_prefix
-  self.mattr_accessor :authorization_service
+  self.mattr_accessor :subscription_authorization_service
+  self.mattr_accessor :update_authorization_service
   self.mattr_accessor :sidekiq_queue
 
   self.schema = {}

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/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,65 @@
+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 wipe_all_subs
+
+  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)

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
@@ -15,7 +16,7 @@ module Jason::Publisher
 
     # Exists
     if self.persisted? && (scope.blank? || self.class.unscoped.send(scope).exists?(self.id))
-      payload = self.reload.as_json(as_json_config)
+      payload = self.as_json(as_json_config)
       gidx = Jason::LuaGenerator.new.cache_json(self.class.name.underscore, self.id, payload)
       return [payload, gidx]
     # Has been destroyed
@@ -72,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
@@ -93,13 +119,17 @@ 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
 
   class_methods do
     def cache_all
-      all.each(&:cache_json)
+      all.find_each(&:cache_json)
     end
 
     def has_jason?
@@ -117,36 +147,8 @@ module Jason::Publisher
       self.after_initialize -> {
         @api_model = Jason::ApiModel.new(self.class.name.underscore)
       }
-      self.after_commit :publish_json_if_changed
-    end
-
-    def find_or_create_by_id(params)
-      object = find_by(id: params[:id])
-
-      if object
-        object.update(params)
-      elsif params[:hidden]
-        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
-      else
-        object = create!(params)
-      end
-
-      object
-    end
-
-    def find_or_create_by_id!(params)
-      object = find_by(id: params[:id])
-
-      if object
-        object.update!(params)
-      elsif params[:hidden]
-        ## TODO: We're diverging from semantics of the Rails bang! methods here, which would normally either raise or return an object. Find a way to make this better.
-        return false ## If an object is passed with hidden = true but didn't already exist, it's safe to never create it
-      else
-        object = create!(params)
-      end
-
-      object
+      self.after_commit :force_publish_json, on: [:create, :destroy]
+      self.after_commit :publish_json_if_changed, on: [:update]
     end
   end