@data-client/core 0.14.4 → 0.14.6

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({ dataExpiryLength: 42, errorExpiryLength: 7 });
-      middleware = NM.getMiddleware();
     });
     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;

package/src/middlewareTypes.ts

@@ -1,14 +1,15 @@
 import type Controller from './controller/Controller.js';
-import { ActionTypes, State } from './types.js';
+import type { ActionTypes, State } from './types.js';
 
-type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
+export type Dispatch<Actions = ActionTypes> = (value: Actions) => Promise<void>;
+
+export interface MiddlewareAPI extends Controller<Dispatch<ActionTypes>> {}
 
-export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer>
-  extends Controller<RHDispatch<ActionTypes>> {}
 export interface MiddlewareController<Actions = ActionTypes>
-  extends Controller<RHDispatch<Actions>> {}
+  extends Controller<Dispatch<Actions>> {}
 
-export type Middleware<Actions = any> = <
+/** @see https://dataclient.io/docs/api/Manager#middleware */
+export type Middleware<Actions = ActionTypes> = <
   C extends MiddlewareController<Actions>,
 >(
   controller: C,
@@ -18,14 +19,3 @@ export type DataClientReducer = (
   prevState: State<unknown>,
   action: ActionTypes,
 ) => State<unknown>;
-
-/* The next are types from React; but we don't want dependencies on it */
-export type Dispatch<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;

package/src/types.ts

@@ -18,6 +18,10 @@ export type { AbstractInstanceType, UpdateFunction };
 
 export type PK = string;
 
+/** Normalized state for Reactive Data Client
+ *
+ * @see https://dataclient.io/docs/concepts/normalization
+ */
 export interface State<T> {
   readonly entities: {
     readonly [entityKey: string]: { readonly [pk: string]: T } | undefined;
@@ -49,9 +53,20 @@ export interface State<T> {
   readonly lastReset: number;
 }
 
+/** Singletons that handle global side-effects
+ *
+ * Kind of like useEffect() for the central data store
+ *
+ * @see https://dataclient.io/docs/api/Manager
+ */
 export interface Manager<Actions = ActionTypes> {
-  getMiddleware(): Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#getmiddleware */
+  getMiddleware?(): Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#middleware */
+  middleware?: Middleware<Actions>;
+  /** @see https://dataclient.io/docs/api/Manager#cleanup */
   cleanup(): void;
+  /** @see https://dataclient.io/docs/api/Manager#init */
   init?: (state: State<any>) => void;
 }
 

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, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, NI, } from '@data-client/normalizr';
+export { NetworkError, UnknownError, ErrorTypes, Schema, EndpointInterface, EntityInterface, SchemaClass, ResolveType, DenormalizeNullable, Denormalize, Normalize, NormalizeNullable, FetchFunction, EndpointExtraOptions, Queryable, SchemaArgs, NI, } 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/manager/DevtoolsManager.d.ts

@@ -1,6 +1,6 @@
 import { DevToolsConfig } from './devtoolsTypes.js';
-import { Middleware } from './LogoutManager.js';
 import { Controller } from '../index.js';
+import { Middleware } from '../middlewareTypes.js';
 import { Manager, State, ActionTypes } from '../types.js';
 export { DevToolsConfig };
 /** Integrates with https://github.com/reduxjs/redux-devtools
@@ -10,7 +10,7 @@ export { DevToolsConfig };
  * @see https://dataclient.io/docs/api/DevToolsManager
  */
 export default class DevToolsManager implements Manager {
-    protected middleware: Middleware;
+    middleware: Middleware;
     protected devTools: undefined | any;
     protected started: boolean;
     protected actions: [
@@ -18,6 +18,7 @@ export default class DevToolsManager implements Manager {
         State<unknown>
     ][];
     protected controller: Controller;
+    skipLogging?: (action: ActionTypes) => boolean;
     maxBufferLength: number;
     constructor(config?: DevToolsConfig, skipLogging?: (action: ActionTypes) => boolean);
     handleAction(action: any, state: any): void;
@@ -25,9 +26,5 @@ export default class DevToolsManager implements Manager {
     init(state: State<any>): void;
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
-    /** Attaches Manager to store
-     *
-     */
-    getMiddleware(): Middleware;
 }
 //# sourceMappingURL=DevtoolsManager.d.ts.map

package/ts3.4/manager/LogoutManager.d.ts

@@ -1,21 +1,18 @@
 import Controller from '../controller/Controller.js';
 import { UnknownError } from '../index.js';
-import { ActionTypes, Manager } from '../types.js';
+import { Manager, Middleware } from '../types.js';
 /** Handling network unauthorized indicators like HTTP 401
  *
  * @see https://dataclient.io/docs/api/LogoutManager
  */
 export default class LogoutManager implements Manager {
-    protected middleware: Middleware;
     constructor({ handleLogout, shouldLogout }?: Props);
+    middleware: Middleware;
     cleanup(): void;
-    getMiddleware(): Middleware;
     protected shouldLogout(error: UnknownError): boolean;
-    handleLogout(controller: Controller<Dispatch>): void;
+    handleLogout(controller: Controller): void;
 }
-type Dispatch = (value: ActionTypes) => Promise<void>;
-export type Middleware = <C extends Controller<Dispatch>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
-type HandleLogout = (controller: Controller<Dispatch>) => void;
+type HandleLogout = (controller: Controller) => void;
 interface Props {
     handleLogout?: HandleLogout;
     shouldLogout?: (error: UnknownError) => boolean;

package/ts3.4/manager/NetworkManager.d.ts

@@ -28,19 +28,19 @@ export default class NetworkManager implements Manager {
     };
     readonly dataExpiryLength: number;
     readonly errorExpiryLength: number;
-    protected middleware: Middleware;
     protected controller: Controller;
     cleanupDate?: number;
     constructor({ dataExpiryLength, errorExpiryLength }?: {
         dataExpiryLength?: number | undefined;
         errorExpiryLength?: number | undefined;
     });
-    /** Used by DevtoolsManager to determine whether to log an action */
-    skipLogging(action: ActionTypes): boolean;
+    middleware: Middleware;
     /** On mount */
     init(): void;
     /** Ensures all promises are completed by rejecting remaining. */
     cleanup(): void;
+    /** Used by DevtoolsManager to determine whether to log an action */
+    skipLogging(action: ActionTypes): boolean;
     allSettled(): Promise<PromiseSettledResult<any>[]> | undefined;
     /** Clear all promise state */
     protected clearAll(): void;
@@ -61,14 +61,6 @@ export default class NetworkManager implements Manager {
      * Will resolve the promise associated with set key.
      */
     protected handleSet(action: SetResponseAction): void;
-    /** Attaches NetworkManager to store
-     *
-     * Intercepts 'rdc/fetch' actions to start requests.
-     *
-     * Resolve/rejects a request when matching 'rdc/set' event
-     * is seen.
-     */
-    getMiddleware(): 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/ts3.4/manager/SubscriptionManager.d.ts

@@ -23,9 +23,9 @@ export default class SubscriptionManager<S extends SubscriptionConstructable = S
         [key: string]: InstanceType<S>;
     };
     protected readonly Subscription: S;
-    protected middleware: Middleware;
     protected controller: Controller;
     constructor(Subscription: S);
+    middleware: Middleware;
     /** Ensures all subscriptions are cleaned up. */
     cleanup(): void;
     /** Called when middleware intercepts 'rdc/subscribe' action.
@@ -36,15 +36,6 @@ export default class SubscriptionManager<S extends SubscriptionConstructable = S
      *
      */
     protected handleUnsubscribe(action: UnsubscribeAction): void;
-    /** 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(): Middleware;
 }
 export {};
 //# sourceMappingURL=SubscriptionManager.d.ts.map

package/ts3.4/manager/applyManager.d.ts

@@ -1,10 +1,13 @@
 import Controller from '../controller/Controller.js';
-import { Reducer, Dispatch, ReducerState } from '../middlewareTypes.js';
 import { Manager } from '../types.js';
-export default function applyManager(managers: Manager[], controller: Controller): Middleware[];
-export interface MiddlewareAPI<R extends Reducer<any, any> = Reducer<any, any>> {
+export default function applyManager(managers: Manager[], controller: Controller): ReduxMiddleware[];
+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>>({ dispatch, }: MiddlewareAPI<R>) => (next: Dispatch<R>) => Dispatch<R>;
+export type ReduxMiddleware = <R extends Reducer<any, any>>({ dispatch, }: ReduxMiddlewareAPI<R>) => (next: ReactDispatch<R>) => ReactDispatch<R>;
+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;
 //# sourceMappingURL=applyManager.d.ts.map

package/ts3.4/middlewareTypes.d.ts

@@ -1,15 +1,11 @@
 import Controller from './controller/Controller.js';
 import { ActionTypes, State } from './types.js';
-type RHDispatch<Actions = any> = (value: Actions) => Promise<void>;
-export interface MiddlewareAPI<R extends DataClientReducer = DataClientReducer> extends Controller<RHDispatch<ActionTypes>> {
+export type Dispatch<Actions = ActionTypes> = (value: Actions) => Promise<void>;
+export interface MiddlewareAPI extends Controller<Dispatch<ActionTypes>> {
 }
-export interface MiddlewareController<Actions = ActionTypes> extends Controller<RHDispatch<Actions>> {
+export interface MiddlewareController<Actions = ActionTypes> extends Controller<Dispatch<Actions>> {
 }
-export type Middleware<Actions = any> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
+/** @see https://dataclient.io/docs/api/Manager#middleware */
+export type Middleware<Actions = ActionTypes> = <C extends MiddlewareController<Actions>>(controller: C) => (next: C['dispatch']) => C['dispatch'];
 export type DataClientReducer = (prevState: State<unknown>, action: ActionTypes) => State<unknown>;
-export type Dispatch<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;
-export {};
 //# sourceMappingURL=middlewareTypes.d.ts.map

package/ts3.4/types.d.ts

@@ -6,6 +6,10 @@ import { Dispatch, Middleware, MiddlewareAPI } from './middlewareTypes.js';
 export * from './actions.js';
 export { AbstractInstanceType, UpdateFunction };
 export type PK = string;
+/** Normalized state for Reactive Data Client
+ *
+ * @see https://dataclient.io/docs/concepts/normalization
+ */
 export interface State<T> {
     readonly entities: {
         readonly [entityKey: string]: {
@@ -38,9 +42,20 @@ export interface State<T> {
     readonly optimistic: (SetResponseAction | OptimisticAction)[];
     readonly lastReset: number;
 }
+/** Singletons that handle global side-effects
+ *
+ * Kind of like useEffect() for the central data store
+ *
+ * @see https://dataclient.io/docs/api/Manager
+ */
 export interface Manager<Actions = ActionTypes> {
-    getMiddleware(): Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#getmiddleware */
+    getMiddleware?(): Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#middleware */
+    middleware?: Middleware<Actions>;
+    /** @see https://dataclient.io/docs/api/Manager#cleanup */
     cleanup(): void;
+    /** @see https://dataclient.io/docs/api/Manager#init */
     init?: (state: State<any>) => void;
 }
 export { Dispatch, Middleware, MiddlewareAPI };