@data-client/core 0.14.2 → 0.14.5

package/src/manager/NetworkManager.ts

@@ -34,76 +34,68 @@ export default class NetworkManager implements Manager {
   protected fetchedAt: { [k: string]: number } = {};
   declare readonly dataExpiryLength: number;
   declare readonly errorExpiryLength: number;
-  protected declare middleware: Middleware;
   protected controller: Controller = new Controller();
   declare cleanupDate?: number;
 
-  constructor(dataExpiryLength = 60000, errorExpiryLength = 1000) {
+  constructor({ dataExpiryLength = 60000, errorExpiryLength = 1000 } = {}) {
     this.dataExpiryLength = dataExpiryLength;
     this.errorExpiryLength = errorExpiryLength;
+  }
 
-    this.middleware = <C extends MiddlewareAPI>(controller: C) => {
-      this.controller = controller;
-      return (next: C['dispatch']): C['dispatch'] =>
-        (action): Promise<void> => {
-          switch (action.type) {
-            case FETCH_TYPE:
-              this.handleFetch(action);
-              // This is the only case that causes any state change
-              // It's important to intercept other fetches as we don't want to trigger reducers during
-              // render - so we need to stop 'readonly' fetches which can be triggered in render
-              if (
-                action.endpoint.getOptimisticResponse !== undefined &&
-                action.endpoint.sideEffect
-              ) {
-                return next(action);
+  middleware: Middleware = controller => {
+    this.controller = controller;
+    return next => action => {
+      switch (action.type) {
+        case FETCH_TYPE:
+          this.handleFetch(action);
+          // This is the only case that causes any state change
+          // It's important to intercept other fetches as we don't want to trigger reducers during
+          // render - so we need to stop 'readonly' fetches which can be triggered in render
+          if (
+            action.endpoint.getOptimisticResponse !== undefined &&
+            action.endpoint.sideEffect
+          ) {
+            return next(action);
+          }
+          return Promise.resolve();
+        case SET_RESPONSE_TYPE:
+          // only set after new state is computed
+          return next(action).then(() => {
+            if (action.key in this.fetched) {
+              // 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
+              if (error) {
+                this.handleSet(
+                  createSetResponse(action.endpoint, {
+                    args: action.args,
+                    response: error,
+                    fetchedAt: action.meta.fetchedAt,
+                    error: true,
+                  }),
+                );
+              } else {
+                this.handleSet(action);
               }
-              return Promise.resolve();
-            case SET_RESPONSE_TYPE:
-              // only set after new state is computed
-              return next(action).then(() => {
-                if (action.key in this.fetched) {
-                  // 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
-                  if (error) {
-                    this.handleSet(
-                      createSetResponse(action.endpoint, {
-                        args: action.args,
-                        response: error,
-                        fetchedAt: action.meta.fetchedAt,
-                        error: true,
-                      }),
-                    );
-                  } else {
-                    this.handleSet(action);
-                  }
-                }
-              });
-            case RESET_TYPE: {
-              const rejectors = { ...this.rejectors };
+            }
+          });
+        case RESET_TYPE: {
+          const rejectors = { ...this.rejectors };
 
-              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());
-                }
-              });
+          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());
             }
-            default:
-              return next(action);
-          }
-        };
+          });
+        }
+        default:
+          return next(action);
+      }
     };
-  }
-
-  /** Used by DevtoolsManager to determine whether to log an action */
-  skipLogging(action: ActionTypes) {
-    /* istanbul ignore next */
-    return action.type === FETCH_TYPE && action.key in this.fetched;
-  }
+  };
 
   /** On mount */
   init() {
@@ -117,6 +109,12 @@ export default class NetworkManager implements Manager {
     this.cleanupDate = Date.now();
   }
 
+  /** Used by DevtoolsManager to determine whether to log an action */
+  skipLogging(action: ActionTypes) {
+    /* istanbul ignore next */
+    return action.type === FETCH_TYPE && action.key in this.fetched;
+  }
+
   allSettled() {
     const fetches = Object.values(this.fetched);
     if (fetches.length) return Promise.allSettled(fetches);
@@ -241,17 +239,6 @@ export default class NetworkManager implements Manager {
     }
   }
 
-  /** Attaches NetworkManager to store
-   *
-   * Intercepts 'rdc/fetch' actions to start requests.
-   *
-   * Resolve/rejects a request when matching 'rdc/set' event
-   * is seen.
-   */
-  getMiddleware() {
-    return this.middleware;
-  }
-
   /** Ensures only one request for a given key is in flight at any time
    *
    * Uses key to either retrieve in-flight promise, or if not

package/src/manager/SubscriptionManager.ts

@@ -32,41 +32,40 @@ export interface SubscriptionConstructable {
  *
  * @see https://dataclient.io/docs/api/SubscriptionManager
  */
-export default class SubscriptionManager<S extends SubscriptionConstructable>
-  implements Manager<Actions>
+export default class SubscriptionManager<
+  S extends SubscriptionConstructable = SubscriptionConstructable,
+> implements Manager<Actions>
 {
   protected subscriptions: {
     [key: string]: InstanceType<S>;
   } = {};
 
   protected declare readonly Subscription: S;
-  protected declare middleware: Middleware;
   protected controller: Controller = new Controller();
 
   constructor(Subscription: S) {
     this.Subscription = Subscription;
+  }
 
-    this.middleware = <C extends MiddlewareAPI>(controller: C) => {
-      this.controller = controller;
-      return (next: C['dispatch']): C['dispatch'] =>
-        action => {
-          switch (action.type) {
-            case SUBSCRIBE_TYPE:
-              try {
-                this.handleSubscribe(action);
-              } catch (e) {
-                console.error(e);
-              }
-              return Promise.resolve();
-            case UNSUBSCRIBE_TYPE:
-              this.handleUnsubscribe(action);
-              return Promise.resolve();
-            default:
-              return next(action);
+  middleware: Middleware = controller => {
+    this.controller = controller;
+    return next => action => {
+      switch (action.type) {
+        case SUBSCRIBE_TYPE:
+          try {
+            this.handleSubscribe(action);
+          } catch (e) {
+            console.error(e);
           }
-        };
+          return Promise.resolve();
+        case UNSUBSCRIBE_TYPE:
+          this.handleUnsubscribe(action);
+          return Promise.resolve();
+        default:
+          return next(action);
+      }
     };
-  }
+  };
 
   /** Ensures all subscriptions are cleaned up. */
   cleanup() {
@@ -109,16 +108,4 @@ export default class SubscriptionManager<S extends SubscriptionConstructable>
       console.error(`Mismatched unsubscribe: ${key} is not subscribed`);
     }
   }
-
-  /** Attaches Manager to store
-   *
-   * Intercepts 'rdc/subscribe'/'rest-hordc/ribe' to register resources that
-   * need to be kept up to date.
-   *
-   * Will possibly dispatch 'rdc/fetch' or 'rest-hordc/' to keep resources fresh
-   *
-   */
-  getMiddleware() {
-    return this.middleware;
-  }
 }

package/src/manager/__tests__/applyManager.ts

@@ -1,5 +1,13 @@
+import { Article } from '__tests__/new';
+
+import { createSet } from '../../controller/actions';
 import Controller from '../../controller/Controller';
-import applyManager from '../applyManager';
+import { Dispatch, Middleware } from '../../middlewareTypes';
+import { Manager } from '../../types';
+import applyManager, {
+  ReduxMiddleware,
+  ReduxMiddlewareAPI,
+} from '../applyManager';
 import NetworkManager from '../NetworkManager';
 
 function onError(e: any) {
@@ -36,3 +44,55 @@ it('applyManagers should not console.warn() when NetworkManager is provided', ()
     warnspy.mockRestore();
   }
 });
+it('applyManagers should handle legacy Manager.getMiddleware()', () => {
+  let initCount = 0;
+  let actionCount = 0;
+  class MyManager implements Manager {
+    getMiddleware = (): Middleware => ctrl => {
+      initCount++;
+      return next => action => {
+        actionCount++;
+        return next(action);
+      };
+    };
+
+    cleanup() {}
+  }
+  const middlewares = applyManager(
+    [new MyManager(), new NetworkManager()],
+    new Controller(),
+  );
+
+  const rootDispatch = jest.fn((action: any) => {
+    return Promise.resolve();
+  });
+
+  const dispatch = middlewareDispatch(middlewares, rootDispatch);
+
+  expect(initCount).toBe(1);
+  expect(actionCount).toBe(0);
+  expect(rootDispatch.mock.calls.length).toBe(0);
+  dispatch(
+    createSet(Article, { args: [{ id: 1 }], value: { id: 1, title: 'hi' } }),
+  );
+  expect(initCount).toBe(1);
+  expect(actionCount).toBe(1);
+  expect(rootDispatch.mock.calls.length).toBe(1);
+});
+
+function middlewareDispatch(
+  middlewares: ReduxMiddleware[],
+  rootDispatch: Dispatch,
+) {
+  const middlewareAPI: ReduxMiddlewareAPI = {
+    getState: () => ({}),
+    dispatch: action => rootDispatch(action),
+  };
+  const comp = compose(
+    middlewares.map(middleware => middleware(middlewareAPI)),
+  );
+  const dispatch = comp(rootDispatch);
+  return dispatch;
+}
+const compose = (fns: ((...args: any) => any)[]) => (initial: any) =>
+  fns.reduceRight((v, f) => f(v), initial);

package/src/manager/__tests__/logoutManager.ts

@@ -21,11 +21,10 @@ describe('LogoutManager', () => {
   const manager = new LogoutManager();
   const getState = () => initialState;
 
-  describe('getMiddleware()', () => {
+  describe('middleware', () => {
     it('should return the same value every call', () => {
-      const a = manager.getMiddleware();
-      expect(a).toBe(manager.getMiddleware());
-      expect(a).toBe(manager.getMiddleware());
+      const a = manager.middleware;
+      expect(a).toBe(manager.middleware);
     });
   });
 
@@ -33,7 +32,6 @@ describe('LogoutManager', () => {
     afterEach(() => {
       jest.useRealTimers();
     });
-    const middleware = manager.getMiddleware();
     const next = jest.fn();
     const dispatch = jest.fn(action => Promise.resolve());
     const controller = new Controller({ dispatch, getState });
@@ -48,7 +46,7 @@ describe('LogoutManager', () => {
         args: [{ id: 5 }],
         response: { id: 5, title: 'hi' },
       });
-      await middleware(API)(next)(action);
+      await manager.middleware(API)(next)(action);
 
       expect(dispatch.mock.calls.length).toBe(0);
     });
@@ -60,7 +58,7 @@ describe('LogoutManager', () => {
         response: error,
         error: true,
       });
-      await middleware(API)(next)(action);
+      await manager.middleware(API)(next)(action);
 
       expect(dispatch.mock.calls.length).toBe(0);
     });
@@ -72,7 +70,7 @@ describe('LogoutManager', () => {
         response: error,
         error: true,
       });
-      await middleware(API)(next)(action);
+      await manager.middleware(API)(next)(action);
 
       expect(dispatch.mock.calls.length).toBe(1);
       expect(dispatch.mock.calls[0][0]?.type).toBe(RESET_TYPE);
@@ -85,7 +83,7 @@ describe('LogoutManager', () => {
           return error.status === 403;
         },
         handleLogout,
-      }).getMiddleware();
+      }).middleware;
       const error: any = new Error('network failed');
       error.status = 403;
       const action = createSetResponse(CoolerArticleResource.get, {
@@ -102,7 +100,7 @@ describe('LogoutManager', () => {
       const action = { type: FETCH_TYPE };
       next.mockReset();
 
-      await middleware(API)(next)(action as any);
+      await manager.middleware(API)(next)(action as any);
 
       expect(next.mock.calls.length).toBe(1);
     });

package/src/manager/__tests__/manager.ts

@@ -1,9 +1,8 @@
 import Controller from '../../controller/Controller';
-import { Middleware } from '../../middlewareTypes';
 import { ActionTypes } from '../../types';
 import NetworkManager from '../NetworkManager';
 
-const middleware: Middleware = new NetworkManager().getMiddleware();
+const netMgr = new NetworkManager();
 it('middlewares should compose with non-data-client middlewares', () => {
   type AnotherAction = {
     type: 'BOB';
@@ -30,7 +29,7 @@ it('middlewares should compose with non-data-client middlewares', () => {
       counter++;
     };
 
-  const [a, b] = [middleware(API), nonRHMiddleware(API)];
+  const [a, b] = [netMgr.middleware(API), nonRHMiddleware(API)];
   const dispA = a(b(dispatch));
   const dispB = b(a(dispatch));
   expect(dispatch.mock.calls.length).toBe(0);

package/src/manager/__tests__/networkManager.ts

@@ -33,18 +33,17 @@ describe('NetworkManager', () => {
     expect(hacked.getHacked()).toEqual(initialState);
   });
 
-  describe('getMiddleware()', () => {
+  describe('middleware', () => {
     it('should return the same value every call', () => {
-      const a = manager.getMiddleware();
-      expect(a).toBe(manager.getMiddleware());
-      expect(a).toBe(manager.getMiddleware());
+      const a = manager.middleware;
+      expect(a).toBe(manager.middleware);
     });
     it('should return the different value for a different instance', () => {
-      const a = manager.getMiddleware();
+      const a = manager.middleware;
       const manager2 = new NetworkManager();
-      const a2 = manager2.getMiddleware();
+      const a2 = manager2.middleware;
       expect(a).not.toBe(a2);
-      expect(a2).toBe(manager2.getMiddleware());
+      expect(a2).toBe(manager2.middleware);
       manager2.cleanup();
     });
   });
@@ -132,10 +131,8 @@ describe('NetworkManager', () => {
     (fetchRejectAction.meta.promise as any).catch((e: unknown) => {});
 
     let NM: NetworkManager;
-    let middleware: Middleware;
     beforeEach(() => {
-      NM = new NetworkManager(42, 7);
-      middleware = NM.getMiddleware();
+      NM = new NetworkManager({ dataExpiryLength: 42, errorExpiryLength: 7 });
     });
     afterEach(() => {
       NM.cleanup();
@@ -152,7 +149,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(next)(fetchResolveAction);
+      NM.middleware(API)(next)(fetchResolveAction);
 
       const response = await fetchResolveAction.endpoint(
         ...fetchResolveAction.args,
@@ -188,7 +185,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(next)(fetchSetWithUpdatersAction);
+      NM.middleware(API)(next)(fetchSetWithUpdatersAction);
 
       const response = await fetchSetWithUpdatersAction.endpoint(
         ...fetchSetWithUpdatersAction.args,
@@ -224,7 +221,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(next)(fetchRpcWithUpdatersAction);
+      NM.middleware(API)(next)(fetchRpcWithUpdatersAction);
 
       const response = await fetchRpcWithUpdatersAction.endpoint(
         ...fetchRpcWithUpdatersAction.args,
@@ -260,7 +257,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(next)(fetchRpcWithUpdatersAndOptimisticAction);
+      NM.middleware(API)(next)(fetchRpcWithUpdatersAndOptimisticAction);
 
       const response = await fetchRpcWithUpdatersAndOptimisticAction.endpoint(
         ...fetchRpcWithUpdatersAndOptimisticAction.args,
@@ -293,7 +290,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(() => Promise.resolve())({
+      NM.middleware(API)(() => Promise.resolve())({
         ...fetchResolveAction,
         endpoint: detailEndpoint.extend({ dataExpiryLength: 314 }),
       });
@@ -314,7 +311,7 @@ describe('NetworkManager', () => {
         },
       );
 
-      middleware(API)(() => Promise.resolve())({
+      NM.middleware(API)(() => Promise.resolve())({
         ...fetchResolveAction,
         endpoint: detailEndpoint.extend({ dataExpiryLength: undefined }),
       });
@@ -337,7 +334,7 @@ describe('NetworkManager', () => {
       );
 
       try {
-        await middleware(API)(next)(fetchRejectAction);
+        await NM.middleware(API)(next)(fetchRejectAction);
       } catch (error) {
         expect(next).not.toHaveBeenCalled();
         expect(dispatch).toHaveBeenCalledWith({
@@ -363,7 +360,7 @@ describe('NetworkManager', () => {
       );
 
       try {
-        await middleware(API)(() => Promise.resolve())({
+        await NM.middleware(API)(() => Promise.resolve())({
           ...fetchRejectAction,
           meta: {
             ...fetchRejectAction.meta,
@@ -386,7 +383,7 @@ describe('NetworkManager', () => {
       );
 
       try {
-        await middleware(API)(() => Promise.resolve())({
+        await NM.middleware(API)(() => Promise.resolve())({
           ...fetchRejectAction,
           meta: {
             ...fetchRejectAction.meta,

package/src/manager/__tests__/subscriptionManager.ts

@@ -27,11 +27,10 @@ describe('SubscriptionManager', () => {
   const manager = new SubscriptionManager(TestSubscription);
   const getState = () => initialState;
 
-  describe('getMiddleware()', () => {
+  describe('middleware', () => {
     it('should return the same value every call', () => {
-      const a = manager.getMiddleware();
-      expect(a).toBe(manager.getMiddleware());
-      expect(a).toBe(manager.getMiddleware());
+      const a = manager.middleware;
+      expect(a).toBe(manager.middleware);
     });
   });
 
@@ -74,7 +73,6 @@ describe('SubscriptionManager', () => {
     }
 
     const manager = new SubscriptionManager(TestSubscription);
-    const middleware = manager.getMiddleware();
     const next = jest.fn();
     const dispatch = () => Promise.resolve();
     const controller = new Controller({ dispatch, getState });
@@ -86,14 +84,14 @@ describe('SubscriptionManager', () => {
     );
     it('subscribe should add a subscription', () => {
       const action = createSubscribeAction({ id: 5 });
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect(next).not.toHaveBeenCalled();
       expect((manager as any).subscriptions[action.key]).toBeDefined();
     });
     it('subscribe should add a subscription (no frequency)', () => {
       const action = createSubscribeAction({ id: 597 });
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect(next).not.toHaveBeenCalled();
       expect((manager as any).subscriptions[action.key]).toBeDefined();
@@ -101,19 +99,19 @@ describe('SubscriptionManager', () => {
 
     it('subscribe with same should call subscription.add', () => {
       const action = createSubscribeAction({ id: 5, title: 'four' });
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect(
         (manager as any).subscriptions[action.key].add.mock.calls.length,
       ).toBe(1);
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
       expect(
         (manager as any).subscriptions[action.key].add.mock.calls.length,
       ).toBe(2);
     });
     it('subscribe with another should create another', () => {
       const action = createSubscribeAction({ id: 7, title: 'four cakes' });
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect((manager as any).subscriptions[action.key]).toBeDefined();
       expect(
@@ -134,13 +132,13 @@ describe('SubscriptionManager', () => {
         () => true,
       );
 
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect((manager as any).subscriptions[action.key]).not.toBeDefined();
     });
 
     it('unsubscribe should delete when remove returns true (no frequency)', () => {
-      middleware(API)(next)(
+      manager.middleware(API)(next)(
         createSubscribeAction({ id: 50, title: 'four cakes' }),
       );
 
@@ -149,7 +147,7 @@ describe('SubscriptionManager', () => {
         () => true,
       );
 
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect((manager as any).subscriptions[action.key]).not.toBeDefined();
     });
@@ -160,7 +158,7 @@ describe('SubscriptionManager', () => {
         () => false,
       );
 
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect((manager as any).subscriptions[action.key]).toBeDefined();
       expect(
@@ -174,7 +172,7 @@ describe('SubscriptionManager', () => {
 
       const action = createUnsubscribeAction({ id: 25 });
 
-      middleware(API)(next)(action);
+      manager.middleware(API)(next)(action);
 
       expect((manager as any).subscriptions[action.key]).not.toBeDefined();
 
@@ -190,7 +188,7 @@ describe('SubscriptionManager', () => {
       const action = { type: SET_RESPONSE_TYPE };
       next.mockReset();
 
-      middleware(API)(next)(action as any);
+      manager.middleware(API)(next)(action as any);
 
       expect(next.mock.calls.length).toBe(1);
     });

package/src/manager/applyManager.ts

@@ -1,12 +1,11 @@
 import NetworkManager from './NetworkManager.js';
 import type Controller from '../controller/Controller.js';
-import type { Reducer, Dispatch, ReducerState } from '../middlewareTypes.js';
 import { Manager } from '../types.js';
 
 export default function applyManager(
   managers: Manager[],
   controller: Controller,
-): Middleware[] {
+): ReduxMiddleware[] {
   /* istanbul ignore next */
   if (
     process.env.NODE_ENV !== 'production' &&
@@ -18,25 +17,38 @@ export default function applyManager(
     );
   }
   return managers.map((manager, i) => {
-    const middleware = manager.getMiddleware();
+    if (!manager.middleware) manager.middleware = manager.getMiddleware?.();
     return ({ dispatch, getState }) => {
       if (i === 0) {
         (controller as any).dispatch = dispatch;
         (controller as any).getState = getState;
       }
       // controller is a superset of the middleware API
-      return middleware(controller as Controller<any>);
+      return (manager as Manager & { middleware: ReduxMiddleware }).middleware(
+        controller as Controller<any>,
+      );
     };
   });
 }
 
 /* These should be compatible with redux */
-export interface MiddlewareAPI<
+export interface ReduxMiddlewareAPI<
   R extends Reducer<any, any> = Reducer<any, any>,
 > {
   getState: () => ReducerState<R>;
-  dispatch: Dispatch<R>;
+  dispatch: ReactDispatch<R>;
 }
-export type Middleware = <R extends Reducer<any, any>>({
+export type ReduxMiddleware = <R extends Reducer<any, any>>({
   dispatch,
-}: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;
+}: ReduxMiddlewareAPI<R>) => (next: ReactDispatch<R>) => ReactDispatch<R>;
+
+/* The next are types from React; but we don't want dependencies on it */
+export type ReactDispatch<R extends Reducer<any, any>> = (
+  action: ReducerAction<R>,
+) => Promise<void>;
+
+export type Reducer<S, A> = (prevState: S, action: A) => S;
+export type ReducerState<R extends Reducer<any, any>> =
+  R extends Reducer<infer S, any> ? S : never;
+export type ReducerAction<R extends Reducer<any, any>> =
+  R extends Reducer<any, infer A> ? A : never;