jason-rails 0.6.8 → 0.7.5

data/client/src/createServerActionQueue.ts

@@ -1,31 +1,65 @@
 // A FIFO queue with deduping of actions whose effect will be cancelled by later actions
-
+import { v4 as uuidv4 } from 'uuid'
 import _ from 'lodash'
 
+class Deferred {
+  promise: Promise<any>;
+  resolve: any;
+  reject: any;
+
+  constructor() {
+    this.promise = new Promise((resolve, reject)=> {
+      this.reject = reject
+      this.resolve = resolve
+    })
+  }
+}
+
 export default function createServerActionQueue() {
   const queue: any[] = []
+  const deferreds = {}
+
   let inFlight = false
 
-  function addItem(item) {
+  function addItem(action) {
     // Check if there are any items ahead in the queue that this item would effectively overwrite.
     // In that case we can remove them
     // If this is an upsert && item ID is the same && current item attributes are a superset of the earlier item attributes
-    const { type, payload } = item
+    const { type, payload } = action
+    const id = uuidv4()
+    const dfd = new Deferred()
+    deferreds[id] = [dfd]
+
+    const item = { id, action }
+
     if (type.split('/')[1] !== 'upsert') {
       queue.push(item)
-      return
+      return dfd.promise
     }
 
     _.remove(queue, item => {
-      const { type: itemType, payload: itemPayload } = item
+      const { type: itemType, payload: itemPayload } = item.action
       if (type !== itemType) return false
       if (itemPayload.id !== payload.id) return false
 
       // Check that all keys of itemPayload are in payload.
+      deferreds[id].push(...deferreds[item.id])
       return _.difference(_.keys(itemPayload),_.keys(payload)).length === 0
     })
 
     queue.push(item)
+    return dfd.promise
+  }
+
+  function itemProcessed(id, data?: any) {
+    inFlight = false
+    deferreds[id].forEach(dfd => dfd.resolve(data))
+  }
+
+  function itemFailed(id, error?: any) {
+    queue.length = 0
+    deferreds[id].forEach(dfd => dfd.reject(error))
+    inFlight = false
   }
 
   return {
@@ -40,7 +74,8 @@ export default function createServerActionQueue() {
       }
       return false
     },
-    itemProcessed: () => inFlight = false,
+    itemProcessed,
+    itemFailed,
     fullySynced: () => queue.length === 0 && !inFlight,
     getData: () => ({ queue, inFlight })
   }

data/client/src/createTransportAdapter.ts

@@ -1,10 +1,10 @@
 import actionCableAdapter from './transportAdapters/actionCableAdapter'
 import pusherAdapter from './transportAdapters/pusherAdapter'
 
-export default function createTransportAdapter(jasonConfig, handlePayload, dispatch, onConnect) {
+export default function createTransportAdapter(jasonConfig, handlePayload, dispatch, onConnect, transportOptions) {
   const { transportService } = jasonConfig
   if (transportService === 'action_cable') {
-    return actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnect)
+    return actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnect, transportOptions)
   } else if (transportService === 'pusher') {
     return pusherAdapter(jasonConfig, handlePayload, dispatch)
   } else {

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,7 +1,14 @@
 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, transportOptions) {
+  const consumerId = uuidv4()
+
+  const { cableUrl } = transportOptions
+  const consumer = cableUrl ? createConsumer(cableUrl) : createConsumer()
 
-export default function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
-  const consumer = createConsumer()
   const subscription = (consumer.subscriptions.create({
     channel: 'Jason::Channel'
   }, {
@@ -22,16 +29,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 = [], transportOptions = {}, extraActions }: { reducers?: any, middleware?: any[], enhancers?: any[], extraActions?: any, transportOptions?: 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 = {}
@@ -50,7 +48,7 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       function handlePayload(payload) {
         const { md5Hash } = payload
 
-        const { handlePayload } = payloadHandlers[md5Hash]
+        const { handlePayload } = payloadHandlers[md5Hash] || {}
         if (handlePayload) {
           handlePayload(payload)
         } else {
@@ -58,7 +56,13 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
         }
       }
 
-      const transportAdapter = createTransportAdapater(jasonConfig, handlePayload, dispatch, () => _.keys(configs).forEach(md5Hash => createSubscription(configs[md5Hash], subOptions[md5Hash])))
+      const transportAdapter = createTransportAdapater(
+        jasonConfig,
+        handlePayload,
+        dispatch,
+        () => _.keys(configs).forEach(md5Hash => createSubscription(configs[md5Hash], subOptions[md5Hash])),
+        transportOptions
+      )
 
       function createSubscription(config, options = {}) {
         // We need the hash to be consistent in Ruby / Javascript
@@ -99,7 +103,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 = {}
@@ -48,7 +51,11 @@ module Jason
         puts "Old config was #{previous_schema[model]}"
         puts "New config is #{config}"
         puts "Rebuilding cache for #{model}"
-        model.classify.constantize.cache_all
+
+        # This is necessary to ensure all Rails methods have been added to model before we attempt to cache.
+        Rails.configuration.after_initialize do
+           model.classify.constantize.cache_all
+        end
         puts "Done"
       end
     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/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