jason-rails 0.5.1 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25daf144fbb017120604c8a458e6eaeeffc705752ae046f9df03aa7b9e0e1f77
-  data.tar.gz: 741129a4872a9d384018f88049ded591989bbfa23f87c6915be317008c278051
+  metadata.gz: 2788ecafe67bc475346d83681912063b1081610e06b685405d4f3b332a665695
+  data.tar.gz: 6647cc3a7815a914b98a9477330c32a642fec64c809aa4195fa5c192a4b4b003
 SHA512:
-  metadata.gz: f09a2f2f7003f4a259dcdbea1edc702f7e21a5797ed8e8bb73684997a8eccc227349d87b3db27d53a9815407408e9051fa7749002b4ab476000b4cded468dda2
-  data.tar.gz: 28a93aa98358bc098921442af5c583eff00b610b2be196365a47233468706dc5e42e4a96ec18aa87bfa339cd12d25c39942708b62ef05a821aa6b9a59898dd4d
+  metadata.gz: cf1b1ed464f9ef46cd5b3aa2dd7e8ebb982a3d6d3ebe68a3f92f2ad8b5ab31ea8476817fd16666346d358e9d5a635b4af792bba16e41105eefb7a789082567f1
+  data.tar.gz: a06afb2c5db05447d7eda5a6f17020a14fd1d486b50f17e14c155738e7166534a52c418f5463742c0956102d744429198ee0101569cef156366586eee3e7c058

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jason-rails (0.4.1)
+    jason-rails (0.6.0)
       connection_pool (>= 2.2.3)
       jsondiff
       rails (>= 5)

data/README.md

@@ -1,6 +1,6 @@
 # Jason
 
-Jason is still in a highly experimental phase with a rapidly changing API. Production use not recommended - but please give it a try!
+Jason is still in an experimental phase with a rapidly changing API. It is being used in some production applications, however it is still in 0.x.x series versions, which means that any 0.x version bump could introduce breaking changes.
 
 ## The goal
 
@@ -14,6 +14,8 @@ I also wanted to avoid writing essentially the same code multiple times in diffe
 
 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.
 
+An alternative way of thinking about Jason is "what if we applied the Flux/Redux state update pattern to make the _database_ the store?".
+
 ## Installation
 
 Add the gem and the NPM package
@@ -54,7 +56,7 @@ end
 
 First you need to wrap your root component in a `JasonProvider`.
 
-```
+```jsx
 import { JasonProvider } from '@jamesr2323/jason'
 
 return <JasonProvider>
@@ -67,7 +69,8 @@ This is a wrapper around `react-redux` Provider component. This accepts the foll
 - `reducers` - An object of reducers that will be included in `configureStore`. Make sure these do not conflict with the names of any of the models you are configuring for use with Jason
 - `extraActions` - Extra actions you want to be available via the `useAct` hook. (See below)
 This must be a function which returns an object which will be merged with the main Jason actions. The function will be passed a dispatch function, store, axios instance and the Jason actions. For example you can add actions for one of your custom slices:
-```
+
+```js
 function extraActions(dispatch, store, restClient, act) {
   return {
     local: {
@@ -80,7 +83,7 @@ function extraActions(dispatch, store, restClient, act) {
 - `middleware` - Passed directly to `configureStore` with additional Jason middleware
 
 ## Usage
-Jason provides two custom hooks to access functionality.
+Jason provides three custom hooks to access functionality.
 
 ### useAct
 This returns an object which allows you to access actions which both update models on the server, and perform an optimistic update to the Redux store.
@@ -109,7 +112,7 @@ export default function PostCreator() {
 This subscribes your Redux store to a model or set of models. It will automatically unsubscribe when the component unmounts.
 
 Example
-```
+```jsx
 import React from 'react'
 import { useSelector } from 'react-redux'
 import { useSub } from '@jamesr2323/jason'
@@ -125,14 +128,45 @@ export default function PostsList() {
 }
 ```
 
+### useEager
+Jason stores all the data in a normalized form - one redux slice per model. Often you might want to get nested data from several slices for use in components. The `useEager` hook provides an API for doing that. Under the hood it's just a wrapper around useSelector, which aims to mimic the behaviour of Rails eager loading.
+
+Example
+This will fetch the comment as well as the post and user linked to it.
+
+```jsx
+import React from 'react'
+import { useSelector } from 'react-redux'
+import { useEager } from '@jamesr2323/jason'
+import _ from 'lodash'
+
+export default function Comment({ id }) {
+  const comment = useEager('comments', id, ['post', 'user'])
+
+  return <div>
+    <p>{ comment.body }</p>
+    <p>Made on post { comment.post.name } by { comment.user.name }</p>
+  </div>
+}
+```
+
+## Authorization
+
+By default all models can be subscribed to and updated without authentication or authorization. Probably you want to lock down access.
+
+### 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.
 
 ## Roadmap
 
 Development is primarily driven by the needs of projects we're using Jason in. In no particular order, being considered is:
 - Failure handling - rolling back local state in case of an error on the server
-- Authorization - integrating with a library like Pundit to determine who can subscribe to given state updates and perform updates on models
+- 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)
-- Integration with pub/sub-as-a-service tools, such as Pusher
+- Benchmark and migrate if necessary ConnectionPool::Wrapper vs ConnectionPool
 
 ## Development
 

data/app/controllers/jason/api/pusher_controller.rb

@@ -0,0 +1,15 @@
+ class Jason::Api::PusherController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def auth
+    channel_main_name = params[:channel_name].remove("private-#{Jason.pusher_channel_prefix}-")
+    subscription_id = channel_main_name.remove('jason-')
+
+    if Jason::Subscription.find_by_id(subscription_id).user_can_access?(current_user)
+      response = Pusher.authenticate(params[:channel_name], params[:socket_id])
+      return render json: response
+    else
+      return head :forbidden
+    end
+  end
+end

data/app/controllers/jason/api_controller.rb

@@ -1,6 +1,21 @@
 class Jason::ApiController < ::ApplicationController
-  def schema
-    render json: Jason.schema
+  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
+    payload = {
+      schema: Jason.schema,
+      transportService: Jason.transport_service,
+    }
+
+    if Jason.transport_service == :pusher
+      payload.merge!({
+        pusherKey: Jason.pusher_key,
+        pusherRegion: Jason.pusher_region,
+        pusherChannelPrefix: Jason.pusher_channel_prefix
+      })
+    end
+
+    render json: payload
   end
 
   def action
@@ -20,10 +35,10 @@ class Jason::ApiController < ::ApplicationController
       all_instance_ids.insert(priority.to_i, instance.id)
 
       all_instance_ids.each_with_index do |id, i|
-        model.find(id).update!(priority: i, skip_publish_json: true)
+        model.find(id).update!(priority: i)
       end
 
-      model.publish_all(model.find(all_instance_ids))
+      model.find(all_instance_ids).each(&:force_publish_json)
     elsif action == 'upsert' || action == 'add'
       payload = api_model.permit(params)
       return render json: model.find_or_create_by_id!(payload).as_json(api_model.as_json_config)
@@ -33,4 +48,31 @@ class Jason::ApiController < ::ApplicationController
 
     return head :ok
   end
+
+  def create_subscription
+    @subscription.add_consumer(params[:consumer_id])
+    render json: { channelName: @subscription.channel }
+  end
+
+  def remove_subscription
+    @subscription.remove_consumer(params[:consumer_id])
+  end
+
+  def get_payload
+    if params[:options].try(:[], :force_refresh)
+      @subscription.set_ids_for_sub_models
+    end
+
+    render json: @subscription.get
+  end
+
+  private
+
+  def load_and_authorize_subscription
+    config = params[:config].to_unsafe_h
+    @subscription = Jason::Subscription.upsert_by_config(config['model'], conditions: config['conditions'], includes: config['includes'])
+    if !@subscription.user_can_access?(current_user)
+      return head :forbidden
+    end
+  end
 end

data/client/lib/JasonContext.d.ts

@@ -2,6 +2,6 @@
 declare const context: import("react").Context<{
     actions: any;
     subscribe: null;
-    eager: null;
+    eager: (entity: any, id: any, relations: any) => void;
 }>;
 export default context;

data/client/lib/JasonContext.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = require("react");
-const context = react_1.createContext({ actions: {}, subscribe: null, eager: null });
+const eager = function (entity, id, relations) {
+    console.error("Eager called but is not implemented");
+};
+const context = react_1.createContext({ actions: {}, subscribe: null, eager });
 exports.default = context;

data/client/lib/JasonProvider.js

@@ -8,7 +8,7 @@ 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, connected] = useJason_1.default({ reducers, middleware, extraActions });
+    const [store, value] = useJason_1.default({ reducers, middleware, extraActions });
     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/createJasonReducers.js

@@ -42,17 +42,23 @@ function generateJasonSlices(models) {
             setSubscriptionIds(s, a) {
                 const { payload } = a;
                 const { subscriptionId, model, ids } = payload;
-                s[model][subscriptionId] = ids;
+                s[model][subscriptionId] = ids.map(id => String(id));
             },
             addSubscriptionId(s, a) {
                 const { payload } = a;
                 const { subscriptionId, model, id } = payload;
-                s[model][subscriptionId] = lodash_1.default.union(s[model][subscriptionId] || [], [id]);
+                s[model][subscriptionId] = lodash_1.default.union(s[model][subscriptionId] || [], [String(id)]);
             },
             removeSubscriptionId(s, a) {
                 const { payload } = a;
                 const { subscriptionId, model, id } = payload;
-                s[model][subscriptionId] = lodash_1.default.remove(s[model][subscriptionId] || [], id);
+                s[model][subscriptionId] = lodash_1.default.difference(s[model][subscriptionId] || [], [String(id)]);
+            },
+            removeSubscription(s, a) {
+                const { payload: { subscriptionId } } = a;
+                lodash_1.default.map(models, model => {
+                    delete s[model][subscriptionId];
+                });
             }
         }
     }).reducer;

data/client/lib/createPayloadHandler.d.ts

@@ -1,6 +1,9 @@
-export default function createPayloadHandler({ dispatch, serverActionQueue, subscription, config }: {
+export default function createPayloadHandler({ dispatch, serverActionQueue, transportAdapter, config }: {
     dispatch: any;
     serverActionQueue: any;
-    subscription: any;
+    transportAdapter: any;
     config: any;
-}): (data: any) => void;
+}): {
+    handlePayload: (data: any) => void;
+    tearDown: () => void;
+};

data/client/lib/createPayloadHandler.js

@@ -11,7 +11,7 @@ function diffSeconds(dt2, dt1) {
     var diff = (dt2.getTime() - dt1.getTime()) / 1000;
     return Math.abs(Math.round(diff));
 }
-function createPayloadHandler({ dispatch, serverActionQueue, subscription, config }) {
+function createPayloadHandler({ dispatch, serverActionQueue, transportAdapter, config }) {
     const subscriptionId = uuid_1.v4();
     let idx = {};
     let patchQueue = {};
@@ -19,7 +19,7 @@ function createPayloadHandler({ dispatch, serverActionQueue, subscription, confi
     let updateDeadline = null;
     let checkInterval;
     function getPayload() {
-        setTimeout(() => subscription.send({ getPayload: config }), 1000);
+        setTimeout(() => transportAdapter.getPayload(config), 1000);
     }
     function camelizeKeys(item) {
         return deepCamelizeKeys_1.default(item, key => uuid_1.validate(key));
@@ -36,16 +36,16 @@ function createPayloadHandler({ dispatch, serverActionQueue, subscription, confi
             }
             const { payload, destroy, id, type } = patchQueue[model][idx[model]];
             if (type === 'payload') {
-                dispatch({ type: `${pluralize_1.default(model)}/upsertMany`, payload });
+                dispatch({ type: `${pluralize_1.default(model)}/upsertMany`, payload: payload.map(m => (Object.assign(Object.assign({}, m), { id: String(m.id) }))) });
                 const ids = payload.map(instance => instance.id);
                 dispatch({ type: `jasonModels/setSubscriptionIds`, payload: { model, subscriptionId, ids } });
             }
             else if (destroy) {
-                dispatch({ type: `${pluralize_1.default(model)}/remove`, payload: id });
+                // 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_1.default(model)}/upsert`, payload });
+                dispatch({ type: `${pluralize_1.default(model)}/upsert`, payload: Object.assign(Object.assign({}, payload), { id: String(payload.id) }) });
                 dispatch({ type: `jasonModels/addSubscriptionId`, payload: { model, subscriptionId, id } });
             }
             delete patchQueue[model][idx[model]];
@@ -87,6 +87,10 @@ function createPayloadHandler({ dispatch, serverActionQueue, subscription, confi
         }
     }
     tGetPayload();
-    return handlePayload;
+    // Clean up after ourselves
+    function tearDown() {
+        dispatch({ type: `jasonModels/removeSubscription`, payload: { subscriptionId } });
+    }
+    return { handlePayload, tearDown };
 }
 exports.default = createPayloadHandler;

data/client/lib/createTransportAdapter.d.ts

@@ -0,0 +1,5 @@
+export default function createTransportAdapter(jasonConfig: any, handlePayload: any, dispatch: any, onConnect: any): {
+    getPayload: (config: any, options: any) => void;
+    createSubscription: (config: any) => void;
+    removeSubscription: (config: any) => void;
+};

data/client/lib/createTransportAdapter.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const actionCableAdapter_1 = __importDefault(require("./transportAdapters/actionCableAdapter"));
+const pusherAdapter_1 = __importDefault(require("./transportAdapters/pusherAdapter"));
+function createTransportAdapter(jasonConfig, handlePayload, dispatch, onConnect) {
+    const { transportService } = jasonConfig;
+    if (transportService === 'action_cable') {
+        return actionCableAdapter_1.default(jasonConfig, handlePayload, dispatch, onConnect);
+    }
+    else if (transportService === 'pusher') {
+        return pusherAdapter_1.default(jasonConfig, handlePayload, dispatch);
+    }
+    else {
+        throw (`Transport adapter does not exist for ${transportService}`);
+    }
+}
+exports.default = createTransportAdapter;

data/client/lib/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 import _useAct from './useAct';
 import _useSub from './useSub';
+import _useEager from './useEager';
 export declare const JasonProvider: ({ reducers, middleware, extraActions, children }: {
     reducers?: any;
     middleware?: any;
@@ -9,3 +10,4 @@ export declare const JasonProvider: ({ reducers, middleware, extraActions, child
 }) => JSX.Element;
 export declare const useAct: typeof _useAct;
 export declare const useSub: typeof _useSub;
+export declare const useEager: typeof _useEager;

data/client/lib/index.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSub = exports.useAct = exports.JasonProvider = void 0;
+exports.useEager = exports.useSub = exports.useAct = exports.JasonProvider = void 0;
 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.JasonProvider = JasonProvider_1.default;
 exports.useAct = useAct_1.default;
 exports.useSub = useSub_1.default;
+exports.useEager = useEager_1.default;

data/client/lib/makeEager.js

@@ -40,10 +40,10 @@ function default_1(schema) {
     }
     function useEager(entity, id = null, relations = []) {
         if (id) {
-            return react_redux_1.useSelector(s => addRelations(s, Object.assign({}, s[entity].entities[String(id)]), entity, relations));
+            return react_redux_1.useSelector(s => addRelations(s, Object.assign({}, s[entity].entities[String(id)]), entity, relations), lodash_1.default.isEqual);
         }
         else {
-            return react_redux_1.useSelector(s => addRelations(s, lodash_1.default.values(s[entity].entities), entity, relations));
+            return react_redux_1.useSelector(s => addRelations(s, lodash_1.default.values(s[entity].entities), entity, relations), lodash_1.default.isEqual);
         }
     }
     return useEager;

data/client/lib/pruneIdsMiddleware.js

@@ -6,20 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const lodash_1 = __importDefault(require("lodash"));
 const pluralize_1 = __importDefault(require("pluralize"));
 const pruneIdsMiddleware = schema => store => next => action => {
-    const { type } = action;
+    const { type, payload } = action;
     const result = next(action);
     const state = store.getState();
-    if (type === 'jasonModels/setSubscriptionIds') {
-        // Check every model
-        lodash_1.default.map(lodash_1.default.keys(schema), model => {
-            let ids = [];
-            lodash_1.default.map(state.jasonModels[model], (subscribedIds, k) => {
-                ids = lodash_1.default.union(ids, subscribedIds);
-            });
-            // Find IDs currently in Redux that aren't in any subscription
-            const idsToRemove = lodash_1.default.difference(state[pluralize_1.default(model)].ids, ids);
-            store.dispatch({ type: `${pluralize_1.default(model)}/removeMany`, payload: idsToRemove });
+    if (type === 'jasonModels/setSubscriptionIds' || type === 'jasonModels/removeSubscriptionId') {
+        const { model, ids } = payload;
+        let idsInSubs = [];
+        lodash_1.default.map(state.jasonModels[model], (subscribedIds, k) => {
+            idsInSubs = lodash_1.default.union(idsInSubs, subscribedIds);
         });
+        // Find IDs currently in Redux that aren't in any subscription
+        const idsToRemove = lodash_1.default.difference(state[pluralize_1.default(model)].ids, idsInSubs);
+        store.dispatch({ type: `${pluralize_1.default(model)}/removeMany`, payload: idsToRemove });
     }
     return result;
 };

data/client/lib/transportAdapters/actionCableAdapter.d.ts

@@ -0,0 +1,5 @@
+export default function actionCableAdapter(jasonConfig: any, handlePayload: any, dispatch: any, onConnected: any): {
+    getPayload: (config: any, options: any) => void;
+    createSubscription: (config: any) => void;
+    removeSubscription: (config: any) => void;
+};

data/client/lib/transportAdapters/actionCableAdapter.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const actioncable_1 = require("@rails/actioncable");
+function actionCableAdapter(jasonConfig, handlePayload, dispatch, onConnected) {
+    const consumer = actioncable_1.createConsumer();
+    const subscription = (consumer.subscriptions.create({
+        channel: 'Jason::Channel'
+    }, {
+        connected: () => {
+            dispatch({ type: 'jason/upsert', payload: { connected: true } });
+            console.debug('Connected to ActionCable');
+            // When AC loses connection - all state is lost, so we need to re-initialize all subscriptions
+            onConnected();
+        },
+        received: payload => {
+            handlePayload(payload);
+            console.debug("ActionCable Payload received: ", payload);
+        },
+        disconnected: () => {
+            dispatch({ type: 'jason/upsert', payload: { connected: false } });
+            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 });
+    }
+    return { getPayload, createSubscription, removeSubscription };
+}
+exports.default = actionCableAdapter;