@data-client/core 0.13.1 → 0.14.0

package/src/actions.ts

@@ -28,102 +28,98 @@ type EndpointDefault = EndpointInterface & {
   update?: EndpointUpdateFunction<EndpointInterface>;
 };
 
-/* SET */
-export interface SetMeta {
-  args: readonly any[];
-  fetchedAt: number;
-  date: number;
-  expiresAt: number;
+/** General meta-data for operators */
+export interface ActionMeta {
+  readonly fetchedAt: number;
+  readonly date: number;
+  readonly expiresAt: number;
 }
 
+/** Action for Controller.set() */
 export interface SetAction<S extends Queryable = any> {
   type: typeof SET_TYPE;
   schema: S;
-  meta: SetMeta;
-  value: Denormalize<S>;
+  args: readonly any[];
+  meta: ActionMeta;
+  value: {} | ((previousValue: Denormalize<S>) => {});
 }
 
 /* setResponse */
-export interface SetResponseMeta {
+export interface SetResponseActionBase<
+  E extends EndpointAndUpdate<E> = EndpointDefault,
+> {
+  type: typeof SET_RESPONSE_TYPE;
+  endpoint: E;
   args: readonly any[];
   key: string;
-  fetchedAt: number;
-  date: number;
-  expiresAt: number;
+  meta: ActionMeta;
 }
 export interface SetResponseActionSuccess<
   E extends EndpointAndUpdate<E> = EndpointDefault,
-> {
-  type: typeof SET_RESPONSE_TYPE;
-  endpoint: E;
-  meta: SetResponseMeta;
-  payload: ResolveType<E>;
+> extends SetResponseActionBase<E> {
+  response: ResolveType<E>;
   error?: false;
 }
 export interface SetResponseActionError<
   E extends EndpointAndUpdate<E> = EndpointDefault,
-> {
-  type: typeof SET_RESPONSE_TYPE;
-  endpoint: E;
-  meta: SetResponseMeta;
-  payload: UnknownError;
+> extends SetResponseActionBase<E> {
+  response: UnknownError;
   error: true;
 }
+/** Action for Controller.setResponse() */
 export type SetResponseAction<
   E extends EndpointAndUpdate<E> = EndpointDefault,
 > = SetResponseActionSuccess<E> | SetResponseActionError<E>;
 
 /* FETCH */
-export interface FetchMeta<A extends readonly any[] = readonly any[]> {
-  args: A;
-  key: string;
-  throttle: boolean;
+export interface FetchMeta {
+  fetchedAt: number;
   resolve: (value?: any | PromiseLike<any>) => void;
   reject: (reason?: any) => void;
   promise: PromiseLike<any>;
-  createdAt: number;
-  // indicates whether network manager processed it
-  nm?: boolean;
 }
 
+/** Action for Controller.fetch() */
 export interface FetchAction<E extends EndpointAndUpdate<E> = EndpointDefault> {
   type: typeof FETCH_TYPE;
   endpoint: E;
-  meta: FetchMeta<readonly [...Parameters<E>]>;
-  payload: () => ReturnType<E>;
+  args: readonly [...Parameters<E>];
+  key: string;
+  meta: FetchMeta;
 }
 
 /* OPTIMISTIC */
+/** Action for Endpoint.getOptimisticResponse() */
 export interface OptimisticAction<
   E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof OPTIMISTIC_TYPE;
   endpoint: E;
-  meta: SetResponseMeta;
+  args: readonly any[];
+  key: string;
+  meta: ActionMeta;
   error?: false;
 }
 
 /* SUBSCRIBE */
+/** Action for Controller.subscribe() */
 export interface SubscribeAction<
   E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof SUBSCRIBE_TYPE;
   endpoint: E;
-  meta: {
-    args: readonly any[];
-    key: string;
-  };
+  args: readonly any[];
+  key: string;
 }
 
+/** Action for Controller.unsubscribe() */
 export interface UnsubscribeAction<
   E extends EndpointAndUpdate<E> = EndpointDefault,
 > {
   type: typeof UNSUBSCRIBE_TYPE;
   endpoint: E;
-  meta: {
-    args: readonly any[];
-    key: string;
-  };
+  args: readonly any[];
+  key: string;
 }
 
 /* EXPIRY */
@@ -140,9 +136,7 @@ export interface InvalidateAllAction {
 
 export interface InvalidateAction {
   type: typeof INVALIDATE_TYPE;
-  meta: {
-    key: string;
-  };
+  key: string;
 }
 
 /* RESET */

package/src/controller/Controller.ts

@@ -20,17 +20,19 @@ import {
 } from '@data-client/normalizr';
 
 import AbortOptimistic from './AbortOptimistic.js';
-import createExpireAll from './createExpireAll.js';
-import createFetch from './createFetch.js';
-import createInvalidate from './createInvalidate.js';
-import createInvalidateAll from './createInvalidateAll.js';
-import createReset from './createReset.js';
-import createSet from './createSet.js';
-import createSetResponse from './createSetResponse.js';
 import {
   createUnsubscription,
   createSubscription,
-} from './createSubscription.js';
+} from './actions/createSubscription.js';
+import {
+  createExpireAll,
+  createFetch,
+  createInvalidate,
+  createInvalidateAll,
+  createReset,
+  createSet,
+  createSetResponse,
+} from './actions/index.js';
 import ensurePojo from './ensurePojo.js';
 import type { EndpointUpdateFunction } from './types.js';
 import { initialState } from '../state/reducer/createReducer.js';
@@ -117,7 +119,7 @@ export default class Controller<
 
     if (endpoint.schema) {
       return action.meta.promise.then(input =>
-        denormalize(input, endpoint.schema, {}, args),
+        denormalize(endpoint.schema, input, {}, args),
       ) as any;
     }
     return action.meta.promise as any;
@@ -186,18 +188,28 @@ export default class Controller<
    * Sets value for the Queryable and args.
    * @see https://dataclient.io/docs/api/Controller#set
    */
-  set = <S extends Queryable>(
+  set<S extends Queryable>(
+    schema: S,
+    ...rest: readonly [...SchemaArgs<S>, (previousValue: Denormalize<S>) => {}]
+  ): Promise<void>;
+
+  set<S extends Queryable>(
+    schema: S,
+    ...rest: readonly [...SchemaArgs<S>, {}]
+  ): Promise<void>;
+
+  set<S extends Queryable>(
     schema: S,
     ...rest: readonly [...SchemaArgs<S>, any]
-  ): Promise<void> => {
-    const value: Denormalize<S> = rest[rest.length - 1];
+  ): Promise<void> {
+    const value = rest[rest.length - 1];
     const action = createSet(schema, {
       args: rest.slice(0, rest.length - 1) as SchemaArgs<S>,
       value,
     });
     // TODO: reject with error if this fails in reducer
     return this.dispatch(action);
-  };
+  }
 
   /**
    * Sets response for the Endpoint and args.
@@ -241,7 +253,7 @@ export default class Controller<
   };
 
   /**
-   * Resolves an inflight fetch. `fetchedAt` should `fetch`'s `createdAt`
+   * Resolves an inflight fetch.
    * @see https://dataclient.io/docs/api/Controller#resolve
    */
   resolve = <
@@ -420,11 +432,11 @@ export default class Controller<
       shouldQuery ?
         // nothing in endpoints cache, so try querying if we have a schema to do so
         this.memo.buildQueryKey(
-          key,
           schema,
           args,
           state.entities as any,
           state.indexes,
+          key,
         )
       : cacheEndpoints;
 
@@ -454,8 +466,8 @@ export default class Controller<
     // second argument is false if any entities are missing
     // eslint-disable-next-line prefer-const
     const { data, paths } = this.memo.denormalize(
-      input,
       schema,
+      input,
       state.entities,
       args,
     ) as { data: any; paths: EntityPath[] };
@@ -490,16 +502,7 @@ export default class Controller<
       .slice(0, rest.length - 1)
       .map(ensurePojo) as SchemaArgs<S>;
 
-    // NOTE: different orders can result in cache busting here; but since it's just a perf penalty we will allow for now
-    const key = JSON.stringify(args);
-
-    return this.memo.query(
-      key,
-      schema,
-      args,
-      state.entities as any,
-      state.indexes,
-    );
+    return this.memo.query(schema, args, state.entities as any, state.indexes);
   }
 
   private getSchemaResponse<T>(

package/src/controller/__tests__/Controller.ts

@@ -36,8 +36,8 @@ describe('Controller', () => {
         tags: ['a', 'best', 'react'],
       };
       const { entities, result } = normalize(
-        payload,
         CoolerArticleResource.get.schema,
+        payload,
       );
       const fetchKey = CoolerArticleResource.get.key({ id: payload.id });
       const state = {
@@ -73,8 +73,8 @@ describe('Controller', () => {
         tags: ['a', 'best', 'react'],
       };
       const { entities, result } = normalize(
-        payload,
         CoolerArticleResource.get.schema,
+        payload,
       );
       const fetchKey = CoolerArticleResource.get.key({ id: payload.id });
       const state = {

package/src/controller/actions/createExpireAll.ts

@@ -0,0 +1,11 @@
+import { EXPIREALL_TYPE } from '../../actionTypes.js';
+import type { ExpireAllAction } from '../../types.js';
+
+export function createExpireAll(
+  testKey: (key: string) => boolean,
+): ExpireAllAction {
+  return {
+    type: EXPIREALL_TYPE,
+    testKey,
+  };
+}

package/src/controller/{createFetch.ts → actions/createFetch.ts}

@@ -1,39 +1,35 @@
 import type { EndpointInterface, NI } from '@data-client/normalizr';
 
-import { EndpointUpdateFunction } from './types.js';
-import { FETCH_TYPE } from '../actionTypes.js';
-import type { FetchAction, FetchMeta } from '../types.js';
+import { FETCH_TYPE } from '../../actionTypes.js';
+import type { FetchAction, FetchMeta } from '../../types.js';
+import { EndpointUpdateFunction } from '../types.js';
 
 /**
  * Requesting a fetch to begin
  */
-export default function createFetch<
+export function createFetch<
   E extends EndpointInterface & { update?: EndpointUpdateFunction<E> },
 >(
   endpoint: E,
   { args }: { args: readonly [...Parameters<E>] },
 ): FetchAction<E> {
-  const key = endpoint.key(...args);
   let resolve: (value?: any | PromiseLike<any>) => void = 0 as any;
   let reject: (reason?: any) => void = 0 as any;
   const promise = new Promise<any>((a, b) => {
     [resolve, reject] = [a, b];
   });
-  const meta: FetchMeta<typeof args> = {
-    args,
-    key,
-    throttle: !endpoint.sideEffect,
+  const meta: FetchMeta = {
+    fetchedAt: Date.now(),
     resolve,
     reject,
     promise,
-    createdAt: Date.now(),
-    nm: false,
   };
 
   return {
     type: FETCH_TYPE,
-    payload: () => endpoint(...args) as any,
-    meta,
     endpoint,
+    args,
+    key: endpoint.key(...args),
+    meta,
   };
 }

package/src/controller/actions/createInvalidate.ts

@@ -0,0 +1,14 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { INVALIDATE_TYPE } from '../../actionTypes.js';
+import type { InvalidateAction } from '../../types.js';
+
+export function createInvalidate<E extends EndpointInterface>(
+  endpoint: E,
+  { args }: { args: readonly [...Parameters<E>] },
+): InvalidateAction {
+  return {
+    type: INVALIDATE_TYPE,
+    key: endpoint.key(...args),
+  };
+}

package/src/controller/actions/createInvalidateAll.ts

@@ -0,0 +1,11 @@
+import { INVALIDATEALL_TYPE } from '../../actionTypes.js';
+import type { InvalidateAllAction } from '../../types.js';
+
+export function createInvalidateAll(
+  testKey: (key: string) => boolean,
+): InvalidateAllAction {
+  return {
+    type: INVALIDATEALL_TYPE,
+    testKey,
+  };
+}

package/src/controller/actions/createMeta.ts

@@ -0,0 +1,13 @@
+import type { ActionMeta } from '../../actions.js';
+
+export function createMeta(
+  expiryLength: number,
+  fetchedAt?: number,
+): ActionMeta {
+  const now = Date.now();
+  return {
+    fetchedAt: fetchedAt ?? now,
+    date: now,
+    expiresAt: now + expiryLength,
+  };
+}

package/src/controller/actions/createOptimistic.ts

@@ -0,0 +1,32 @@
+import type { EndpointInterface } from '@data-client/normalizr';
+
+import { createMeta } from './createMeta.js';
+import { OPTIMISTIC_TYPE } from '../../actionTypes.js';
+import type { OptimisticAction } from '../../types.js';
+import type { EndpointUpdateFunction } from '../types.js';
+
+export function createOptimistic<
+  E extends EndpointInterface & {
+    update?: EndpointUpdateFunction<E>;
+  },
+>(
+  endpoint: E,
+  args: readonly [...Parameters<E>],
+  fetchedAt: number,
+): OptimisticAction<E> {
+  /* istanbul ignore next */
+  if (
+    process.env.NODE_ENV === 'development' &&
+    (endpoint.dataExpiryLength ?? 0) < 0
+  ) {
+    throw new Error('Negative expiry length are not allowed.');
+  }
+
+  return {
+    type: OPTIMISTIC_TYPE,
+    endpoint,
+    args,
+    key: endpoint.key(...args),
+    meta: createMeta(endpoint.dataExpiryLength ?? 60000, fetchedAt),
+  };
+}

package/src/controller/actions/createReset.ts

@@ -0,0 +1,9 @@
+import { RESET_TYPE } from '../../actionTypes.js';
+import type { ResetAction } from '../../types.js';
+
+export function createReset(): ResetAction {
+  return {
+    type: RESET_TYPE,
+    date: Date.now(),
+  };
+}

package/src/controller/actions/createSet.ts

@@ -0,0 +1,31 @@
+import type {
+  Denormalize,
+  Queryable,
+  SchemaArgs,
+} from '@data-client/normalizr';
+
+import { createMeta } from './createMeta.js';
+import { SET_TYPE } from '../../actionTypes.js';
+import type { SetAction } from '../../types.js';
+import ensurePojo from '../ensurePojo.js';
+
+export function createSet<S extends Queryable>(
+  schema: S,
+  {
+    args,
+    fetchedAt,
+    value,
+  }: {
+    args: readonly [...SchemaArgs<S>];
+    value: {} | ((previousValue: Denormalize<S>) => {});
+    fetchedAt?: number;
+  },
+): SetAction<S> {
+  return {
+    type: SET_TYPE,
+    schema,
+    value,
+    args: args.map(ensurePojo) as SchemaArgs<S>,
+    meta: createMeta(60000, fetchedAt),
+  };
+}

package/src/controller/{createSetResponse.ts → actions/createSetResponse.ts}

@@ -1,11 +1,12 @@
 import type { EndpointInterface, ResolveType } from '@data-client/normalizr';
 
-import ensurePojo from './ensurePojo.js';
-import { EndpointUpdateFunction } from './types.js';
-import { SET_RESPONSE_TYPE } from '../actionTypes.js';
-import type { SetResponseAction, SetResponseMeta } from '../types.js';
+import { createMeta } from './createMeta.js';
+import { SET_RESPONSE_TYPE } from '../../actionTypes.js';
+import type { SetResponseAction } from '../../types.js';
+import ensurePojo from '../ensurePojo.js';
+import { EndpointUpdateFunction } from '../types.js';
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -19,7 +20,7 @@ export default function createSetResponse<
   },
 ): SetResponseAction<E>;
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -33,7 +34,7 @@ export default function createSetResponse<
   },
 ): SetResponseAction<E>;
 
-export default function createSetResponse<
+export function createSetResponse<
   E extends EndpointInterface & {
     update?: EndpointUpdateFunction<E>;
   },
@@ -53,27 +54,20 @@ export default function createSetResponse<
 ): SetResponseAction<E> {
   const expiryLength: number =
     error ?
-      endpoint.errorExpiryLength ?? 1000
-    : endpoint.dataExpiryLength ?? 60000;
+      (endpoint.errorExpiryLength ?? 1000)
+    : (endpoint.dataExpiryLength ?? 60000);
   /* istanbul ignore next */
   if (process.env.NODE_ENV === 'development' && expiryLength < 0) {
     throw new Error('Negative expiry length are not allowed.');
   }
-  const now = Date.now();
-  const meta: SetResponseMeta = {
-    args: args.map(ensurePojo),
-    fetchedAt: fetchedAt ?? now,
-    date: now,
-    expiresAt: now + expiryLength,
-    key: endpoint.key(...args),
-  };
 
-  const action: SetResponseAction<E> = {
+  return {
     type: SET_RESPONSE_TYPE,
-    payload: response,
-    endpoint: endpoint,
-    meta,
+    endpoint,
+    response,
+    args: args.map(ensurePojo),
+    key: endpoint.key(...args),
+    meta: createMeta(expiryLength, fetchedAt),
+    error,
   };
-  if (error) (action as any).error = true;
-  return action;
 }

package/src/controller/{createSubscription.ts → actions/createSubscription.ts}

@@ -1,7 +1,7 @@
 import type { EndpointInterface } from '@data-client/normalizr';
 
-import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../actionTypes.js';
-import type { SubscribeAction, UnsubscribeAction } from '../types.js';
+import { SUBSCRIBE_TYPE, UNSUBSCRIBE_TYPE } from '../../actionTypes.js';
+import type { SubscribeAction, UnsubscribeAction } from '../../types.js';
 
 export function createSubscription<E extends EndpointInterface>(
   endpoint: E,
@@ -10,10 +10,8 @@ export function createSubscription<E extends EndpointInterface>(
   return {
     type: SUBSCRIBE_TYPE,
     endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args),
-    },
+    args,
+    key: endpoint.key(...args),
   };
 }
 
@@ -24,9 +22,7 @@ export function createUnsubscription<E extends EndpointInterface>(
   return {
     type: UNSUBSCRIBE_TYPE,
     endpoint,
-    meta: {
-      args,
-      key: endpoint.key(...args),
-    },
+    args,
+    key: endpoint.key(...args),
   };
 }

package/src/controller/actions/index.ts

@@ -0,0 +1,13 @@
+export {
+  createSubscription,
+  createUnsubscription,
+} from './createSubscription.js';
+export { createSetResponse } from './createSetResponse.js';
+export { createSet } from './createSet.js';
+export { createReset } from './createReset.js';
+export { createOptimistic } from './createOptimistic.js';
+export { createMeta } from './createMeta.js';
+export { createInvalidateAll } from './createInvalidateAll.js';
+export { createInvalidate } from './createInvalidate.js';
+export { createFetch } from './createFetch.js';
+export { createExpireAll } from './createExpireAll.js';

package/src/index.ts

@@ -39,9 +39,7 @@ export type {
   DataClientDispatch,
   GenericDispatch,
 } from './controller/Controller.js';
-export { default as createFetch } from './controller/createFetch.js';
-export { default as createSet } from './controller/createSet.js';
-export { default as createSetResponse } from './controller/createSetResponse.js';
+export * as actions from './controller/actions/index.js';
 
 export * from './controller/types.js';
 export * as actionTypes from './actionTypes.js';

package/src/internal.ts

@@ -1,3 +1,2 @@
 export { MemoCache, INVALID } from '@data-client/normalizr';
-export { default as RIC } from './state/RIC.js';
 export { initialState } from './state/reducer/createReducer.js';

package/src/manager/LogoutManager.ts

@@ -18,7 +18,7 @@ export default class LogoutManager implements Manager {
       if (
         action.type === SET_RESPONSE_TYPE &&
         action.error &&
-        this.shouldLogout(action.payload)
+        this.shouldLogout(action.response)
       ) {
         this.handleLogout(controller);
       }