jason-rails 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2788ecafe67bc475346d83681912063b1081610e06b685405d4f3b332a665695
-  data.tar.gz: 6647cc3a7815a914b98a9477330c32a642fec64c809aa4195fa5c192a4b4b003
+  metadata.gz: a0bfff0c4de046d090ba0c1708fcd4692da2cccc2caf0911d6ae752310a7a8ee
+  data.tar.gz: 8851a0bfdbd521426f3650cbfa44eeea25a4e4bc0bceb8fac3bad7a667563a9c
 SHA512:
-  metadata.gz: cf1b1ed464f9ef46cd5b3aa2dd7e8ebb982a3d6d3ebe68a3f92f2ad8b5ab31ea8476817fd16666346d358e9d5a635b4af792bba16e41105eefb7a789082567f1
-  data.tar.gz: a06afb2c5db05447d7eda5a6f17020a14fd1d486b50f17e14c155738e7166534a52c418f5463742c0956102d744429198ee0101569cef156366586eee3e7c058
+  metadata.gz: 47cc3c7df9c3a4c9fedef6899a3948ba78d44a6a507f830c1f7a50dd920794654777d5a5a3c98f6431d2ef2edef3c1d104222bc06abccc39937f5d55fcd3d33e
+  data.tar.gz: b6305008dd05be63e8fa1dbfa785179129ecf4554877a801dbe44b979906997ce44761d2978ffd7a1129ab1ed4ce44e83e4464ab8566c3fccb9a137516dd48e7

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+## 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
+
+## v0.6.6
+- Fix: don't run the schema change detection and cache rebuild inside rake tasks or migrations
+
+## v0.6.5
+- Added `reset!` and `reset!(hard: true)` methods to `Subscription`. Reset will load the IDs that should be part of the subscription from the database, and ensure that the graph matches those. It then re-broadcasts the payloads to all connected clients. Hard reset will do the same, but also clear all cached IDs and subscription hooks on instances - this is equivalent from starting from scratch.
+- Added `enforce: boolean` option to GraphHelper
+- When subscriptions are re-activated they now set the IDs with `enforce: true`, as there could be conditions where updates that were made while a subscription was not active would not be properly registered.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jason-rails (0.6.0)
+    jason-rails (0.6.8)
       connection_pool (>= 2.2.3)
       jsondiff
       rails (>= 5)
@@ -93,7 +93,7 @@ GEM
     mini_mime (1.0.2)
     mini_portile2 (2.5.0)
     minitest (5.14.3)
-    nio4r (2.5.4)
+    nio4r (2.5.7)
     nokogiri (1.11.1)
       mini_portile2 (~> 2.5.0)
       racc (~> 1.4)
@@ -153,6 +153,10 @@ GEM
       rspec-mocks (~> 3.10)
       rspec-support (~> 3.10)
     rspec-support (3.10.0)
+    sidekiq (6.1.3)
+      connection_pool (>= 2.2.2)
+      rack (~> 2.0)
+      redis (>= 4.2.0)
     sprockets (4.0.2)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
@@ -178,6 +182,7 @@ DEPENDENCIES
   rake (~> 12.0)
   rspec (~> 3.0)
   rspec-rails
+  sidekiq
   sqlite3
 
 BUNDLED WITH

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.
 
@@ -163,23 +163,15 @@ Similarly to authorizing subscriptions, you can do this by providing an class to
 ## Roadmap
 
 Development is primarily driven by the needs of projects we're using Jason in. In no particular order, being considered is:
+- Better detection of when subscriptions drop, delete subscription
 - Failure handling - rolling back local state in case of an error on the server
 - Authorization - more thorough authorization integration, with utility functions for common authorizations. Allowing authorization of access to particular fields such as restricting the fields of a user that are publicly broadcast.
 - 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
-
-## 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).
+- Assess using RedisGraph for the graph diffing functionality, to see if this would provide a performance boost
 
 ## License
 
 The gem is 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/{api_controller.rb → jason_controller.rb}

@@ -1,4 +1,4 @@
-class Jason::ApiController < ::ApplicationController
+class Jason::JasonController < ::ApplicationController
   before_action :load_and_authorize_subscription, only: [:create_subscription, :remove_subscription, :get_payload]
   # config seems to be a reserved name, resulting in infinite loop
   def configuration

data/app/controllers/jason/{api/pusher_controller.rb → pusher_controller.rb}

@@ -1,4 +1,4 @@
- class Jason::Api::PusherController < ApplicationController
+ class Jason::PusherController < ApplicationController
   skip_before_action :verify_authenticity_token
 
   def auth

data/app/workers/jason/outbound_message_queue_worker.rb

@@ -0,0 +1,21 @@
+class Jason::OutboundMessageQueueWorker
+  include Sidekiq::Worker if defined?(Sidekiq) # Even if not using Pusher, this gets autoloaded
+
+  def perform
+    batch = get_batch
+    return if batch.size == 0
+
+    Jason.pusher.trigger_batch(batch)
+  end
+
+  private
+
+  def get_batch
+    batch_json = $redis_jason.multi do |r|
+      r.lrange("jason:outbound_message_queue", 0, 9) # get first 10 elements
+      r.ltrim("jason:outbound_message_queue", 10, -1) # delete first 10 elements
+    end[0]
+
+    batch_json.map { |event| JSON.parse(event).with_indifferent_access } # Pusher wants symbol keys
+  end
+end

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']);
+    });
 });