jason-rails 0.6.7 → 0.7.3

data/client/lib/createThenable.d.ts

@@ -0,0 +1 @@
+export default function createThenable(): void;

data/client/lib/createThenable.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function createThenable() {
+}
+exports.default = createThenable;

data/client/lib/index.d.ts

@@ -2,9 +2,15 @@
 import _useAct from './useAct';
 import _useSub from './useSub';
 import _useEager from './useEager';
-export declare const JasonProvider: ({ reducers, middleware, extraActions, children }: {
+export declare const JasonContext: import("react").Context<{
+    actions: any;
+    subscribe: null;
+    eager: (entity: any, id: any, relations: any) => void;
+}>;
+export declare const JasonProvider: ({ reducers, middleware, enhancers, extraActions, children }: {
     reducers?: any;
     middleware?: any;
+    enhancers?: any;
     extraActions?: any;
     children?: import("react").FC<{}> | undefined;
 }) => JSX.Element;

data/client/lib/index.js

@@ -3,11 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useEager = exports.useSub = exports.useAct = exports.JasonProvider = void 0;
+exports.useEager = exports.useSub = exports.useAct = exports.JasonProvider = exports.JasonContext = void 0;
+const JasonContext_1 = __importDefault(require("./JasonContext"));
 const JasonProvider_1 = __importDefault(require("./JasonProvider"));
 const useAct_1 = __importDefault(require("./useAct"));
 const useSub_1 = __importDefault(require("./useSub"));
 const useEager_1 = __importDefault(require("./useEager"));
+exports.JasonContext = JasonContext_1.default;
 exports.JasonProvider = JasonProvider_1.default;
 exports.useAct = useAct_1.default;
 exports.useSub = useSub_1.default;

data/client/lib/transportAdapters/actionCableAdapter.js

@@ -1,7 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const actioncable_1 = require("@rails/actioncable");
+const restClient_1 = __importDefault(require("../restClient"));
+const uuid_1 = require("uuid");
+const lodash_1 = __importDefault(require("lodash"));
 function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
+    const consumerId = uuid_1.v4();
     const consumer = actioncable_1.createConsumer();
     const subscription = (consumer.subscriptions.create({
         channel: 'Jason::Channel'
@@ -21,14 +28,27 @@ function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
             console.warn('Disconnected from ActionCable');
         }
     }));
-    function getPayload(config, options) {
-        subscription.send(Object.assign({ getPayload: config }, options));
-    }
     function createSubscription(config) {
         subscription.send({ createSubscription: config });
     }
     function removeSubscription(config) {
-        subscription.send({ removeSubscription: config });
+        restClient_1.default.post('/jason/api/remove_subscription', { config, consumerId })
+            .catch(e => console.error(e));
+    }
+    function getPayload(config, options) {
+        restClient_1.default.post('/jason/api/get_payload', {
+            config,
+            options
+        })
+            .then(({ data }) => {
+            lodash_1.default.map(data, (payload, modelName) => {
+                handlePayload(payload);
+            });
+        })
+            .catch(e => console.error(e));
+    }
+    function fullChannelName(channelName) {
+        return channelName;
     }
     return { getPayload, createSubscription, removeSubscription };
 }

data/client/lib/transportAdapters/pusherAdapter.js

@@ -8,7 +8,7 @@ const restClient_1 = __importDefault(require("../restClient"));
 const uuid_1 = require("uuid");
 const lodash_1 = __importDefault(require("lodash"));
 function pusherAdapter(jasonConfig, handlePayload, dispatch) {
-    let consumerId = uuid_1.v4();
+    const consumerId = uuid_1.v4();
     const { pusherKey, pusherRegion, pusherChannelPrefix } = jasonConfig;
     const pusher = new pusher_js_1.default(pusherKey, {
         cluster: 'eu',

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.d.ts

@@ -1,5 +1,6 @@
-export default function useJason({ reducers, middleware, extraActions }: {
+export default function useJason({ reducers, middleware, enhancers, extraActions }: {
     reducers?: any;
     middleware?: any[];
+    enhancers?: any[];
     extraActions?: any;
 }): any[];

data/client/lib/useJason.js

@@ -12,12 +12,11 @@ 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"));
 const react_1 = require("react");
-function useJason({ reducers, middleware = [], extraActions }) {
+function useJason({ reducers, middleware = [], enhancers = [], extraActions }) {
     const [store, setStore] = react_1.useState(null);
     const [value, setValue] = react_1.useState(null);
     react_1.useEffect(() => {
@@ -29,11 +28,10 @@ function useJason({ reducers, middleware = [], extraActions }) {
             const serverActionQueue = createServerActionQueue_1.default();
             const allReducers = Object.assign(Object.assign({}, reducers), createJasonReducers_1.default(schema));
             console.debug({ allReducers });
-            const store = toolkit_1.configureStore({ reducer: allReducers, middleware: [...middleware, pruneIdsMiddleware_1.default(schema)] });
+            const store = toolkit_1.configureStore({ reducer: allReducers, middleware: [...middleware, pruneIdsMiddleware_1.default(schema)], enhancers });
             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 = {};
@@ -73,9 +71,10 @@ function useJason({ reducers, middleware = [], extraActions }) {
                 };
             }
             function removeSubscription(config) {
+                var _a;
                 transportAdapter.removeSubscription(config);
                 const md5Hash = blueimp_md5_1.default(JSON.stringify(config));
-                payloadHandlers[md5Hash].tearDown();
+                (_a = payloadHandlers[md5Hash]) === null || _a === void 0 ? void 0 : _a.tearDown(); // Race condition where component mounts then unmounts quickly
                 delete payloadHandlers[md5Hash];
                 delete configs[md5Hash];
                 delete subOptions[md5Hash];
@@ -83,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.3",
   "module": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "scripts": {

data/client/src/JasonProvider.tsx

@@ -3,8 +3,8 @@ import useJason from './useJason'
 import { Provider } from 'react-redux'
 import JasonContext from './JasonContext'
 
-const JasonProvider = ({ reducers, middleware, extraActions, children }: { reducers?: any, middleware?: any, extraActions?: any, children?: React.FC }) => {
-  const [store, value] = useJason({ reducers, middleware, extraActions })
+const JasonProvider = ({ reducers, middleware, enhancers, extraActions, children }: { reducers?: any, middleware?: any, enhancers?: any, extraActions?: any, children?: React.FC }) => {
+  const [store, value] = useJason({ reducers, middleware, enhancers, extraActions })
 
   if(!(store && value)) return <div /> // Wait for async fetch of schema to complete
 

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 })
   }