jason-rails 0.5.1 → 0.6.4

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);
@@ -77,5 +83,45 @@ test('pruning IDs', async () => {
   })
 
   // The ID 4 should have been pruned
-  expect(store.getState().posts.ids).toStrictEqual([5])
+  expect(store.getState().posts.ids).toStrictEqual(['5'])
+})
+
+test('pruning IDs by destroy', async () => {
+  const resp = { data: {
+    schema: { post: {} },
+    transportService: 'action_cable'
+  } };
+
+  // @ts-ignore
+  restClient.get.mockResolvedValue(resp);
+
+  const { result, waitForNextUpdate } = renderHook(() => useJason({ reducers: {
+    test: (s,a) => s || {}
+  }}));
+
+  await waitForNextUpdate()
+  const [store, value, connected] = result.current
+  const { handlePayload, subscribe } = value
+
+  const subscription = subscribe({ post: {} })
+
+  handlePayload({
+    type: 'payload',
+    model: 'post',
+    payload: [{ id: 4, name: 'test' }, { id: 5, name: 'test it out' }],
+    md5Hash: subscription.md5Hash,
+    idx: 1
+  })
+  expect(store.getState().posts.ids).toStrictEqual(['4', '5'])
+
+  handlePayload({
+    destroy: true,
+    model: 'post',
+    id: 5,
+    md5Hash: subscription.md5Hash,
+    idx: 2
+  })
+
+  // The ID 4 should have been pruned
+  expect(store.getState().posts.ids).toStrictEqual(['4'])
 })

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)
@@ -50,54 +50,32 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       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
-          _.keys(configs).forEach(md5Hash => createSubscription(configs[md5Hash], subOptions[md5Hash]))
-        },
-        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, 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(() => subscription.send({ createSubscription: hashableConfig }), 500)
+        setTimeout(() => transportAdapter.createSubscription(hashableConfig), 500)
         let pollInterval = null as any;
 
-        console.log("createSubscription", { config, options })
-
         // This is only for debugging / dev - not prod!
         // @ts-ignore
         if (options.pollInterval) {
           // @ts-ignore
-          pollInterval = setInterval(() => subscription.send({ getPayload: config, forceRefresh: true }), options.pollInterval)
+          pollInterval = setInterval(() => transportAdapter.getPayload(hashableConfig, { forceRefresh: true }), options.pollInterval)
         }
 
         return {
@@ -110,8 +88,9 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       }
 
       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]
@@ -127,5 +106,5 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
     })
   }, [])
 
-  return [store, value, connected]
+  return [store, value]
 }

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

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

@@ -32,6 +32,8 @@ class Jason::Channel < ActionCable::Channel::Base
 
   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)
@@ -52,10 +54,12 @@ class Jason::Channel < ActionCable::Channel::Base
 
   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(enforce: true)
+      subscription.set_ids_for_sub_models
     end
-    subscription.get.each do |payload|
+    subscription.get.each do |model_name, payload|
       transmit(payload) if payload.present?
     end
   end