@data-client/core 0.13.1 → 0.14.0

package/src/state/__tests__/reducer.ts

@@ -1,4 +1,4 @@
-import { INVALID } from '@data-client/endpoint';
+import { INVALID, Entity } from '@data-client/endpoint';
 import { ArticleResource, Article, PaginatedArticle } from '__tests__/new';
 
 import { Controller } from '../..';
@@ -34,22 +34,22 @@ describe('reducer', () => {
 
   describe('singles', () => {
     const id = 20;
-    const payload = { id, title: 'hi', content: 'this is the content' };
+    const response = { id, title: 'hi', content: 'this is the content' };
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload,
+      response,
       endpoint: ArticleResource.get,
+      args: [{ id }],
+      key: ArticleResource.get.url({ id }),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.get.url({ id }),
         date: 5000000000,
         expiresAt: 5000500000,
         fetchedAt: 5000000000,
       },
     };
-    const partialResultAction = {
+    const partialResultAction: SetResponseAction = {
       ...action,
-      payload: { id, title: 'hello' },
+      response: { id, title: 'hello' },
     };
     const iniState = initialState;
     let newState = initialState;
@@ -59,7 +59,7 @@ describe('reducer', () => {
     });
     it('should overwrite existing entity', () => {
       const getEntity = (state: any): Article =>
-        state.entities[Article.key][`${Article.pk(action.payload)}`];
+        state.entities[Article.key][`${Article.pk(action.response)}`];
       const prevEntity = getEntity(newState);
       expect(prevEntity).toBeDefined();
       const nextState = reducer(newState, action);
@@ -69,7 +69,7 @@ describe('reducer', () => {
     });
     it('should merge partial entity with existing entity', () => {
       const getEntity = (state: any): Article =>
-        state.entities[Article.key][`${Article.pk(action.payload)}`];
+        state.entities[Article.key][`${Article.pk(action.response)}`];
       const prevEntity = getEntity(newState);
       expect(prevEntity).toBeDefined();
       const nextState = reducer(newState, partialResultAction);
@@ -78,16 +78,17 @@ describe('reducer', () => {
       expect(nextEntity).toBeDefined();
 
       expect(nextEntity.title).not.toBe(prevEntity.title);
-      expect(nextEntity.title).toBe(partialResultAction.payload.title);
+      expect(nextEntity.title).toBe(partialResultAction.response.title);
 
       expect(nextEntity.content).toBe(prevEntity.content);
       expect(nextEntity.content).not.toBe(undefined);
 
       expect(
-        nextState.entityMeta[Article.key][`${Article.pk(action.payload)}`],
+        nextState.entityMeta[Article.key][`${Article.pk(action.response)}`],
       ).toBeDefined();
       expect(
-        nextState.entityMeta[Article.key][`${Article.pk(action.payload)}`].date,
+        nextState.entityMeta[Article.key][`${Article.pk(action.response)}`]
+          .date,
       ).toBe(action.meta.date);
     });
 
@@ -101,7 +102,7 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { expiresAt: number } =>
-        state.entityMeta[Article.key][`${Article.pk(action.payload)}`];
+        state.entityMeta[Article.key][`${Article.pk(action.response)}`];
       const prevMeta = getMeta(newState);
       expect(prevMeta).toBeDefined();
       const nextState = reducer(newState, localAction);
@@ -122,9 +123,9 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { date: number } =>
-        state.entityMeta[Article.key][`${Article.pk(action.payload)}`];
+        state.entityMeta[Article.key][`${Article.pk(action.response)}`];
       const getEntity = (state: any): Article =>
-        state.entities[Article.key][`${Article.pk(action.payload)}`];
+        state.entities[Article.key][`${Article.pk(action.response)}`];
       const prevEntity = getEntity(newState);
       const prevMeta = getMeta(newState);
       expect(prevMeta).toBeDefined();
@@ -181,9 +182,9 @@ describe('reducer', () => {
         },
       };
       const getMeta = (state: any): { date: number; expiresAt: number } =>
-        state.entityMeta[ExpiresSoon.key][`${ExpiresSoon.pk(action.payload)}`];
+        state.entityMeta[ExpiresSoon.key][`${ExpiresSoon.pk(action.response)}`];
       const getEntity = (state: any): ExpiresSoon =>
-        state.entities[ExpiresSoon.key][`${ExpiresSoon.pk(action.payload)}`];
+        state.entities[ExpiresSoon.key][`${ExpiresSoon.pk(action.response)}`];
 
       const prevEntity = getEntity(newState);
       const prevMeta = getMeta(newState);
@@ -202,6 +203,75 @@ describe('reducer', () => {
     });
   });
 
+  it('set(function) should do nothing when entity does not exist', () => {
+    const id = 20;
+    const value = (previous: { counter: number }) => ({
+      counter: previous.counter + 1,
+    });
+    class Counter extends Entity {
+      id = 0;
+      counter = 0;
+      pk() {
+        return this.id;
+      }
+
+      static key = 'Counter';
+    }
+    const action: SetAction = {
+      type: SET_TYPE,
+      value,
+      schema: Counter,
+      args: [{ id }],
+      meta: {
+        date: 0,
+        fetchedAt: 0,
+        expiresAt: 1000000000000,
+      },
+    };
+    const newState = reducer(initialState, action);
+    expect(newState).toBe(initialState);
+  });
+
+  it('set(function) should increment when it is found', () => {
+    const id = 20;
+    const value = (previous: { id: number; counter: number }) => ({
+      id: previous.id,
+      counter: previous.counter + 1,
+    });
+    class Counter extends Entity {
+      id = 0;
+      counter = 0;
+      pk() {
+        return this.id;
+      }
+
+      static key = 'Counter';
+    }
+    const action: SetAction = {
+      type: SET_TYPE,
+      value,
+      schema: Counter,
+      args: [{ id }],
+      meta: {
+        date: 0,
+        fetchedAt: 0,
+        expiresAt: 1000000000000,
+      },
+    };
+    const state = {
+      ...initialState,
+      entities: {
+        [Counter.key]: {
+          [id]: { id, counter: 5 },
+        },
+      },
+    };
+    const newState = reducer(state, action);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(newState.entities[Counter.key]?.[id]?.counter).toBe(6);
+  });
+
   it('set should add entity when it does not exist', () => {
     const id = 20;
     const value = { id, title: 'hi', content: 'this is the content' };
@@ -209,8 +279,8 @@ describe('reducer', () => {
       type: SET_TYPE,
       value,
       schema: Article,
+      args: [{ id }],
       meta: {
-        args: [{ id }],
         date: 0,
         fetchedAt: 0,
         expiresAt: 1000000000000,
@@ -231,8 +301,8 @@ describe('reducer', () => {
       type: SET_TYPE,
       value,
       schema: Article,
+      args: [{ id }],
       meta: {
-        args: [{ id }],
         date: 0,
         fetchedAt: 0,
         expiresAt: 1000000000000,
@@ -248,14 +318,14 @@ describe('reducer', () => {
 
   it('mutate should never change endpoints', () => {
     const id = 20;
-    const payload = { id, title: 'hi', content: 'this is the content' };
+    const response = { id, title: 'hi', content: 'this is the content' };
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload,
+      response,
       endpoint: ArticleResource.get,
+      args: [{ id }],
+      key: ArticleResource.get.key(response),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.get.key(payload),
         date: 0,
         fetchedAt: 0,
         expiresAt: 1000000000000,
@@ -263,7 +333,7 @@ describe('reducer', () => {
     };
     const iniState = {
       ...initialState,
-      endpoints: { abc: '5', [ArticleResource.get.key(payload)]: `${id}` },
+      endpoints: { abc: '5', [ArticleResource.get.key(response)]: `${id}` },
     };
     const newState = reducer(iniState, action);
     expect(newState.endpoints).toStrictEqual(iniState.endpoints);
@@ -272,11 +342,11 @@ describe('reducer', () => {
     const id = 20;
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload: { id },
+      response: { id },
       endpoint: ArticleResource.delete,
+      args: [{ id }],
+      key: ArticleResource.delete.key({ id }),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.delete.key({ id }),
         fetchedAt: 0,
         date: 0,
         expiresAt: 0,
@@ -422,9 +492,7 @@ describe('reducer', () => {
     const id = 20;
     const action: InvalidateAction = {
       type: INVALIDATE_TYPE,
-      meta: {
-        key: id.toString(),
-      },
+      key: id.toString(),
     };
     const iniState: any = {
       ...initialState,
@@ -461,11 +529,11 @@ describe('reducer', () => {
     const error = new Error('hi');
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload: error,
+      response: error,
       endpoint: ArticleResource.get,
+      args: [{ id }],
+      key: ArticleResource.get.key({ id }),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.get.key({ id }),
         fetchedAt: 5000000000,
         date: 5000000000,
         expiresAt: 5000500000,
@@ -481,11 +549,11 @@ describe('reducer', () => {
     const error = new Error('hi');
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload: error,
+      response: error,
       endpoint: ArticleResource.get,
+      args: [{ id }],
+      key: ArticleResource.get.key({ id }),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.get.key({ id }),
         fetchedAt: 0,
         date: 0,
         expiresAt: 10000000000000000000,
@@ -502,11 +570,11 @@ describe('reducer', () => {
     const error = new Error('hi');
     const action: SetResponseAction = {
       type: SET_RESPONSE_TYPE,
-      payload: error,
+      response: error,
       endpoint: ArticleResource.delete,
+      args: [{ id }],
+      key: ArticleResource.delete.key({ id }),
       meta: {
-        args: [{ id }],
-        key: ArticleResource.delete.key({ id }),
         fetchedAt: 0,
         date: 0,
         expiresAt: 0,
@@ -534,16 +602,14 @@ describe('reducer', () => {
     try {
       const action: FetchAction = {
         type: FETCH_TYPE,
-        payload: () => new Promise<any>(() => null),
         endpoint: ArticleResource.get,
+        args: [{ id: 5 }],
+        key: ArticleResource.get.url({ id: 5 }),
         meta: {
-          args: [{ id: 5 }],
-          key: ArticleResource.get.url({ id: 5 }),
-          throttle: true,
           reject: (v: any) => null,
           resolve: (v: any) => null,
           promise: new Promise((v: any) => null),
-          createdAt: 0,
+          fetchedAt: 0,
         },
       };
       const iniState = {

package/src/state/reducer/createReducer.ts

@@ -44,7 +44,7 @@ export default function createReducer(controller: Controller): ReducerType {
         return setResponseReducer(state, action, controller);
 
       case SET_TYPE:
-        return setReducer(state, action);
+        return setReducer(state, action, controller);
 
       case INVALIDATEALL_TYPE:
       case INVALIDATE_TYPE:

package/src/state/reducer/fetchReducer.ts

@@ -1,19 +1,17 @@
-import createOptimistic from '../../controller/createOptimistic.js';
-import type {
-  State,
-  SetResponseAction,
-  OptimisticAction,
-  FetchAction,
-} from '../../types.js';
+import { createOptimistic } from '../../controller/actions/createOptimistic.js';
+import type { State, FetchAction } from '../../types.js';
 
 export function fetchReducer(state: State<unknown>, action: FetchAction) {
-  let setAction: SetResponseAction | OptimisticAction;
-
   if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
-    setAction = createOptimistic(action.endpoint, {
-      args: action.meta.args,
-      fetchedAt: action.meta.createdAt,
-    });
+    const setAction = createOptimistic(
+      action.endpoint,
+      action.args,
+      action.meta.fetchedAt,
+    );
+    return {
+      ...state,
+      optimistic: [...state.optimistic, setAction],
+    };
   } else {
     // If 'fetch' action reaches the reducer there are no middlewares installed to handle it
     /* istanbul ignore next */
@@ -22,14 +20,10 @@ export function fetchReducer(state: State<unknown>, action: FetchAction) {
         'Fetch appears unhandled - you are likely missing the NetworkManager middleware',
       );
       console.warn(
-        'See https://dataclient.io/docs/guides/redux#indextsx for hooking up redux',
+        'See https://dataclient.io/docs/guides/redux for hooking up redux',
       );
     }
 
     return state;
   }
-  return {
-    ...state,
-    optimistic: [...state.optimistic, setAction],
-  };
 }

package/src/state/reducer/invalidateReducer.ts

@@ -22,7 +22,7 @@ export function invalidateReducer(
     meta[key] = itemMeta;
   };
   if (action.type === INVALIDATE_TYPE) {
-    invalidateKey(action.meta.key);
+    invalidateKey(action.key);
   } else {
     Object.keys(endpoints).forEach(key => {
       if (action.testKey(key)) {

package/src/state/reducer/setReducer.ts

@@ -1,16 +1,27 @@
 import { normalize } from '@data-client/normalizr';
 
+import Controller from '../../controller/Controller.js';
 import type { State, SetAction } from '../../types.js';
 
-export function setReducer(state: State<unknown>, action: SetAction) {
+export function setReducer(
+  state: State<unknown>,
+  action: SetAction,
+  controller: Controller,
+) {
+  let value: any;
+  if (typeof action.value === 'function') {
+    const previousValue = controller.get(action.schema, ...action.args, state);
+    if (previousValue === undefined) return state;
+    value = action.value(previousValue);
+  } else {
+    value = action.value;
+  }
   try {
     const { entities, indexes, entityMeta } = normalize(
-      action.value,
       action.schema,
-      action.meta.args as any,
-      state.entities,
-      state.indexes,
-      state.entityMeta,
+      value,
+      action.args,
+      state,
       action.meta,
     );
     return {

package/src/state/reducer/setResponseReducer.ts

@@ -15,21 +15,21 @@ export function setResponseReducer(
   controller: Controller,
 ) {
   if (action.error) {
-    return reduceError(state, action, action.payload);
+    return reduceError(state, action, action.response);
   }
   try {
-    let payload: any;
-    // for true set's payload is contained in action
+    let response: any;
+    // for true set's response is contained in action
     if (action.type === OPTIMISTIC_TYPE) {
       // this should never happen
       /* istanbul ignore if */
       if (!action.endpoint.getOptimisticResponse) return state;
       try {
         // compute optimistic response based on current state
-        payload = action.endpoint.getOptimisticResponse.call(
+        response = action.endpoint.getOptimisticResponse.call(
           action.endpoint,
           controller.snapshot(state, action.meta.fetchedAt),
-          ...action.meta.args,
+          ...action.args,
         );
       } catch (e: any) {
         // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
@@ -39,24 +39,22 @@ export function setResponseReducer(
         throw e;
       }
     } else {
-      payload = action.payload;
+      response = action.response;
     }
     const { result, entities, indexes, entityMeta } = normalize(
-      payload,
       action.endpoint.schema,
-      action.meta.args as any,
-      state.entities,
-      state.indexes,
-      state.entityMeta,
+      response,
+      action.args,
+      state,
       action.meta,
     );
     const endpoints: Record<string, unknown> = {
       ...state.endpoints,
-      [action.meta.key]: result,
+      [action.key]: result,
     };
     try {
       if (action.endpoint.update) {
-        const updaters = action.endpoint.update(result, ...action.meta.args);
+        const updaters = action.endpoint.update(result, ...action.args);
         Object.keys(updaters).forEach(key => {
           endpoints[key] = updaters[key](endpoints[key]);
         });
@@ -65,7 +63,7 @@ export function setResponseReducer(
       // integrity of this state update is still guaranteed
     } catch (error) {
       console.error(
-        `The following error occured during Endpoint.update() for ${action.meta.key}`,
+        `The following error occured during Endpoint.update() for ${action.key}`,
       );
       console.error(error);
     }
@@ -76,10 +74,10 @@ export function setResponseReducer(
       entityMeta,
       meta: {
         ...state.meta,
-        [action.meta.key]: {
+        [action.key]: {
           date: action.meta.date,
           expiresAt: action.meta.expiresAt,
-          prevExpiresAt: state.meta[action.meta.key]?.expiresAt,
+          prevExpiresAt: state.meta[action.key]?.expiresAt,
         },
       },
       optimistic: filterOptimistic(state, action),
@@ -89,13 +87,13 @@ export function setResponseReducer(
   } catch (error: any) {
     if (typeof error === 'object') {
       error.message = `Error processing ${
-        action.meta.key
+        action.key
       }\n\nFull Schema: ${JSON.stringify(
         action.endpoint.schema,
         undefined,
         2,
       )}\n\nError:\n${error.message}`;
-      if ('payload' in action) error.payload = action.payload;
+      if ('response' in action) error.response = action.response;
       error.status = 400;
     }
 
@@ -126,7 +124,7 @@ function reduceError(
     ...state,
     meta: {
       ...state.meta,
-      [action.meta.key]: {
+      [action.key]: {
         date: action.meta.date,
         error,
         expiresAt: action.meta.expiresAt,
@@ -143,7 +141,7 @@ function filterOptimistic(
 ) {
   return state.optimistic.filter(
     optimisticAction =>
-      optimisticAction.meta.key !== resolvingAction.meta.key ||
+      optimisticAction.key !== resolvingAction.key ||
       (optimisticAction.type === OPTIMISTIC_TYPE ?
         optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt
       : optimisticAction.meta.date > resolvingAction.meta.date),

package/src/types.ts

@@ -12,6 +12,8 @@ import type {
 } from './actions.js';
 import type { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
 
+export * from './actions.js';
+
 export type { AbstractInstanceType, UpdateFunction };
 
 export type PK = string;
@@ -27,9 +29,9 @@ export interface State<T> {
   readonly meta: {
     readonly [key: string]: {
       readonly date: number;
-      readonly error?: ErrorTypes;
       readonly expiresAt: number;
       readonly prevExpiresAt?: number;
+      readonly error?: ErrorTypes;
       readonly invalidated?: boolean;
       readonly errorPolicy?: 'hard' | 'soft' | undefined;
     };
@@ -37,9 +39,9 @@ export interface State<T> {
   readonly entityMeta: {
     readonly [entityKey: string]: {
       readonly [pk: string]: {
+        readonly fetchedAt: number;
         readonly date: number;
         readonly expiresAt: number;
-        readonly fetchedAt: number;
       };
     };
   };
@@ -47,8 +49,6 @@ export interface State<T> {
   readonly lastReset: number;
 }
 
-export * from './actions.js';
-
 export interface Manager<Actions = ActionTypes> {
   getMiddleware(): Middleware<Actions>;
   cleanup(): void;