@data-client/core 0.14.18 → 0.14.19

package/dist/index.js

@@ -1,8 +1,7 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var normalizr = require('@data-client/normalizr');
+var _pushInstanceProperty = require('core-js-pure/stable/instance/push.js');
 
 function expireReducer(state, action) {
   const meta = {
@@ -57,28 +56,28 @@ const GC_TYPE = GC;
 
 var actionTypes = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  EXPIREALL: EXPIREALL,
+  EXPIREALL_TYPE: EXPIREALL_TYPE,
   FETCH: FETCH,
-  SET: SET,
-  SET_RESPONSE: SET_RESPONSE,
-  OPTIMISTIC: OPTIMISTIC,
-  RESET: RESET,
-  SUBSCRIBE: SUBSCRIBE,
-  UNSUBSCRIBE: UNSUBSCRIBE,
+  FETCH_TYPE: FETCH_TYPE,
+  GC: GC,
+  GC_TYPE: GC_TYPE,
   INVALIDATE: INVALIDATE,
   INVALIDATEALL: INVALIDATEALL,
-  EXPIREALL: EXPIREALL,
-  GC: GC,
-  FETCH_TYPE: FETCH_TYPE,
-  SET_TYPE: SET_TYPE,
-  SET_RESPONSE_TYPE: SET_RESPONSE_TYPE,
+  INVALIDATEALL_TYPE: INVALIDATEALL_TYPE,
+  INVALIDATE_TYPE: INVALIDATE_TYPE,
+  OPTIMISTIC: OPTIMISTIC,
   OPTIMISTIC_TYPE: OPTIMISTIC_TYPE,
+  RESET: RESET,
   RESET_TYPE: RESET_TYPE,
+  SET: SET,
+  SET_RESPONSE: SET_RESPONSE,
+  SET_RESPONSE_TYPE: SET_RESPONSE_TYPE,
+  SET_TYPE: SET_TYPE,
+  SUBSCRIBE: SUBSCRIBE,
   SUBSCRIBE_TYPE: SUBSCRIBE_TYPE,
-  UNSUBSCRIBE_TYPE: UNSUBSCRIBE_TYPE,
-  INVALIDATE_TYPE: INVALIDATE_TYPE,
-  INVALIDATEALL_TYPE: INVALIDATEALL_TYPE,
-  EXPIREALL_TYPE: EXPIREALL_TYPE,
-  GC_TYPE: GC_TYPE
+  UNSUBSCRIBE: UNSUBSCRIBE,
+  UNSUBSCRIBE_TYPE: UNSUBSCRIBE_TYPE
 });
 
 function createOptimistic(endpoint, args, fetchedAt) {
@@ -233,6 +232,7 @@ function setResponseReducer(state, action, controller) {
         ...state.meta,
         [action.key]: {
           date: action.meta.date,
+          fetchedAt: action.meta.fetchedAt,
           expiresAt: action.meta.expiresAt,
           prevExpiresAt: (_state$meta$action$ke = state.meta[action.key]) == null ? void 0 : _state$meta$action$ke.expiresAt
         }
@@ -273,8 +273,9 @@ function reduceError(state, action, error) {
       ...state.meta,
       [action.key]: {
         date: action.meta.date,
-        error,
+        fetchedAt: action.meta.fetchedAt,
         expiresAt: action.meta.expiresAt,
+        error,
         errorPolicy: action.endpoint.errorPolicy == null ? void 0 : action.endpoint.errorPolicy(error)
       }
     },
@@ -292,7 +293,10 @@ function createReducer(controller) {
     switch (action.type) {
       case GC:
         // inline deletes are fine as these should have 0 refcounts
-        action.entities.forEach(([key, pk]) => {
+        action.entities.forEach(({
+          key,
+          pk
+        }) => {
           var _entities$key, _entityMeta$key;
           (_entities$key = state.entities[key]) == null || delete _entities$key[pk];
           (_entityMeta$key = state.entityMeta[key]) == null || delete _entityMeta$key[pk];
@@ -339,8 +343,8 @@ const initialState = {
 
 var internal = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  MemoCache: normalizr.MemoCache,
   INVALID: normalizr.INVALID,
+  MemoCache: normalizr.MemoCache,
   initialState: initialState
 });
 
@@ -369,7 +373,6 @@ const ensurePojo =
 // FormData doesn't exist in node
 /* istanbul ignore else we don't run coverage when we test node*/
 typeof FormData !== 'undefined' ? body => body instanceof FormData ? Object.fromEntries(body.entries()) : body : /* istanbul ignore next */body => body;
-var ensurePojo$1 = ensurePojo;
 
 function createSetResponse(endpoint, {
   args,
@@ -387,7 +390,7 @@ function createSetResponse(endpoint, {
     type: SET_RESPONSE,
     key: endpoint.key(...args),
     response,
-    args: args.map(ensurePojo$1),
+    args: args.map(ensurePojo),
     endpoint,
     meta: createMeta(expiryLength, fetchedAt),
     error
@@ -402,7 +405,7 @@ function createSet(schema, {
   return {
     type: SET,
     value,
-    args: args.map(ensurePojo$1),
+    args: args.map(ensurePojo),
     schema,
     meta: createMeta(60000, fetchedAt)
   };
@@ -466,19 +469,170 @@ function createExpireAll(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,
+  createExpireAll: createExpireAll,
   createFetch: createFetch,
-  createExpireAll: createExpireAll
+  createInvalidate: createInvalidate,
+  createInvalidateAll: createInvalidateAll,
+  createMeta: createMeta,
+  createOptimistic: createOptimistic,
+  createReset: createReset,
+  createSet: createSet,
+  createSetResponse: createSetResponse,
+  createSubscription: createSubscription,
+  createUnsubscription: createUnsubscription
 });
 
+class GCPolicy {
+  endpointCount = new Map();
+  entityCount = new Map();
+  endpointsQ = new Set();
+  entitiesQ = [];
+  constructor({
+    // every 5 min
+    intervalMS = 60 * 1000 * 5,
+    expiryMultiplier = 2,
+    expiresAt
+  } = {}) {
+    if (expiresAt) {
+      this.expiresAt = expiresAt.bind(this);
+    }
+    this.options = {
+      intervalMS,
+      expiryMultiplier
+    };
+  }
+  init(controller) {
+    this.controller = controller;
+    this.intervalId = setInterval(() => {
+      this.idleCallback(() => this.runSweep(), {
+        timeout: 1000
+      });
+    }, this.options.intervalMS);
+  }
+  cleanup() {
+    clearInterval(this.intervalId);
+  }
+  createCountRef({
+    key,
+    paths = []
+  }) {
+    // increment
+    return () => {
+      var _this$endpointCount$g;
+      if (key) this.endpointCount.set(key, ((_this$endpointCount$g = this.endpointCount.get(key)) != null ? _this$endpointCount$g : 0) + 1);
+      paths.forEach(path => {
+        var _instanceCount$get;
+        if (!this.entityCount.has(path.key)) {
+          this.entityCount.set(path.key, new Map());
+        }
+        const instanceCount = this.entityCount.get(path.key);
+        instanceCount.set(path.pk, ((_instanceCount$get = instanceCount.get(path.pk)) != null ? _instanceCount$get : 0) + 1);
+      });
+
+      // decrement
+      return () => {
+        if (key) {
+          const currentCount = this.endpointCount.get(key);
+          if (currentCount !== undefined) {
+            if (currentCount <= 1) {
+              this.endpointCount.delete(key);
+              // queue for cleanup
+              this.endpointsQ.add(key);
+            } else {
+              this.endpointCount.set(key, currentCount - 1);
+            }
+          }
+        }
+        paths.forEach(path => {
+          if (!this.entityCount.has(path.key)) {
+            return;
+          }
+          const instanceCount = this.entityCount.get(path.key);
+          const entityCount = instanceCount.get(path.pk);
+          if (entityCount !== undefined) {
+            if (entityCount <= 1) {
+              var _context;
+              instanceCount.delete(path.pk);
+              // queue for cleanup
+              _pushInstanceProperty(_context = this.entitiesQ).call(_context, path);
+            } else {
+              instanceCount.set(path.pk, entityCount - 1);
+            }
+          }
+        });
+      };
+    };
+  }
+  expiresAt({
+    fetchedAt,
+    expiresAt
+  }) {
+    return Math.max((expiresAt - fetchedAt) * this.options.expiryMultiplier, 120000) + fetchedAt;
+  }
+  runSweep() {
+    const state = this.controller.getState();
+    const entities = [];
+    const endpoints = [];
+    const now = Date.now();
+    const nextEndpointsQ = new Set();
+    for (const key of this.endpointsQ) {
+      var _state$meta$key;
+      if (!this.endpointCount.has(key) && this.expiresAt((_state$meta$key = state.meta[key]) != null ? _state$meta$key : {
+        fetchedAt: 0,
+        date: 0,
+        expiresAt: 0
+      }) < now) {
+        _pushInstanceProperty(endpoints).call(endpoints, key);
+      } else {
+        nextEndpointsQ.add(key);
+      }
+    }
+    this.endpointsQ = nextEndpointsQ;
+    const nextEntitiesQ = [];
+    for (const path of this.entitiesQ) {
+      var _this$entityCount$get, _state$entityMeta$pat, _state$entityMeta$pat2;
+      if (!((_this$entityCount$get = this.entityCount.get(path.key)) != null && _this$entityCount$get.has(path.pk)) && this.expiresAt((_state$entityMeta$pat = (_state$entityMeta$pat2 = state.entityMeta[path.key]) == null ? void 0 : _state$entityMeta$pat2[path.pk]) != null ? _state$entityMeta$pat : {
+        fetchedAt: 0,
+        date: 0,
+        expiresAt: 0
+      }) < now) {
+        _pushInstanceProperty(entities).call(entities, path);
+      } else {
+        _pushInstanceProperty(nextEntitiesQ).call(nextEntitiesQ, path);
+      }
+    }
+    this.entitiesQ = nextEntitiesQ;
+    if (entities.length || endpoints.length) {
+      this.controller.dispatch({
+        type: GC,
+        entities,
+        endpoints
+      });
+    }
+  }
+
+  /** Calls the callback when client is not 'busy' with high priority interaction tasks
+   *
+   * Override for platform-specific implementations
+   */
+  idleCallback(callback, options) {
+    if (typeof requestIdleCallback === 'function') {
+      requestIdleCallback(callback, options);
+    } else {
+      callback();
+    }
+  }
+}
+class ImmortalGCPolicy {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  init() {}
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  cleanup() {}
+  createCountRef() {
+    return () => () => undefined;
+  }
+}
+
 function selectMeta(state, fetchKey) {
   return state.meta[fetchKey];
 }
@@ -515,131 +669,104 @@ class Controller {
    * Singleton to maintain referential equality between calls
    */
 
+  /**
+   * Handles garbage collection
+   */
+
   constructor({
     dispatch = unsetDispatch,
     getState = unsetState,
-    memo = new normalizr.MemoCache()
+    memo = new normalizr.MemoCache(),
+    gcPolicy = new ImmortalGCPolicy()
   } = {}) {
-    /*************** Action Dispatchers ***************/
-    /**
-     * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
-     * @see https://dataclient.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(endpoint.schema, input, {}, args));
-      }
-      return action.meta.promise;
-    };
-    /**
-     * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
-     * @see https://dataclient.io/docs/api/Controller#fetchIfStale
-     */
-    this.fetchIfStale = (endpoint, ...args) => {
-      const {
-        data,
-        expiresAt,
-        expiryStatus
-      } = this.getResponse(endpoint, ...args, this.getState());
-      if (expiryStatus !== normalizr.ExpiryStatus.Invalid && Date.now() <= expiresAt) return data;
-      return this.fetch(endpoint, ...args);
-    };
-    /**
-     * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
-     * @see https://dataclient.io/docs/api/Controller#invalidate
-     */
-    this.invalidate = (endpoint, ...args) => args[0] !== null ? this.dispatch(createInvalidate(endpoint, {
-      args: args
-    })) : Promise.resolve();
-    /**
-     * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
-     * @see https://dataclient.io/docs/api/Controller#invalidateAll
-     * @returns Promise that resolves when invalidation is commited.
-     */
-    this.invalidateAll = options => this.dispatch(createInvalidateAll(key => options.testKey(key)));
-    /**
-     * Sets all matching endpoint result keys to be STALE.
-     * @see https://dataclient.io/docs/api/Controller#expireAll
-     * @returns Promise that resolves when expiry is commited. *NOT* fetch promise
-     */
-    this.expireAll = options => this.dispatch(createExpireAll(key => options.testKey(key)));
-    /**
-     * Resets the entire Reactive Data Client cache. All inflight requests will not resolve.
-     * @see https://dataclient.io/docs/api/Controller#resetEntireStore
-     */
-    this.resetEntireStore = () => this.dispatch(createReset());
-    /**
-     * Sets response for the Endpoint and args.
-     * @see https://dataclient.io/docs/api/Controller#setResponse
-     */
-    this.setResponse = (endpoint, ...rest) => {
-      const response = rest[rest.length - 1];
-      const action = createSetResponse(endpoint, {
-        args: rest.slice(0, rest.length - 1),
-        response
-      });
-      return this.dispatch(action);
-    };
-    /**
-     * Sets an error response for the Endpoint and args.
-     * @see https://dataclient.io/docs/api/Controller#setError
-     */
-    this.setError = (endpoint, ...rest) => {
-      const response = rest[rest.length - 1];
-      const action = createSetResponse(endpoint, {
-        args: rest.slice(0, rest.length - 1),
-        response,
-        error: true
-      });
-      return this.dispatch(action);
-    };
-    /**
-     * Resolves an inflight fetch.
-     * @see https://dataclient.io/docs/api/Controller#resolve
-     */
-    this.resolve = (endpoint, meta) => {
-      return this.dispatch(createSetResponse(endpoint, meta));
-    };
-    /**
-     * Marks a new subscription to a given Endpoint.
-     * @see https://dataclient.io/docs/api/Controller#subscribe
-     */
-    this.subscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createSubscription(endpoint, {
-      args: args
-    })) : Promise.resolve();
-    /**
-     * Marks completion of subscription to a given Endpoint.
-     * @see https://dataclient.io/docs/api/Controller#unsubscribe
-     */
-    this.unsubscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createUnsubscription(endpoint, {
-      args: args
-    })) : Promise.resolve();
-    /*************** More ***************/
-    /* TODO:
-    abort = <E extends EndpointInterface>(
-      endpoint: E,
-      ...args: readonly [...Parameters<E>]
-    ): Promise<void>
-    */
-    /**
-     * Gets a snapshot (https://dataclient.io/docs/api/Snapshot)
-     * @see https://dataclient.io/docs/api/Controller#snapshot
-     */
-    this.snapshot = (state, fetchedAt) => {
-      return new Snapshot(this, state, fetchedAt);
-    };
-    this.dispatch = dispatch;
+    this._dispatch = dispatch;
     this.getState = getState;
     this.memo = memo;
+    this.gcPolicy = gcPolicy;
+  }
+
+  // TODO: drop when drop support for destructuring (0.14 and below)
+  set dispatch(dispatch) {
+    /* istanbul ignore next */
+    this._dispatch = dispatch;
+  }
+
+  // TODO: drop when drop support for destructuring (0.14 and below)
+  get dispatch() {
+    return this._dispatch;
+  }
+  bindMiddleware({
+    dispatch,
+    getState
+  }) {
+    this._dispatch = dispatch;
+    this.getState = getState;
   }
+
+  /*************** Action Dispatchers ***************/
+
+  /**
+   * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
+   * @see https://dataclient.io/docs/api/Controller#fetch
+   */
+  fetch = (endpoint, ...args) => {
+    const action = createFetch(endpoint, {
+      args
+    });
+    this.dispatch(action);
+    if (endpoint.schema) {
+      return action.meta.promise.then(input => normalizr.denormalize(endpoint.schema, input, {}, args));
+    }
+    return action.meta.promise;
+  };
+
+  /**
+   * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
+   * @see https://dataclient.io/docs/api/Controller#fetchIfStale
+   */
+  fetchIfStale = (endpoint, ...args) => {
+    const {
+      data,
+      expiresAt,
+      expiryStatus
+    } = this.getResponse(endpoint, ...args, this.getState());
+    if (expiryStatus !== normalizr.ExpiryStatus.Invalid && Date.now() <= expiresAt) return data;
+    return this.fetch(endpoint, ...args);
+  };
+
+  /**
+   * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
+   * @see https://dataclient.io/docs/api/Controller#invalidate
+   */
+  invalidate = (endpoint, ...args) => args[0] !== null ? this.dispatch(createInvalidate(endpoint, {
+    args: args
+  })) : Promise.resolve();
+
+  /**
+   * Forces refetching and suspense on useSuspense on all matching endpoint result keys.
+   * @see https://dataclient.io/docs/api/Controller#invalidateAll
+   * @returns Promise that resolves when invalidation is commited.
+   */
+  invalidateAll = options => this.dispatch(createInvalidateAll(key => options.testKey(key)));
+
+  /**
+   * Sets all matching endpoint result keys to be STALE.
+   * @see https://dataclient.io/docs/api/Controller#expireAll
+   * @returns Promise that resolves when expiry is commited. *NOT* fetch promise
+   */
+  expireAll = options => this.dispatch(createExpireAll(key => options.testKey(key)));
+
+  /**
+   * Resets the entire Reactive Data Client cache. All inflight requests will not resolve.
+   * @see https://dataclient.io/docs/api/Controller#resetEntireStore
+   */
+  resetEntireStore = () => this.dispatch(createReset());
+
   /**
    * 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, {
@@ -649,10 +776,80 @@ class Controller {
     // 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
+   */
+  setResponse = (endpoint, ...rest) => {
+    const response = rest[rest.length - 1];
+    const action = createSetResponse(endpoint, {
+      args: rest.slice(0, rest.length - 1),
+      response
+    });
+    return this.dispatch(action);
+  };
+
+  /**
+   * Sets an error response for the Endpoint and args.
+   * @see https://dataclient.io/docs/api/Controller#setError
+   */
+  setError = (endpoint, ...rest) => {
+    const response = rest[rest.length - 1];
+    const action = createSetResponse(endpoint, {
+      args: rest.slice(0, rest.length - 1),
+      response,
+      error: true
+    });
+    return this.dispatch(action);
+  };
+
+  /**
+   * Resolves an inflight fetch.
+   * @see https://dataclient.io/docs/api/Controller#resolve
+   */
+  resolve = (endpoint, meta) => {
+    return this.dispatch(createSetResponse(endpoint, meta));
+  };
+
+  /**
+   * Marks a new subscription to a given Endpoint.
+   * @see https://dataclient.io/docs/api/Controller#subscribe
+   */
+  subscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createSubscription(endpoint, {
+    args: args
+  })) : Promise.resolve();
+
+  /**
+   * Marks completion of subscription to a given Endpoint.
+   * @see https://dataclient.io/docs/api/Controller#unsubscribe
+   */
+  unsubscribe = (endpoint, ...args) => args[0] !== null ? this.dispatch(createUnsubscription(endpoint, {
+    args: args
+  })) : Promise.resolve();
+
+  /*************** More ***************/
+
+  /* TODO:
+  abort = <E extends EndpointInterface>(
+    endpoint: E,
+    ...args: readonly [...Parameters<E>]
+  ): Promise<void>
+  */
+
+  /**
+   * Gets a snapshot (https://dataclient.io/docs/api/Snapshot)
+   * @see https://dataclient.io/docs/api/Controller#snapshot
+   */
+  snapshot = (state, fetchedAt) => {
+    return new Snapshot(this, state, fetchedAt);
+  };
+
   /**
    * Gets the error, if any, for a given endpoint. Returns undefined for no errors.
    * @see https://dataclient.io/docs/api/Controller#getError
    */
+
   getError(endpoint, ...rest) {
     if (rest[0] === null) return;
     const state = rest[rest.length - 1];
@@ -671,11 +868,21 @@ class Controller {
    */
 
   getResponse(endpoint, ...rest) {
+    // TODO: breaking: only return data
+    return this.getResponseMeta(endpoint, ...rest);
+  }
+
+  /**
+   * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
+   * @see https://dataclient.io/docs/api/Controller#getResponseMeta
+   */
+
+  getResponseMeta(endpoint, ...rest) {
     const state = rest[rest.length - 1];
     // this is typescript generics breaking
     const args = rest.slice(0, rest.length - 1)
     // handle FormData
-    .map(ensurePojo$1);
+    .map(ensurePojo);
     const isActive = args.length !== 1 || args[0] !== null;
     const key = isActive ? endpoint.key(...args) : '';
     const cacheEndpoints = isActive ? state.endpoints[key] : undefined;
@@ -692,17 +899,22 @@ class Controller {
       return {
         data: input,
         expiryStatus: normalizr.ExpiryStatus.Valid,
-        expiresAt: Infinity
+        expiresAt: Infinity,
+        countRef: () => () => undefined
       };
     }
     let isInvalid = false;
     if (shouldQuery) {
       isInvalid = !normalizr.validateQueryKey(input);
+      // endpoint without entities
     } else if (!schema || !schemaHasEntity(schema)) {
       return {
         data: cacheEndpoints,
         expiryStatus: meta != null && meta.invalidated ? normalizr.ExpiryStatus.Invalid : cacheEndpoints && !endpoint.invalidIfStale ? normalizr.ExpiryStatus.Valid : normalizr.ExpiryStatus.InvalidIfStale,
-        expiresAt: expiresAt || 0
+        expiresAt: expiresAt || 0,
+        countRef: this.gcPolicy.createCountRef({
+          key
+        })
       };
     }
 
@@ -715,7 +927,7 @@ class Controller {
 
     // note: isInvalid can only be true if shouldQuery is true
     if (!expiresAt && isInvalid) expiresAt = 1;
-    return this.getSchemaResponse(data, paths, state.entityMeta, expiresAt, endpoint.invalidIfStale || isInvalid, meta);
+    return this.getSchemaResponse(data, key, paths, state.entityMeta, expiresAt, endpoint.invalidIfStale || isInvalid, meta);
   }
 
   /**
@@ -725,10 +937,40 @@ class Controller {
   get(schema, ...rest) {
     const state = rest[rest.length - 1];
     // this is typescript generics breaking
-    const args = rest.slice(0, rest.length - 1).map(ensurePojo$1);
+    const args = rest.slice(0, rest.length - 1).map(ensurePojo);
     return this.memo.query(schema, args, state.entities, state.indexes);
   }
-  getSchemaResponse(data, paths, entityMeta, expiresAt, invalidIfStale, meta = {}) {
+
+  /**
+   * Queries the store for a Querable schema; providing related metadata
+   * @see https://dataclient.io/docs/api/Controller#getQueryMeta
+   */
+  getQueryMeta(schema, ...rest) {
+    const state = rest[rest.length - 1];
+    // this is typescript generics breaking
+    const args = rest.slice(0, rest.length - 1).map(ensurePojo);
+
+    // TODO: breaking: Switch back to this.memo.query(schema, args, state.entities as any, state.indexes) to do
+    // this logic
+    const input = this.memo.buildQueryKey(schema, args, state.entities, state.indexes, JSON.stringify(args));
+    if (!input) {
+      return {
+        data: undefined,
+        countRef: () => () => undefined
+      };
+    }
+    const {
+      data,
+      paths
+    } = this.memo.denormalize(schema, input, state.entities, args);
+    return {
+      data: typeof data === 'symbol' ? undefined : data,
+      countRef: this.gcPolicy.createCountRef({
+        paths
+      })
+    };
+  }
+  getSchemaResponse(data, key, paths, entityMeta, expiresAt, invalidIfStale, meta = {}) {
     const invalidDenormalize = typeof data === 'symbol';
 
     // fallback to entity expiry time
@@ -743,7 +985,11 @@ class Controller {
     return {
       data,
       expiryStatus,
-      expiresAt
+      expiresAt,
+      countRef: this.gcPolicy.createCountRef({
+        key,
+        paths
+      })
     };
   }
 }
@@ -781,11 +1027,12 @@ function schemaHasEntity(schema) {
   return false;
 }
 class Snapshot {
+  static abort = new AbortOptimistic();
+  state;
+  controller;
+  fetchedAt;
+  abort = Snapshot.abort;
   constructor(controller, state, fetchedAt = 0) {
-    this.state = void 0;
-    this.controller = void 0;
-    this.fetchedAt = void 0;
-    this.abort = Snapshot.abort;
     this.state = state;
     this.controller = controller;
     this.fetchedAt = fetchedAt;
@@ -798,6 +1045,12 @@ class Snapshot {
     return this.controller.getResponse(endpoint, ...args, this.state);
   }
 
+  /** @see https://dataclient.io/docs/api/Snapshot#getResponseMeta */
+
+  getResponseMeta(endpoint, ...args) {
+    return this.controller.getResponseMeta(endpoint, ...args, this.state);
+  }
+
   /** @see https://dataclient.io/docs/api/Snapshot#getError */
 
   getError(endpoint, ...args) {
@@ -811,13 +1064,20 @@ class Snapshot {
   get(schema, ...args) {
     return this.controller.get(schema, ...args, this.state);
   }
+
+  /**
+   * Queries the store for a Querable schema; providing related metadata
+   * @see https://dataclient.io/docs/api/Snapshot#getQueryMeta
+   */
+  getQueryMeta(schema, ...args) {
+    return this.controller.getQueryMeta(schema, ...args, this.state);
+  }
 }
-Snapshot.abort = new AbortOptimistic();
 
 class ResetError extends Error {
+  name = 'ResetError';
   constructor() {
     super('Aborted due to RESET');
-    this.name = 'ResetError';
   }
 }
 
@@ -831,70 +1091,71 @@ class ResetError extends Error {
  * @see https://dataclient.io/docs/api/NetworkManager
  */
 class NetworkManager {
+  fetched = Object.create(null);
+  resolvers = {};
+  rejectors = {};
+  fetchedAt = {};
+  controller = new Controller();
   constructor({
     dataExpiryLength = 60000,
     errorExpiryLength = 1000
   } = {}) {
-    this.fetched = Object.create(null);
-    this.resolvers = {};
-    this.rejectors = {};
-    this.fetchedAt = {};
-    this.controller = new Controller();
-    this.middleware = controller => {
-      this.controller = controller;
-      return next => action => {
-        switch (action.type) {
-          case FETCH:
-            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.endpoint.getOptimisticResponse !== undefined && action.endpoint.sideEffect) {
-              return next(action);
+    this.dataExpiryLength = dataExpiryLength;
+    this.errorExpiryLength = errorExpiryLength;
+  }
+  middleware = controller => {
+    this.controller = controller;
+    return next => action => {
+      switch (action.type) {
+        case FETCH:
+          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.endpoint.getOptimisticResponse !== undefined && action.endpoint.sideEffect) {
+            return next(action);
+          }
+          return Promise.resolve();
+        case SET_RESPONSE:
+          // only set after new state is computed
+          return next(action).then(() => {
+            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.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.args,
+                  response: error,
+                  fetchedAt: action.meta.fetchedAt,
+                  error: true
+                }));
+              } else {
+                this.handleSet(action);
+              }
             }
-            return Promise.resolve();
-          case SET_RESPONSE:
-            // only set after new state is computed
+          });
+        case RESET:
+          {
+            const rejectors = {
+              ...this.rejectors
+            };
+            this.clearAll();
             return next(action).then(() => {
-              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.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.args,
-                    response: error,
-                    fetchedAt: action.meta.fetchedAt,
-                    error: true
-                  }));
-                } else {
-                  this.handleSet(action);
-                }
+              // there could be external listeners to the promise
+              // this must happen after commit so our own rejector knows not to dispatch an error based on this
+              for (const k in rejectors) {
+                rejectors[k](new ResetError());
               }
             });
-          case RESET:
-            {
-              const rejectors = {
-                ...this.rejectors
-              };
-              this.clearAll();
-              return next(action).then(() => {
-                // there could be external listeners to the promise
-                // this must happen after commit so our own rejector knows not to dispatch an error based on this
-                for (const k in rejectors) {
-                  rejectors[k](new ResetError());
-                }
-              });
-            }
-          default:
-            return next(action);
-        }
-      };
+          }
+        default:
+          return next(action);
+      }
     };
-    this.dataExpiryLength = dataExpiryLength;
-    this.errorExpiryLength = errorExpiryLength;
-  }
+  };
+
   /** On mount */
   init() {
     delete this.cleanupDate;
@@ -1076,13 +1337,9 @@ function applyManager(managers, controller) {
   }
   return managers.map((manager, i) => {
     if (!manager.middleware) manager.middleware = manager.getMiddleware == null ? void 0 : manager.getMiddleware();
-    return ({
-      dispatch,
-      getState
-    }) => {
+    return api => {
       if (i === 0) {
-        controller.dispatch = dispatch;
-        controller.getState = getState;
+        controller.bindMiddleware(api);
       }
       // controller is a superset of the middleware API
       return manager.middleware(controller);
@@ -1094,6 +1351,21 @@ function applyManager(managers, controller) {
 
 /* The next are types from React; but we don't want dependencies on it */
 
+function initManager(managers, controller, initialState) {
+  return () => {
+    managers.forEach(manager => {
+      manager.init == null || manager.init(initialState);
+    });
+    controller.gcPolicy.init(controller);
+    return () => {
+      managers.forEach(manager => {
+        manager.cleanup();
+      });
+      controller.gcPolicy.cleanup();
+    };
+  };
+}
+
 class BrowserConnectionListener {
   isOnline() {
     if (navigator.onLine !== undefined) {
@@ -1142,29 +1414,8 @@ var DefaultConnectionListener$1 = DefaultConnectionListener;
  * @see https://dataclient.io/docs/api/PollingSubscription
  */
 class PollingSubscription {
+  frequencyHistogram = new Map();
   constructor(action, controller, connectionListener) {
-    this.frequencyHistogram = new Map();
-    /** What happens when browser goes offline */
-    this.offlineListener = () => {
-      // this clears existing listeners, so no need to clear offline listener
-      this.cleanup();
-      this.connectionListener.addOnlineListener(this.onlineListener);
-    };
-    /** What happens when browser comes online */
-    this.onlineListener = () => {
-      this.connectionListener.removeOnlineListener(this.onlineListener);
-      const now = Date.now();
-      this.startId = setTimeout(() => {
-        if (this.startId) {
-          delete this.startId;
-          this.update();
-          this.run();
-        } else if (process.env.NODE_ENV !== 'production') {
-          console.warn(`Poll setTimeout for ${this.key} still running, but timeoutId deleted`);
-        }
-      }, Math.max(0, this.lastFetchTime() - now + this.frequency));
-      this.connectionListener.addOfflineListener(this.offlineListener);
-    };
     if (action.endpoint.pollFrequency === undefined) throw new Error('frequency needed for polling subscription');
     this.endpoint = action.endpoint;
     this.frequency = action.endpoint.pollFrequency;
@@ -1256,6 +1507,30 @@ class PollingSubscription {
     // stop any errors here from bubbling
     this.controller.fetch(endpoint, ...this.args).catch(() => null);
   }
+
+  /** What happens when browser goes offline */
+  offlineListener = () => {
+    // this clears existing listeners, so no need to clear offline listener
+    this.cleanup();
+    this.connectionListener.addOnlineListener(this.onlineListener);
+  };
+
+  /** What happens when browser comes online */
+  onlineListener = () => {
+    this.connectionListener.removeOnlineListener(this.onlineListener);
+    const now = Date.now();
+    this.startId = setTimeout(() => {
+      if (this.startId) {
+        delete this.startId;
+        this.update();
+        this.run();
+      } else if (process.env.NODE_ENV !== 'production') {
+        console.warn(`Poll setTimeout for ${this.key} still running, but timeoutId deleted`);
+      }
+    }, Math.max(0, this.lastFetchTime() - now + this.frequency));
+    this.connectionListener.addOfflineListener(this.offlineListener);
+  };
+
   /** Run polling process with current frequency
    *
    * Will clean up old poll interval on next run
@@ -1295,30 +1570,31 @@ class PollingSubscription {
  * @see https://dataclient.io/docs/api/SubscriptionManager
  */
 class SubscriptionManager {
+  subscriptions = {};
+  controller = new Controller();
   constructor(Subscription) {
-    this.subscriptions = {};
-    this.controller = new Controller();
-    this.middleware = controller => {
-      this.controller = controller;
-      return next => action => {
-        switch (action.type) {
-          case SUBSCRIBE:
-            try {
-              this.handleSubscribe(action);
-            } catch (e) {
-              console.error(e);
-            }
-            return Promise.resolve();
-          case UNSUBSCRIBE:
-            this.handleUnsubscribe(action);
-            return Promise.resolve();
-          default:
-            return next(action);
-        }
-      };
-    };
     this.Subscription = Subscription;
   }
+  middleware = controller => {
+    this.controller = controller;
+    return next => action => {
+      switch (action.type) {
+        case SUBSCRIBE:
+          try {
+            this.handleSubscribe(action);
+          } catch (e) {
+            console.error(e);
+          }
+          return Promise.resolve();
+        case UNSUBSCRIBE:
+          this.handleUnsubscribe(action);
+          return Promise.resolve();
+        default:
+          return next(action);
+      }
+    };
+  };
+
   /** Ensures all subscriptions are cleaned up. */
   cleanup() {
     for (const key in this.subscriptions) {
@@ -1449,11 +1725,12 @@ class DevToolsManager {
     if (this.started) {
       this.devTools.send(action, state);
     } else {
+      var _context;
       // avoid this getting too big in case this is long running
       // we cut in half so we aren't constantly reallocating
       if (this.actions.length > this.maxBufferLength) this.actions = this.actions.slice(this.maxBufferLength / 2);
       // queue actions
-      this.actions.push([action, state]);
+      _pushInstanceProperty(_context = this.actions).call(_context, [action, state]);
     }
   }
 
@@ -1529,15 +1806,15 @@ class LogoutManager {
     handleLogout,
     shouldLogout
   } = {}) {
-    this.middleware = controller => next => async action => {
-      await next(action);
-      if (action.type === SET_RESPONSE && action.error && this.shouldLogout(action.response)) {
-        this.handleLogout(controller);
-      }
-    };
     if (handleLogout) this.handleLogout = handleLogout;
     if (shouldLogout) this.shouldLogout = shouldLogout;
   }
+  middleware = controller => next => async action => {
+    await next(action);
+    if (action.type === SET_RESPONSE && action.error && this.shouldLogout(action.response)) {
+      this.handleLogout(controller);
+    }
+  };
   cleanup() {}
   shouldLogout(error) {
     // 401 indicates reauthorization is needed
@@ -1548,17 +1825,15 @@ class LogoutManager {
   }
 }
 
-Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
-  return Object.prototype.hasOwnProperty.call(it, key);
-};
-
-Object.defineProperty(exports, 'ExpiryStatus', {
+Object.defineProperty(exports, "ExpiryStatus", {
   enumerable: true,
   get: function () { return normalizr.ExpiryStatus; }
 });
 exports.Controller = Controller;
 exports.DefaultConnectionListener = DefaultConnectionListener$1;
 exports.DevToolsManager = DevToolsManager;
+exports.GCPolicy = GCPolicy;
+exports.ImmortalGCPolicy = ImmortalGCPolicy;
 exports.LogoutManager = LogoutManager;
 exports.NetworkManager = NetworkManager;
 exports.PollingSubscription = PollingSubscription;
@@ -1569,4 +1844,5 @@ exports.actionTypes = actionTypes;
 exports.actions = index;
 exports.applyManager = applyManager;
 exports.createReducer = createReducer;
+exports.initManager = initManager;
 exports.initialState = initialState;