jason-rails 0.3.0 → 0.6.0

data/client/src/createOptDis.ts

@@ -0,0 +1,45 @@
+import _ from 'lodash'
+import pluralize from 'pluralize'
+import { v4 as uuidv4 } from 'uuid'
+
+function enrich(type, payload) {
+  if (type.split('/')[1] === 'upsert' && !(type.split('/')[0] === 'session')) {
+    if (!payload.id) {
+      return { ...payload, id: uuidv4() }
+    }
+  }
+  return payload
+}
+
+export default function createOptDis(schema, dispatch, restClient, serverActionQueue) {
+  const plurals = _.keys(schema).map(k => pluralize(k))
+
+  function enqueueServerAction (action) {
+    serverActionQueue.addItem(action)
+  }
+
+  function dispatchServerAction() {
+    const action = serverActionQueue.getItem()
+    if (!action) return
+
+    restClient.post('/jason/api/action', action)
+    .then(serverActionQueue.itemProcessed)
+    .catch(e => {
+      dispatch({ type: 'upsertLocalUi', data: { error: JSON.stringify(e) } })
+      serverActionQueue.itemProcessed()
+    })
+  }
+
+  setInterval(dispatchServerAction, 10)
+
+  return function (action) {
+    const { type, payload } = action
+    const data = enrich(type, payload)
+
+    dispatch({ type, payload: data })
+
+    if (plurals.indexOf(type.split('/')[0]) > -1) {
+      enqueueServerAction({ type, payload: data })
+    }
+  }
+}

data/client/src/createPayloadHandler.ts

@@ -1,17 +1,18 @@
 import { apply_patch } from 'jsonpatch'
-import { camelizeKeys } from 'humps'
+import deepCamelizeKeys from './deepCamelizeKeys'
 import pluralize from 'pluralize'
 import _ from 'lodash'
+import { validate as isUuid, v4 as uuidv4 } from 'uuid'
 
 function diffSeconds(dt2, dt1) {
   var diff =(dt2.getTime() - dt1.getTime()) / 1000
   return Math.abs(Math.round(diff))
 }
 
-export default function createPayloadHandler(dispatch, subscription, model, config) {
-  console.log({ model, config })
-  let payload = {}
-  let idx = 0
+export default function createPayloadHandler({ dispatch, serverActionQueue, transportAdapter, config }) {
+  const subscriptionId = uuidv4()
+
+  let idx = {}
   let patchQueue = {}
 
   let lastCheckAt = new Date()
@@ -19,77 +20,87 @@ export default function createPayloadHandler(dispatch, subscription, model, conf
   let checkInterval
 
   function getPayload() {
-    console.log({ getPayload: model, subscription })
-    subscription.send({ getPayload: { model, config } })
+    setTimeout(() => transportAdapter.getPayload(config), 1000)
   }
 
-  const tGetPayload = _.throttle(getPayload, 10000)
-
-  function dispatchPayload() {
-    const includeModels = (config.includeModels || []).map(m => _.camelCase(m))
-
-    console.log("Dispatching", { payload, includeModels })
-
-    includeModels.forEach(m => {
-      const subPayload = _.flatten(_.compact(camelizeKeys(payload).map(instance => instance[m])))
-      console.log({ type: `${pluralize(m)}/upsertMany`, payload: subPayload })
-      dispatch({ type: `${pluralize(m)}/upsertMany`, payload: subPayload })
-    })
-
-    dispatch({ type: `${pluralize(model)}/upsertMany`, payload: camelizeKeys(payload) })
+  function camelizeKeys(item) {
+    return deepCamelizeKeys(item, key => isUuid(key))
   }
 
-  function processQueue() {
-    console.log({ idx, patchQueue })
+  const tGetPayload = _.throttle(getPayload, 10000)
+
+  function processQueue(model) {
+    console.debug("processQueue", model, idx[model], patchQueue[model])
     lastCheckAt = new Date()
-    if (patchQueue[idx]) {
-      payload = apply_patch(payload, patchQueue[idx])
-      if (patchQueue[idx]) {
-        dispatchPayload()
+    if (patchQueue[model][idx[model]]) {
+      if (!serverActionQueue.fullySynced()) {
+        console.debug(serverActionQueue.getData())
+        setTimeout(() => processQueue(model), 100)
+        return
       }
-      delete patchQueue[idx]
-      idx++
+
+      const { payload, destroy, id, type } = patchQueue[model][idx[model]]
+
+      if (type === 'payload') {
+        dispatch({ type: `${pluralize(model)}/upsertMany`, payload })
+        const ids = payload.map(instance => instance.id)
+        dispatch({ type: `jasonModels/setSubscriptionIds`, payload: { model, subscriptionId, ids }})
+      } else if (destroy) {
+        // Middleware will determine if this model should be removed if it isn't in any other subscriptions
+        dispatch({ type: `jasonModels/removeSubscriptionId`, payload: { model, subscriptionId, id }})
+      } else {
+        dispatch({ type: `${pluralize(model)}/upsert`, payload })
+        dispatch({ type: `jasonModels/addSubscriptionId`, payload: { model, subscriptionId, id }})
+      }
+
+      delete patchQueue[model][idx[model]]
+      idx[model]++
       updateDeadline = null
-      processQueue()
+      processQueue(model)
     // If there are updates in the queue that are ahead of the index, some have arrived out of order
     // Set a deadline for new updates before it declares the update missing and refetches.
-    } else if (_.keys(patchQueue).length > 0 && !updateDeadline) {
+    } else if (_.keys(patchQueue[model]).length > 0 && !updateDeadline) {
       var t = new Date()
       t.setSeconds(t.getSeconds() + 3)
       updateDeadline = t
-      setTimeout(processQueue, 3100)
+      setTimeout(() => processQueue(model), 3100)
     // If more than 10 updates in queue, or deadline has passed, restart
-    } else if (_.keys(patchQueue).length > 10 || (updateDeadline && diffSeconds(updateDeadline, new Date()) < 0)) {
+    } else if (_.keys(patchQueue[model]).length > 10 || (updateDeadline && diffSeconds(updateDeadline, new Date()) < 0)) {
       tGetPayload()
       updateDeadline = null
     }
   }
 
   function handlePayload(data) {
-    const { value, idx: newIdx, diff, latency, type } = data
-    console.log({ data })
+    const { idx: newIdx, model: snake_model, type } = data
+    const model = _.camelCase(snake_model)
 
-    if (type === 'payload') {
-      if (!value) return null;
+    idx[model] = idx[model] || 0
+    patchQueue[model] = patchQueue[model] || {}
 
-      payload = value
-      dispatchPayload()
-      idx = newIdx + 1
+    if (type === 'payload') {
+      idx[model] = newIdx
       // Clear any old changes left in the queue
-      patchQueue= _.pick(patchQueue, _.keys(patchQueue).filter(k => k > newIdx + 1))
-      return
+      patchQueue[model] = _.pick(patchQueue[model], _.keys(patchQueue[model]).filter(k => k > newIdx + 1))
     }
 
-    patchQueue[newIdx] = diff
-
-    processQueue()
+    patchQueue[model][newIdx] = camelizeKeys({ ...data, model })
+    console.debug("Added to queue", model, idx[model], camelizeKeys({ ...data, model }), serverActionQueue.getData())
+    processQueue(model)
 
     if (diffSeconds((new Date()), lastCheckAt) >= 3) {
       lastCheckAt = new Date()
-      console.log('Interval lost. Pulling from server')
+      console.debug('Interval lost. Pulling from server')
       tGetPayload()
     }
   }
 
-  return handlePayload
+  tGetPayload()
+
+  // Clean up after ourselves
+  function tearDown() {
+    dispatch({ type: `jasonModels/removeSubscription`, payload: { subscriptionId }})
+  }
+
+  return { handlePayload, tearDown }
 }

data/client/src/createServerActionQueue.test.ts

@@ -0,0 +1,42 @@
+import createServerActionQueue from './createServerActionQueue'
+
+test('Adding items', () => {
+  const serverActionQueue = createServerActionQueue()
+  serverActionQueue.addItem({ type: 'entity/add', payload: { id: 'abc', attribute: 1 } })
+  const item = serverActionQueue.getItem()
+  expect(item).toStrictEqual({ type: 'entity/add', payload: { id: 'abc', attribute: 1 } })
+})
+
+test('Deduping of items that will overwrite each other', () => {
+  const serverActionQueue = createServerActionQueue()
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2 } })
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 3 } })
+
+  const item = serverActionQueue.getItem()
+
+  expect(item).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 3 } })
+})
+
+test('Deduping of items with a superset', () => {
+  const serverActionQueue = createServerActionQueue()
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } })
+
+  const item = serverActionQueue.getItem()
+
+  expect(item).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } })
+})
+
+test("doesn't dedupe items with some attributes missing", () => {
+  const serverActionQueue = createServerActionQueue()
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute2: 'test' } })
+
+  const item = serverActionQueue.getItem()
+  serverActionQueue.itemProcessed()
+  const item2 = serverActionQueue.getItem()
+
+  expect(item).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  expect(item2).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute2: 'test' } })
+})

data/client/src/createServerActionQueue.ts

@@ -0,0 +1,47 @@
+// A FIFO queue with deduping of actions whose effect will be cancelled by later actions
+
+import _ from 'lodash'
+
+export default function createServerActionQueue() {
+  const queue: any[] = []
+  let inFlight = false
+
+  function addItem(item) {
+    // 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
+    if (type.split('/')[1] !== 'upsert') {
+      queue.push(item)
+      return
+    }
+
+    _.remove(queue, item => {
+      const { type: itemType, payload: itemPayload } = item
+      if (type !== itemType) return false
+      if (itemPayload.id !== payload.id) return false
+
+      // Check that all keys of itemPayload are in payload.
+      return _.difference(_.keys(itemPayload),_.keys(payload)).length === 0
+    })
+
+    queue.push(item)
+  }
+
+  return {
+    addItem,
+    getItem: () => {
+      if (inFlight) return false
+
+      const item = queue.shift()
+      if (item) {
+        inFlight = true
+        return item
+      }
+      return false
+    },
+    itemProcessed: () => inFlight = false,
+    fullySynced: () => queue.length === 0 && !inFlight,
+    getData: () => ({ queue, inFlight })
+  }
+}

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/deepCamelizeKeys.test.ts

@@ -0,0 +1,113 @@
+import deepCamelizeKeys from './deepCamelizeKeys'
+
+test('scalar number', () => {
+  expect(deepCamelizeKeys(1)).toBe(1)
+})
+
+test('scalar number float', () => {
+  expect(deepCamelizeKeys(1.123)).toBe(1.123)
+})
+
+test('scalar string', () => {
+  expect(deepCamelizeKeys('test')).toBe('test')
+})
+
+test('scalar null', () => {
+  expect(deepCamelizeKeys(null)).toBe(null)
+})
+
+test('scalar boolean', () => {
+  expect(deepCamelizeKeys(true)).toBe(true)
+})
+
+test('object with existing camelized keys', () => {
+  expect(deepCamelizeKeys({ testMe: 'test' })).toStrictEqual({ testMe: 'test' })
+})
+
+test('array with existing camelized keys', () => {
+  expect(deepCamelizeKeys([{ testMe: 'test' }, { testMe2: 'test' }])).toStrictEqual([{ testMe: 'test' }, { testMe2: 'test' }])
+})
+
+test('object with mixed keys', () => {
+  expect(deepCamelizeKeys({ testMe: 'test', test_2: 'dog', test_me2: true })).toStrictEqual({ testMe: 'test', test2: 'dog', testMe2: true })
+})
+
+test('array with mixed keys', () => {
+  expect(deepCamelizeKeys([
+    { testMe: 'test', test_2: 'dog', test_me2: true },
+    { testMe3: 'test', test_3: 'dog', test_me4: true }
+  ])).toStrictEqual([
+    { testMe: 'test', test2: 'dog', testMe2: true },
+    { testMe3: 'test', test3: 'dog', testMe4: true }
+  ])
+})
+
+test('nested with object at top level', () => {
+  expect(deepCamelizeKeys({
+    test_me: {
+      test_me2: {
+        test_me3: [
+          { test_it_out: '49' },
+          { test_fun: 'what' }
+        ]
+      }
+    }
+  })).toStrictEqual({
+    testMe: {
+      testMe2: {
+        testMe3: [
+          { testItOut: '49' },
+          { testFun: 'what' }
+        ]
+      }
+    }
+  })
+})
+
+test('nested with object at top level', () => {
+  expect(deepCamelizeKeys([{
+    test_me: {
+      test_me2: {
+        test_me3: [
+          { test_it_out: '49' },
+          { test_fun: 'what' }
+        ]
+      }
+    }
+  }, {
+    test_it52: 'what?'
+  }])).toStrictEqual([{
+    testMe: {
+      testMe2: {
+        testMe3: [
+          { testItOut: '49' },
+          { testFun: 'what' }
+        ]
+      }
+    }
+  }, {
+    testIt52: 'what?'
+  }])
+})
+
+test('excludes keys by function', () => {
+  expect(deepCamelizeKeys({
+    test_me: {
+      test_me2: {
+        test_me3: [
+          { test_it_out: '49' },
+          { test_fun: 'what' }
+        ]
+      }
+    }
+  }, k => (k === 'test_me2'))).toStrictEqual({
+    testMe: {
+      test_me2: {
+        testMe3: [
+          { testItOut: '49' },
+          { testFun: 'what' }
+        ]
+      }
+    }
+  })
+})

data/client/src/deepCamelizeKeys.ts

@@ -0,0 +1,17 @@
+import _ from 'lodash'
+
+export default function deepCamelizeKeys(item, excludeIf = k => false) {
+  function camelizeKey(key) {
+    if (excludeIf(key)) return key
+    return _.camelCase(key)
+  }
+
+  if (_.isArray(item)) {
+    return _.map(item, item => deepCamelizeKeys(item, excludeIf))
+  } else if (_.isObject(item)) {
+    return _.mapValues(_.mapKeys(item, (v, k) => camelizeKey(k)), (v, k) => deepCamelizeKeys(v, excludeIf))
+  } else {
+    return item
+  }
+}
+

data/client/src/pruneIdsMiddleware.ts

@@ -0,0 +1,24 @@
+import _ from 'lodash'
+import pluralize from 'pluralize'
+
+const pruneIdsMiddleware = schema => store => next => action => {
+  const { type, payload } = action
+  const result = next(action)
+
+  const state = store.getState()
+  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
+}
+
+export default pruneIdsMiddleware