@data-client/core 0.1.0 → 0.2.1

package/dist/index.js

@@ -8,7 +8,7 @@ const RIC = typeof requestIdleCallback === 'function' ? requestIdleCallback : cb
 var RIC$1 = RIC;
 
 const FETCH_TYPE = 'rest-hooks/fetch';
-// TODO(breaking): deprecate this
+/** @deprecated use SET_TYPE instead */
 const RECEIVE_TYPE = 'rest-hooks/receive';
 const SET_TYPE = RECEIVE_TYPE;
 const OPTIMISTIC_TYPE = 'rest-hooks/optimistic';
@@ -44,19 +44,13 @@ function createOptimistic(endpoint, {
     throw new Error('Negative expiry length are not allowed.');
   }
   const now = Date.now();
-  // TODO: Use correct type once we no longer need backcompat
   const meta = {
     args,
     fetchedAt,
     date: now,
     expiresAt: now + expiryLength,
-    // For legacy support; TODO: remove
-    schema: endpoint.schema,
     key: endpoint.key(...args)
   };
-  // For legacy support; TODO: remove
-  if (endpoint.update) meta.update = endpoint.update;
-  if (endpoint.errorPolicy) meta.errorPolicy = endpoint.errorPolicy;
   const action = {
     type: OPTIMISTIC_TYPE,
     endpoint,
@@ -65,152 +59,12 @@ function createOptimistic(endpoint, {
   return action;
 }
 
-// TODO(breaking): remove file - not used
-/** Requesting a fetch to begin
- *
- * @param fetchShape
- * @param param1 { params, body, throttle, updateParams }
- */
-function createFetch$1(fetchShape, {
-  params,
-  body,
-  throttle,
-  updateParams
-}) {
-  const {
-    schema,
-    type,
-    getFetchKey,
-    options
-  } = fetchShape;
-  const key = getFetchKey(params);
-  let resolve = 0;
-  let reject = 0;
-  const promise = new Promise((a, b) => {
-    [resolve, reject] = [a, b];
-  });
-  const meta = {
-    schema,
-    type,
-    args: [params, body],
-    key,
-    throttle,
-    options,
-    resolve,
-    reject,
-    promise,
-    createdAt: Date.now()
-  };
-  if (fetchShape.update) {
-    meta.update = fetchShape.update;
-  }
-
-  // for simplicity we simply override if updateParams are defined - usage together is silly to support as we are migrating
-  if (updateParams) {
-    meta.update = newresult => {
-      const updateMap = {};
-      updateParams.forEach(([toShape, toParams, updateFn]) => {
-        updateMap[toShape.getFetchKey(toParams)] = existing => updateFn(newresult, existing);
-      });
-      return updateMap;
-    };
-  }
-  if (options != null && options.optimisticUpdate) {
-    meta.optimisticResponse = options.optimisticUpdate(params, body);
-  }
-  return {
-    type: FETCH_TYPE,
-    payload: () => fetchShape.fetch(params, body),
-    meta
-  };
-}
-
-/** Update state with data
- *
- * @param data
- * @param param1 { schema, key, type, updaters, dataExpiryLength }
- */
-function createReceive$1(data, {
-  schema,
-  key,
-  args,
-  updaters,
-  fetchedAt = 0,
-  update,
-  dataExpiryLength
-}) {
-  /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && dataExpiryLength < 0) {
-    throw new Error('Negative dataExpiryLength are not allowed.');
-  }
-  const now = Date.now();
-  const meta = {
-    schema,
-    key,
-    args,
-    date: now,
-    fetchedAt,
-    expiresAt: now + dataExpiryLength
-  };
-  meta.updaters = updaters;
-  meta.update = update;
-  return {
-    type: RECEIVE_TYPE,
-    payload: data,
-    meta
-  };
-}
-
-function createReceiveError(error, {
-  schema,
-  key,
-  options,
-  errorExpiryLength = 60000,
-  fetchedAt = 0
-}) {
-  /* istanbul ignore next */
-  if (process.env.NODE_ENV === 'development' && errorExpiryLength < 0) {
-    throw new Error('Negative errorExpiryLength are not allowed.');
-  }
-  const now = Date.now();
-  return {
-    type: RECEIVE_TYPE,
-    payload: error,
-    meta: {
-      schema,
-      key,
-      date: now,
-      fetchedAt,
-      expiresAt: now + errorExpiryLength,
-      errorPolicy: options == null ? void 0 : options.errorPolicy
-    },
-    error: true
-  };
-}
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  createFetch: createFetch$1,
-  createReceive: createReceive$1,
-  createReceiveError: createReceiveError
-});
-
 function fetchReducer(state, action) {
-  var _action$endpoint;
-  const optimisticResponse = action.meta.optimisticResponse;
-  const getOptimisticResponse = (_action$endpoint = action.endpoint) == null ? void 0 : _action$endpoint.getOptimisticResponse;
   let receiveAction;
-  if (getOptimisticResponse && action.endpoint && action.endpoint.sideEffect) {
+  if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
     receiveAction = createOptimistic(action.endpoint, {
       args: action.meta.args,
-      fetchedAt: typeof action.meta.createdAt !== 'number' ? action.meta.createdAt.getTime() : action.meta.createdAt
-    });
-  } /* istanbul ignore if */else if (optimisticResponse) {
-    // TODO(breaking): this is no longer used, remove this branch
-    /* istanbul ignore next */
-    receiveAction = createReceive$1(optimisticResponse, {
-      ...action.meta,
-      dataExpiryLength: Infinity
+      fetchedAt: action.meta.createdAt
     });
   } else {
     // If 'fetch' action reaches the reducer there are no middlewares installed to handle it
@@ -260,13 +114,6 @@ function invalidateReducer(state, action) {
   };
 }
 
-function applyUpdatersToResults(results, result, updaters) {
-  return {
-    ...results,
-    ...Object.fromEntries(Object.entries(updaters).map(([fetchKey, updater]) => [fetchKey, updater(result, results[fetchKey])]))
-  };
-}
-
 function setReducer(state, action, controller) {
   if (action.error) {
     return reduceError(state, action, action.payload);
@@ -276,12 +123,11 @@ function setReducer(state, action, controller) {
     let payload;
     // for true receives payload is contained in action
     if (action.type === OPTIMISTIC_TYPE) {
+      // this should never happen
       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),
-        // if endpoint exists, so must args; TODO: fix typing
-        ...action.meta.args);
+        payload = action.endpoint.getOptimisticResponse.call(action.endpoint, controller.snapshot(state, action.meta.fetchedAt), ...action.meta.args);
       } catch (e) {
         var _e$constructor;
         // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
@@ -298,20 +144,14 @@ function setReducer(state, action, controller) {
       entities,
       indexes,
       entityMeta
-    } = normalizr.normalize(payload, action.meta.schema, action.meta.args, state.entities, state.indexes, state.entityMeta, {
-      fetchedAt: action.meta.date,
-      ...action.meta
-    });
-    let results = {
+    } = normalizr.normalize(payload, action.endpoint.schema, action.meta.args, state.entities, state.indexes, state.entityMeta, action.meta);
+    const results = {
       ...state.results,
       [action.meta.key]: result
     };
     try {
-      if ('updaters' in action.meta && action.meta.updaters) {
-        results = applyUpdatersToResults(results, result, action.meta.updaters);
-      }
-      if (action.meta.update) {
-        const updaters = action.meta.update(result, ...(action.meta.args || []));
+      if (action.endpoint.update) {
+        const updaters = action.endpoint.update(result, ...action.meta.args);
         Object.keys(updaters).forEach(key => {
           results[key] = updaters[key](results[key]);
         });
@@ -341,7 +181,7 @@ function setReducer(state, action, controller) {
     // reducer must update the state, so in case of processing errors we simply compute the results inline
   } catch (error) {
     if (typeof error === 'object') {
-      error.message = `Error processing ${action.meta.key}\n\nFull Schema: ${JSON.stringify(action.meta.schema, undefined, 2)}\n\nError:\n${error.message}`;
+      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.status = 400;
     }
@@ -372,7 +212,7 @@ function reduceError(state, action, error) {
         date: action.meta.date,
         error,
         expiresAt: action.meta.expiresAt,
-        errorPolicy: action.meta.errorPolicy == null ? void 0 : action.meta.errorPolicy(error)
+        errorPolicy: action.endpoint.errorPolicy == null ? void 0 : action.endpoint.errorPolicy(error)
       }
     },
     optimistic: filterOptimistic(state, action)
@@ -385,7 +225,6 @@ function filterOptimistic(state, resolvingAction) {
 
 function createReducer(controller) {
   return function reducer(state, action) {
-    var _action$date;
     if (!state) state = initialState;
     switch (action.type) {
       case GC_TYPE:
@@ -410,12 +249,9 @@ function createReducer(controller) {
       case INVALIDATE_TYPE:
         return invalidateReducer(state, action);
       case RESET_TYPE:
-        if (process.env.NODE_ENV !== 'production' && action.date === undefined) {
-          console.warn(`${RESET_TYPE} sent without 'date' member. This is deprecated. Please use createReset() action creator to ensure correct action shape.`);
-        }
         return {
           ...initialState,
-          lastReset: (_action$date = action.date) != null ? _action$date : Date.now()
+          lastReset: action.date
         };
       default:
         // A reducer must always return a valid state.
@@ -438,10 +274,41 @@ var internal = /*#__PURE__*/Object.freeze({
   __proto__: null,
   inferResults: normalizr.inferResults,
   DELETED: normalizr.DELETED,
+  INVALID: normalizr.INVALID,
   RIC: RIC$1,
   initialState: initialState
 });
 
+/**
+ * Requesting a fetch to begin
+ */
+function createFetch(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
+  };
+}
+
 function createInvalidate(endpoint, {
   args
 }) {
@@ -460,7 +327,14 @@ function createInvalidateAll(testKey) {
   };
 }
 
-function createReceive(endpoint, {
+function createReset() {
+  return {
+    type: RESET_TYPE,
+    date: Date.now()
+  };
+}
+
+function createSet(endpoint, {
   args,
   fetchedAt,
   response,
@@ -478,13 +352,8 @@ function createReceive(endpoint, {
     fetchedAt: fetchedAt != null ? fetchedAt : now,
     date: now,
     expiresAt: now + expiryLength,
-    // For legacy support; TODO: remove
-    schema: endpoint.schema,
     key: endpoint.key(...args)
   };
-  // For legacy support; TODO: remove
-  if (endpoint.update) meta.update = endpoint.update;
-  if (endpoint.errorPolicy) meta.errorPolicy = endpoint.errorPolicy;
   const action = {
     type: SET_TYPE,
     payload: response,
@@ -495,13 +364,6 @@ function createReceive(endpoint, {
   return action;
 }
 
-function createReset() {
-  return {
-    type: RESET_TYPE,
-    date: Date.now()
-  };
-}
-
 function createSubscription(endpoint, {
   args
 }) {
@@ -510,10 +372,7 @@ function createSubscription(endpoint, {
     endpoint,
     meta: {
       args,
-      key: endpoint.key(...args),
-      fetch: () => endpoint(...args),
-      schema: endpoint.schema,
-      options: endpoint
+      key: endpoint.key(...args)
     }
   };
 }
@@ -525,8 +384,7 @@ function createUnsubscription(endpoint, {
     endpoint,
     meta: {
       args,
-      key: endpoint.key(...args),
-      options: endpoint
+      key: endpoint.key(...args)
     }
   };
 }
@@ -548,7 +406,7 @@ const unsetState = () => {
  * Imperative control of Rest Hooks store
  * @see https://resthooks.io/docs/api/Controller
  */
-class Controller$1 {
+class Controller {
   /**
    * Dispatches an action to Rest Hooks reducer.
    *
@@ -572,6 +430,20 @@ class Controller$1 {
     }
   } = {}) {
     /*************** Action Dispatchers ***************/
+    /**
+     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
+     * @see https://resthooks.io/docs/api/Controller#fetch
+     */
+    this.fetch = (endpoint, ...args) => {
+      const action = createFetch(endpoint, {
+        args
+      });
+      this.dispatch(action);
+      if (endpoint.schema) {
+        return action.meta.promise.then(input => normalizr.denormalize(input, endpoint.schema, {}, args));
+      }
+      return action.meta.promise;
+    };
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
      * @see https://resthooks.io/docs/api/Controller#invalidate
@@ -595,16 +467,14 @@ class Controller$1 {
      */
     this.setResponse = (endpoint, ...rest) => {
       const response = rest[rest.length - 1];
-      const action = createReceive(endpoint, {
+      const action = createSet(endpoint, {
         args: rest.slice(0, rest.length - 1),
         response
       });
       return this.dispatch(action);
     };
-    // TODO: deprecate
     /**
-     * Another name for setResponse
-     * @see https://resthooks.io/docs/api/Controller#setResponse
+     * @deprecated use https://resthooks.io/docs/api/Controller#setResponse instead
      */
     /* istanbul ignore next */
     this.receive = (endpoint, ...rest) => {
@@ -617,17 +487,16 @@ class Controller$1 {
      */
     this.setError = (endpoint, ...rest) => {
       const response = rest[rest.length - 1];
-      const action = createReceive(endpoint, {
+      const action = createSet(endpoint, {
         args: rest.slice(0, rest.length - 1),
         response,
         error: true
       });
       return this.dispatch(action);
     };
-    // TODO: deprecate
     /**
      * Another name for setError
-     * @see https://resthooks.io/docs/api/Controller#setError
+     * @deprecated use https://resthooks.io/docs/api/Controller#setError instead
      */
     /* istanbul ignore next */
     this.receiveError = (endpoint, ...rest) => {
@@ -639,7 +508,7 @@ class Controller$1 {
      * @see https://resthooks.io/docs/api/Controller#resolve
      */
     this.resolve = (endpoint, meta) => {
-      return this.dispatch(createReceive(endpoint, meta));
+      return this.dispatch(createSet(endpoint, meta));
     };
     /**
      * Marks a new subscription to a given Endpoint.
@@ -721,17 +590,6 @@ class Controller$1 {
           expiresAt: expiresAt || 0
         };
       }
-
-      // Warn users with bad configurations
-      /* istanbul ignore next */
-      if (process.env.NODE_ENV !== 'production' && schema && normalizr.isEntity(schema)) {
-        if (Array.isArray(results)) {
-          throw new Error(`fetch key ${key} has list results when single result is expected`);
-        }
-        if (typeof results === 'object') {
-          throw new Error(`fetch key ${key} has object results when entity's primary key (string) result is expected`);
-        }
-      }
       if (!this.globalCache.results[key]) this.globalCache.results[key] = new normalizr.WeakEntityMap();
 
       // second argument is false if any entities are missing
@@ -815,64 +673,6 @@ class Snapshot {
   }
 }
 
-/**
- * Requesting a fetch to begin
- */
-function createFetch(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 = {
-    schema: endpoint.schema,
-    type: endpoint.sideEffect ? 'mutate' : 'read',
-    args,
-    key,
-    throttle: !endpoint.sideEffect,
-    options: endpoint,
-    resolve,
-    reject,
-    promise,
-    createdAt: Date.now()
-  };
-  if (endpoint.update) {
-    meta.update = endpoint.update;
-  }
-
-  // TODO: Remove once EOL on this deprecated piece
-  /* istanbul ignore if */
-  if (endpoint.optimisticUpdate) {
-    meta.optimisticResponse = endpoint.optimisticUpdate(...args);
-  }
-  return {
-    type: FETCH_TYPE,
-    payload: () => endpoint(...args),
-    meta,
-    endpoint
-  };
-}
-
-class Controller extends Controller$1 {
-  constructor(..._args) {
-    super(..._args);
-    /**
-     * Fetches the endpoint with given args, updating the Rest Hooks cache with the response or error upon completion.
-     * @see https://resthooks.io/docs/api/Controller#fetch
-     */
-    this.fetch = (endpoint, ...args) => {
-      const action = createFetch(endpoint, {
-        args
-      });
-      this.dispatch(action);
-      return action.meta.promise;
-    };
-  }
-}
-
 class ResetError extends Error {
   constructor() {
     super('Aborted due to RESET');
@@ -887,7 +687,7 @@ class ResetError extends Error {
  *
  * Interfaces with store via a redux-compatible middleware.
  *
- * @see https://resthooks.io/docs/api/NetworkManager
+ * @see https://dataclient.io/docs/api/NetworkManager
  */
 class NetworkManager {
   constructor(dataExpiryLength = 60000, errorExpiryLength = 1000) {
@@ -895,26 +695,19 @@ class NetworkManager {
     this.resolvers = {};
     this.rejectors = {};
     this.fetchedAt = {};
-    this.getState = () => initialState;
     this.controller = new Controller();
     this.dataExpiryLength = dataExpiryLength;
     this.errorExpiryLength = errorExpiryLength;
-    this.middleware = ({
-      dispatch,
-      getState,
-      controller
-    }) => {
-      this.getState = getState;
+    this.middleware = controller => {
       this.controller = controller;
       return next => action => {
-        var _action$endpoint;
         switch (action.type) {
           case FETCH_TYPE:
-            this.handleFetch(action, dispatch, controller);
+            this.handleFetch(action);
             // This is the only case that causes any state change
             // It's important to intercept other fetches as we don't want to trigger reducers during
             // render - so we need to stop 'readonly' fetches which can be triggered in render
-            if (action.meta.optimisticResponse !== undefined || ((_action$endpoint = action.endpoint) == null ? void 0 : _action$endpoint.getOptimisticResponse) !== undefined && action.endpoint.sideEffect) {
+            if (action.endpoint.getOptimisticResponse !== undefined && action.endpoint.sideEffect) {
               return next(action);
             }
             return Promise.resolve();
@@ -927,8 +720,12 @@ class NetworkManager {
                 const error = (_controller$getState$ = controller.getState().meta[action.meta.key]) == null ? void 0 : _controller$getState$.error;
                 // processing errors result in state meta having error, so we should reject the promise
                 if (error) {
-                  // TODO: use only new action types
-                  this.handleReceive(createReceiveError(error, action.meta));
+                  this.handleReceive(createSet(action.endpoint, {
+                    args: action.meta.args,
+                    response: error,
+                    fetchedAt: action.meta.fetchedAt,
+                    error: true
+                  }));
                 } else {
                   this.handleReceive(action);
                 }
@@ -994,10 +791,7 @@ class NetworkManager {
   }
   getLastReset() {
     if (this.cleanupDate) return this.cleanupDate;
-    const lastReset = this.controller.getState().lastReset;
-    if (lastReset instanceof Date) return lastReset.valueOf();
-    if (typeof lastReset !== 'number') return -Infinity;
-    return lastReset;
+    return this.controller.getState().lastReset;
   }
 
   /** Called when middleware intercepts 'rest-hooks/fetch' action.
@@ -1008,16 +802,15 @@ class NetworkManager {
    * Uses throttle only when instructed by action meta. This is valuable
    * for ensures mutation requests always go through.
    */
-  handleFetch(action, dispatch, controller) {
+  handleFetch(action) {
     const fetch = action.payload;
     const {
       key,
       throttle,
       resolve,
-      reject
+      reject,
+      createdAt
     } = action.meta;
-    // TODO(breaking): remove support for Date type in 'Receive' action
-    const createdAt = typeof action.meta.createdAt !== 'number' ? action.meta.createdAt.getTime() : action.meta.createdAt;
     const deferedFetch = () => {
       let promise = fetch();
       const resolvePromise = promise => promise.then(data => {
@@ -1030,7 +823,7 @@ class NetworkManager {
       // schedule non-throttled resolutions in a microtask before receive
       // this enables users awaiting their fetch to trigger any react updates needed to deal
       // with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)
-      if (!throttle && action.endpoint) {
+      if (!throttle) {
         promise = resolvePromise(promise);
       }
       promise = promise.then(data => {
@@ -1044,51 +837,26 @@ class NetworkManager {
 
         // don't update state with promises started before last clear
         if (createdAt >= lastReset) {
-          // we still check for controller in case someone didn't have type protection since this didn't always exist
-          if (action.endpoint && this.controller) {
-            this.controller.resolve(action.endpoint, {
-              args: action.meta.args,
-              response: data,
-              fetchedAt: createdAt
-            });
-          } else {
-            var _action$meta$options$, _action$meta$options;
-            // TODO(breaking): is this branch still possible? remove in next major update
-            // does this throw if the reducer fails? - no because reducer is wrapped in try/catch
-            this.controller.dispatch(createReceive$1(data, {
-              ...action.meta,
-              fetchedAt: createdAt,
-              dataExpiryLength: (_action$meta$options$ = (_action$meta$options = action.meta.options) == null ? void 0 : _action$meta$options.dataExpiryLength) != null ? _action$meta$options$ : this.dataExpiryLength
-            }));
-          }
+          this.controller.resolve(action.endpoint, {
+            args: action.meta.args,
+            response: data,
+            fetchedAt: createdAt
+          });
         }
         return data;
       }).catch(error => {
         const lastReset = this.getLastReset();
         // don't update state with promises started before last clear
         if (createdAt >= lastReset) {
-          if (action.endpoint && this.controller) {
-            this.controller.resolve(action.endpoint, {
-              args: action.meta.args,
-              response: error,
-              fetchedAt: createdAt,
-              error: true
-            });
-          } else {
-            var _action$meta$options$2, _action$meta$options2;
-            this.controller.dispatch(createReceiveError(error, {
-              ...action.meta,
-              errorExpiryLength: (_action$meta$options$2 = (_action$meta$options2 = action.meta.options) == null ? void 0 : _action$meta$options2.errorExpiryLength) != null ? _action$meta$options$2 : this.errorExpiryLength,
-              fetchedAt: createdAt
-            }));
-          }
+          this.controller.resolve(action.endpoint, {
+            args: action.meta.args,
+            response: error,
+            fetchedAt: createdAt,
+            error: true
+          });
         }
         throw error;
       });
-      // legacy behavior schedules resolution after dispatch
-      if (!throttle && !action.endpoint) {
-        promise = resolvePromise(promise);
-      }
       return promise;
     };
     if (throttle) {
@@ -1163,16 +931,10 @@ class NetworkManager {
   }
 }
 
-/* istanbul ignore file */
-/**
- * @deprecated use createReducer instead
- */
-const reducer = createReducer(new Controller());
-var reducer$1 = reducer;
-
 function applyManager(managers, controller) {
   return managers.map(manager => {
     const middleware = manager.getMiddleware();
+    // TODO(breaking): remove this once controller prop is no longer supported
     return ({
       dispatch,
       getState
@@ -1242,16 +1004,10 @@ var DefaultConnectionListener$1 = DefaultConnectionListener;
  * dispatching a fetch at a rate equal to the minimum update
  * interval requested.
  *
- * @see https://resthooks.io/docs/api/PollingSubscription
+ * @see https://dataclient.io/docs/api/PollingSubscription
  */
 class PollingSubscription {
-  constructor({
-    key,
-    schema,
-    fetch,
-    frequency,
-    getState
-  }, dispatch, connectionListener) {
+  constructor(action, controller, connectionListener) {
     this.frequencyHistogram = new Map();
     /** What happens when browser goes offline */
     this.offlineListener = () => {
@@ -1274,14 +1030,13 @@ class PollingSubscription {
       }, Math.max(0, this.lastFetchTime() - now + this.frequency));
       this.connectionListener.addOfflineListener(this.offlineListener);
     };
-    if (frequency === undefined) throw new Error('frequency needed for polling subscription');
-    this.schema = schema;
-    this.fetch = fetch;
-    this.frequency = frequency;
-    this.key = key;
+    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.frequencyHistogram.set(this.frequency, 1);
-    this.dispatch = dispatch;
-    this.getState = getState;
+    this.controller = controller;
     this.connectionListener = connectionListener || new DefaultConnectionListener$1();
 
     // Kickstart running since this is initialized after the online notif is sent
@@ -1354,18 +1109,17 @@ class PollingSubscription {
 
   /** Trigger request for latest resource */
   update() {
-    const endpoint = () => this.fetch();
-    endpoint.schema = this.schema;
-    endpoint.key = () => this.key;
+    const sup = this.endpoint;
+    const endpoint = function (...args) {
+      return sup.call(this, ...args);
+    };
+    Object.assign(endpoint, this.endpoint);
     endpoint.dataExpiryLength = this.frequency / 2;
     endpoint.errorExpiryLength = this.frequency / 10;
     endpoint.errorPolicy = () => 'soft';
-    const action = createFetch(endpoint, {
-      args: []
-    });
+    endpoint.key = () => this.key;
     // stop any errors here from bubbling
-    action.meta.promise.catch(e => null);
-    this.dispatch(action);
+    this.controller.fetch(endpoint, ...this.args).catch(() => null);
   }
   /** Run polling process with current frequency
    *
@@ -1389,13 +1143,11 @@ class PollingSubscription {
 
   /** Last fetch time */
   lastFetchTime() {
-    var _this$getState$meta$t, _this$getState$meta$t2;
-    return (_this$getState$meta$t = (_this$getState$meta$t2 = this.getState().meta[this.key]) == null ? void 0 : _this$getState$meta$t2.date) != null ? _this$getState$meta$t : 0;
+    var _this$controller$getS, _this$controller$getS2;
+    return (_this$controller$getS = (_this$controller$getS2 = this.controller.getState().meta[this.key]) == null ? void 0 : _this$controller$getS2.date) != null ? _this$controller$getS : 0;
   }
 }
 
-/** Properties sent to Subscription constructor */
-
 /** Interface handling a single resource subscription */
 
 /** The static class that constructs Subscription */
@@ -1405,27 +1157,26 @@ class PollingSubscription {
  * Constructor takes a SubscriptionConstructable class to control how
  * subscriptions are handled. (e.g., polling, websockets)
  *
- * @see https://resthooks.io/docs/api/SubscriptionManager
+ * @see https://dataclient.io/docs/api/SubscriptionManager
  */
 class SubscriptionManager {
   constructor(Subscription) {
     this.subscriptions = {};
+    this.controller = new Controller();
     this.Subscription = Subscription;
-    this.middleware = ({
-      dispatch,
-      getState
-    }) => {
+    this.middleware = controller => {
+      this.controller = controller;
       return next => action => {
         switch (action.type) {
           case SUBSCRIBE_TYPE:
             try {
-              this.handleSubscribe(action, dispatch, getState);
+              this.handleSubscribe(action);
             } catch (e) {
               console.error(e);
             }
             return Promise.resolve();
           case UNSUBSCRIBE_TYPE:
-            this.handleUnsubscribe(action, dispatch);
+            this.handleUnsubscribe(action);
             return Promise.resolve();
           default:
             return next(action);
@@ -1444,49 +1195,25 @@ class SubscriptionManager {
   /** Called when middleware intercepts 'rest-hooks/subscribe' action.
    *
    */
-  handleSubscribe(action, dispatch, getState) {
-    let options;
-    if (action.endpoint) {
-      const {
-        endpoint
-      } = action;
-      const {
-        args
-      } = action.meta;
-      options = {
-        schema: endpoint.schema,
-        fetch: () => endpoint(...args),
-        frequency: endpoint.pollFrequency,
-        key: endpoint.key(...args),
-        getState
-      };
-    } else {
-      var _action$meta$options;
-      options = {
-        key: action.meta.key,
-        frequency: (_action$meta$options = action.meta.options) == null ? void 0 : _action$meta$options.pollFrequency,
-        schema: action.meta.schema,
-        fetch: action.meta.fetch,
-        getState
-      };
-    }
-    if (options.key in this.subscriptions) {
-      this.subscriptions[options.key].add(options.frequency);
+  handleSubscribe(action) {
+    const key = action.meta.key;
+    if (key in this.subscriptions) {
+      const frequency = action.endpoint.pollFrequency;
+      this.subscriptions[key].add(frequency);
     } else {
-      this.subscriptions[options.key] = new this.Subscription(options, dispatch);
+      this.subscriptions[key] = new this.Subscription(action, this.controller);
     }
   }
 
   /** Called when middleware intercepts 'rest-hooks/unsubscribe' action.
    *
    */
-  handleUnsubscribe(action, dispatch) {
-    var _action$meta$options2;
+  handleUnsubscribe(action) {
     const key = action.meta.key;
-    const frequency = (_action$meta$options2 = action.meta.options) == null ? void 0 : _action$meta$options2.pollFrequency;
 
     /* istanbul ignore else */
     if (key in this.subscriptions) {
+      const frequency = action.endpoint.pollFrequency;
       const empty = this.subscriptions[key].remove(frequency);
       if (empty) {
         delete this.subscriptions[key];
@@ -1535,7 +1262,7 @@ const DEFAULT_CONFIG = {
  *
  * Options: https://github.com/reduxjs/redux-devtools/blob/main/extension/docs/API/Arguments.md
  *
- * @see https://resthooks.io/docs/api/DevToolsManager
+ * @see https://dataclient.io/docs/api/DevToolsManager
  */
 class DevToolsManager {
   constructor(config, skipLogging) {
@@ -1584,7 +1311,7 @@ class DevToolsManager {
 
 /** Handling network unauthorized indicators like HTTP 401
  *
- * @see https://resthooks.io/docs/api/LogoutManager
+ * @see https://dataclient.io/docs/api/LogoutManager
  */
 class LogoutManager {
   constructor({
@@ -1635,9 +1362,7 @@ exports.__INTERNAL__ = internal;
 exports.actionTypes = actionTypes;
 exports.applyManager = applyManager;
 exports.createFetch = createFetch;
-exports.createReceive = createReceive;
+exports.createReceive = createSet;
 exports.createReducer = createReducer;
 exports.initialState = initialState;
-exports.legacyActions = index;
 exports.newActions = newActions;
-exports.reducer = reducer$1;