Revert "add finalHandler to ProtoMiddlewareDispatcher"

This reverts commit d85606a1.

src/middleware-dispatcher/proto-middleware-dispatcher.ts

-import {
-  AnyFunc,
-  Middleware,
-  MiddlewareDispatcherOptions,
-  MiddlewareResult,
-} from './types';
+import { Middleware, MiddlewareNext, MiddlewareResult } from './types';
 import { AnyClass, ClassType } from '../types';
 import { DynamicMiddlewareDispatcher } from './dynamic-middleware-dispatcher';
 
-type StripLastParam<F extends AnyFunc> = F extends (
-  ...args: [...infer A, any]
-) => infer R
-  ? (...args: A) => R
-  : never;
-
-type ProtoMiddlewareArgs<F extends AnyFunc, T = any> = [
-  ...args: Parameters<StripLastParam<F>>,
+export type ProtoMiddlewareArgs<A extends any[], T = any> = [
+  ...args: A,
   inst: T,
 ];
-export type ProtoMiddlewareFunc<F extends AnyFunc, T = any> = (
-  ...args: ProtoMiddlewareArgs<F, T>
-) => Awaited<ReturnType<F>>;
-
-type LastParam<F extends AnyFunc> = F extends (
-  ...args: [...any, infer L]
-) => any
-  ? L
-  : never;
+export type ProtoMiddlewareFunc<A extends any[], T = any> = (
+  ...args: ProtoMiddlewareArgs<A, T>
+) => T;
 
 export class ProtoMiddlewareDispatcher<
-  F extends AnyFunc,
-> extends DynamicMiddlewareDispatcher<ProtoMiddlewareFunc<F>> {
-  constructor(
-    private finalHandler: F,
-    options: MiddlewareDispatcherOptions<ProtoMiddlewareFunc<F>> = {},
-  ) {
-    super(options);
-  }
-
+  A extends any[],
+> extends DynamicMiddlewareDispatcher<ProtoMiddlewareFunc<A>> {
   private middlewareProtoMap = new Map<
     AnyClass,
-    Middleware<ProtoMiddlewareFunc<F>>[]
+    Middleware<ProtoMiddlewareFunc<A>>[]
   >();
   private middlewareProtoMapPrior = new Map<
     AnyClass,
-    Middleware<ProtoMiddlewareFunc<F>>[]
+    Middleware<ProtoMiddlewareFunc<A>>[]
   >();
 
-  middleware<T extends LastParam<F>>(
+  middleware<T>(
     cls: ClassType<T>,
-    mw: Middleware<ProtoMiddlewareFunc<F, T>>,
+    mw: Middleware<ProtoMiddlewareFunc<A, T>>,
     prior = false,
   ) {
     const map = prior ? this.middlewareProtoMapPrior : this.middlewareProtoMap;
@@ -58,9 +34,9 @@ export class ProtoMiddlewareDispatcher<
     return this;
   }
 
-  removeMiddleware<T extends LastParam<F>>(
+  removeMiddleware<T>(
     cls: ClassType<T>,
-    mw: Middleware<ProtoMiddlewareFunc<F, T>>,
+    mw: Middleware<ProtoMiddlewareFunc<A, T>>,
   ) {
     for (const map of [this.middlewareProtoMap, this.middlewareProtoMapPrior]) {
       const mws = map.get(cls);
@@ -74,13 +50,13 @@ export class ProtoMiddlewareDispatcher<
     return this;
   }
 
-  async dispatch<T extends LastParam<F>>(
-    ...args: ProtoMiddlewareArgs<F, T>
-  ): MiddlewareResult<ProtoMiddlewareFunc<F, T>> {
+  async dispatch<T>(
+    ...args: ProtoMiddlewareArgs<A, T>
+  ): MiddlewareResult<ProtoMiddlewareFunc<A, T>> {
     return super.dispatch(...args);
   }
 
-  async buildMiddlewares(...args: ProtoMiddlewareArgs<F>) {
+  async buildMiddlewares(...args: ProtoMiddlewareArgs<A>) {
     // buildMiddlewares 只需要知道 inst
     if (args.length === 0) return [];
 
@@ -98,13 +74,13 @@ export class ProtoMiddlewareDispatcher<
 
     chain.reverse();
 
-    const result: Middleware<ProtoMiddlewareFunc<F>>[] = [];
+    const result: Middleware<ProtoMiddlewareFunc<A>>[] = [];
 
     // 2. prior：Base → Sub
     for (const cls of chain) {
       const mws = this.middlewareProtoMapPrior.get(cls);
       if (mws) {
-        result.push(...[...mws].reverse());
+        result.push(...mws);
       }
     }
 
@@ -118,7 +94,7 @@ export class ProtoMiddlewareDispatcher<
     }
 
     result.push((...args) => {
-      return this.finalHandler(...args.slice(0, -1));
+      return args[args.length - 2]; // inst
     });
 
     return result;

tests/proto-middleware-dispatcher.spec.ts

@@ -7,23 +7,13 @@ describe('ProtoMiddlewareDispatcher', () => {
   class Sub extends Base {}
 
   it('builds middlewares by prototype chain (prior: Base->Sub, normal: Sub->Base)', async () => {
-    const d = new ProtoMiddlewareDispatcher(async (x: number, inst: Base) => {
-      return inst;
-    });
+    const d = new ProtoMiddlewareDispatcher<[res: number]>();
     const order: string[] = [];
 
     d.middleware(
       Base,
       async (x, inst, next) => {
-        order.push('base:prior1');
-        return next();
-      },
-      true,
-    );
-    d.middleware(
-      Base,
-      async (x, inst, next) => {
-        order.push('base:prior2');
+        order.push('base:prior');
         return next();
       },
       true,
@@ -36,10 +26,6 @@ describe('ProtoMiddlewareDispatcher', () => {
       },
       true,
     );
-    d.middleware(Sub, async (x, inst, next) => {
-      order.push('sub:normalpre');
-      return next();
-    });
     d.middleware(Sub, async (x, inst, next) => {
       order.push('sub:normal');
       expect(inst).toBeInstanceOf(Sub);
@@ -61,10 +47,8 @@ describe('ProtoMiddlewareDispatcher', () => {
     sub.value = 5;
     const res = await d.dispatch(3, sub);
     expect(order).toEqual([
-      'base:prior2',
-      'base:prior1',
+      'base:prior',
       'sub:prior',
-      'sub:normalpre',
       'sub:normal',
       'base:normal',
     ]);