jason-rails 0.4.1 → 0.6.2

data/client/lib/createServerActionQueue.test.d.ts

@@ -0,0 +1 @@
+export {};

data/client/lib/createServerActionQueue.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createServerActionQueue_1 = __importDefault(require("./createServerActionQueue"));
+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 } });
+});
+test('Deduping of items that will overwrite each other', () => {
+    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 } });
+    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 } });
+});
+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' } });
+});
+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();
+    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' } });
+});

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,10 +1,13 @@
+/// <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;
     extraActions?: any;
-    children?: any;
-}) => any;
+    children?: import("react").FC<{}> | undefined;
+}) => 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.d.ts

@@ -0,0 +1,2 @@
+declare const pruneIdsMiddleware: (schema: any) => (store: any) => (next: any) => (action: any) => any;
+export default pruneIdsMiddleware;

data/client/lib/pruneIdsMiddleware.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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, payload } = action;
+    const result = next(action);
+    const state = store.getState();
+    if (type === 'jasonModels/setSubscriptionIds' || type === 'jasonModels/removeSubscriptionIds') {
+        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;
+};
+exports.default = pruneIdsMiddleware;

data/client/lib/restClient.d.ts

@@ -0,0 +1,2 @@
+declare const restClient: any;
+export default restClient;

data/client/lib/restClient.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const axios_case_converter_1 = __importDefault(require("axios-case-converter"));
+const uuid_1 = require("uuid");
+const csrfToken = (_a = document === null || document === void 0 ? void 0 : document.querySelector("meta[name=csrf-token]")) === null || _a === void 0 ? void 0 : _a.content;
+axios_1.default.defaults.headers.common['X-CSRF-Token'] = csrfToken;
+const restClient = axios_case_converter_1.default(axios_1.default.create(), {
+    preservedKeys: (key) => {
+        return uuid_1.validate(key);
+    }
+});
+exports.default = restClient;

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;

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

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

data/client/lib/transportAdapters/pusherAdapter.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pusher_js_1 = __importDefault(require("pusher-js"));
+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 { pusherKey, pusherRegion, pusherChannelPrefix } = jasonConfig;
+    const pusher = new pusher_js_1.default(pusherKey, {
+        cluster: 'eu',
+        forceTLS: true,
+        authEndpoint: '/jason/api/pusher/auth'
+    });
+    pusher.connection.bind('state_change', ({ current }) => {
+        if (current === 'connected') {
+            dispatch({ type: 'jason/upsert', payload: { connected: true } });
+        }
+        else {
+            dispatch({ type: 'jason/upsert', payload: { connected: false } });
+        }
+    });
+    pusher.connection.bind('error', error => {
+        dispatch({ type: 'jason/upsert', payload: { connected: false } });
+    });
+    const configToChannel = {};
+    function createSubscription(config) {
+        restClient_1.default.post('/jason/api/create_subscription', { config, consumerId })
+            .then(({ data: { channelName } }) => {
+            configToChannel[JSON.stringify(config)] = channelName;
+            subscribeToChannel(channelName);
+        })
+            .catch(e => console.error(e));
+    }
+    function removeSubscription(config) {
+        const channelName = configToChannel[JSON.stringify(config)];
+        unsubscribeFromChannel(fullChannelName(channelName));
+        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 subscribeToChannel(channelName) {
+        const channel = pusher.subscribe(fullChannelName(channelName));
+        channel.bind('changed', message => handlePayload(message));
+    }
+    function unsubscribeFromChannel(channelName) {
+        const channel = pusher.unsubscribe(fullChannelName(channelName));
+    }
+    function fullChannelName(channelName) {
+        return `private-${pusherChannelPrefix}-${channelName}`;
+    }
+    return { getPayload, createSubscription, removeSubscription };
+}
+exports.default = pusherAdapter;

data/client/lib/useJason.d.ts

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

data/client/lib/useJason.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const createActions_1 = __importDefault(require("./createActions"));
+const createJasonReducers_1 = __importDefault(require("./createJasonReducers"));
+const createPayloadHandler_1 = __importDefault(require("./createPayloadHandler"));
+const createOptDis_1 = __importDefault(require("./createOptDis"));
+const createServerActionQueue_1 = __importDefault(require("./createServerActionQueue"));
+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 }) {
+    const [store, setStore] = react_1.useState(null);
+    const [value, setValue] = react_1.useState(null);
+    react_1.useEffect(() => {
+        restClient_1.default.get('/jason/api/config')
+            .then(({ data: jasonConfig }) => {
+            const { schema: snakey_schema } = jasonConfig;
+            const schema = humps_1.camelizeKeys(snakey_schema);
+            console.debug({ schema });
+            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 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 = {};
+            function handlePayload(payload) {
+                const { md5Hash } = payload;
+                const { handlePayload } = payloadHandlers[md5Hash];
+                if (handlePayload) {
+                    handlePayload(payload);
+                }
+                else {
+                    console.warn("Payload arrived with no handler", payload, payloadHandlers);
+                }
+            }
+            const transportAdapter = createTransportAdapter_1.default(jasonConfig, handlePayload, dispatch, () => lodash_1.default.keys(configs).forEach(md5Hash => createSubscription(configs[md5Hash], subOptions[md5Hash])));
+            function createSubscription(config, options = {}) {
+                // We need the hash to be consistent in Ruby / Javascript
+                const hashableConfig = lodash_1.default(Object.assign({ conditions: {}, includes: {} }, config)).toPairs().sortBy(0).fromPairs().value();
+                const md5Hash = blueimp_md5_1.default(JSON.stringify(hashableConfig));
+                payloadHandlers[md5Hash] = createPayloadHandler_1.default({ dispatch, serverActionQueue, transportAdapter, config });
+                configs[md5Hash] = hashableConfig;
+                subOptions[md5Hash] = options;
+                setTimeout(() => transportAdapter.createSubscription(hashableConfig), 500);
+                let pollInterval = null;
+                // This is only for debugging / dev - not prod!
+                // @ts-ignore
+                if (options.pollInterval) {
+                    // @ts-ignore
+                    pollInterval = setInterval(() => transportAdapter.getPayload(hashableConfig, { forceRefresh: true }), options.pollInterval);
+                }
+                return {
+                    remove() {
+                        removeSubscription(hashableConfig);
+                        if (pollInterval)
+                            clearInterval(pollInterval);
+                    },
+                    md5Hash
+                };
+            }
+            function removeSubscription(config) {
+                transportAdapter.removeSubscription(config);
+                const md5Hash = blueimp_md5_1.default(JSON.stringify(config));
+                payloadHandlers[md5Hash].tearDown();
+                delete payloadHandlers[md5Hash];
+                delete configs[md5Hash];
+                delete subOptions[md5Hash];
+            }
+            setValue({
+                actions: actions,
+                subscribe: createSubscription,
+                eager,
+                handlePayload
+            });
+            setStore(store);
+        });
+    }, []);
+    return [store, value];
+}
+exports.default = useJason;

data/client/lib/useJason.test.d.ts

@@ -0,0 +1 @@
+export {};

data/client/lib/useJason.test.js

@@ -0,0 +1,85 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_hooks_1 = require("@testing-library/react-hooks");
+const useJason_1 = __importDefault(require("./useJason"));
+const restClient_1 = __importDefault(require("./restClient"));
+jest.mock('./restClient');
+test('it works', () => __awaiter(void 0, void 0, void 0, function* () {
+    const resp = { data: {
+            schema: { post: {} },
+            transportService: 'action_cable'
+        } };
+    // @ts-ignore
+    restClient_1.default.get.mockResolvedValue(resp);
+    const { result, waitForNextUpdate } = react_hooks_1.renderHook(() => useJason_1.default({ reducers: {
+            test: (s, a) => s || {}
+        } }));
+    yield waitForNextUpdate();
+    const [store, value, connected] = result.current;
+    const { handlePayload, subscribe } = value;
+    const subscription = subscribe({ post: {} });
+    handlePayload({
+        type: 'payload',
+        model: 'post',
+        payload: [{ id: 4, name: 'test' }],
+        md5Hash: subscription.md5Hash,
+        idx: 1
+    });
+    handlePayload({
+        id: 4,
+        model: 'post',
+        destroy: true,
+        md5Hash: subscription.md5Hash,
+        idx: 2
+    });
+    handlePayload({
+        id: 5,
+        model: 'post',
+        payload: { id: 5, name: 'test2' },
+        md5Hash: subscription.md5Hash,
+        idx: 3
+    });
+}));
+test('pruning IDs', () => __awaiter(void 0, void 0, void 0, function* () {
+    const resp = { data: {
+            schema: { post: {} },
+            transportService: 'action_cable'
+        } };
+    // @ts-ignore
+    restClient_1.default.get.mockResolvedValue(resp);
+    const { result, waitForNextUpdate } = react_hooks_1.renderHook(() => useJason_1.default({ reducers: {
+            test: (s, a) => s || {}
+        } }));
+    yield waitForNextUpdate();
+    const [store, value, connected] = result.current;
+    const { handlePayload, subscribe } = value;
+    const subscription = subscribe({ post: {} });
+    handlePayload({
+        type: 'payload',
+        model: 'post',
+        payload: [{ id: 4, name: 'test' }],
+        md5Hash: subscription.md5Hash,
+        idx: 1
+    });
+    handlePayload({
+        type: 'payload',
+        model: 'post',
+        payload: [{ id: 5, name: 'test it out' }],
+        md5Hash: subscription.md5Hash,
+        idx: 2
+    });
+    // The ID 4 should have been pruned
+    expect(store.getState().posts.ids).toStrictEqual([5]);
+}));