jason-rails 0.3.0 → 0.6.0

data/client/lib/createServerActionQueue.d.ts

@@ -0,0 +1,10 @@
+export default function createServerActionQueue(): {
+    addItem: (item: any) => void;
+    getItem: () => any;
+    itemProcessed: () => boolean;
+    fullySynced: () => boolean;
+    getData: () => {
+        queue: any[];
+        inFlight: boolean;
+    };
+};

data/client/lib/createServerActionQueue.js

@@ -0,0 +1,48 @@
+"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 });
+const lodash_1 = __importDefault(require("lodash"));
+function createServerActionQueue() {
+    const queue = [];
+    let inFlight = false;
+    function addItem(item) {
+        // 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;
+        if (type.split('/')[1] !== 'upsert') {
+            queue.push(item);
+            return;
+        }
+        lodash_1.default.remove(queue, item => {
+            const { type: itemType, payload: itemPayload } = item;
+            if (type !== itemType)
+                return false;
+            if (itemPayload.id !== payload.id)
+                return false;
+            // Check that all keys of itemPayload are in payload.
+            return lodash_1.default.difference(lodash_1.default.keys(itemPayload), lodash_1.default.keys(payload)).length === 0;
+        });
+        queue.push(item);
+    }
+    return {
+        addItem,
+        getItem: () => {
+            if (inFlight)
+                return false;
+            const item = queue.shift();
+            if (item) {
+                inFlight = true;
+                return item;
+            }
+            return false;
+        },
+        itemProcessed: () => inFlight = false,
+        fullySynced: () => queue.length === 0 && !inFlight,
+        getData: () => ({ queue, inFlight })
+    };
+}
+exports.default = createServerActionQueue;

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

@@ -0,0 +1 @@
+export default function deepCamelizeKeys(item: any, excludeIf?: (k: any) => boolean): any;

data/client/lib/deepCamelizeKeys.js

@@ -0,0 +1,23 @@
+"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"));
+function deepCamelizeKeys(item, excludeIf = k => false) {
+    function camelizeKey(key) {
+        if (excludeIf(key))
+            return key;
+        return lodash_1.default.camelCase(key);
+    }
+    if (lodash_1.default.isArray(item)) {
+        return lodash_1.default.map(item, item => deepCamelizeKeys(item, excludeIf));
+    }
+    else if (lodash_1.default.isObject(item)) {
+        return lodash_1.default.mapValues(lodash_1.default.mapKeys(item, (v, k) => camelizeKey(k)), (v, k) => deepCamelizeKeys(v, excludeIf));
+    }
+    else {
+        return item;
+    }
+}
+exports.default = deepCamelizeKeys;

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

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

data/client/lib/deepCamelizeKeys.test.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepCamelizeKeys_1 = __importDefault(require("./deepCamelizeKeys"));
+test('scalar number', () => {
+    expect(deepCamelizeKeys_1.default(1)).toBe(1);
+});
+test('scalar number float', () => {
+    expect(deepCamelizeKeys_1.default(1.123)).toBe(1.123);
+});
+test('scalar string', () => {
+    expect(deepCamelizeKeys_1.default('test')).toBe('test');
+});
+test('scalar null', () => {
+    expect(deepCamelizeKeys_1.default(null)).toBe(null);
+});
+test('scalar boolean', () => {
+    expect(deepCamelizeKeys_1.default(true)).toBe(true);
+});
+test('object with existing camelized keys', () => {
+    expect(deepCamelizeKeys_1.default({ testMe: 'test' })).toStrictEqual({ testMe: 'test' });
+});
+test('array with existing camelized keys', () => {
+    expect(deepCamelizeKeys_1.default([{ testMe: 'test' }, { testMe2: 'test' }])).toStrictEqual([{ testMe: 'test' }, { testMe2: 'test' }]);
+});
+test('object with mixed keys', () => {
+    expect(deepCamelizeKeys_1.default({ testMe: 'test', test_2: 'dog', test_me2: true })).toStrictEqual({ testMe: 'test', test2: 'dog', testMe2: true });
+});
+test('array with mixed keys', () => {
+    expect(deepCamelizeKeys_1.default([
+        { testMe: 'test', test_2: 'dog', test_me2: true },
+        { testMe3: 'test', test_3: 'dog', test_me4: true }
+    ])).toStrictEqual([
+        { testMe: 'test', test2: 'dog', testMe2: true },
+        { testMe3: 'test', test3: 'dog', testMe4: true }
+    ]);
+});
+test('nested with object at top level', () => {
+    expect(deepCamelizeKeys_1.default({
+        test_me: {
+            test_me2: {
+                test_me3: [
+                    { test_it_out: '49' },
+                    { test_fun: 'what' }
+                ]
+            }
+        }
+    })).toStrictEqual({
+        testMe: {
+            testMe2: {
+                testMe3: [
+                    { testItOut: '49' },
+                    { testFun: 'what' }
+                ]
+            }
+        }
+    });
+});
+test('nested with object at top level', () => {
+    expect(deepCamelizeKeys_1.default([{
+            test_me: {
+                test_me2: {
+                    test_me3: [
+                        { test_it_out: '49' },
+                        { test_fun: 'what' }
+                    ]
+                }
+            }
+        }, {
+            test_it52: 'what?'
+        }])).toStrictEqual([{
+            testMe: {
+                testMe2: {
+                    testMe3: [
+                        { testItOut: '49' },
+                        { testFun: 'what' }
+                    ]
+                }
+            }
+        }, {
+            testIt52: 'what?'
+        }]);
+});
+test('excludes keys by function', () => {
+    expect(deepCamelizeKeys_1.default({
+        test_me: {
+            test_me2: {
+                test_me3: [
+                    { test_it_out: '49' },
+                    { test_fun: 'what' }
+                ]
+            }
+        }
+    }, k => (k === 'test_me2'))).toStrictEqual({
+        testMe: {
+            test_me2: {
+                testMe3: [
+                    { testItOut: '49' },
+                    { testFun: 'what' }
+                ]
+            }
+        }
+    });
+});

data/client/lib/index.d.ts

@@ -1,10 +1,11 @@
+/// <reference types="react" />
 import _useAct from './useAct';
 import _useSub from './useSub';
 export declare const JasonProvider: ({ reducers, middleware, extraActions, children }: {
-    reducers: any;
-    middleware: any;
-    extraActions: any;
-    children: any;
-}) => any;
+    reducers?: any;
+    middleware?: any;
+    extraActions?: any;
+    children?: import("react").FC<{}> | undefined;
+}) => JSX.Element;
 export declare const useAct: typeof _useAct;
 export declare const useSub: typeof _useSub;

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;