@data-client/core 0.10.0 → 0.11.0

package/src/state/reducer/createReducer.ts

@@ -28,8 +28,8 @@ export default function createReducer(controller: Controller): ReducerType {
           delete (state as any).entities[key]?.[pk];
           delete (state as any).entityMeta[key]?.[pk];
         });
-        action.results.forEach(fetchKey => {
-          delete (state as any).results[fetchKey];
+        action.endpoints.forEach(fetchKey => {
+          delete (state as any).endpoints[fetchKey];
           delete (state as any).meta[fetchKey];
         });
         return state;
@@ -62,7 +62,7 @@ export default function createReducer(controller: Controller): ReducerType {
 export const initialState: State<unknown> = {
   entities: {},
   indexes: {},
-  results: {},
+  endpoints: {},
   meta: {},
   entityMeta: {},
   optimistic: [],

package/src/state/reducer/invalidateReducer.ts

@@ -9,10 +9,10 @@ export function invalidateReducer(
   state: State<unknown>,
   action: InvalidateAction | InvalidateAllAction,
 ) {
-  const results = { ...state.results };
+  const endpoints = { ...state.endpoints };
   const meta = { ...state.meta };
   const invalidateKey = (key: string) => {
-    delete results[key];
+    delete endpoints[key];
     const itemMeta = {
       ...meta[key],
       expiresAt: 0,
@@ -24,7 +24,7 @@ export function invalidateReducer(
   if (action.type === INVALIDATE_TYPE) {
     invalidateKey(action.meta.key);
   } else {
-    Object.keys(results).forEach(key => {
+    Object.keys(endpoints).forEach(key => {
       if (action.testKey(key)) {
         invalidateKey(key);
       }
@@ -33,7 +33,7 @@ export function invalidateReducer(
 
   return {
     ...state,
-    results,
+    endpoints,
     meta,
   };
 }

package/src/state/reducer/setReducer.ts

@@ -1,6 +1,7 @@
 import { normalize } from '@data-client/normalizr';
 
 import { OPTIMISTIC_TYPE } from '../../actionTypes.js';
+import AbortOptimistic from '../../controller/AbortOptimistic.js';
 import type Controller from '../../controller/Controller.js';
 import type { State, SetAction, OptimisticAction } from '../../types.js';
 
@@ -27,7 +28,7 @@ export function setReducer(
         );
       } catch (e: any) {
         // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
-        if (e.constructor?.name === 'AbortOptimistic') {
+        if (e.constructor === AbortOptimistic) {
           return state;
         }
         throw e;
@@ -44,15 +45,15 @@ export function setReducer(
       state.entityMeta,
       action.meta,
     );
-    const results = {
-      ...state.results,
+    const endpoints = {
+      ...state.endpoints,
       [action.meta.key]: result,
     };
     try {
       if (action.endpoint.update) {
         const updaters = action.endpoint.update(result, ...action.meta.args);
         Object.keys(updaters).forEach(key => {
-          results[key] = updaters[key](results[key]);
+          endpoints[key] = updaters[key](endpoints[key]);
         });
       }
       // no reason to completely fail because of user-code error
@@ -66,7 +67,7 @@ export function setReducer(
     return {
       entities,
       indexes,
-      results,
+      endpoints,
       entityMeta,
       meta: {
         ...state.meta,
@@ -79,7 +80,7 @@ export function setReducer(
       optimistic: filterOptimistic(state, action),
       lastReset: state.lastReset,
     };
-    // reducer must update the state, so in case of processing errors we simply compute the results inline
+    // reducer must update the state, so in case of processing errors we simply compute the endpoints inline
   } catch (error: any) {
     if (typeof error === 'object') {
       error.message = `Error processing ${

package/src/types.ts

@@ -20,7 +20,9 @@ export interface State<T> {
     readonly [entityKey: string]: { readonly [pk: string]: T } | undefined;
   };
   readonly indexes: NormalizedIndex;
-  readonly results: { readonly [key: string]: unknown | PK[] | PK | undefined };
+  readonly endpoints: {
+    readonly [key: string]: unknown | PK[] | PK | undefined;
+  };
   readonly meta: {
     readonly [key: string]: {
       readonly date: number;

package/ts3.4/actions.d.ts

@@ -91,7 +91,7 @@ export interface GCAction {
         string,
         string
     ][];
-    results: string[];
+    endpoints: string[];
 }
 export type ActionTypes = FetchAction | OptimisticAction | SetAction | SubscribeAction | UnsubscribeAction | InvalidateAction | InvalidateAllAction | ExpireAllAction | ResetAction | GCAction;
 export {};

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

@@ -0,0 +1,3 @@
+export default class AbortOptimistic extends Error {
+}
+//# sourceMappingURL=AbortOptimistic.d.ts.map

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

@@ -1,5 +1,5 @@
-import { ErrorTypes, SnapshotInterface, DenormalizeCache, Schema, Denormalize } from '@data-client/normalizr';
-import { ExpiryStatus, EndpointInterface, FetchFunction, ResolveType, DenormalizeNullable } from '@data-client/normalizr';
+import { ErrorTypes, SnapshotInterface, Schema, Denormalize, Queryable, SchemaArgs } from '@data-client/normalizr';
+import { ExpiryStatus, EndpointInterface, FetchFunction, ResolveType, DenormalizeNullable, MemoCache } from '@data-client/normalizr';
 import { EndpointUpdateFunction } from './types.js';
 import { ActionTypes, State } from '../types.js';
 export type GenericDispatch = (value: any) => Promise<void>;
@@ -7,7 +7,7 @@ export type DataClientDispatch = (value: ActionTypes) => Promise<void>;
 interface ConstructorProps<D extends GenericDispatch = DataClientDispatch> {
     dispatch?: D;
     getState?: () => State<unknown>;
-    globalCache?: DenormalizeCache;
+    memo?: Pick<MemoCache, 'denormalize' | 'query' | 'buildQueryKey'>;
 }
 /**
  * Imperative control of Reactive Data Client store
@@ -28,8 +28,11 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      * @see https://dataclient.io/docs/api/Controller#getState
      */
     readonly getState: () => State<unknown>;
-    readonly globalCache: DenormalizeCache;
-    constructor({ dispatch, getState, globalCache, }?: ConstructorProps<D>);
+    /**
+     * Singleton to maintain referential equality between calls
+     */
+    readonly memo: Pick<MemoCache, 'denormalize' | 'query' | 'buildQueryKey'>;
+    constructor({ dispatch, getState, memo, }?: ConstructorProps<D>);
     /*************** Action Dispatchers ***************/
     /**
      * Fetches the endpoint with given args, updating the Reactive Data Client cache with the response or error upon completion.
@@ -37,14 +40,14 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      */
     fetch: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> : Promise<Denormalize<E["schema"]>>;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E['schema'] extends undefined | null ? ReturnType<E> : Promise<Denormalize<E['schema']>>;
     /**
      * Fetches only if endpoint is considered 'stale'; otherwise returns undefined
      * @see https://dataclient.io/docs/api/Controller#fetchIfStale
      */
     fetchIfStale: <E extends EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined> & {
         update?: EndpointUpdateFunction<E> | undefined;
-    }>(endpoint: E, ...args_0: Parameters<E>) => E["schema"] extends null | undefined ? ReturnType<E> | ResolveType<E> : Denormalize<E["schema"]> | Promise<Denormalize<E["schema"]>>;
+    }>(endpoint: E, ...args_0: Parameters<E>) => E['schema'] extends undefined | null ? ReturnType<E> | ResolveType<E> : Promise<Denormalize<E['schema']>> | Denormalize<E['schema']>;
     /**
      * Forces refetching and suspense on useSuspense with the same Endpoint and parameters.
      * @see https://dataclient.io/docs/api/Controller#invalidate
@@ -121,18 +124,18 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      * @see https://dataclient.io/docs/api/Controller#subscribe
      */
     subscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
-        null
-    ] | readonly [
         ...Parameters<E>
+    ] | readonly [
+        null
     ]) => Promise<void>;
     /**
      * Marks completion of subscription to a given Endpoint.
      * @see https://dataclient.io/docs/api/Controller#unsubscribe
      */
     unsubscribe: <E extends EndpointInterface<FetchFunction, Schema | undefined, false | undefined>>(endpoint: E, ...args: readonly [
-        null
-    ] | readonly [
         ...Parameters<E>
+    ] | readonly [
+        null
     ]) => Promise<void>;
     /*************** More ***************/
     /**
@@ -156,18 +159,43 @@ export default class Controller<D extends GenericDispatch = DataClientDispatch>
      * Gets the (globally referentially stable) response for a given endpoint/args pair from state given.
      * @see https://dataclient.io/docs/api/Controller#getResponse
      */
-    getResponse: <E extends Pick<EndpointInterface<FetchFunction, Schema | undefined, boolean | undefined>, "schema" | "key" | "invalidIfStale">, Args extends readonly [
-        null
-    ] | readonly [
-        ...Parameters<E["key"]>
-    ]>(endpoint: E, ...rest: [
-        ...Args,
+    getResponse<E extends EndpointInterface>(endpoint: E, ...rest: readonly [
+        null,
+        State<unknown>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    getResponse<E extends EndpointInterface>(endpoint: E, ...rest: readonly [
+        ...Parameters<E>,
         State<unknown>
-    ]) => {
-        data: DenormalizeNullable<E["schema"]>;
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
         expiryStatus: ExpiryStatus;
         expiresAt: number;
     };
+    getResponse<E extends Pick<EndpointInterface, 'key' | 'schema' | 'invalidIfStale'>>(endpoint: E, ...rest: readonly [
+        ...(readonly [
+            ...Parameters<E['key']>
+        ] | readonly [
+            null
+        ]),
+        State<unknown>
+    ]): {
+        data: DenormalizeNullable<E['schema']>;
+        expiryStatus: ExpiryStatus;
+        expiresAt: number;
+    };
+    /**
+     * Queries the store for a Querable schema
+     * @see https://dataclient.io/docs/api/Controller#get
+     */
+    get<S extends Queryable>(schema: S, ...rest: readonly [
+        ...SchemaArgs<S>,
+        Pick<State<unknown>, 'entities' | 'entityMeta'>
+    ]): DenormalizeNullable<S> | undefined;
+    private getSchemaResponse;
 }
 export { ErrorTypes };
 //# sourceMappingURL=Controller.d.ts.map

package/ts3.4/index.d.ts

@@ -1,6 +1,6 @@
 import * as __INTERNAL__1 from './internal.js';
 export { __INTERNAL__1 as __INTERNAL__ };
-export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, ResolveType, DenormalizeCache, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, } from '@data-client/normalizr';
+export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, } from '@data-client/normalizr';
 export { ExpiryStatus } from '@data-client/normalizr';
 export { default as NetworkManager, ResetError, } from './manager/NetworkManager.js';
 export { default as createReducer, initialState, } from './state/reducer/createReducer.js';

package/ts3.4/internal.d.ts

@@ -1,4 +1,4 @@
-export { inferResults, INVALID } from '@data-client/normalizr';
+export { MemoCache, INVALID } from '@data-client/normalizr';
 export { default as RIC } from './state/RIC.js';
 export { initialState } from './state/reducer/createReducer.js';
 //# sourceMappingURL=internal.d.ts.map

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

@@ -16,7 +16,7 @@ export declare function expireReducer(state: State<unknown>, action: ExpireAllAc
         } | undefined;
     };
     indexes: import("packages/normalizr/lib/interface.js").NormalizedIndex;
-    results: {
+    endpoints: {
         readonly [key: string]: unknown;
     };
     entityMeta: {

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

@@ -1,6 +1,6 @@
 import { State, InvalidateAllAction, InvalidateAction } from '../../types.js';
 export declare function invalidateReducer(state: State<unknown>, action: InvalidateAction | InvalidateAllAction): {
-    results: {
+    endpoints: {
         [x: string]: unknown;
     };
     meta: {

package/ts3.4/types.d.ts

@@ -14,7 +14,7 @@ export interface State<T> {
         } | undefined;
     };
     readonly indexes: NormalizedIndex;
-    readonly results: {
+    readonly endpoints: {
         readonly [key: string]: unknown | PK[] | PK | undefined;
     };
     readonly meta: {