@data-client/core 0.12.3 → 0.13.0

package/src/manager/__tests__/logoutManager.ts

@@ -2,7 +2,7 @@ import { CoolerArticleResource } from '__tests__/new';
 
 import { Controller, initialState } from '../..';
 import { FETCH_TYPE, RESET_TYPE } from '../../actionTypes';
-import createSet from '../../controller/createSet';
+import createSetResponse from '../../controller/createSetResponse';
 import LogoutManager from '../LogoutManager.js';
 
 function onError(e: any) {
@@ -44,7 +44,7 @@ describe('LogoutManager', () => {
       },
     );
     it('should ignore non-error set', async () => {
-      const action = createSet(CoolerArticleResource.get, {
+      const action = createSetResponse(CoolerArticleResource.get, {
         args: [{ id: 5 }],
         response: { id: 5, title: 'hi' },
       });
@@ -55,7 +55,7 @@ describe('LogoutManager', () => {
     it('should ignore non-401 set', async () => {
       const error: any = new Error('network failed');
       error.status = 404;
-      const action = createSet(CoolerArticleResource.get, {
+      const action = createSetResponse(CoolerArticleResource.get, {
         args: [{ id: 5 }],
         response: error,
         error: true,
@@ -67,7 +67,7 @@ describe('LogoutManager', () => {
     it('should dispatch reset on 401', async () => {
       const error: any = new Error('network failed');
       error.status = 401;
-      const action = createSet(CoolerArticleResource.get, {
+      const action = createSetResponse(CoolerArticleResource.get, {
         args: [{ id: 5 }],
         response: error,
         error: true,
@@ -88,7 +88,7 @@ describe('LogoutManager', () => {
       }).getMiddleware();
       const error: any = new Error('network failed');
       error.status = 403;
-      const action = createSet(CoolerArticleResource.get, {
+      const action = createSetResponse(CoolerArticleResource.get, {
         args: [{ id: 5 }],
         response: error,
         error: true,

package/src/manager/__tests__/networkManager.ts

@@ -1,7 +1,7 @@
 import { Endpoint } from '@data-client/endpoint';
 import { Article, ArticleResource } from '__tests__/new';
 
-import { SET_TYPE } from '../../actionTypes';
+import { SET_RESPONSE_TYPE } from '../../actionTypes';
 import Controller from '../../controller/Controller';
 import createFetch from '../../controller/createFetch';
 import NetworkManager from '../../manager/NetworkManager';
@@ -160,7 +160,7 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: SET_TYPE,
+        type: SET_RESPONSE_TYPE,
         endpoint: fetchResolveAction.endpoint,
         payload: data,
         meta: {
@@ -193,7 +193,7 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: SET_TYPE,
+        type: SET_RESPONSE_TYPE,
         endpoint: fetchSetWithUpdatersAction.endpoint,
         payload: data,
         meta: {
@@ -226,7 +226,7 @@ describe('NetworkManager', () => {
       await new Promise(resolve => setTimeout(resolve, 0));
 
       const action = {
-        type: SET_TYPE,
+        type: SET_RESPONSE_TYPE,
         endpoint: fetchRpcWithUpdatersAction.endpoint,
         payload: data,
         meta: {
@@ -259,7 +259,7 @@ describe('NetworkManager', () => {
       // mutations resolve before dispatch, so we must wait for next tick to see set
       await new Promise(resolve => setTimeout(resolve, 0));
       expect(dispatch).toHaveBeenCalledWith({
-        type: SET_TYPE,
+        type: SET_RESPONSE_TYPE,
         endpoint: fetchRpcWithUpdatersAndOptimisticAction.endpoint,
         payload: data,
         meta: {
@@ -329,7 +329,7 @@ describe('NetworkManager', () => {
       } catch (error) {
         expect(next).not.toHaveBeenCalled();
         expect(dispatch).toHaveBeenCalledWith({
-          type: SET_TYPE,
+          type: SET_RESPONSE_TYPE,
           payload: error,
           meta: {
             key: fetchRejectAction.meta.key,

package/src/manager/__tests__/subscriptionManager.ts

@@ -4,7 +4,7 @@ import { actionTypes, Controller, initialState } from '../..';
 import { SubscribeAction, UnsubscribeAction } from '../../types';
 import SubscriptionManager, { Subscription } from '../SubscriptionManager.js';
 
-const { UNSUBSCRIBE_TYPE, SUBSCRIBE_TYPE, SET_TYPE } = actionTypes;
+const { UNSUBSCRIBE_TYPE, SUBSCRIBE_TYPE, SET_RESPONSE_TYPE } = actionTypes;
 
 function onError(e: any) {
   e.preventDefault();
@@ -192,7 +192,7 @@ describe('SubscriptionManager', () => {
     });
 
     it('should let other actions pass through', () => {
-      const action = { type: SET_TYPE };
+      const action = { type: SET_RESPONSE_TYPE };
       next.mockReset();
 
       middleware(API)(next)(action as any);

package/src/state/__tests__/reducer.ts

@@ -1,29 +1,24 @@
 import { INVALID } from '@data-client/endpoint';
-import {
-  ArticleResource,
-  PaginatedArticleResource,
-  Article,
-  PaginatedArticle,
-} from '__tests__/new';
+import { ArticleResource, Article, PaginatedArticle } from '__tests__/new';
 
 import { Controller } from '../..';
 import {
-  SET_TYPE,
   INVALIDATE_TYPE,
   FETCH_TYPE,
   RESET_TYPE,
   GC_TYPE,
+  SET_RESPONSE_TYPE,
+  SET_TYPE,
 } from '../../actionTypes';
-import createSet from '../../controller/createSet';
 import {
-  UpdateFunction,
   State,
   ActionTypes,
   FetchAction,
-  SetAction,
+  SetResponseAction,
   ResetAction,
   InvalidateAction,
   GCAction,
+  SetAction,
 } from '../../types';
 import createReducer, { initialState } from '../reducer/createReducer';
 
@@ -40,8 +35,8 @@ describe('reducer', () => {
   describe('singles', () => {
     const id = 20;
     const payload = { id, title: 'hi', content: 'this is the content' };
-    const action: SetAction = {
-      type: SET_TYPE,
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload,
       endpoint: ArticleResource.get,
       meta: {
@@ -207,11 +202,55 @@ describe('reducer', () => {
     });
   });
 
-  it('mutate should never change endpoints', () => {
+  it('set should add entity when it does not exist', () => {
     const id = 20;
-    const payload = { id, title: 'hi', content: 'this is the content' };
+    const value = { id, title: 'hi', content: 'this is the content' };
+    const action: SetAction = {
+      type: SET_TYPE,
+      value,
+      schema: Article,
+      meta: {
+        args: [{ id }],
+        date: 0,
+        fetchedAt: 0,
+        expiresAt: 1000000000000,
+      },
+    };
+    const iniState = {
+      ...initialState,
+      endpoints: { abc: '5', [ArticleResource.get.key(value)]: `${id}` },
+    };
+    const newState = reducer(iniState, action);
+    expect(newState.entities[Article.key]?.[id]).toEqual(value);
+  });
+
+  it('set should never change endpoints', () => {
+    const id = 20;
+    const value = { id, title: 'hi', content: 'this is the content' };
     const action: SetAction = {
       type: SET_TYPE,
+      value,
+      schema: Article,
+      meta: {
+        args: [{ id }],
+        date: 0,
+        fetchedAt: 0,
+        expiresAt: 1000000000000,
+      },
+    };
+    const iniState = {
+      ...initialState,
+      endpoints: { abc: '5', [ArticleResource.get.key(value)]: `${id}` },
+    };
+    const newState = reducer(iniState, action);
+    expect(newState.endpoints).toStrictEqual(iniState.endpoints);
+  });
+
+  it('mutate should never change endpoints', () => {
+    const id = 20;
+    const payload = { id, title: 'hi', content: 'this is the content' };
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload,
       endpoint: ArticleResource.get,
       meta: {
@@ -231,8 +270,8 @@ describe('reducer', () => {
   });
   it('purge should delete entities', () => {
     const id = 20;
-    const action: SetAction = {
-      type: SET_TYPE,
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload: { id },
       endpoint: ArticleResource.delete,
       meta: {
@@ -283,7 +322,7 @@ describe('reducer', () => {
       };
 
       it('should insert a new page of resources into a list request', () => {
-        const action = createSet(
+        const action = createSetResponse(
           { results: [{ id: 11 }, { id: 12 }] },
           {
             ...endpoint,
@@ -310,7 +349,7 @@ describe('reducer', () => {
       it('should insert correctly into the beginning of the list request', () => {
         const newState = reducer(
           iniState,
-          createSet(
+          createSetResponse(
             { results: [{ id: 11 }, { id: 12 }] },
             {
               ...endpoint,
@@ -350,7 +389,7 @@ describe('reducer', () => {
         };
         const newState = reducer(
           iniState,
-          createSet(
+          createSetResponse(
             { results: [{ id: 11 }, { id: 12 }] },
             {
               ...endpoint,
@@ -420,8 +459,8 @@ describe('reducer', () => {
   it('should set error in meta for "set"', () => {
     const id = 20;
     const error = new Error('hi');
-    const action: SetAction = {
-      type: SET_TYPE,
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload: error,
       endpoint: ArticleResource.get,
       meta: {
@@ -440,8 +479,8 @@ describe('reducer', () => {
   it('should not modify state on error for "rpc"', () => {
     const id = 20;
     const error = new Error('hi');
-    const action: SetAction = {
-      type: SET_TYPE,
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload: error,
       endpoint: ArticleResource.get,
       meta: {
@@ -461,8 +500,8 @@ describe('reducer', () => {
   it('should not delete on error for "purge"', () => {
     const id = 20;
     const error = new Error('hi');
-    const action: SetAction = {
-      type: SET_TYPE,
+    const action: SetResponseAction = {
+      type: SET_RESPONSE_TYPE,
       payload: error,
       endpoint: ArticleResource.delete,
       meta: {

package/src/state/reducer/createReducer.ts

@@ -2,6 +2,7 @@ import { expireReducer } from './expireReducer.js';
 import { fetchReducer } from './fetchReducer.js';
 import { invalidateReducer } from './invalidateReducer.js';
 import { setReducer } from './setReducer.js';
+import { setResponseReducer } from './setResponseReducer.js';
 import {
   SET_TYPE,
   INVALIDATE_TYPE,
@@ -11,6 +12,7 @@ import {
   OPTIMISTIC_TYPE,
   INVALIDATEALL_TYPE,
   EXPIREALL_TYPE,
+  SET_RESPONSE_TYPE,
 } from '../../actionTypes.js';
 import type Controller from '../../controller/Controller.js';
 import type { ActionTypes, State } from '../../types.js';
@@ -38,8 +40,11 @@ export default function createReducer(controller: Controller): ReducerType {
 
       case OPTIMISTIC_TYPE:
       // eslint-disable-next-line no-fallthrough
+      case SET_RESPONSE_TYPE:
+        return setResponseReducer(state, action, controller);
+
       case SET_TYPE:
-        return setReducer(state, action, controller);
+        return setReducer(state, action);
 
       case INVALIDATEALL_TYPE:
       case INVALIDATE_TYPE:

package/src/state/reducer/fetchReducer.ts

@@ -1,13 +1,13 @@
 import createOptimistic from '../../controller/createOptimistic.js';
 import type {
   State,
-  SetAction,
+  SetResponseAction,
   OptimisticAction,
   FetchAction,
 } from '../../types.js';
 
 export function fetchReducer(state: State<unknown>, action: FetchAction) {
-  let setAction: SetAction | OptimisticAction;
+  let setAction: SetResponseAction | OptimisticAction;
 
   if (action.endpoint.getOptimisticResponse && action.endpoint.sideEffect) {
     setAction = createOptimistic(action.endpoint, {

package/src/state/reducer/setReducer.ts

@@ -1,146 +1,34 @@
 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';
+import type { State, SetAction } from '../../types.js';
 
-export function setReducer(
-  state: State<unknown>,
-  action: OptimisticAction | SetAction,
-  controller: Controller,
-) {
-  if (action.error) {
-    return reduceError(state, action, action.payload);
-  }
+export function setReducer(state: State<unknown>, action: SetAction) {
   try {
-    let payload: any;
-    // for true set's payload is contained in action
-    if (action.type === OPTIMISTIC_TYPE) {
-      // this should never happen
-      if (!action.endpoint.getOptimisticResponse) return state;
-      try {
-        // compute optimistic response based on current state
-        payload = action.endpoint.getOptimisticResponse.call(
-          action.endpoint,
-          controller.snapshot(state, action.meta.fetchedAt),
-          ...action.meta.args,
-        );
-      } catch (e: any) {
-        // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
-        if (e.constructor === AbortOptimistic) {
-          return state;
-        }
-        throw e;
-      }
-    } else {
-      payload = action.payload;
-    }
-    const { result, entities, indexes, entityMeta } = normalize(
-      payload,
-      action.endpoint.schema,
+    const { entities, indexes, entityMeta } = normalize(
+      action.value,
+      action.schema,
       action.meta.args as any,
       state.entities,
       state.indexes,
       state.entityMeta,
       action.meta,
     );
-    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 => {
-          endpoints[key] = updaters[key](endpoints[key]);
-        });
-      }
-      // no reason to completely fail because of user-code error
-      // integrity of this state update is still guaranteed
-    } catch (error) {
-      console.error(
-        `The following error occured during Endpoint.update() for ${action.meta.key}`,
-      );
-      console.error(error);
-    }
     return {
       entities,
       indexes,
-      endpoints,
+      endpoints: state.endpoints,
       entityMeta,
-      meta: {
-        ...state.meta,
-        [action.meta.key]: {
-          date: action.meta.date,
-          expiresAt: action.meta.expiresAt,
-          prevExpiresAt: state.meta[action.meta.key]?.expiresAt,
-        },
-      },
-      optimistic: filterOptimistic(state, action),
+      meta: state.meta,
+      optimistic: state.optimistic,
       lastReset: state.lastReset,
     };
     // 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 ${
-        action.meta.key
-      }\n\nFull Schema: ${JSON.stringify(
-        action.endpoint.schema,
-        undefined,
-        2,
-      )}\n\nError:\n${error.message}`;
-      if ('payload' in action) error.payload = action.payload;
-      error.status = 400;
-    }
-
     // this is not always bubbled up, so let's double sure this doesn't fail silently
     /* istanbul ignore else */
     if (process.env.NODE_ENV !== 'production') {
       console.error(error);
     }
-    return reduceError(state, action, error);
+    return state;
   }
 }
-
-function reduceError(
-  state: State<unknown>,
-  action: SetAction | OptimisticAction,
-  error: any,
-): State<unknown> {
-  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.
-    return {
-      ...state,
-      optimistic: filterOptimistic(state, action),
-    };
-  }
-  return {
-    ...state,
-    meta: {
-      ...state.meta,
-      [action.meta.key]: {
-        date: action.meta.date,
-        error,
-        expiresAt: action.meta.expiresAt,
-        errorPolicy: action.endpoint.errorPolicy?.(error),
-      },
-    },
-    optimistic: filterOptimistic(state, action),
-  };
-}
-/** Filter all requests with same serialization that did not start after the resolving request */
-function filterOptimistic(
-  state: State<unknown>,
-  resolvingAction: SetAction | OptimisticAction,
-) {
-  return state.optimistic.filter(
-    optimisticAction =>
-      optimisticAction.meta.key !== resolvingAction.meta.key ||
-      (optimisticAction.type === OPTIMISTIC_TYPE ?
-        optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt
-      : optimisticAction.meta.date > resolvingAction.meta.date),
-  );
-}

package/src/state/reducer/setResponseReducer.ts

@@ -0,0 +1,151 @@
+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,
+  SetResponseAction,
+  OptimisticAction,
+} from '../../types.js';
+
+export function setResponseReducer(
+  state: State<unknown>,
+  action: OptimisticAction | SetResponseAction,
+  controller: Controller,
+) {
+  if (action.error) {
+    return reduceError(state, action, action.payload);
+  }
+  try {
+    let payload: any;
+    // for true set's payload 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(
+          action.endpoint,
+          controller.snapshot(state, action.meta.fetchedAt),
+          ...action.meta.args,
+        );
+      } catch (e: any) {
+        // AbortOptimistic means 'do nothing', otherwise we count the exception as endpoint failure
+        if (e.constructor === AbortOptimistic) {
+          return state;
+        }
+        throw e;
+      }
+    } else {
+      payload = action.payload;
+    }
+    const { result, entities, indexes, entityMeta } = normalize(
+      payload,
+      action.endpoint.schema,
+      action.meta.args as any,
+      state.entities,
+      state.indexes,
+      state.entityMeta,
+      action.meta,
+    );
+    const endpoints: Record<string, unknown> = {
+      ...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 => {
+          endpoints[key] = updaters[key](endpoints[key]);
+        });
+      }
+      // no reason to completely fail because of user-code error
+      // integrity of this state update is still guaranteed
+    } catch (error) {
+      console.error(
+        `The following error occured during Endpoint.update() for ${action.meta.key}`,
+      );
+      console.error(error);
+    }
+    return {
+      entities,
+      indexes,
+      endpoints,
+      entityMeta,
+      meta: {
+        ...state.meta,
+        [action.meta.key]: {
+          date: action.meta.date,
+          expiresAt: action.meta.expiresAt,
+          prevExpiresAt: state.meta[action.meta.key]?.expiresAt,
+        },
+      },
+      optimistic: filterOptimistic(state, action),
+      lastReset: state.lastReset,
+    };
+    // 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 ${
+        action.meta.key
+      }\n\nFull Schema: ${JSON.stringify(
+        action.endpoint.schema,
+        undefined,
+        2,
+      )}\n\nError:\n${error.message}`;
+      if ('payload' in action) error.payload = action.payload;
+      error.status = 400;
+    }
+
+    // this is not always bubbled up, so let's double sure this doesn't fail silently
+    /* istanbul ignore else */
+    if (process.env.NODE_ENV !== 'production') {
+      console.error(error);
+    }
+    return reduceError(state, action, error);
+  }
+}
+
+function reduceError(
+  state: State<unknown>,
+  action: SetResponseAction | OptimisticAction,
+  error: any,
+): State<unknown> {
+  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.
+    return {
+      ...state,
+      optimistic: filterOptimistic(state, action),
+    };
+  }
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      [action.meta.key]: {
+        date: action.meta.date,
+        error,
+        expiresAt: action.meta.expiresAt,
+        errorPolicy: action.endpoint.errorPolicy?.(error),
+      },
+    },
+    optimistic: filterOptimistic(state, action),
+  };
+}
+/** Filter all requests with same serialization that did not start after the resolving request */
+function filterOptimistic(
+  state: State<unknown>,
+  resolvingAction: SetResponseAction | OptimisticAction,
+) {
+  return state.optimistic.filter(
+    optimisticAction =>
+      optimisticAction.meta.key !== resolvingAction.meta.key ||
+      (optimisticAction.type === OPTIMISTIC_TYPE ?
+        optimisticAction.meta.fetchedAt !== resolvingAction.meta.fetchedAt
+      : optimisticAction.meta.date > resolvingAction.meta.date),
+  );
+}

package/src/types.ts

@@ -5,14 +5,15 @@ import type {
 } from '@data-client/normalizr';
 import type { ErrorTypes } from '@data-client/normalizr';
 
-import type { ActionTypes, SetAction, OptimisticAction } from './actions.js';
-import { SET_TYPE } from './actionTypes.js';
+import type {
+  ActionTypes,
+  SetResponseAction,
+  OptimisticAction,
+} from './actions.js';
 import type { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
 
 export type { AbstractInstanceType, UpdateFunction };
 
-export type SetTypes = typeof SET_TYPE;
-
 export type PK = string;
 
 export interface State<T> {
@@ -42,7 +43,7 @@ export interface State<T> {
       };
     };
   };
-  readonly optimistic: (SetAction | OptimisticAction)[];
+  readonly optimistic: (SetResponseAction | OptimisticAction)[];
   readonly lastReset: number;
 }
 

package/ts3.4/actionTypes.d.ts

@@ -1,5 +1,6 @@
 export declare const FETCH_TYPE: "rdc/fetch";
 export declare const SET_TYPE: "rdc/set";
+export declare const SET_RESPONSE_TYPE: "rdc/setresponse";
 export declare const OPTIMISTIC_TYPE: "rdc/optimistic";
 export declare const RESET_TYPE: "rdc/reset";
 export declare const SUBSCRIBE_TYPE: "rdc/subscribe";