jason-rails 0.6.8 → 0.7.0

data/client/lib/useDraft.d.ts

@@ -0,0 +1 @@
+export default function useDraft(entity: any, id: any, relations?: never[]): void;

data/client/lib/useDraft.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* Can be called as
+useDraft() => draft object for making updates
+useDraft('entity', id) => returns [draft, object]
+useDraft('entity', id, relations) => returns [draft, objectWithEmbeddedRelations]
+*/
+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)
+}
+exports.default = useDraft;

data/client/lib/useEager.d.ts

@@ -1 +1 @@
-export default function useEager(entity: any, id?: null, relations?: never[]): void;
+export default function useEager(entity: string, id?: string, relations?: any): any;

data/client/lib/useEager.js

@@ -3,10 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const JasonContext_1 = __importDefault(require("./JasonContext"));
-const react_1 = require("react");
-function useEager(entity, id = null, relations = []) {
-    const { eager } = react_1.useContext(JasonContext_1.default);
-    return eager(entity, id, relations);
+const lodash_1 = __importDefault(require("lodash"));
+const react_redux_1 = require("react-redux");
+const addRelations_1 = __importDefault(require("./addRelations"));
+function useEager(entity, id = '', relations = []) {
+    if (id) {
+        return react_redux_1.useSelector(s => addRelations_1.default(s, Object.assign({}, s[entity].entities[String(id)]), entity, relations), lodash_1.default.isEqual);
+    }
+    else {
+        return react_redux_1.useSelector(s => addRelations_1.default(s, lodash_1.default.values(s[entity].entities), entity, relations), lodash_1.default.isEqual);
+    }
 }
 exports.default = useEager;

data/client/lib/useJason.js

@@ -12,7 +12,6 @@ const restClient_1 = __importDefault(require("./restClient"));
 const pruneIdsMiddleware_1 = __importDefault(require("./pruneIdsMiddleware"));
 const createTransportAdapter_1 = __importDefault(require("./createTransportAdapter"));
 const toolkit_1 = require("@reduxjs/toolkit");
-const makeEager_1 = __importDefault(require("./makeEager"));
 const humps_1 = require("humps");
 const blueimp_md5_1 = __importDefault(require("blueimp-md5"));
 const lodash_1 = __importDefault(require("lodash"));
@@ -33,7 +32,6 @@ function useJason({ reducers, middleware = [], extraActions }) {
             const dispatch = store.dispatch;
             const optDis = createOptDis_1.default(schema, dispatch, restClient_1.default, serverActionQueue);
             const actions = createActions_1.default(schema, store, restClient_1.default, optDis, extraActions);
-            const eager = makeEager_1.default(schema);
             let payloadHandlers = {};
             let configs = {};
             let subOptions = {};
@@ -84,7 +82,6 @@ function useJason({ reducers, middleware = [], extraActions }) {
             setValue({
                 actions: actions,
                 subscribe: createSubscription,
-                eager,
                 handlePayload
             });
             setStore(store);

data/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jamesr2323/jason",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {

data/client/src/addRelations.ts

@@ -0,0 +1,33 @@
+import pluralize from 'pluralize'
+import _ from 'lodash'
+
+export default function addRelations(s, objects, objectType, relations, suffix = '') {
+  // first find out relation name
+  if (_.isArray(relations)) {
+    relations.forEach(relation => {
+      objects = addRelations(s, objects, objectType, relation)
+    })
+  } else if (typeof(relations) === 'object') {
+    const relation = Object.keys(relations)[0]
+    const subRelations = relations[relation]
+
+    objects = addRelations(s, objects, objectType, relation)
+    objects[relation] = addRelations(s, objects[relation], pluralize(relation), subRelations)
+    // #
+  } else if (typeof(relations) === 'string') {
+    const relation = relations
+    if (_.isArray(objects)) {
+      objects = objects.map(obj => addRelations(s, obj, objectType, relation))
+    } else if (_.isObject(objects)) {
+      const relatedObjects = _.values(s[pluralize(relation) + suffix].entities)
+
+      if(pluralize.isSingular(relation)) {
+        objects = { ...objects, [relation]: _.find(relatedObjects, { id: objects[relation + 'Id'] }) }
+      } else {
+        objects = { ...objects, [relation]: relatedObjects.filter(e => e[pluralize.singular(objectType) + 'Id'] === objects.id) }
+      }
+    }
+  }
+
+  return objects
+}

data/client/src/createJasonReducers.ts

@@ -3,7 +3,8 @@ import pluralize from 'pluralize'
 import _ from 'lodash'
 
 function generateSlices(models) {
-  const sliceNames = models.map(k => pluralize(k))
+  // create two slices for each model. One to hold the persisted data, and one to hold draft data
+  const sliceNames = models.map(k => pluralize(k)).concat(models.map(k => `${pluralize(k)}Drafts`))
   const adapter = createEntityAdapter()
 
   return _.fromPairs(_.map(sliceNames, name => {
@@ -67,7 +68,8 @@ function generateJasonSlices(models) {
     name: 'jason',
     initialState: {
       connected: false,
-      queueSize: 0
+      queueSize: 0,
+      error: null
     },
     reducers: {
       upsert: (s,a) => ({ ...s, ...a.payload })

data/client/src/createOptDis.ts

@@ -15,18 +15,20 @@ export default function createOptDis(schema, dispatch, restClient, serverActionQ
   const plurals = _.keys(schema).map(k => pluralize(k))
 
   function enqueueServerAction (action) {
-    serverActionQueue.addItem(action)
+    return serverActionQueue.addItem(action)
   }
 
   function dispatchServerAction() {
-    const action = serverActionQueue.getItem()
-    if (!action) return
+    const item = serverActionQueue.getItem()
+    if (!item) return
+
+    const { id, action } = item
 
     restClient.post('/jason/api/action', action)
-    .then(serverActionQueue.itemProcessed)
-    .catch(e => {
-      dispatch({ type: 'upsertLocalUi', data: { error: JSON.stringify(e) } })
-      serverActionQueue.itemProcessed()
+    .then(({ data }) => serverActionQueue.itemProcessed(id, data))
+    .catch(error => {
+      dispatch({ type: 'jason/upsert', payload: { error } })
+      serverActionQueue.itemFailed(id, error)
     })
   }
 
@@ -39,7 +41,7 @@ export default function createOptDis(schema, dispatch, restClient, serverActionQ
     dispatch({ type, payload: data })
 
     if (plurals.indexOf(type.split('/')[0]) > -1) {
-      enqueueServerAction({ type, payload: data })
+      return enqueueServerAction({ type, payload: data })
     }
   }
 }

data/client/src/createServerActionQueue.test.ts

@@ -4,7 +4,7 @@ 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 } })
+  expect(item.action).toStrictEqual({ type: 'entity/add', payload: { id: 'abc', attribute: 1 } })
 })
 
 test('Deduping of items that will overwrite each other', () => {
@@ -15,7 +15,7 @@ test('Deduping of items that will overwrite each other', () => {
 
   const item = serverActionQueue.getItem()
 
-  expect(item).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 3 } })
+  expect(item.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 3 } })
 })
 
 test('Deduping of items with a superset', () => {
@@ -25,7 +25,7 @@ test('Deduping of items with a superset', () => {
 
   const item = serverActionQueue.getItem()
 
-  expect(item).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } })
+  expect(item.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } })
 })
 
 test("doesn't dedupe items with some attributes missing", () => {
@@ -34,9 +34,63 @@ test("doesn't dedupe items with some attributes missing", () => {
   serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute2: 'test' } })
 
   const item = serverActionQueue.getItem()
-  serverActionQueue.itemProcessed()
+  serverActionQueue.itemProcessed(item.id)
   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' } })
+  expect(item.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  expect(item2.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute2: 'test' } })
 })
+
+test("executes success callback", async function() {
+  const serverActionQueue = createServerActionQueue()
+  let cb = ''
+  let data = ''
+
+  // Check it can resolve chained promises
+  const promise = serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  .then(d => data = d)
+  .then(() => cb = 'resolved')
+
+  const item = serverActionQueue.getItem()
+  serverActionQueue.itemProcessed(item.id, 'testdata');
+
+  await promise
+  expect(data).toEqual('testdata')
+  expect(cb).toEqual('resolved')
+})
+
+test("executes error callback", async function() {
+  const serverActionQueue = createServerActionQueue()
+  let cb = ''
+  let error = ''
+
+  // Check it can resolve chained promises
+  const promise = serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  .then(() => cb = 'resolved')
+  .catch(e => error = e)
+
+  const item = serverActionQueue.getItem()
+  serverActionQueue.itemFailed(item.id, 'testerror');
+
+  await promise
+  expect(cb).toEqual('')
+  expect(error).toEqual('testerror')
+})
+
+
+test("merges success callbacks", async function() {
+  const results: any[] = []
+
+  const serverActionQueue = createServerActionQueue()
+  const p1 = serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 1 } })
+  .then(data => results.push(data))
+
+  const p2 = serverActionQueue.addItem({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } })
+  .then(data => results.push(data))
+
+  const item = serverActionQueue.getItem()
+  serverActionQueue.itemProcessed(item.id, 'complete')
+
+  await Promise.all([p1,p2])
+  expect(results).toEqual(['complete', 'complete'])
+})

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/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,7 +9,6 @@ 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'
@@ -41,7 +40,6 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
 
       const optDis = createOptDis(schema, dispatch, restClient, serverActionQueue)
       const actions = createActions(schema, store, restClient, optDis, extraActions)
-      const eager = makeEager(schema)
 
       let payloadHandlers = {}
       let configs = {}
@@ -99,7 +97,6 @@ export default function useJason({ reducers, middleware = [], extraActions }: {
       setValue({
         actions: actions,
         subscribe: createSubscription,
-        eager,
         handlePayload
       })
       setStore(store)