jason-rails 0.5.0 → 0.6.3

data/client/src/createTransportAdapter.ts

@@ -0,0 +1,13 @@
+import actionCableAdapter from './transportAdapters/actionCableAdapter'
+import pusherAdapter from './transportAdapters/pusherAdapter'
+
+export default function createTransportAdapter(jasonConfig, handlePayload, dispatch, onConnect) {
+  const { transportService } = jasonConfig
+  if (transportService === 'action_cable') {
+    return actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnect)
+  } else if (transportService === 'pusher') {
+    return pusherAdapter(jasonConfig, handlePayload, dispatch)
+  } else {
+    throw(`Transport adapter does not exist for ${transportService}`)
+  }
+}

data/client/src/index.ts

@@ -1,7 +1,9 @@
 import _JasonProvider from './JasonProvider'
 import _useAct from './useAct'
 import _useSub from './useSub'
+import _useEager from './useEager'
 
 export const JasonProvider = _JasonProvider
 export const useAct = _useAct
-export const useSub = _useSub
+export const useSub = _useSub
+export const useEager = _useEager

data/client/src/makeEager.ts

@@ -36,9 +36,9 @@ export default function (schema) {
 
   function useEager(entity, id = null, relations = []) {
     if (id) {
-      return useSelector(s => addRelations(s, { ...s[entity].entities[String(id)] }, entity, relations))
+      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))
+      return useSelector(s => addRelations(s, _.values(s[entity].entities), entity, relations), _.isEqual)
     }
   }
 

data/client/src/pruneIdsMiddleware.ts

@@ -2,20 +2,20 @@ import _ from 'lodash'
 import pluralize from 'pluralize'
 
 const pruneIdsMiddleware = schema => store => next => action => {
-  const { type } = action
+  const { type, payload } = action
   const result = next(action)
+
   const state = store.getState()
-  if (type === 'jasonModels/setSubscriptionIds') {
-    // Check every model
-    _.map(_.keys(schema), model => {
-      let ids = []
-      _.map(state.jasonModels[model], (subscribedIds, k) => {
-        ids = _.union(ids, subscribedIds)
-      })
-      // Find IDs currently in Redux that aren't in any subscription
-      const idsToRemove = _.difference(state[pluralize(model)].ids, ids)
-      store.dispatch({ type: `${pluralize(model)}/removeMany`, payload: idsToRemove })
+  if (type === 'jasonModels/setSubscriptionIds' || type === 'jasonModels/removeSubscriptionIds') {
+    const { model, ids } = payload
+
+    let idsInSubs = []
+    _.map(state.jasonModels[model], (subscribedIds, k) => {
+      idsInSubs = _.union(idsInSubs, subscribedIds)
     })
+    // Find IDs currently in Redux that aren't in any subscription
+    const idsToRemove = _.difference(state[pluralize(model)].ids, idsInSubs)
+    store.dispatch({ type: `${pluralize(model)}/removeMany`, payload: idsToRemove })
   }
 
   return result

data/client/src/restClient.ts

@@ -4,10 +4,11 @@ import { validate as isUuid } from 'uuid'
 
 const csrfToken = (document?.querySelector("meta[name=csrf-token]") as any)?.content
 axios.defaults.headers.common['X-CSRF-Token'] = csrfToken
+
 const restClient = applyCaseMiddleware(axios.create() as any, {
   preservedKeys: (key) => {
     return isUuid(key)
   }
-})
+}) as any
 
 export default restClient

data/client/src/transportAdapters/actionCableAdapter.ts

@@ -0,0 +1,38 @@
+import { createConsumer } from "@rails/actioncable"
+
+export default function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
+  const consumer = createConsumer()
+  const subscription = (consumer.subscriptions.create({
+    channel: 'Jason::Channel'
+  }, {
+    connected: () => {
+      dispatch({ type: 'jason/upsert', payload: { connected: true } })
+      console.debug('Connected to ActionCable')
+
+      // When AC loses connection - all state is lost, so we need to re-initialize all subscriptions
+      onConnected()
+    },
+    received: payload => {
+      handlePayload(payload)
+      console.debug("ActionCable Payload received: ", payload)
+    },
+    disconnected: () => {
+      dispatch({ type: 'jason/upsert', payload: { connected: false } })
+      console.warn('Disconnected from ActionCable')
+    }
+  }));
+
+  function getPayload(config, options) {
+    subscription.send({ getPayload: config, ...options })
+  }
+
+  function createSubscription(config) {
+    subscription.send({ createSubscription: config })
+  }
+
+  function removeSubscription(config) {
+    subscription.send({ removeSubscription: config })
+  }
+
+  return { getPayload, createSubscription, removeSubscription }
+}

data/client/src/transportAdapters/pusherAdapter.ts

@@ -0,0 +1,72 @@
+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 { pusherKey, pusherRegion, pusherChannelPrefix } = jasonConfig
+  const pusher = new Pusher(pusherKey, {
+    cluster: 'eu',
+    forceTLS: true,
+    authEndpoint: '/jason/api/pusher/auth'
+  })
+  pusher.connection.bind('state_change', ({ current }) => {
+    if (current === 'connected') {
+      dispatch({ type: 'jason/upsert', payload: { connected: true } })
+    } else {
+      dispatch({ type: 'jason/upsert', payload: { connected: false } })
+    }
+  })
+  pusher.connection.bind( 'error', error => {
+    dispatch({ type: 'jason/upsert', payload: { connected: false } })
+  });
+
+  const configToChannel = {}
+
+  function createSubscription(config) {
+    restClient.post('/jason/api/create_subscription', { config, consumerId })
+    .then(({ data: { channelName } }) => {
+      configToChannel[JSON.stringify(config)] = channelName
+      subscribeToChannel(channelName)
+    })
+    .catch(e => console.error(e))
+  }
+
+  function removeSubscription(config) {
+    const channelName = configToChannel[JSON.stringify(config)]
+    unsubscribeFromChannel(fullChannelName(channelName))
+    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 subscribeToChannel(channelName) {
+    const channel = pusher.subscribe(fullChannelName(channelName))
+    channel.bind('changed', message => handlePayload(message))
+  }
+
+  function unsubscribeFromChannel(channelName) {
+    const channel = pusher.unsubscribe(fullChannelName(channelName))
+  }
+
+  function fullChannelName(channelName) {
+    return `private-${pusherChannelPrefix}-${channelName}`
+  }
+
+  return { getPayload, createSubscription, removeSubscription }
+}

data/client/src/useEager.ts

@@ -0,0 +1,9 @@
+import JasonContext from './JasonContext'
+import { useContext } from 'react'
+
+export default function useEager(entity, id = null, relations = []) {
+  const { eager } = useContext(JasonContext)
+
+  return eager(entity, id, relations)
+}
+

data/client/src/useJason.test.ts

@@ -5,7 +5,10 @@ import restClient from './restClient'
 jest.mock('./restClient')
 
 test('it works', async () => {
-  const resp = { data: { post: {} } };
+  const resp = { data: {
+    schema: { post: {} },
+    transportService: 'action_cable'
+  } };
   // @ts-ignore
   restClient.get.mockResolvedValue(resp);
 
@@ -45,7 +48,10 @@ test('it works', async () => {
 })
 
 test('pruning IDs', async () => {
-  const resp = { data: { post: {} } };
+  const resp = { data: {
+    schema: { post: {} },
+    transportService: 'action_cable'
+  } };
 
   // @ts-ignore
   restClient.get.mockResolvedValue(resp);

data/client/src/useJason.ts

@@ -5,8 +5,8 @@ import createOptDis from './createOptDis'
 import createServerActionQueue from './createServerActionQueue'
 import restClient from './restClient'
 import pruneIdsMiddleware from './pruneIdsMiddleware'
+import createTransportAdapater from './createTransportAdapter'
 
-import { createConsumer } from "@rails/actioncable"
 import { createEntityAdapter, createSlice, createReducer, configureStore } from '@reduxjs/toolkit'
 
 import makeEager from './makeEager'
@@ -18,17 +18,17 @@ import React, { useState, useEffect } from 'react'
 export default function useJason({ reducers, middleware = [], extraActions }: { reducers?: any, middleware?: any[], extraActions?: any }) {
   const [store, setStore] = useState(null as any)
   const [value, setValue] = useState(null as any)
-  const [connected, setConnected] = useState(false)
 
   useEffect(() => {
-    restClient.get('/jason/api/schema')
-    .then(({ data: snakey_schema }) => {
+    restClient.get('/jason/api/config')
+    .then(({ data: jasonConfig }) => {
+      const { schema: snakey_schema } = jasonConfig
       const schema = camelizeKeys(snakey_schema)
       console.debug({ schema })
 
       const serverActionQueue = createServerActionQueue()
 
-      const consumer = createConsumer()
+
       const allReducers = {
         ...reducers,
         ...createJasonReducers(schema)
@@ -45,65 +45,60 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
 
       let payloadHandlers = {}
       let configs = {}
+      let subOptions = {}
 
       function handlePayload(payload) {
         const { md5Hash } = payload
 
-        const handler = payloadHandlers[md5Hash]
-        if (handler) {
-          handler(payload)
+        const { handlePayload } = payloadHandlers[md5Hash]
+        if (handlePayload) {
+          handlePayload(payload)
         } else {
           console.warn("Payload arrived with no handler", payload, payloadHandlers)
         }
       }
 
-      const subscription = (consumer.subscriptions.create({
-        channel: 'Jason::Channel'
-      }, {
-        connected: () => {
-          setConnected(true)
-          dispatch({ type: 'jason/upsert', payload: { connected: true } })
-          console.debug('Connected to ActionCable')
-
-          // When AC loses connection - all state is lost, so we need to re-initialize all subscriptions
-          _.values(configs).forEach(config => createSubscription(config))
-        },
-        received: payload => {
-          handlePayload(payload)
-          console.debug("ActionCable Payload received: ", payload)
-        },
-        disconnected: () => {
-          setConnected(false)
-          dispatch({ type: 'jason/upsert', payload: { connected: false } })
-          console.warn('Disconnected from ActionCable')
-        }
-      }));
+      const transportAdapter = createTransportAdapater(jasonConfig, handlePayload, dispatch, () => _.keys(configs).forEach(md5Hash => createSubscription(configs[md5Hash], subOptions[md5Hash])))
 
-      function createSubscription(config) {
+      function createSubscription(config, options = {}) {
         // We need the hash to be consistent in Ruby / Javascript
         const hashableConfig = _({ conditions: {}, includes: {}, ...config }).toPairs().sortBy(0).fromPairs().value()
         const md5Hash = md5(JSON.stringify(hashableConfig))
-        payloadHandlers[md5Hash] = createPayloadHandler({ dispatch, serverActionQueue, subscription, config })
+        payloadHandlers[md5Hash] = createPayloadHandler({ dispatch, serverActionQueue, transportAdapter, config })
         configs[md5Hash] = hashableConfig
+        subOptions[md5Hash] = options
+
+        setTimeout(() => transportAdapter.createSubscription(hashableConfig), 500)
+        let pollInterval = null as any;
 
-        setTimeout(() => subscription.send({ createSubscription: hashableConfig }), 500)
+        // This is only for debugging / dev - not prod!
+        // @ts-ignore
+        if (options.pollInterval) {
+          // @ts-ignore
+          pollInterval = setInterval(() => transportAdapter.getPayload(hashableConfig, { forceRefresh: true }), options.pollInterval)
+        }
 
         return {
-          remove: () => removeSubscription(hashableConfig),
+          remove() {
+            removeSubscription(hashableConfig)
+            if (pollInterval) clearInterval(pollInterval)
+          },
           md5Hash
         }
       }
 
       function removeSubscription(config) {
-        subscription.send({ removeSubscription: config })
+        transportAdapter.removeSubscription(config)
         const md5Hash = md5(JSON.stringify(config))
+        payloadHandlers[md5Hash].tearDown()
         delete payloadHandlers[md5Hash]
         delete configs[md5Hash]
+        delete subOptions[md5Hash]
       }
 
       setValue({
         actions: actions,
-        subscribe: config => createSubscription(config),
+        subscribe: createSubscription,
         eager,
         handlePayload
       })
@@ -111,5 +106,5 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
     })
   }, [])
 
-  return [store, value, connected]
+  return [store, value]
 }

data/client/src/useSub.ts

@@ -1,11 +1,13 @@
 import JasonContext from './JasonContext'
 import { useContext, useEffect } from 'react'
 
-export default function useSub(config) {
+export default function useSub(config, options = {}) {
+  // useEffect uses strict equality
+  const configJson = JSON.stringify(config)
   const subscribe = useContext(JasonContext).subscribe
 
   useEffect(() => {
     // @ts-ignore
-    return subscribe(config)
-  }, [])
+    return subscribe(config, options).remove
+  }, [configJson])
 }

data/client/yarn.lock

@@ -3645,6 +3645,13 @@ punycode@^2.1.0, punycode@^2.1.1:
   resolved "https://registry.yarnpkg.com/punycode/-/punycode-2.1.1.tgz#b58b010ac40c22c5657616c8d2c2c02c7bf479ec"
   integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==
 
+pusher-js@^7.0.3:
+  version "7.0.3"
+  resolved "https://registry.yarnpkg.com/pusher-js/-/pusher-js-7.0.3.tgz#f81c78cdf2ad32f546caa7532ec7f9081ef00b8d"
+  integrity sha512-HIfCvt00CAqgO4W0BrdpPsDcAwy51rB6DN0VMC+JeVRRbo8mn3XTeUeIFjmmlRLZLX8rPhUtLRo7vPag6b8GCw==
+  dependencies:
+    tweetnacl "^1.0.3"
+
 qs@~6.5.2:
   version "6.5.2"
   resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36"
@@ -4358,6 +4365,11 @@ tweetnacl@^0.14.3, tweetnacl@~0.14.0:
   resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64"
   integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=
 
+tweetnacl@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-1.0.3.tgz#ac0af71680458d8a6378d0d0d050ab1407d35596"
+  integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==
+
 type-check@~0.3.2:
   version "0.3.2"
   resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72"

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/lib/jason.rb

@@ -7,22 +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'
 
-   self.mattr_accessor :schema
-   self.schema = {}
-   # add default values of more config vars here
+  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
 
-   # this function maps the vars from your app into your engine
-   def self.setup(&block)
-      yield self
-   end
+    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