@data-client/core 0.14.24 → 0.15.0-beta-20251022142546-a457d1596871fb28f1a91f2531cc259db4d55a9c

package/src/manager/NetworkManager.ts

@@ -5,7 +5,6 @@ import type {
   FetchAction,
   Manager,
   ActionTypes,
-  MiddlewareAPI,
   Middleware,
   SetResponseAction,
 } from '../types.js';
@@ -18,6 +17,13 @@ export class ResetError extends Error {
   }
 }
 
+export interface FetchingMeta {
+  promise: Promise<any>;
+  resolve: (value?: any) => void;
+  reject: (value?: any) => void;
+  fetchedAt: number;
+}
+
 /** Handles all async network dispatches
  *
  * Dedupes concurrent requests by keeping track of all fetches in flight
@@ -28,10 +34,7 @@ export class ResetError extends Error {
  * @see https://dataclient.io/docs/api/NetworkManager
  */
 export default class NetworkManager implements Manager {
-  protected fetched: { [k: string]: Promise<any> } = Object.create(null);
-  protected resolvers: { [k: string]: (value?: any) => void } = {};
-  protected rejectors: { [k: string]: (value?: any) => void } = {};
-  protected fetchedAt: { [k: string]: number } = {};
+  protected fetching: Map<string, FetchingMeta> = new Map();
   declare readonly dataExpiryLength: number;
   declare readonly errorExpiryLength: number;
   protected controller: Controller = new Controller();
@@ -61,7 +64,7 @@ export default class NetworkManager implements Manager {
         case SET_RESPONSE:
           // only set after new state is computed
           return next(action).then(() => {
-            if (action.key in this.fetched) {
+            if (this.fetching.has(action.key)) {
               // Note: meta *must* be set by reducer so this should be safe
               const error = controller.getState().meta[action.key]?.error;
               // processing errors result in state meta having error, so we should reject the promise
@@ -80,14 +83,16 @@ export default class NetworkManager implements Manager {
             }
           });
         case RESET: {
-          const rejectors = { ...this.rejectors };
+          // take snapshot of rejectors at this point in time
+          // we must use Array.from since iteration does not freeze state at this point in time
+          const fetches = Array.from(this.fetching.values());
 
           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());
+            for (const { reject } of fetches) {
+              reject(new ResetError());
             }
           });
         }
@@ -112,28 +117,29 @@ export default class NetworkManager implements Manager {
   /** Used by DevtoolsManager to determine whether to log an action */
   skipLogging(action: ActionTypes) {
     /* istanbul ignore next */
-    return action.type === FETCH && action.key in this.fetched;
+    return action.type === FETCH && this.fetching.has(action.key);
   }
 
   allSettled() {
-    const fetches = Object.values(this.fetched);
-    if (fetches.length) return Promise.allSettled(fetches);
+    if (this.fetching.size)
+      return Promise.allSettled(
+        this.fetching.values().map(({ promise }) => promise),
+      );
   }
 
   /** Clear all promise state */
   protected clearAll() {
-    for (const k in this.rejectors) {
+    for (const k of this.fetching.keys()) {
       this.clear(k);
     }
   }
 
   /** Clear promise state for a given key */
   protected clear(key: string) {
-    this.fetched[key].catch(() => {});
-    delete this.resolvers[key];
-    delete this.rejectors[key];
-    delete this.fetched[key];
-    delete this.fetchedAt[key];
+    if (this.fetching.has(key)) {
+      (this.fetching.get(key) as FetchingMeta).promise.catch(() => {});
+      this.fetching.delete(key);
+    }
   }
 
   protected getLastReset() {
@@ -226,14 +232,14 @@ export default class NetworkManager implements Manager {
    */
   protected handleSet(action: SetResponseAction) {
     // this can still turn out to be untrue since this is async
-    if (action.key in this.fetched) {
-      let promiseHandler: (value?: any) => void;
+    if (this.fetching.has(action.key)) {
+      const { reject, resolve } = this.fetching.get(action.key) as FetchingMeta;
       if (action.error) {
-        promiseHandler = this.rejectors[action.key];
+        reject(action.response);
       } else {
-        promiseHandler = this.resolvers[action.key];
+        resolve(action.response);
       }
-      promiseHandler(action.response);
+
       // since we're resolved we no longer need to keep track of this promise
       this.clear(action.key);
     }
@@ -253,19 +259,18 @@ export default class NetworkManager implements Manager {
     key: string,
     fetch: () => Promise<any>,
     fetchedAt: number,
-  ) {
+  ): Promise<any> {
     const lastReset = this.getLastReset();
+    let fetchMeta = this.fetching.get(key);
+
     // we're already fetching so reuse the promise
     // fetches after reset do not count
-    if (key in this.fetched && this.fetchedAt[key] > lastReset) {
-      return this.fetched[key];
+    if (fetchMeta && fetchMeta.fetchedAt > lastReset) {
+      return fetchMeta.promise;
     }
 
-    this.fetched[key] = new Promise((resolve, reject) => {
-      this.resolvers[key] = resolve;
-      this.rejectors[key] = reject;
-    });
-    this.fetchedAt[key] = fetchedAt;
+    fetchMeta = newFetchMeta(fetchedAt);
+    this.fetching.set(key, fetchMeta);
 
     this.idleCallback(
       () => {
@@ -277,7 +282,7 @@ export default class NetworkManager implements Manager {
       { timeout: 500 },
     );
 
-    return this.fetched[key];
+    return fetchMeta.promise;
   }
 
   /** Calls the callback when client is not 'busy' with high priority interaction tasks
@@ -291,3 +296,12 @@ export default class NetworkManager implements Manager {
     callback();
   }
 }
+
+function newFetchMeta(fetchedAt: number): FetchingMeta {
+  const fetchMeta = { fetchedAt } as FetchingMeta;
+  fetchMeta.promise = new Promise((resolve, reject) => {
+    fetchMeta.resolve = resolve;
+    fetchMeta.reject = reject;
+  });
+  return fetchMeta;
+}

package/src/manager/__tests__/__snapshots__/pollingSubscription.ts.snap

@@ -1,4 +1,4 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
 exports[`PollingSubscription fresh data cleanup() should not run even if interval not cancelled 1`] = `
 [

package/src/manager/__tests__/pollingSubscription.ts

@@ -1,5 +1,5 @@
 import { Endpoint } from '@data-client/endpoint';
-import { Article, PollingArticleResource } from '__tests__/new';
+import { Article } from '__tests__/new';
 
 import { createSubscription } from '../../controller/actions/createSubscription';
 import Controller from '../../controller/Controller';
@@ -284,13 +284,13 @@ describe('PollingSubscription', () => {
     });
 
     describe('cleanup()', () => {
-      let warnSpy: jest.SpyInstance;
+      let warnSpy: jest.Spied<typeof console.warn>;
       afterEach(() => {
         warnSpy.mockRestore();
       });
-      beforeEach(() =>
-        (warnSpy = jest.spyOn(console, 'warn')).mockImplementation(() => {}),
-      );
+      beforeEach(() => {
+        (warnSpy = jest.spyOn(console, 'warn')).mockImplementation(() => {});
+      });
 
       it('should stop all timers', () => {
         dispatch.mockClear();
@@ -394,6 +394,8 @@ describe('PollingSubscription', () => {
     });
 
     it('should not run when timeoutId is deleted after coming online', () => {
+      // Silence console.warn for this test
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
       const listener = new MockConnectionListener(false);
       const { dispatch, pollingSubscription } = createMocks(listener);
       expect(dispatch.mock.calls.length).toBe(0);
@@ -406,6 +408,8 @@ describe('PollingSubscription', () => {
       expect(dispatch.mock.calls.length).toBe(0);
       expect(listener.offlineHandlers.length).toBe(1);
       expect(listener.onlineHandlers.length).toBe(0);
+      expect(warnSpy.mock.calls.length).toBe(1);
+      warnSpy.mockRestore();
     });
 
     it('should stop dispatching when offline again', () => {

package/src/state/GCPolicy.ts

@@ -46,11 +46,12 @@ export class GCPolicy implements GCInterface {
       if (key)
         this.endpointCount.set(key, (this.endpointCount.get(key) ?? 0) + 1);
       paths.forEach(path => {
-        if (!this.entityCount.has(path.key)) {
-          this.entityCount.set(path.key, new Map<string, number>());
+        const { key, pk } = path;
+        if (!this.entityCount.has(key)) {
+          this.entityCount.set(key, new Map<string, number>());
         }
-        const instanceCount = this.entityCount.get(path.key)!;
-        instanceCount.set(path.pk, (instanceCount.get(path.pk) ?? 0) + 1);
+        const instanceCount = this.entityCount.get(key)!;
+        instanceCount.set(pk, (instanceCount.get(pk) ?? 0) + 1);
       });
 
       // decrement
@@ -68,18 +69,19 @@ export class GCPolicy implements GCInterface {
           }
         }
         paths.forEach(path => {
-          if (!this.entityCount.has(path.key)) {
+          const { key, pk } = path;
+          if (!this.entityCount.has(key)) {
             return;
           }
-          const instanceCount = this.entityCount.get(path.key)!;
-          const entityCount = instanceCount.get(path.pk)!;
+          const instanceCount = this.entityCount.get(key)!;
+          const entityCount = instanceCount.get(pk)!;
           if (entityCount !== undefined) {
             if (entityCount <= 1) {
-              instanceCount.delete(path.pk);
+              instanceCount.delete(pk);
               // queue for cleanup
               this.entitiesQ.push(path);
             } else {
-              instanceCount.set(path.pk, entityCount - 1);
+              instanceCount.set(pk, entityCount - 1);
             }
           }
         });
@@ -133,7 +135,7 @@ export class GCPolicy implements GCInterface {
       if (
         !this.entityCount.get(path.key)?.has(path.pk) &&
         this.expiresAt(
-          state.entityMeta[path.key]?.[path.pk] ?? {
+          state.entitiesMeta[path.key]?.[path.pk] ?? {
             fetchedAt: 0,
             date: 0,
             expiresAt: 0,

package/src/state/__tests__/GCPolicy.test.ts

@@ -48,7 +48,7 @@ describe('GCPolicy', () => {
           expiresAt: 0,
         },
       },
-      entityMeta: {
+      entitiesMeta: {
         testEntity: {
           '1': {
             date: 0,
@@ -90,7 +90,7 @@ describe('GCPolicy', () => {
           expiresAt: 0,
         },
       },
-      entityMeta: {
+      entitiesMeta: {
         testEntity: {
           '1': {
             date: 0,
@@ -127,7 +127,7 @@ describe('GCPolicy', () => {
     const paths: EntityPath[] = [{ key: 'testEntity', pk: '1' }];
     const state = {
       meta: {},
-      entityMeta: {},
+      entitiesMeta: {},
     };
     (controller.getState as jest.Mock).mockReturnValue(state);
 
@@ -163,7 +163,7 @@ describe('GCPolicy', () => {
           expiresAt: futureTime,
         },
       },
-      entityMeta: {
+      entitiesMeta: {
         testEntity: {
           '1': {
             date: futureTime - 100,
@@ -196,7 +196,7 @@ describe('GCPolicy', () => {
           expiresAt: 0,
         },
       },
-      entityMeta: {
+      entitiesMeta: {
         testEntity: {
           '1': {
             date: 0,
@@ -233,7 +233,7 @@ describe('GCPolicy', () => {
           expiresAt: futureTime,
         },
       },
-      entityMeta: {
+      entitiesMeta: {
         testEntity: {
           '1': {
             date: futureTime - 100,

package/src/state/__tests__/__snapshots__/reducer.ts.snap

@@ -1,10 +1,10 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
 exports[`reducer should set error in meta for "set" 1`] = `
 {
   "endpoints": {},
   "entities": {},
-  "entityMeta": {},
+  "entitiesMeta": {},
   "indexes": {},
   "lastReset": 0,
   "meta": {
@@ -34,7 +34,7 @@ exports[`reducer singles should update state correctly 1`] = `
       },
     },
   },
-  "entityMeta": {
+  "entitiesMeta": {
     "Article": {
       "20": {
         "date": 5000000000,

package/src/state/__tests__/reducer.ts

@@ -1,4 +1,5 @@
-import { INVALID, Entity } from '@data-client/endpoint';
+import { Entity } from '@data-client/endpoint';
+import { INVALID } from '@data-client/normalizr';
 import { ArticleResource, Article, PaginatedArticle } from '__tests__/new';
 
 import { Controller } from '../..';
@@ -84,10 +85,10 @@ describe('reducer', () => {
       expect(nextEntity.content).not.toBe(undefined);
 
       expect(
-        nextState.entityMeta[Article.key][`${Article.pk(action.response)}`],
+        nextState.entitiesMeta[Article.key][`${Article.pk(action.response)}`],
       ).toBeDefined();
       expect(
-        nextState.entityMeta[Article.key][`${Article.pk(action.response)}`]
+        nextState.entitiesMeta[Article.key][`${Article.pk(action.response)}`]
           .date,
       ).toBe(action.meta.date);
     });
@@ -102,7 +103,7 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { expiresAt: number } =>
-        state.entityMeta[Article.key][`${Article.pk(action.response)}`];
+        state.entitiesMeta[Article.key][`${Article.pk(action.response)}`];
       const prevMeta = getMeta(newState);
       expect(prevMeta).toBeDefined();
       const nextState = reducer(newState, localAction);
@@ -123,7 +124,7 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { date: number } =>
-        state.entityMeta[Article.key][`${Article.pk(action.response)}`];
+        state.entitiesMeta[Article.key][`${Article.pk(action.response)}`];
       const getEntity = (state: any): Article =>
         state.entities[Article.key][`${Article.pk(action.response)}`];
       const prevEntity = getEntity(newState);
@@ -182,7 +183,9 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { date: number; expiresAt: number } =>
-        state.entityMeta[ExpiresSoon.key][`${ExpiresSoon.pk(action.response)}`];
+        state.entitiesMeta[ExpiresSoon.key][
+          `${ExpiresSoon.pk(action.response)}`
+        ];
       const getEntity = (state: any): ExpiresSoon =>
         state.entities[ExpiresSoon.key][`${ExpiresSoon.pk(action.response)}`];
 
@@ -259,6 +262,11 @@ describe('reducer', () => {
           [id]: { id, counter: 5 },
         },
       },
+      entitiesMeta: {
+        [Counter.key]: {
+          [id]: { date: 0, fetchedAt: 0, expiresAt: 0 },
+        },
+      },
     };
     const newState = reducer(state, action);
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -630,7 +638,7 @@ describe('reducer', () => {
     expect(newState).toBe(iniState);
   });
   describe('RESET', () => {
-    let warnspy: jest.SpyInstance;
+    let warnspy: jest.Spied<any>;
     beforeEach(() => {
       warnspy = jest.spyOn(global.console, 'warn').mockImplementation(() => {});
     });
@@ -683,7 +691,7 @@ describe('reducer', () => {
           },
           '5': undefined,
         },
-        entityMeta: {
+        entitiesMeta: {
           [Article.key]: {
             '10': { date: 0, expiresAt: 10000, fetchedAt: 0 },
             '20': { date: 0, expiresAt: 10000, fetchedAt: 0 },
@@ -721,7 +729,7 @@ describe('reducer', () => {
       const newState = reducer(iniState, action);
       expect(newState).toBe(iniState);
       expect(Object.keys(newState.entities[Article.key] ?? {}).length).toBe(2);
-      expect(Object.keys(newState.entityMeta[Article.key] ?? {}).length).toBe(
+      expect(Object.keys(newState.entitiesMeta[Article.key] ?? {}).length).toBe(
         2,
       );
       expect(Object.keys(newState.endpoints).length).toBe(0);

package/src/state/reducer/createReducer.ts

@@ -28,7 +28,7 @@ export default function createReducer(controller: Controller): ReducerType {
         // inline deletes are fine as these should have 0 refcounts
         action.entities.forEach(({ key, pk }) => {
           delete (state as any).entities[key]?.[pk];
-          delete (state as any).entityMeta[key]?.[pk];
+          delete (state as any).entitiesMeta[key]?.[pk];
         });
         action.endpoints.forEach(fetchKey => {
           delete (state as any).endpoints[fetchKey];
@@ -69,7 +69,7 @@ export const initialState: State<unknown> = {
   endpoints: {},
   indexes: {},
   meta: {},
-  entityMeta: {},
+  entitiesMeta: {},
   optimistic: [],
   lastReset: 0,
 };

package/src/state/reducer/setReducer.ts

@@ -17,7 +17,7 @@ export function setReducer(
     value = action.value;
   }
   try {
-    const { entities, indexes, entityMeta } = normalize(
+    const { entities, indexes, entitiesMeta } = normalize(
       action.schema,
       value,
       action.args,
@@ -29,7 +29,7 @@ export function setReducer(
       endpoints: state.endpoints,
       indexes,
       meta: state.meta,
-      entityMeta,
+      entitiesMeta,
       optimistic: state.optimistic,
       lastReset: state.lastReset,
     };

package/src/state/reducer/setResponseReducer.ts

@@ -41,7 +41,7 @@ export function setResponseReducer(
     } else {
       response = action.response;
     }
-    const { result, entities, indexes, entityMeta } = normalize(
+    const { result, entities, indexes, entitiesMeta } = normalize(
       action.endpoint.schema,
       response,
       action.args,
@@ -80,7 +80,7 @@ export function setResponseReducer(
           prevExpiresAt: state.meta[action.key]?.expiresAt,
         },
       },
-      entityMeta,
+      entitiesMeta,
       optimistic: filterOptimistic(state, action),
       lastReset: state.lastReset,
     };
@@ -115,7 +115,7 @@ function reduceError(
   if (error.name === 'AbortError') {
     // In case we abort simply undo the optimistic update and act like no fetch even occured
     // We still want those watching promises from fetch directly to observed the abort, but we don't want to
-    // Trigger errors in this case. This means theoretically improperly built abortes useResource() could suspend forever.
+    // Trigger errors in this case. This means theoretically improperly built aborts useSuspense() could suspend forever.
     return {
       ...state,
       optimistic: filterOptimistic(state, action),

package/src/types.ts

@@ -41,7 +41,7 @@ export interface State<T> {
       readonly errorPolicy?: 'hard' | 'soft' | undefined;
     };
   };
-  readonly entityMeta: {
+  readonly entitiesMeta: {
     readonly [entityKey: string]: {
       readonly [pk: string]: {
         readonly fetchedAt: number;

package/ts3.4/controller/Controller.d.ts

@@ -254,7 +254,7 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      */
     get<S extends Queryable>(schema: S, ...rest: readonly [
         ...SchemaArgs<S>,
-        Pick<State<unknown>, 'entities' | 'entityMeta'>
+        Pick<State<unknown>, 'entities' | 'indexes'>
     ]): DenormalizeNullable<S> | undefined;
     /**
      * Queries the store for a Querable schema; providing related metadata
@@ -262,12 +262,12 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      */
     getQueryMeta<S extends Queryable>(schema: S, ...rest: readonly [
         ...SchemaArgs<S>,
-        Pick<State<unknown>, 'entities' | 'entityMeta'>
+        Pick<State<unknown>, 'entities' | 'indexes'>
     ]): {
         data: DenormalizeNullable<S> | undefined;
         countRef: () => () => void;
     };
-    private getSchemaResponse;
+    private getExpiryStatus;
 }
 export { ErrorTypes };
 declare class Snapshot<T = unknown> implements SnapshotInterface {

package/ts3.4/index.d.ts

@@ -1,8 +1,9 @@
 import * as __INTERNAL__1 from './internal.js';
 export { __INTERNAL__1 as __INTERNAL__ };
-export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, SchemaClass, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, NI, } from '@data-client/normalizr';
+export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, SchemaClass, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, Mergeable, IQueryDelegate, INormalizeDelegate, NI, } from '@data-client/normalizr';
 export { ExpiryStatus } from '@data-client/normalizr';
 export { default as NetworkManager, ResetError, } from './manager/NetworkManager.js';
+export { FetchingMeta } from './manager/NetworkManager.js';
 export * from './state/GCPolicy.js';
 export { default as createReducer, initialState, } from './state/reducer/createReducer.js';
 export { default as applyManager } from './manager/applyManager.js';

package/ts3.4/manager/NetworkManager.d.ts

@@ -4,6 +4,12 @@ export declare class ResetError extends Error {
     name: string;
     constructor();
 }
+export interface FetchingMeta {
+    promise: Promise<any>;
+    resolve: (value?: any) => void;
+    reject: (value?: any) => void;
+    fetchedAt: number;
+}
 /** Handles all async network dispatches
  *
  * Dedupes concurrent requests by keeping track of all fetches in flight
@@ -14,18 +20,7 @@ export declare class ResetError extends Error {
  * @see https://dataclient.io/docs/api/NetworkManager
  */
 export default class NetworkManager implements Manager {
-    protected fetched: {
-        [k: string]: Promise<any>;
-    };
-    protected resolvers: {
-        [k: string]: (value?: any) => void;
-    };
-    protected rejectors: {
-        [k: string]: (value?: any) => void;
-    };
-    protected fetchedAt: {
-        [k: string]: number;
-    };
+    protected fetching: Map<string, FetchingMeta>;
     readonly dataExpiryLength: number;
     readonly errorExpiryLength: number;
     protected controller: Controller;

package/ts3.4/state/reducer/expireReducer.d.ts

@@ -20,7 +20,7 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
         readonly [key: string]: unknown | import("../../types.js").PK[] | import("../../types.js").PK | undefined;
     };
     indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
-    entityMeta: {
+    entitiesMeta: {
         readonly [entityKey: string]: {
             readonly [pk: string]: {
                 readonly fetchedAt: number;

package/ts3.4/state/reducer/invalidateReducer.d.ts

@@ -20,7 +20,7 @@ export declare function invalidateReducer(state: State<unknown>, action: Invalid
         } | undefined;
     };
     indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
-    entityMeta: {
+    entitiesMeta: {
         readonly [entityKey: string]: {
             readonly [pk: string]: {
                 readonly fetchedAt: number;

package/ts3.4/state/reducer/setReducer.d.ts

@@ -19,7 +19,7 @@ export declare function setReducer(state: State<unknown>, action: SetAction, con
             readonly errorPolicy?: "hard" | "soft" | undefined;
         };
     };
-    entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
+    entitiesMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
         [x: string]: any;
     }>;
     optimistic: (import("../../actions.js").OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {

package/ts3.4/state/reducer/setResponseReducer.d.ts

@@ -22,7 +22,7 @@ export declare function setResponseReducer(state: State<unknown>, action: Optimi
             prevExpiresAt: number;
         };
     };
-    entityMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
+    entitiesMeta: import("packages/normalizr/lib/types.js").EntitiesToMeta<{
         [x: string]: any;
     }>;
     optimistic: (OptimisticAction<import("@data-client/normalizr").EndpointInterface<import("@data-client/normalizr").FetchFunction, import("@data-client/normalizr").Schema | undefined, boolean | undefined> & {

package/ts3.4/types.d.ts

@@ -31,7 +31,7 @@ export interface State<T> {
             readonly errorPolicy?: 'hard' | 'soft' | undefined;
         };
     };
-    readonly entityMeta: {
+    readonly entitiesMeta: {
         readonly [entityKey: string]: {
             readonly [pk: string]: {
                 readonly fetchedAt: number;