jason-rails 0.6.8 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64f8392cc200b54c7584534cedb35ccbb1675d8c15d1193152e4cbdec558a934
-  data.tar.gz: eb285b6c8660017fda735dee46802b9617f08c121c67ce0e9e68efb448e6765c
+  metadata.gz: b901c6b15b2b4f00d307c0e86811d660a68be05ac8c43f3d48c41412a020b4e8
+  data.tar.gz: 3fbed93cb66f5acffe86a8254f0be3ed67979bf93d72ab8faed77a0ae552fff3
 SHA512:
-  metadata.gz: 7505f22ac0737faa51726c9ba5dbbaeab2b6634583e32e574f8e0c4ffc6ba8de4e14eb78f3184d3d9a961ac153cc396253d95ac225fc2f853ebaa6c805197d0f
-  data.tar.gz: 1f6b1f4472d04876566c0edb050a9890cc42b8a6ac083072de38c7d64f7f5780c9e14c1c16f7443eaf98e9ba2ef3b06f400542582c96d619bc0cb2f6645ce8e4
+  metadata.gz: 6959b8b6e2b97547a9c596d4efe5332339deb240c31c3951eb10e017e54932e529c851303e38bdc347c8ed89b4a209974fe790f3377128b0fb4229d14c490f66
+  data.tar.gz: a9a17d52153d5580efcd2940437b1f5eac249f7611d38a152a4a043ea35803f1de6d2ce9e53ecd0e8dee923efd47df1be3c1b1d73e515095a4356875e25f0438

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## v0.7.3
+- Added: Add JasonContext to exports, for use in scenarios where you need to forward the context into some other React reconciler (e.g. `react-three-fiber`)
+- Fixed: Unneeded `reload` in Publisher resulting in extra database calls
+
+## v0.7.1
+- Added: Authorization for REST endpoints. Previously these just inherited logic from ApplicationController. Pass a `update_authorization_service` option to the Jason initializer to use this.
+
+## v0.7.0
+- Added: New forms of conditional subscription. You can now add conditions on fields other than the primary key.
+E.g.
+```
+useSub({ model: 'post', conditions: { created_at: { type: 'between' value: ['2020-01-01', '2020-02-01'] } })
+useSub({ model: 'post', conditions: { hidden: false } })
+```
+
+- Added: Consistency checker. You can run `Jason::ConsistencyChecker.check_all` to validate all current subscriptions against the contents of the database. If you call `check_all(fix: true)` it will called `reset!(hard: true)` on any subscription whose contents do not match the database.
+
+- Changed: Subscriptions no longer get cleared when consumer count drops to 0. This will be replaced in a future release with a reaping process to clean up inactive subscriptions.
+
+- Changed: ActionCable subscriptions get their initial payload via REST instead of ActionCable, as this seems to deliver snappier results
+
+- Fixed: Small bug in useEager that could throw error if relation wasn't present.
+
+## v0.6.9
+- Added: Optimistic updates now return a promise which can chained to perform actions _after_ an update is persisted to server. (For example, if your component depends on fetching additional data that only exists once your instance is persisted)
+```
+act.posts.add({ name: 'new post' })
+  .then(loadEditPostModal)
+  .catch(e => console.error("Oh no!", e))
+```
+
+## v0.6.8
+- Fix: Objects in 'all' subscription not always being broadcast
+
 ## v0.6.7
 - Fix: Change names of controllers to be less likely to conflict with host app inflections
 - Added: Pusher now pushes asychronously via Sidekiq using the Pusher batch API

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jason-rails (0.6.7)
+    jason-rails (0.7.1)
       connection_pool (>= 2.2.3)
       jsondiff
       rails (>= 5)
@@ -89,8 +89,10 @@ GEM
     marcel (0.3.3)
       mimemagic (~> 0.3.2)
     method_source (1.0.0)
-    mimemagic (0.3.5)
-    mini_mime (1.0.2)
+    mimemagic (0.3.10)
+      nokogiri (~> 1)
+      rake
+    mini_mime (1.1.0)
     mini_portile2 (2.5.0)
     minitest (5.14.3)
     nio4r (2.5.7)

data/README.md

@@ -4,13 +4,13 @@ Jason is still in an experimental phase with a rapidly changing API. It is being
 
 ## The goal
 
-I wanted:
+We wanted:
  - Automatic updates to client state based on database state
  - Persistence to the database without many layers of passing parameters
  - Redux for awesome state management
  - Optimistic updates
 
-I also wanted to avoid writing essentially the same code multiple times in different places to handle common CRUD-like operations. Combine Rails schema definition files, REST endpoints, Redux actions, stores, reducers, handlers for websocket payloads and the translations between them, and it adds up to tons of repetitive boilerplate. Every change to the data schema requires updates in five or six files. This inhibits refactoring and makes mistakes more likely.
+We also wanted to avoid writing essentially the same code multiple times in different places to handle common CRUD-like operations. Combine Rails schema definition files, REST endpoints, Redux actions, stores, reducers, handlers for websocket payloads and the translations between them, and it adds up to tons of repetitive boilerplate. Every change to the data schema requires updates in five or six files. This inhibits refactoring and makes mistakes more likely.
 
 Jason attempts to minimize this repitition by auto-generating API endpoints, redux stores and actions from a single schema definition. Further it adds listeners to ActiveRecord models allowing the redux store to be subscribed to updates from a model or set of models.
 
@@ -52,6 +52,11 @@ Jason.setup do |config|
 end
 ```
 
+Mount the Jason engine in `routes.rb`
+```ruby
+mount Jason::Engine => "/jason"
+```
+
 ### In your frontend code
 
 First you need to wrap your root component in a `JasonProvider`.
@@ -152,13 +157,15 @@ export default function Comment({ id }) {
 
 ## Authorization
 
-By default all models can be subscribed to and updated without authentication or authorization. Probably you want to lock down access.
+By default all models can be subscribed to and updated without authentication or authorization. Probably you want to lock down access. At the moment Jason has no opinion on how to handle authorization, it simply forwards parameters to a service that you provide - so the implementation can be as simple or as complex as you need.
 
 ### Authorizing subscriptions
 You can do this by providing an class to Jason in the initializer under the `subscription_authorization_service` key. This must be a class receiving a message `call` with the parameters `user`, `model`, `conditions`, `sub_models` and return true or false for whether the user is allowed to access a subscription with those parameters. You can decide the implementation details of this to be as simple or complex as your app requires.
 
 ### Authorizing updates
-Similarly to authorizing subscriptions, you can do this by providing an class to Jason in the initializer under the `update_authorization_service` key. This must be a class receiving a message `call` with the parameters `user`, `model`, `instance`, `update`, `remove` and return true or false for whether the user is allowed to access a subscription with those parameters.
+Similarly to authorizing subscriptions, you can do this by providing an class to Jason in the initializer under the `update_authorization_service` key. This must be a class receiving a message `call` with the parameters `user`, `model`, `action`, `instance`, `params`  and return true or false for whether the user is allowed to make this update.
+
+See the specs for some examples of this.
 
 ## Roadmap
 
@@ -169,19 +176,18 @@ Development is primarily driven by the needs of projects we're using Jason in. I
 - Utilities for "Draft editing" - both storing client-side copies of model trees which can be committed or discarded, as well as persisting a shadow copy to the database (to allow resumable editing, or possibly collaborative editing features)
 - Benchmark and migrate if necessary ConnectionPool::Wrapper vs ConnectionPool
 - Assess using RedisGraph for the graph diffing functionality, to see if this would provide a performance boost
+- Improve the Typescript definitions (ie remove the abundant `any` typing currently used)
 
-## Development
-
-
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/jason. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/jason/blob/master/CODE_OF_CONDUCT.md).
+## Publishing a new version
+- Update `version.rb`
+- `gem build`
+- `gem push`
+- `npm version [major/minor/patch]`
+- `npm publish`
+- Push new version to Github
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem, npm package and source code in the git repository are available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## Code of Conduct
 
-Everyone interacting in the Jason project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/jason/blob/master/CODE_OF_CONDUCT.md).

data/app/controllers/jason/jason_controller.rb

@@ -21,14 +21,17 @@ class Jason::JasonController < ::ApplicationController
   def action
     type = params[:type]
     entity = type.split('/')[0].underscore
-    api_model = Jason::ApiModel.new(entity.singularize)
-    model = entity.singularize.camelize.constantize
+    model_name = entity.singularize
+    api_model = Jason::ApiModel.new(model_name)
+    model = model_name.camelize.constantize
     action = type.split('/')[1].underscore
 
     if action == 'move_priority'
       id, priority = params[:payload].values_at(:id, :priority)
 
       instance = model.find(id)
+
+      return head :forbidden if !action_permitted?(model_name, action, instance, params)
       priority_filter = instance.as_json.with_indifferent_access.slice(*api_model.priority_scope)
 
       all_instance_ids = model.send(api_model.scope || :all).where(priority_filter).where.not(id: instance.id).order(:priority).pluck(:id)
@@ -40,10 +43,24 @@ class Jason::JasonController < ::ApplicationController
 
       model.find(all_instance_ids).each(&:force_publish_json)
     elsif action == 'upsert' || action == 'add'
+      id = params[:payload][:id]
       payload = api_model.permit(params)
-      return render json: model.find_or_create_by_id!(payload).as_json(api_model.as_json_config)
+
+      instance = model.find_by(id: id)
+      return head :forbidden if !action_permitted?(model_name, action, instance, params)
+
+      if instance.present?
+        instance.update!(payload)
+      else
+        instance = model.create!(payload)
+      end
+
+      return render json: instance.as_json(api_model.as_json_config)
     elsif action == 'remove'
-      model.find(params[:payload]).destroy!
+      instance = model.find(params[:payload])
+      return head :forbidden if !action_permitted?(model_name, action, instance, params)
+
+      instance.destroy!
     end
 
     return head :ok
@@ -75,4 +92,9 @@ class Jason::JasonController < ::ApplicationController
       return head :forbidden
     end
   end
+
+  def action_permitted?(model_name, action, instance, params)
+    return true if Jason.update_authorization_service.blank?
+    Jason.update_authorization_service.call(current_user, model_name, action, instance, params)
+  end
 end

data/app/workers/jason/outbound_message_queue_worker.rb

@@ -1,5 +1,5 @@
 class Jason::OutboundMessageQueueWorker
-  include Sidekiq::Worker
+  include Sidekiq::Worker if defined?(Sidekiq) # Even if not using Pusher, this gets autoloaded
 
   def perform
     batch = get_batch

data/client/lib/JasonProvider.d.ts

@@ -1,8 +1,10 @@
 import React from 'react';
-declare const JasonProvider: ({ reducers, middleware, extraActions, children }: {
+declare const JasonProvider: ({ reducers, middleware, enhancers, extraActions, transportOptions, children }: {
     reducers?: any;
     middleware?: any;
+    enhancers?: any;
     extraActions?: any;
+    transportOptions?: any;
     children?: React.FC<{}> | undefined;
 }) => JSX.Element;
 export default JasonProvider;

data/client/lib/JasonProvider.js

@@ -7,8 +7,8 @@ const react_1 = __importDefault(require("react"));
 const useJason_1 = __importDefault(require("./useJason"));
 const react_redux_1 = require("react-redux");
 const JasonContext_1 = __importDefault(require("./JasonContext"));
-const JasonProvider = ({ reducers, middleware, extraActions, children }) => {
-    const [store, value] = useJason_1.default({ reducers, middleware, extraActions });
+const JasonProvider = ({ reducers, middleware, enhancers, extraActions, transportOptions = {}, children }) => {
+    const [store, value] = useJason_1.default({ reducers, middleware, enhancers, extraActions, transportOptions });
     if (!(store && value))
         return react_1.default.createElement("div", null); // Wait for async fetch of schema to complete
     return react_1.default.createElement(react_redux_1.Provider, { store: store },

data/client/lib/addRelations.d.ts

@@ -0,0 +1 @@
+export default function addRelations(s: any, objects: any, objectType: any, relations: any, suffix?: string): any;

data/client/lib/addRelations.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluralize_1 = __importDefault(require("pluralize"));
+const lodash_1 = __importDefault(require("lodash"));
+function addRelations(s, objects, objectType, relations, suffix = '') {
+    // first find out relation name
+    if (lodash_1.default.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_1.default(relation), subRelations);
+        // #
+    }
+    else if (typeof (relations) === 'string') {
+        const relation = relations;
+        if (lodash_1.default.isArray(objects)) {
+            objects = objects.map(obj => addRelations(s, obj, objectType, relation));
+        }
+        else if (lodash_1.default.isObject(objects)) {
+            const relatedObjects = lodash_1.default.values(s[pluralize_1.default(relation) + suffix].entities);
+            if (pluralize_1.default.isSingular(relation)) {
+                objects = Object.assign(Object.assign({}, objects), { [relation]: lodash_1.default.find(relatedObjects, { id: objects[relation + 'Id'] }) });
+            }
+            else {
+                objects = Object.assign(Object.assign({}, objects), { [relation]: relatedObjects.filter(e => e[pluralize_1.default.singular(objectType) + 'Id'] === objects.id) });
+            }
+        }
+    }
+    return objects;
+}
+exports.default = addRelations;

data/client/lib/createJasonReducers.js

@@ -7,7 +7,8 @@ const toolkit_1 = require("@reduxjs/toolkit");
 const pluralize_1 = __importDefault(require("pluralize"));
 const lodash_1 = __importDefault(require("lodash"));
 function generateSlices(models) {
-    const sliceNames = models.map(k => pluralize_1.default(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_1.default(k)).concat(models.map(k => `${pluralize_1.default(k)}Drafts`));
     const adapter = toolkit_1.createEntityAdapter();
     return lodash_1.default.fromPairs(lodash_1.default.map(sliceNames, name => {
         return [name, toolkit_1.createSlice({
@@ -66,7 +67,8 @@ function generateJasonSlices(models) {
         name: 'jason',
         initialState: {
             connected: false,
-            queueSize: 0
+            queueSize: 0,
+            error: null
         },
         reducers: {
             upsert: (s, a) => (Object.assign(Object.assign({}, s), a.payload))

data/client/lib/createOptDis.d.ts

@@ -1 +1 @@
-export default function createOptDis(schema: any, dispatch: any, restClient: any, serverActionQueue: any): (action: any) => void;
+export default function createOptDis(schema: any, dispatch: any, restClient: any, serverActionQueue: any): (action: any) => any;

data/client/lib/createOptDis.js

@@ -17,17 +17,18 @@ function enrich(type, payload) {
 function createOptDis(schema, dispatch, restClient, serverActionQueue) {
     const plurals = lodash_1.default.keys(schema).map(k => pluralize_1.default(k));
     function enqueueServerAction(action) {
-        serverActionQueue.addItem(action);
+        return serverActionQueue.addItem(action);
     }
     function dispatchServerAction() {
-        const action = serverActionQueue.getItem();
-        if (!action)
+        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);
         });
     }
     setInterval(dispatchServerAction, 10);
@@ -36,7 +37,7 @@ function createOptDis(schema, dispatch, restClient, serverActionQueue) {
         const data = enrich(type, payload);
         dispatch({ type, payload: data });
         if (plurals.indexOf(type.split('/')[0]) > -1) {
-            enqueueServerAction({ type, payload: data });
+            return enqueueServerAction({ type, payload: data });
         }
     };
 }

data/client/lib/createServerActionQueue.d.ts

@@ -1,7 +1,8 @@
 export default function createServerActionQueue(): {
-    addItem: (item: any) => void;
+    addItem: (action: any) => Promise<any>;
     getItem: () => any;
-    itemProcessed: () => boolean;
+    itemProcessed: (id: any, data?: any) => void;
+    itemFailed: (id: any, error?: any) => void;
     fullySynced: () => boolean;
     getData: () => {
         queue: any[];

data/client/lib/createServerActionQueue.js

@@ -1,32 +1,57 @@
 "use strict";
-// A FIFO queue with deduping of actions whose effect will be cancelled by later actions
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// A FIFO queue with deduping of actions whose effect will be cancelled by later actions
+const uuid_1 = require("uuid");
 const lodash_1 = __importDefault(require("lodash"));
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.reject = reject;
+            this.resolve = resolve;
+        });
+    }
+}
 function createServerActionQueue() {
     const queue = [];
+    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 = uuid_1.v4();
+        const dfd = new Deferred();
+        deferreds[id] = [dfd];
+        const item = { id, action };
         if (type.split('/')[1] !== 'upsert') {
             queue.push(item);
-            return;
+            return dfd.promise;
         }
         lodash_1.default.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 lodash_1.default.difference(lodash_1.default.keys(itemPayload), lodash_1.default.keys(payload)).length === 0;
         });
         queue.push(item);
+        return dfd.promise;
+    }
+    function itemProcessed(id, data) {
+        inFlight = false;
+        deferreds[id].forEach(dfd => dfd.resolve(data));
+    }
+    function itemFailed(id, error) {
+        queue.length = 0;
+        deferreds[id].forEach(dfd => dfd.reject(error));
+        inFlight = false;
     }
     return {
         addItem,
@@ -40,7 +65,8 @@ function createServerActionQueue() {
             }
             return false;
         },
-        itemProcessed: () => inFlight = false,
+        itemProcessed,
+        itemFailed,
         fullySynced: () => queue.length === 0 && !inFlight,
         getData: () => ({ queue, inFlight })
     };

data/client/lib/createServerActionQueue.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,7 +17,7 @@ test('Adding items', () => {
     const serverActionQueue = createServerActionQueue_1.default();
     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', () => {
     const serverActionQueue = createServerActionQueue_1.default();
@@ -16,22 +25,68 @@ test('Deduping of items that will overwrite each other', () => {
     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 } });
+    expect(item.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 3 } });
 });
 test('Deduping of items with a superset', () => {
     const serverActionQueue = createServerActionQueue_1.default();
     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' } });
+    expect(item.action).toStrictEqual({ type: 'entity/upsert', payload: { id: 'abc', attribute: 2, attribute2: 'test' } });
 });
 test("doesn't dedupe items with some attributes missing", () => {
     const serverActionQueue = createServerActionQueue_1.default();
     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();
+    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", function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const serverActionQueue = createServerActionQueue_1.default();
+        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');
+        yield promise;
+        expect(data).toEqual('testdata');
+        expect(cb).toEqual('resolved');
+    });
+});
+test("executes error callback", function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const serverActionQueue = createServerActionQueue_1.default();
+        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');
+        yield promise;
+        expect(cb).toEqual('');
+        expect(error).toEqual('testerror');
+    });
+});
+test("merges success callbacks", function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const results = [];
+        const serverActionQueue = createServerActionQueue_1.default();
+        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');
+        yield Promise.all([p1, p2]);
+        expect(results).toEqual(['complete', 'complete']);
+    });
 });