put inst at first

src/middleware-dispatcher/dynamic-middleware-dispatcher.ts

@@ -38,10 +38,10 @@ export class DynamicMiddlewareDispatcher<F extends AnyFunc> {
           return undefined;
         }
         nextCalled = true;
-        return dispatch(
-          i + 1,
-          passedArgs.length === 0 ? useArgs : (passedArgs as Parameters<F>),
-        );
+        return dispatch(i + 1, [
+          ...passedArgs,
+          ...useArgs.slice(passedArgs.length),
+        ] as Parameters<F>);
       };
 
       const runMw = async (cb: () => MiddlewareReturn<F>) => {

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

@@ -2,16 +2,16 @@ import { Middleware, MiddlewareResult } from './types';
 import { AnyClass, ClassType } from '../types';
 import { DynamicMiddlewareDispatcher } from './dynamic-middleware-dispatcher';
 
-export type ProtoMiddlewareArgs<A extends any[], T = any> = [
-  ...args: A,
+export type ProtoMiddlewareArgs<A extends any[] = [], T = any> = [
   inst: T,
+  ...args: A,
 ];
-export type ProtoMiddlewareFunc<A extends any[], T = any> = (
+export type ProtoMiddlewareFunc<A extends any[] = [], T = any> = (
   ...args: ProtoMiddlewareArgs<A, T>
 ) => T;
 
 export class ProtoMiddlewareDispatcher<
-  A extends any[],
+  A extends any[] = [],
 > extends DynamicMiddlewareDispatcher<ProtoMiddlewareFunc<A>> {
   private middlewareProtoMap = new Map<
     AnyClass,
@@ -93,8 +93,8 @@ export class ProtoMiddlewareDispatcher<
       }
     }
 
-    result.push((...args) => {
-      return args[args.length - 2]; // inst
+    result.push((inst, ...args) => {
+      return inst;
     });
 
     return result;

src/middleware-dispatcher/types.ts

@@ -4,7 +4,16 @@ export type AnyFunc = (...args: any[]) => any;
 
 export type MiddlewareValue<F extends AnyFunc> = Awaited<ReturnType<F>>;
 export type MiddlewareResult<F extends AnyFunc> = Promise<MiddlewareValue<F>>;
-export type MiddlewareNextArgs<F extends AnyFunc> = Parameters<F> | [];
+
+type StaircaseParams<A extends any[]> = A extends []
+  ? []
+  : A extends [...infer Rest, any]
+    ? A | StaircaseParams<Rest>
+    : never;
+
+export type MiddlewareNextArgs<F extends AnyFunc> =
+  | StaircaseParams<Parameters<F>>
+  | [];
 export type MiddlewareNext<F extends AnyFunc> = (
   ...args: MiddlewareNextArgs<F>
 ) => MiddlewareResult<F>;

tests/proto-middleware-dispatcher.spec.ts

@@ -16,7 +16,7 @@ describe('ProtoMiddlewareDispatcher', () => {
 
     d.middleware(
       Base,
-      async (x, inst, next) => {
+      async (inst, x, next) => {
         order.push('base:prior1');
         return next();
       },
@@ -24,7 +24,7 @@ describe('ProtoMiddlewareDispatcher', () => {
     );
     d.middleware(
       Base,
-      async (x, inst, next) => {
+      async (inst, x, next) => {
         order.push('base:prior2');
         return next();
       },
@@ -32,25 +32,25 @@ describe('ProtoMiddlewareDispatcher', () => {
     );
     d.middleware(
       Sub,
-      async (x, inst, next) => {
+      async (inst, x, next) => {
         order.push('sub:prior');
         return next();
       },
       true,
     );
-    d.middleware(Sub, async (x, inst, next) => {
+    d.middleware(Sub, async (inst, x, next) => {
       order.push('sub:normal0');
       return next();
     });
-    d.middleware(Sub, async (x, inst, next) => {
+    d.middleware(Sub, async (inst, x, next) => {
       order.push('sub:normal');
       expect(inst).toBeInstanceOf(Sub);
       expect(inst.value).toBe(5);
       const newSub = new Sub();
       newSub.value = inst.value + x;
-      return next(7, newSub); // override args
+      return next(newSub, 555); // override args
     });
-    d.middleware(Base, async (x, inst, next) => {
+    d.middleware(Base, async (inst, x, next) => {
       order.push('base:normal');
       expect(inst).toBeInstanceOf(Base);
       expect(inst.value).toBe(8); // 5 + 3
@@ -61,7 +61,7 @@ describe('ProtoMiddlewareDispatcher', () => {
 
     const sub = new Sub();
     sub.value = 5;
-    const res = await d.dispatch(3, sub);
+    const res = await d.dispatch(sub, 3);
     expect(order).toEqual([
       'base:prior2',
       'base:prior1',