Use matchers for cDM and include instanceId in final instance.

Author: EskiMojo14

packages/toolkit/src/dynamicMiddleware/index.ts

@@ -2,10 +2,10 @@ import type {
   Middleware,
   Dispatch as ReduxDispatch,
   UnknownAction,
-  MiddlewareAPI,
 } from 'redux'
 import { compose } from 'redux'
 import { createAction, isAction } from '../createAction'
+import { isAllOf } from '../matchers'
 import { nanoid } from '../nanoid'
 import { find } from '../utils'
 import type {
@@ -27,6 +27,11 @@ const createMiddlewareEntry = <
   applied: new Map(),
 })
 
+const matchInstance =
+  (instanceId: string) =>
+  (action: any): action is { meta: { instanceId: string } } =>
+    action?.meta?.instanceId === instanceId
+
 export const createDynamicMiddleware = <
   State = any,
   Dispatch extends ReduxDispatch<UnknownAction> = ReduxDispatch<UnknownAction>
@@ -70,9 +75,7 @@ export const createDynamicMiddleware = <
     return addMiddleware as AddMiddleware<State, Dispatch>
   })()
 
-  const getFinalMiddleware = (
-    api: MiddlewareAPI<Dispatch, State>
-  ): ReturnType<Middleware<any, State, Dispatch>> => {
+  const getFinalMiddleware: Middleware<{}, State, Dispatch> = (api) => {
     const appliedMiddleware = Array.from(middlewareMap.values()).map(
       (entry) => {
         let applied = entry.applied.get(api)
@@ -86,13 +89,15 @@ export const createDynamicMiddleware = <
     return compose(...appliedMiddleware)
   }
 
+  const isWithMiddleware = isAllOf(
+    isAction,
+    withMiddleware,
+    matchInstance(instanceId)
+  )
+
   const middleware: DynamicMiddleware<State, Dispatch> =
     (api) => (next) => (action) => {
-      if (
-        isAction(action) &&
-        withMiddleware.match(action) &&
-        action.meta.instanceId === instanceId
-      ) {
+      if (isWithMiddleware(action)) {
         addMiddleware(...action.payload)
         return api.dispatch
       }
@@ -103,5 +108,6 @@ export const createDynamicMiddleware = <
     middleware,
     addMiddleware,
     withMiddleware,
+    instanceId,
   }
 }

packages/toolkit/src/dynamicMiddleware/tests/index.test.ts

@@ -4,6 +4,7 @@ import { configureStore } from '../../configureStore'
 import type { BaseActionCreator, PayloadAction } from '../../createAction'
 import { isAction } from '../../createAction'
 import { createAction } from '../../createAction'
+import { isAllOf } from '../../matchers'
 
 export interface ProbeMiddleware
   extends BaseActionCreator<number, 'probeableMW/probe'> {
@@ -14,24 +15,24 @@ export const probeMiddleware = createAction<number>(
   'probeableMW/probe'
 ) as ProbeMiddleware
 
-export const makeProbeableMiddleware =
-  <Id extends number>(
-    id: Id
-  ): Middleware<{
-    (action: PayloadAction<Id, 'probeableMW/probe'>): Id
-  }> =>
-  (api) =>
-  (next) =>
-  (action) => {
-    if (
-      isAction(action) &&
-      probeMiddleware.match(action) &&
-      action.payload === id
-    ) {
+const matchId =
+  <Id extends number>(id: Id) =>
+  (action: any): action is PayloadAction<Id> =>
+    action.payload === id
+
+export const makeProbeableMiddleware = <Id extends number>(
+  id: Id
+): Middleware<{
+  (action: PayloadAction<Id, 'probeableMW/probe'>): Id
+}> => {
+  const isMiddlewareAction = isAllOf(isAction, probeMiddleware, matchId(id))
+  return (api) => (next) => (action) => {
+    if (isMiddlewareAction(action)) {
       return id
     }
     return next(action)
   }
+}
 
 const staticMiddleware = makeProbeableMiddleware(1)
 

packages/toolkit/src/dynamicMiddleware/types.ts

@@ -89,4 +89,5 @@ export type DynamicMiddlewareInstance<
   middleware: DynamicMiddleware<State, Dispatch>
   addMiddleware: AddMiddleware<State, Dispatch>
   withMiddleware: WithMiddleware<State, Dispatch>
+  instanceId: string
 }