vuex-xhr-state/lib/actions.js

Use Vuex to manage the state of you're ajax calls.

import { GLOBAL_ACTIONS, GLOBAL_NAMESPACE } from './globalXhrState';
import { payloadToKey } from './helpers';
import { ACTION, GET, MUTATIONS } from './keys';
export default (function (alwaysRefetch, method, inValidateGroup) {
    var _a;
    var fetchPromise = null;
    function isPending(store, payload) {
        return store.getters[GET.PENDING](payload);
    }
    function isFetched(store, payload) {
        return store.getters[GET.FETCHED](payload);
    }
    var result = (_a = {},
        _a[ACTION.SEND] = function (store, payload) {
            var methodPromise = runMethod(result.method, store, payload);
            methodPromise = methodPromise.then(function (promResult) {
                inValidateGroup();
                return promResult;
            });
            return methodPromise;
        },
        _a[ACTION.FETCH] = function (store, payload) {
            if (!alwaysRefetch && isPending(store, payload)) {
                if (!fetchPromise) {
                    return getResolvingPromiseFromGetter(store, payload);
                }
                return fetchPromise;
            }
            if (!alwaysRefetch && isFetched(store, payload)) {
                return getResolvingPromiseFromGetter(store, payload);
            }
            fetchPromise = runMethod(result.method, store, payload);
            fetchPromise = fetchPromise.finally(function () {
                fetchPromise = null;
            });
            return fetchPromise;
        },
        _a[ACTION.RESET] = function (store) {
            store.commit(MUTATIONS.RESET);
        },
        _a);
    if (!alwaysRefetch) {
        result[ACTION.FORCE_FETCH] = function (store, payload) {
            return runMethod(result.method, store, payload);
        };
        result[ACTION.INVALIDATE] = function (store, payload) {
            var key = payloadToKey(payload);
            store.commit(MUTATIONS.INVALIDATE, { key: key });
        };
        result[ACTION.INVALIDATE_ALL] = function (store) {
            var payloadKeys = store.getters[GET.PAYLOAD_KEYS]();
            payloadKeys.forEach(function (key) { return store.commit(MUTATIONS.INVALIDATE, { key: key }); });
        };
    }
    result.method = method;
    return result;
    function runMethod(vxsMethod, store, payload) {
        var prom;
        var reply = vxsMethod(payload);
        var key = payloadToKey(payload);
        var uniqueId = Math.random();
        if (reply.then !== undefined) {
            prom = reply;
            prom.then(function (response) {
                mutateReceived(store, key, uniqueId, response);
            }).catch(function (error) {
                var catched = handleError(payload, error);
                mutateFailed(store, key, uniqueId, error, catched);
            });
        }
        else {
            var data = reply;
            prom = getResolvingPromise({
                data: data,
            });
            mutateReceived(store, key, uniqueId, {
                data: data,
            });
        }
        store.commit(MUTATIONS.REQUEST, { key: key });
        store.dispatch(GLOBAL_NAMESPACE + "/" + GLOBAL_ACTIONS.REQUEST, uniqueId, { root: true });
        return prom;
    }
    // tslint:disable-next-line:no-any
    function handleError(payload, error) {
        if (payload !== undefined &&
            payload.errorHandler !== undefined) {
            return payload.errorHandler(error);
        }
        return false;
    }
    function mutateReceived(store, key, uniqueId, response) {
        store.commit(MUTATIONS.RECEIVED, { key: key, response: response });
        store.dispatch(GLOBAL_NAMESPACE + "/" + GLOBAL_ACTIONS.RECEIVED, uniqueId, { root: true });
    }
    function mutateFailed(store, key, uniqueId, response, catched) {
        store.commit(MUTATIONS.FAILED, { key: key, response: response });
        store.dispatch(GLOBAL_NAMESPACE + "/" + GLOBAL_ACTIONS.FAILED, { key: uniqueId, response: response, catched: catched }, { root: true });
    }
    function getResolvingPromiseFromGetter(store, payload) {
        return getResolvingPromise(store.getters[GET.RESPONSE](payload));
    }
    function getResolvingPromise(data) {
        return new Promise(function (resolve) {
            resolve(data);
        });
    }
});