@data-client/core 0.13.1 → 0.14.0

package/dist/index.js

@@ -4,9 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var normalizr = require('@data-client/normalizr');
 
-const RIC = typeof requestIdleCallback === 'function' ? requestIdleCallback : cb => cb();
-var RIC$1 = RIC;
-
 function expireReducer(state, action) {
   const meta = {
     ...state.meta
@@ -26,6 +23,15 @@ function expireReducer(state, action) {
   };
 }
 
+function createMeta(expiryLength, fetchedAt) {
+  const now = Date.now();
+  return {
+    fetchedAt: fetchedAt != null ? fetchedAt : now,
+    date: now,
+    expiresAt: now + expiryLength
+  };
+}
+
 const FETCH_TYPE = 'rdc/fetch';
 const SET_TYPE = 'rdc/set';
 const SET_RESPONSE_TYPE = 'rdc/setresponse';
@@ -53,52 +59,37 @@ var actionTypes = /*#__PURE__*/Object.freeze({
   GC_TYPE: GC_TYPE
 });
 
-function createOptimistic(endpoint, {
-  args,
-  fetchedAt
-}) {
-  var _endpoint$dataExpiryL;
-  const expiryLength = (_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 60000;
+function createOptimistic(endpoint, args, fetchedAt) {
+  var _endpoint$dataExpiryL, _endpoint$dataExpiryL2;
   /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
+  if (process.env.NODE_ENV === 'development' && ((_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 0) < 0) {
     throw new Error('Negative expiry length are not allowed.');
   }
-  const now = Date.now();
-  const meta = {
-    args,
-    fetchedAt,
-    date: now,
-    expiresAt: now + expiryLength,
-    key: endpoint.key(...args)
-  };
-  const action = {
+  return {
     type: OPTIMISTIC_TYPE,
     endpoint,
-    meta
+    args,
+    key: endpoint.key(...args),
+    meta: createMeta((_endpoint$dataExpiryL2 = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL2 : 60000, fetchedAt)
   };
-  return action;
 }
 
 function fetchReducer(state, action) {
-  let setAction;
   if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
-    setAction = createOptimistic(action.endpoint, {
-      args: action.meta.args,
-      fetchedAt: action.meta.createdAt
-    });
+    const setAction = createOptimistic(action.endpoint, action.args, action.meta.fetchedAt);
+    return {
+      ...state,
+      optimistic: [...state.optimistic, setAction]
+    };
   } else {
     // If 'fetch' action reaches the reducer there are no middlewares installed to handle it
     /* istanbul ignore next */
     if (process.env.NODE_ENV !== 'production') {
       console.warn('Fetch appears unhandled - you are likely missing the NetworkManager middleware');
-      console.warn('See https://dataclient.io/docs/guides/redux#indextsx for hooking up redux');
+      console.warn('See https://dataclient.io/docs/guides/redux for hooking up redux');
     }
     return state;
   }
-  return {
-    ...state,
-    optimistic: [...state.optimistic, setAction]
-  };
 }
 
 function invalidateReducer(state, action) {
@@ -119,7 +110,7 @@ function invalidateReducer(state, action) {
     meta[key] = itemMeta;
   };
   if (action.type === INVALIDATE_TYPE) {
-    invalidateKey(action.meta.key);
+    invalidateKey(action.key);
   } else {
     Object.keys(endpoints).forEach(key => {
       if (action.testKey(key)) {
@@ -134,13 +125,21 @@ function invalidateReducer(state, action) {
   };
 }
 
-function setReducer(state, action) {
+function setReducer(state, action, controller) {
+  let value;
+  if (typeof action.value === 'function') {
+    const previousValue = controller.get(action.schema, ...action.args, state);
+    if (previousValue === undefined) return state;
+    value = action.value(previousValue);
+  } else {
+    value = action.value;
+  }
   try {
     const {
       entities,
       indexes,
       entityMeta
-    } = normalizr.normalize(action.value, action.schema, action.meta.args, state.entities, state.indexes, state.entityMeta, action.meta);
+    } = normalizr.normalize(action.schema, value, action.args, state, action.meta);
     return {
       entities,
       indexes,
@@ -165,19 +164,19 @@ class AbortOptimistic extends Error {}
 
 function setResponseReducer(state, action, controller) {
   if (action.error) {
-    return reduceError(state, action, action.payload);
+    return reduceError(state, action, action.response);
   }
   try {
-    var _state$meta$action$me;
-    let payload;
-    // for true set's payload is contained in action
+    var _state$meta$action$ke;
+    let response;
+    // for true set's response is contained in action
     if (action.type === OPTIMISTIC_TYPE) {
       // this should never happen
       /* istanbul ignore if */
       if (!action.endpoint.getOptimisticResponse) return state;
       try {
         // compute optimistic response based on current state
-        payload = action.endpoint.getOptimisticResponse.call(action.endpoint, controller.snapshot(state, action.meta.fetchedAt), ...action.meta.args);
+        response = action.endpoint.getOptimisticResponse.call(action.endpoint, controller.snapshot(state, action.meta.fetchedAt), ...action.args);
       } catch (e) {
         // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
         if (e.constructor === AbortOptimistic) {
@@ -186,21 +185,21 @@ function setResponseReducer(state, action, controller) {
         throw e;
       }
     } else {
-      payload = action.payload;
+      response = action.response;
     }
     const {
       result,
       entities,
       indexes,
       entityMeta
-    } = normalizr.normalize(payload, action.endpoint.schema, action.meta.args, state.entities, state.indexes, state.entityMeta, action.meta);
+    } = normalizr.normalize(action.endpoint.schema, response, action.args, state, action.meta);
     const endpoints = {
       ...state.endpoints,
-      [action.meta.key]: result
+      [action.key]: result
     };
     try {
       if (action.endpoint.update) {
-        const updaters = action.endpoint.update(result, ...action.meta.args);
+        const updaters = action.endpoint.update(result, ...action.args);
         Object.keys(updaters).forEach(key => {
           endpoints[key] = updaters[key](endpoints[key]);
         });
@@ -208,7 +207,7 @@ function setResponseReducer(state, action, controller) {
       // no reason to completely fail because of user-code error
       // integrity of this state update is still guaranteed
     } catch (error) {
-      console.error(`The following error occured during Endpoint.update() for ${action.meta.key}`);
+      console.error(`The following error occured during Endpoint.update() for ${action.key}`);
       console.error(error);
     }
     return {
@@ -218,10 +217,10 @@ function setResponseReducer(state, action, controller) {
       entityMeta,
       meta: {
         ...state.meta,
-        [action.meta.key]: {
+        [action.key]: {
           date: action.meta.date,
           expiresAt: action.meta.expiresAt,
-          prevExpiresAt: (_state$meta$action$me = state.meta[action.meta.key]) == null ? void 0 : _state$meta$action$me.expiresAt
+          prevExpiresAt: (_state$meta$action$ke = state.meta[action.key]) == null ? void 0 : _state$meta$action$ke.expiresAt
         }
       },
       optimistic: filterOptimistic(state, action),
@@ -230,8 +229,8 @@ function setResponseReducer(state, action, controller) {
     // reducer must update the state, so in case of processing errors we simply compute the endpoints inline
   } catch (error) {
     if (typeof error === 'object') {
-      error.message = `Error processing ${action.meta.key}\n\nFull Schema: ${JSON.stringify(action.endpoint.schema, undefined, 2)}\n\nError:\n${error.message}`;
-      if ('payload' in action) error.payload = action.payload;
+      error.message = `Error processing ${action.key}\n\nFull Schema: ${JSON.stringify(action.endpoint.schema, undefined, 2)}\n\nError:\n${error.message}`;
+      if ('response' in action) error.response = action.response;
       error.status = 400;
     }
 
@@ -257,7 +256,7 @@ function reduceError(state, action, error) {
     ...state,
     meta: {
       ...state.meta,
-      [action.meta.key]: {
+      [action.key]: {
         date: action.meta.date,
         error,
         expiresAt: action.meta.expiresAt,
@@ -269,7 +268,7 @@ function reduceError(state, action, error) {
 }
 /** Filter all requests with same serialization that did not start after the resolving request */
 function filterOptimistic(state, resolvingAction) {
-  return state.optimistic.filter(optimisticAction => optimisticAction.meta.key !== resolvingAction.meta.key || (optimisticAction.type === OPTIMISTIC_TYPE ? optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt : optimisticAction.meta.date > resolvingAction.meta.date));
+  return state.optimistic.filter(optimisticAction => optimisticAction.key !== resolvingAction.key || (optimisticAction.type === OPTIMISTIC_TYPE ? optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt : optimisticAction.meta.date > resolvingAction.meta.date));
 }
 
 function createReducer(controller) {
@@ -295,7 +294,7 @@ function createReducer(controller) {
       case SET_RESPONSE_TYPE:
         return setResponseReducer(state, action, controller);
       case SET_TYPE:
-        return setReducer(state, action);
+        return setReducer(state, action, controller);
       case INVALIDATEALL_TYPE:
       case INVALIDATE_TYPE:
         return invalidateReducer(state, action);
@@ -327,69 +326,27 @@ var internal = /*#__PURE__*/Object.freeze({
   __proto__: null,
   MemoCache: normalizr.MemoCache,
   INVALID: normalizr.INVALID,
-  RIC: RIC$1,
   initialState: initialState
 });
 
-function createExpireAll(testKey) {
-  return {
-    type: EXPIREALL_TYPE,
-    testKey
-  };
-}
-
-/**
- * Requesting a fetch to begin
- */
-function createFetch(endpoint, {
+function createSubscription(endpoint, {
   args
 }) {
-  const key = endpoint.key(...args);
-  let resolve = 0;
-  let reject = 0;
-  const promise = new Promise((a, b) => {
-    [resolve, reject] = [a, b];
-  });
-  const meta = {
-    args,
-    key,
-    throttle: !endpoint.sideEffect,
-    resolve,
-    reject,
-    promise,
-    createdAt: Date.now(),
-    nm: false
-  };
   return {
-    type: FETCH_TYPE,
-    payload: () => endpoint(...args),
-    meta,
-    endpoint
+    type: SUBSCRIBE_TYPE,
+    endpoint,
+    args,
+    key: endpoint.key(...args)
   };
 }
-
-function createInvalidate(endpoint, {
+function createUnsubscription(endpoint, {
   args
 }) {
   return {
-    type: INVALIDATE_TYPE,
-    meta: {
-      key: endpoint.key(...args)
-    }
-  };
-}
-
-function createInvalidateAll(testKey) {
-  return {
-    type: INVALIDATEALL_TYPE,
-    testKey
-  };
-}
-
-function createReset() {
-  return {
-    type: RESET_TYPE,
-    date: Date.now()
+    type: UNSUBSCRIBE_TYPE,
+    endpoint,
+    args,
+    key: endpoint.key(...args)
   };
 }
 
@@ -399,87 +356,114 @@ const ensurePojo =
 typeof FormData !== 'undefined' ? body => body instanceof FormData ? Object.fromEntries(body.entries()) : body : /* istanbul ignore next */body => body;
 var ensurePojo$1 = ensurePojo;
 
-function createSet(schema, {
+function createSetResponse(endpoint, {
   args,
   fetchedAt,
-  value
+  response,
+  error = false
 }) {
-  const expiryLength = 60000;
+  var _endpoint$errorExpiry, _endpoint$dataExpiryL;
+  const expiryLength = error ? (_endpoint$errorExpiry = endpoint.errorExpiryLength) != null ? _endpoint$errorExpiry : 1000 : (_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 60000;
   /* istanbul ignore next */
   if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
     throw new Error('Negative expiry length are not allowed.');
   }
-  const now = Date.now();
-  const meta = {
+  return {
+    type: SET_RESPONSE_TYPE,
+    endpoint,
+    response,
     args: args.map(ensurePojo$1),
-    fetchedAt: fetchedAt != null ? fetchedAt : now,
-    date: now,
-    expiresAt: now + expiryLength
+    key: endpoint.key(...args),
+    meta: createMeta(expiryLength, fetchedAt),
+    error
   };
-  const action = {
-    type: SET_TYPE,
-    value,
-    schema,
-    meta
-  };
-  return action;
 }
 
-function createSetResponse(endpoint, {
+function createSet(schema, {
   args,
   fetchedAt,
-  response,
-  error = false
+  value
 }) {
-  var _endpoint$errorExpiry, _endpoint$dataExpiryL;
-  const expiryLength = error ? (_endpoint$errorExpiry = endpoint.errorExpiryLength) != null ? _endpoint$errorExpiry : 1000 : (_endpoint$dataExpiryL = endpoint.dataExpiryLength) != null ? _endpoint$dataExpiryL : 60000;
-  /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
-    throw new Error('Negative expiry length are not allowed.');
-  }
-  const now = Date.now();
-  const meta = {
+  return {
+    type: SET_TYPE,
+    schema,
+    value,
     args: args.map(ensurePojo$1),
-    fetchedAt: fetchedAt != null ? fetchedAt : now,
-    date: now,
-    expiresAt: now + expiryLength,
-    key: endpoint.key(...args)
+    meta: createMeta(60000, fetchedAt)
   };
-  const action = {
-    type: SET_RESPONSE_TYPE,
-    payload: response,
-    endpoint: endpoint,
-    meta
+}
+
+function createReset() {
+  return {
+    type: RESET_TYPE,
+    date: Date.now()
   };
-  if (error) action.error = true;
-  return action;
 }
 
-function createSubscription(endpoint, {
+function createInvalidateAll(testKey) {
+  return {
+    type: INVALIDATEALL_TYPE,
+    testKey
+  };
+}
+
+function createInvalidate(endpoint, {
   args
 }) {
   return {
-    type: SUBSCRIBE_TYPE,
-    endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args)
-    }
+    type: INVALIDATE_TYPE,
+    key: endpoint.key(...args)
   };
 }
-function createUnsubscription(endpoint, {
+
+/**
+ * Requesting a fetch to begin
+ */
+function createFetch(endpoint, {
   args
 }) {
+  let resolve = 0;
+  let reject = 0;
+  const promise = new Promise((a, b) => {
+    [resolve, reject] = [a, b];
+  });
+  const meta = {
+    fetchedAt: Date.now(),
+    resolve,
+    reject,
+    promise
+  };
   return {
-    type: UNSUBSCRIBE_TYPE,
+    type: FETCH_TYPE,
     endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args)
-    }
+    args,
+    key: endpoint.key(...args),
+    meta
+  };
+}
+
+function createExpireAll(testKey) {
+  return {
+    type: EXPIREALL_TYPE,
+    testKey
   };
 }
 
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  createSubscription: createSubscription,
+  createUnsubscription: createUnsubscription,
+  createSetResponse: createSetResponse,
+  createSet: createSet,
+  createReset: createReset,
+  createOptimistic: createOptimistic,
+  createMeta: createMeta,
+  createInvalidateAll: createInvalidateAll,
+  createInvalidate: createInvalidate,
+  createFetch: createFetch,
+  createExpireAll: createExpireAll
+});
+
 function selectMeta(state, fetchKey) {
   return state.meta[fetchKey];
 }
@@ -532,7 +516,7 @@ class Controller {
       });
       this.dispatch(action);
       if (endpoint.schema) {
-        return action.meta.promise.then(input => normalizr.denormalize(input, endpoint.schema, {}, args));
+        return action.meta.promise.then(input => normalizr.denormalize(endpoint.schema, input, {}, args));
       }
       return action.meta.promise;
     };
@@ -573,19 +557,6 @@ class Controller {
      * @see https://dataclient.io/docs/api/Controller#resetEntireStore
      */
     this.resetEntireStore = () => this.dispatch(createReset());
-    /**
-     * Sets value for the Queryable and args.
-     * @see https://dataclient.io/docs/api/Controller#set
-     */
-    this.set = (schema, ...rest) => {
-      const value = rest[rest.length - 1];
-      const action = createSet(schema, {
-        args: rest.slice(0, rest.length - 1),
-        value
-      });
-      // TODO: reject with error if this fails in reducer
-      return this.dispatch(action);
-    };
     /**
      * Sets response for the Endpoint and args.
      * @see https://dataclient.io/docs/api/Controller#setResponse
@@ -612,7 +583,7 @@ class Controller {
       return this.dispatch(action);
     };
     /**
-     * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+     * Resolves an inflight fetch.
      * @see https://dataclient.io/docs/api/Controller#resolve
      */
     this.resolve = (endpoint, meta) => {
@@ -650,6 +621,19 @@ class Controller {
     this.getState = getState;
     this.memo = memo;
   }
+  /**
+   * Sets value for the Queryable and args.
+   * @see https://dataclient.io/docs/api/Controller#set
+   */
+  set(schema, ...rest) {
+    const value = rest[rest.length - 1];
+    const action = createSet(schema, {
+      args: rest.slice(0, rest.length - 1),
+      value
+    });
+    // TODO: reject with error if this fails in reducer
+    return this.dispatch(action);
+  }
   /**
    * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
    * @see https://dataclient.io/docs/api/Controller#getError
@@ -687,7 +671,7 @@ class Controller {
     const shouldQuery = cacheEndpoints === undefined && schema !== undefined;
     const input = shouldQuery ?
     // nothing in endpoints cache, so try querying if we have a schema to do so
-    this.memo.buildQueryKey(key, schema, args, state.entities, state.indexes) : cacheEndpoints;
+    this.memo.buildQueryKey(schema, args, state.entities, state.indexes, key) : cacheEndpoints;
     if (!isActive) {
       // when not active simply return the query input without denormalizing
       return {
@@ -712,7 +696,7 @@ class Controller {
     const {
       data,
       paths
-    } = this.memo.denormalize(input, schema, state.entities, args);
+    } = this.memo.denormalize(schema, input, state.entities, args);
 
     // note: isInvalid can only be true if shouldQuery is true
     if (!expiresAt && isInvalid) expiresAt = 1;
@@ -727,10 +711,7 @@ class Controller {
     const state = rest[rest.length - 1];
     // this is typescript generics breaking
     const args = rest.slice(0, rest.length - 1).map(ensurePojo$1);
-
-    // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
-    const key = JSON.stringify(args);
-    return this.memo.query(key, schema, args, state.entities, state.indexes);
+    return this.memo.query(schema, args, state.entities, state.indexes);
   }
   getSchemaResponse(data, paths, entityMeta, expiresAt, invalidIfStale, meta = {}) {
     const invalidDenormalize = typeof data === 'symbol';
@@ -859,14 +840,14 @@ class NetworkManager {
           case SET_RESPONSE_TYPE:
             // only set after new state is computed
             return next(action).then(() => {
-              if (action.meta.key in this.fetched) {
+              if (action.key in this.fetched) {
                 var _controller$getState$;
                 // Note: meta *must* be set by reducer so this should be safe
-                const error = (_controller$getState$ = controller.getState().meta[action.meta.key]) == null ? void 0 : _controller$getState$.error;
+                const error = (_controller$getState$ = controller.getState().meta[action.key]) == null ? void 0 : _controller$getState$.error;
                 // processing errors result in state meta having error, so we should reject the promise
                 if (error) {
                   this.handleSet(createSetResponse(action.endpoint, {
-                    args: action.meta.args,
+                    args: action.args,
                     response: error,
                     fetchedAt: action.meta.fetchedAt,
                     error: true
@@ -900,7 +881,7 @@ class NetworkManager {
   /** Used by DevtoolsManager to determine whether to log an action */
   skipLogging(action) {
     /* istanbul ignore next */
-    return action.type === FETCH_TYPE && action.meta.key in this.fetched;
+    return action.type === FETCH_TYPE && action.key in this.fetched;
   }
 
   /** On mount */
@@ -944,20 +925,18 @@ class NetworkManager {
    * Will then start a promise for a key and potentially start the network
    * fetch.
    *
-   * Uses throttle only when instructed by action meta. This is valuable
+   * Uses throttle endpoints without sideEffects. This is valuable
    * for ensures mutation requests always go through.
    */
   handleFetch(action) {
-    const fetch = action.payload;
     const {
-      key,
-      throttle,
       resolve,
       reject,
-      createdAt
+      fetchedAt
     } = action.meta;
+    const throttle = !action.endpoint.sideEffect;
     const deferedFetch = () => {
-      let promise = fetch();
+      let promise = action.endpoint(...action.args);
       const resolvePromise = promise => promise.then(data => {
         resolve(data);
         return data;
@@ -971,7 +950,7 @@ class NetworkManager {
       if (!throttle) {
         promise = resolvePromise(promise);
       }
-      promise = promise.then(data => {
+      promise = promise.then(response => {
         let lastReset = this.getLastReset();
 
         /* istanbul ignore else */
@@ -981,22 +960,22 @@ class NetworkManager {
         }
 
         // don't update state with promises started before last clear
-        if (createdAt >= lastReset) {
+        if (fetchedAt >= lastReset) {
           this.controller.resolve(action.endpoint, {
-            args: action.meta.args,
-            response: data,
-            fetchedAt: createdAt
+            args: action.args,
+            response,
+            fetchedAt
           });
         }
-        return data;
+        return response;
       }).catch(error => {
         const lastReset = this.getLastReset();
         // don't update state with promises started before last clear
-        if (createdAt >= lastReset) {
+        if (fetchedAt >= lastReset) {
           this.controller.resolve(action.endpoint, {
-            args: action.meta.args,
+            args: action.args,
             response: error,
-            fetchedAt: createdAt,
+            fetchedAt,
             error: true
           });
         }
@@ -1005,7 +984,7 @@ class NetworkManager {
       return promise;
     };
     if (throttle) {
-      return this.throttle(key, deferedFetch, createdAt).then(data => resolve(data)).catch(error => reject(error));
+      return this.throttle(action.key, deferedFetch, fetchedAt).then(data => resolve(data)).catch(error => reject(error));
     } else {
       return deferedFetch().catch(() => {});
     }
@@ -1017,16 +996,16 @@ class NetworkManager {
    */
   handleSet(action) {
     // this can still turn out to be untrue since this is async
-    if (action.meta.key in this.fetched) {
+    if (action.key in this.fetched) {
       let promiseHandler;
       if (action.error) {
-        promiseHandler = this.rejectors[action.meta.key];
+        promiseHandler = this.rejectors[action.key];
       } else {
-        promiseHandler = this.resolvers[action.meta.key];
+        promiseHandler = this.resolvers[action.key];
       }
-      promiseHandler(action.payload);
+      promiseHandler(action.response);
       // since we're resolved we no longer need to keep track of this promise
-      this.clear(action.meta.key);
+      this.clear(action.key);
     }
   }
 
@@ -1051,7 +1030,7 @@ class NetworkManager {
    * This ensures promises are resolved only once their data is processed
    * by the reducer.
    */
-  throttle(key, fetch, createdAt) {
+  throttle(key, fetch, fetchedAt) {
     const lastReset = this.getLastReset();
     // we're already fetching so reuse the promise
     // fetches after reset do not count
@@ -1062,18 +1041,25 @@ class NetworkManager {
       this.resolvers[key] = resolve;
       this.rejectors[key] = reject;
     });
-    this.fetchedAt[key] = createdAt;
-
-    // since our real promise is resolved via the wrapReducer(),
-    // we should just stop all errors here.
-    // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
-    RIC$1(() => {
+    this.fetchedAt[key] = fetchedAt;
+    this.idleCallback(() => {
+      // since our real promise is resolved via the wrapReducer(),
+      // we should just stop all errors here.
+      // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
       fetch().catch(() => null);
     }, {
       timeout: 500
     });
     return this.fetched[key];
   }
+
+  /** Calls the callback when client is not 'busy' with high priority interaction tasks
+   *
+   * Override for platform-specific implementations
+   */
+  idleCallback(callback, options) {
+    callback();
+  }
 }
 
 function applyManager(managers, controller) {
@@ -1167,8 +1153,8 @@ class PollingSubscription {
     if (action.endpoint.pollFrequency === undefined) throw new Error('frequency needed for polling subscription');
     this.endpoint = action.endpoint;
     this.frequency = action.endpoint.pollFrequency;
-    this.args = action.meta.args;
-    this.key = action.meta.key;
+    this.args = action.args;
+    this.key = action.key;
     this.frequencyHistogram.set(this.frequency, 1);
     this.controller = controller;
     this.connectionListener = connectionListener || new DefaultConnectionListener$1();
@@ -1330,7 +1316,7 @@ class SubscriptionManager {
    *
    */
   handleSubscribe(action) {
-    const key = action.meta.key;
+    const key = action.key;
     if (key in this.subscriptions) {
       const frequency = action.endpoint.pollFrequency;
       this.subscriptions[key].add(frequency);
@@ -1343,7 +1329,7 @@ class SubscriptionManager {
    *
    */
   handleUnsubscribe(action) {
-    const key = action.meta.key;
+    const key = action.key;
 
     /* istanbul ignore else */
     if (key in this.subscriptions) {
@@ -1526,7 +1512,7 @@ class LogoutManager {
     if (shouldLogout) this.shouldLogout = shouldLogout;
     this.middleware = controller => next => async action => {
       await next(action);
-      if (action.type === SET_RESPONSE_TYPE && action.error && this.shouldLogout(action.payload)) {
+      if (action.type === SET_RESPONSE_TYPE && action.error && this.shouldLogout(action.response)) {
         this.handleLogout(controller);
       }
     };
@@ -1564,9 +1550,7 @@ exports.ResetError = ResetError;
 exports.SubscriptionManager = SubscriptionManager;
 exports.__INTERNAL__ = internal;
 exports.actionTypes = actionTypes;
+exports.actions = index;
 exports.applyManager = applyManager;
-exports.createFetch = createFetch;
 exports.createReducer = createReducer;
-exports.createSet = createSet;
-exports.createSetResponse = createSetResponse;
 exports.initialState = initialState;