typespeed 2.4.10 → 2.5.0

package/src/core.decorator.ts

@@ -1,12 +1,21 @@
 import "reflect-metadata";
 import * as cron from "cron";
 import LogFactory from "./factory/log-factory.class";
+import { isStd, getStdArgs } from "./decorator-utils";
 
 const resourceObjects = new Map<string, object>();
 const beanMapper: Map<string, any> = new Map<string, any>();
 const objectMapper: Map<string, any> = new Map<string, any>();
 
-function component(constructorFunction) {
+function component(...args: any[]): any {
+    if (isStd(args)) {
+        const [ctor, ctx] = getStdArgs(args);
+        ctx.addInitializer(function (this: any) {
+            objectMapper.set(this.name, new this());
+        });
+        return;
+    }
+    const constructorFunction = args[0];
     objectMapper.set(constructorFunction.name, new constructorFunction());
 }
 
@@ -14,13 +23,36 @@ function getComponent(constructorFunction) {
     return objectMapper.get(constructorFunction.name);
 }
 
-function bean(target: any, propertyKey: string) {
-    let returnType = Reflect.getMetadata("design:returntype", target, propertyKey);
-    //const targetObject = new target.constructor();
-    beanMapper.set(returnType.name, {
-        "target": target, "propertyKey": propertyKey,
-        "factory": target[propertyKey]()
-    });
+function bean(...args: any[]): any {
+    if (args.length >= 2) {
+        // 直接装饰器形式：@bean（无 token，走 legacy design:returntype）
+        return beanWithToken(undefined)(...args);
+    }
+    // 工厂形式：@bean(Token)（显式返回类型 token，标准模式必需）
+    return beanWithToken(args[0]);
+}
+
+function beanWithToken(token?: any) {
+    return function (...args: any[]): any {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            const key = String(ctx.name);
+            ctx.addInitializer(function (this: any) {
+                beanMapper.set(token ? token.name : key, {
+                    "target": this, "propertyKey": key,
+                    "factory": this[key]()
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        let returnType = token || Reflect.getMetadata("design:returntype", target, propertyKey);
+        beanMapper.set(returnType.name, {
+            "target": target, "propertyKey": propertyKey,
+            "factory": target[propertyKey]()
+        });
+    };
 }
 
 function getBean(mappingClass: Function): any {
@@ -29,31 +61,76 @@ function getBean(mappingClass: Function): any {
 }
 
 
-function autoware(target: any, propertyKey: string): void {
-    const type = Reflect.getMetadata("design:type", target, propertyKey);
-    Object.defineProperty(target, propertyKey, {
-        get: () => {
-            const targetObject = beanMapper.get(type.name);
-            if (targetObject === undefined) {
-                const resourceKey = [target.constructor.name, propertyKey, type.name].toString();
-                if (!resourceObjects[resourceKey]) {
-                    resourceObjects[resourceKey] = new type();
+function autoware(...args: any[]): any {
+    if (args.length >= 2) {
+        // 直接装饰器形式：@autoware（无 token，走 legacy design:type）
+        return autowareWithToken(undefined)(...args);
+    }
+    // 工厂形式：@autoware(Token)（显式 token，标准模式必需）
+    return autowareWithToken(args[0]);
+}
+
+function autowareWithToken(token?: any) {
+    return function (...args: any[]): any {
+        if (isStd(args)) {
+            // 标准 field 装饰器：标准模式无 design:type，有 token 才能注入。
+            return (initialValue: any) => {
+                if (!token) return initialValue;
+                const bean = beanMapper.get(token.name);
+                if (bean !== undefined) return bean["factory"];
+                return new token();
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        const type = token || Reflect.getMetadata("design:type", target, propertyKey);
+        Object.defineProperty(target, propertyKey, {
+            get: () => {
+                const targetObject = beanMapper.get(type.name);
+                if (targetObject === undefined) {
+                    const resourceKey = [target.constructor.name, propertyKey, type.name].toString();
+                    if (!resourceObjects[resourceKey]) {
+                        resourceObjects[resourceKey] = new type();
+                    }
+                    return resourceObjects[resourceKey];
                 }
-                return resourceObjects[resourceKey];
+                return targetObject["factory"];
             }
-            return targetObject["factory"];
-        }
-    });
+        });
+    };
+}
+
+/**
+ * 解析 @resource(...args) 的首参：若首参是 Function（类/token），作为显式 token，
+ * 其余作为构造参数；否则全部作为构造参数（legacy 行为，如 @resource("user")）。
+ */
+function extractTokenAndArgs(args: any[]): [any, any[]] {
+    if (args.length > 0 && typeof args[0] === "function") {
+        return [args[0], args.slice(1)];
+    }
+    return [undefined, args];
 }
 
 function resource(...args): any {
-    return (target: any, propertyKey: string) => {
-        const type = Reflect.getMetadata("design:type", target, propertyKey);
+    const [token, initArgs] = extractTokenAndArgs(args);
+    return (...decoratorArgs: any[]): any => {
+        if (isStd(decoratorArgs)) {
+            // 标准 field 装饰器：标准模式无 design:type，需显式 token。
+            return (initialValue: any) => {
+                if (!token) return initialValue;
+                const bean = beanMapper.get(token.name);
+                if (bean !== undefined) return bean["factory"];
+                return new token(...initArgs);
+            };
+        }
+        const target = decoratorArgs[0];
+        const propertyKey = decoratorArgs[1] as string;
+        const type = token || Reflect.getMetadata("design:type", target, propertyKey);
         Object.defineProperty(target, propertyKey, {
             get: () => {
                 const resourceKey = [target.constructor.name, propertyKey, type.name].toString();
                 if (!resourceObjects[resourceKey]) {
-                    resourceObjects[resourceKey] = new type(...args);
+                    resourceObjects[resourceKey] = new type(...initArgs);
                 }
                 return resourceObjects[resourceKey];
             }
@@ -90,7 +167,16 @@ function error(message?: any, ...optionalParams: any[]) {
 }
 
 function schedule(cronTime: string | Date) {
-    return (target: any, propertyKey: string) => {
+    return (...args: any[]): any => {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            ctx.addInitializer(function (this: any) {
+                new cron.CronJob(cronTime, this[String(ctx.name)]).start();
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
         new cron.CronJob(cronTime, target[propertyKey]).start();
     }
 }

package/src/database.decorator.ts

@@ -1,5 +1,7 @@
 import { ResultSetHeader } from 'mysql2';
 import { log, getBean } from './core.decorator';
+import { isStd, getStdArgs } from './decorator-utils';
+import { getBindMapping } from './bind.decorator';
 import CacheFactory from './factory/cache-factory.class';
 import DataSourceFactory from './factory/data-source-factory.class';
 
@@ -10,9 +12,24 @@ const tableVersionMap = new Map<string, number>();
 let cacheBean: CacheFactory;
 
 function insert(sql: string) {
-    return (target, propertyKey: string, descriptor: PropertyDescriptor) => {
-        descriptor.value = async (...args: any[]) => {
-            const result: ResultSetHeader = await queryForExecute(sql, args, target, propertyKey);
+    return (...args: any[]): any => {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            const propertyKey = String(ctx.name);
+            return async function (this: any, ...callArgs: any[]) {
+                const result: ResultSetHeader = await queryForExecute(sql, callArgs, this, propertyKey);
+                if (cacheBean && result.affectedRows > 0) {
+                    const [tableName, tableVersion] = getTableAndVersion("insert", sql);
+                    tableVersionMap.set(tableName, tableVersion + 1);
+                }
+                return result.insertId;
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        const descriptor = args[2] as PropertyDescriptor;
+        descriptor.value = async (...callArgs: any[]) => {
+            const result: ResultSetHeader = await queryForExecute(sql, callArgs, target, propertyKey);
             if (cacheBean && result.affectedRows > 0) {
                 const [tableName, tableVersion] = getTableAndVersion("insert", sql);
                 tableVersionMap.set(tableName, tableVersion + 1);
@@ -23,9 +40,24 @@ function insert(sql: string) {
 }
 
 function update(sql: string) {
-    return (target, propertyKey: string, descriptor: PropertyDescriptor) => {
-        descriptor.value = async (...args: any[]) => {
-            const result: ResultSetHeader = await queryForExecute(sql, args, target, propertyKey);
+    return (...args: any[]): any => {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            const propertyKey = String(ctx.name);
+            return async function (this: any, ...callArgs: any[]) {
+                const result: ResultSetHeader = await queryForExecute(sql, callArgs, this, propertyKey);
+                if (cacheBean && result.affectedRows > 0) {
+                    const [tableName, tableVersion] = getTableAndVersion("update", sql);
+                    tableVersionMap.set(tableName, tableVersion + 1);
+                }
+                return result.affectedRows;
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        const descriptor = args[2] as PropertyDescriptor;
+        descriptor.value = async (...callArgs: any[]) => {
+            const result: ResultSetHeader = await queryForExecute(sql, callArgs, target, propertyKey);
             if (cacheBean && result.affectedRows > 0) {
                 const [tableName, tableVersion] = getTableAndVersion("update", sql);
                 tableVersionMap.set(tableName, tableVersion + 1);
@@ -36,9 +68,24 @@ function update(sql: string) {
 }
 
 function remove(sql: string) {
-    return (target, propertyKey: string, descriptor: PropertyDescriptor) => {
-        descriptor.value = async (...args: any[]) => {
-            const result: ResultSetHeader = await queryForExecute(sql, args, target, propertyKey);
+    return (...args: any[]): any => {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            const propertyKey = String(ctx.name);
+            return async function (this: any, ...callArgs: any[]) {
+                const result: ResultSetHeader = await queryForExecute(sql, callArgs, this, propertyKey);
+                if (cacheBean && result.affectedRows > 0) {
+                    const [tableName, tableVersion] = getTableAndVersion("delete", sql);
+                    tableVersionMap.set(tableName, tableVersion + 1);
+                }
+                return result.affectedRows;
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        const descriptor = args[2] as PropertyDescriptor;
+        descriptor.value = async (...callArgs: any[]) => {
+            const result: ResultSetHeader = await queryForExecute(sql, callArgs, target, propertyKey);
             if (cacheBean && result.affectedRows > 0) {
                 const [tableName, tableVersion] = getTableAndVersion("delete", sql);
                 tableVersionMap.set(tableName, tableVersion + 1);
@@ -49,9 +96,33 @@ function remove(sql: string) {
 }
 
 function select(sql: string) {
-    return (target, propertyKey: string, descriptor: PropertyDescriptor) => {
-        descriptor.value = async (...args: any[]) => {
-            const [newSql, sqlValues] = convertSQLParams(sql, target, propertyKey, args);
+    return (...args: any[]): any => {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            const propertyKey = String(ctx.name);
+            return async function (this: any, ...callArgs: any[]) {
+                const [newSql, sqlValues] = convertSQLParams(sql, this, propertyKey, callArgs);
+                const resultType = resultTypeMap.get([this.constructor.name, propertyKey].toString());
+                if (cacheBean && cacheDefindMap.has([this.constructor.name, propertyKey].toString())) {
+                    const [tableName, tableVersion] = getTableAndVersion("select", newSql);
+                    const cacheKey = JSON.stringify([tableName, tableVersion, newSql, sqlValues]);
+                    if (cacheBean.get(cacheKey)) {
+                        return cacheBean.get(cacheKey);
+                    } else {
+                        const rows = await actionQuery(newSql, sqlValues, resultType);
+                        cacheBean.set(cacheKey, rows, cacheDefindMap.get([this.constructor.name, propertyKey].toString()));
+                        return rows;
+                    }
+                } else {
+                    return await actionQuery(newSql, sqlValues, resultType);
+                }
+            };
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
+        const descriptor = args[2] as PropertyDescriptor;
+        descriptor.value = async (...callArgs: any[]) => {
+            const [newSql, sqlValues] = convertSQLParams(sql, target, propertyKey, callArgs);
             const resultType = resultTypeMap.get([target.constructor.name, propertyKey].toString());
             if (cacheBean && cacheDefindMap.has([target.constructor.name, propertyKey].toString())) {
                 const [tableName, tableVersion] = getTableAndVersion("select", newSql);
@@ -71,7 +142,16 @@ function select(sql: string) {
 }
 
 function resultType(dataClass) {
-    return function (target, propertyKey: string) {
+    return function (...args: any[]): any {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            ctx.addInitializer(function (this: any) {
+                resultTypeMap.set([this.constructor.name, String(ctx.name)].toString(), dataClass);
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
         resultTypeMap.set([target.constructor.name, propertyKey].toString(), dataClass);
         //never return
     };
@@ -124,8 +204,17 @@ function convertSQLParams(decoratorSQL: string, target: any, propertyKey: string
         if (typeof args[0] === 'object') {
             argsVal = new Map(Object.getOwnPropertyNames(args[0]).map((valName) => [valName, args[0][valName]]));
         } else {
-            const existingParameters: [string, number][] = Reflect.getOwnMetadata(paramMetadataKey, target, propertyKey,);
-            argsVal = new Map(existingParameters.map(([argName, argIdx]) => [argName, args[argIdx]]));
+            // 优先 @param（legacy reflect-metadata），否则回退 @bind（方法级声明，标准模式）
+            let existingParameters: [string, number][] = Reflect.getOwnMetadata(paramMetadataKey, target, propertyKey);
+            if (!existingParameters) {
+                const bindMapping = getBindMapping(target.constructor.name, propertyKey);
+                if (bindMapping) {
+                    existingParameters = Object.entries(bindMapping)
+                        .filter(([, value]) => typeof value === "number")
+                        .map(([name, value]) => [name, value as number]);
+                }
+            }
+            argsVal = new Map((existingParameters || []).map(([argName, argIdx]) => [argName, args[argIdx]]));
         }
         const regExp = /#{(\w+)}/;
         let match;
@@ -139,7 +228,22 @@ function convertSQLParams(decoratorSQL: string, target: any, propertyKey: string
 }
 
 function cache(ttl: number) {
-    return function (target: any, propertyKey: string) {
+    return function (...args: any[]): any {
+        if (isStd(args)) {
+            const [, ctx] = getStdArgs(args);
+            ctx.addInitializer(function (this: any) {
+                cacheDefindMap.set([this.constructor.name, String(ctx.name)].toString(), ttl);
+                if (cacheBean == null) {
+                    const cacheFactory = getBean(CacheFactory);
+                    if (cacheFactory || cacheFactory["factory"]) {
+                        cacheBean = cacheFactory["factory"];
+                    }
+                }
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1] as string;
         cacheDefindMap.set([target.constructor.name, propertyKey].toString(), ttl);
         if (cacheBean == null) {
             const cacheFactory = getBean(CacheFactory);

package/src/decorator-utils.ts

@@ -0,0 +1,53 @@
+/**
+ * 装饰器双签名感知工具。
+ *
+ * typespeed 2.5.x 起，装饰器同时支持两套运行时签名：
+ *   - legacy（experimentalDecorators: true，2.4.x 现状）：
+ *       类装饰器 (ctor)；方法/属性装饰器 (target, key)；带 descriptor 的方法 (target, key, descriptor)；参数 (target, key, index)
+ *   - 标准（TC39 装饰器提案，当前 Stage 2.7，experimentalDecorators: false）：
+ *       统一 (value, context)，context 恒为带 kind 字段的对象
+ *
+ * 装饰器函数本质是普通函数，运行时收到什么签名由「调用方（用户代码）」的编译模式决定，
+ * 因此库可以单份源码、运行时按签名形态分流：legacy 分支逻辑与 2.4.x 逐字一致，标准分支为新增。
+ */
+
+/** 标准装饰器 context 的 kind 取值（TS/Babel 2022-03 版语义） */
+export type StdDecoratorKind = "class" | "method" | "getter" | "setter" | "field" | "accessor";
+
+/** 标准装饰器 context 的宽松类型描述（不依赖 esnext.decorators lib，保持 ES2017 可编译） */
+export interface StdDecoratorContext {
+    kind: StdDecoratorKind;
+    name?: string | symbol;
+    static?: boolean;
+    private?: boolean;
+    access?: { get?: boolean; set?: boolean };
+    metadata?: Record<PropertyKey, unknown>;
+    addInitializer(fn: (this: any) => void): void;
+}
+
+/**
+ * 判断装饰器收到的运行时参数是否为标准装饰器签名 (value, context)。
+ *
+ * 判据（与 `2.5.x-新版装饰器使用方案.md` 一致）：
+ *   参数个数 === 2 且第二个参数是「带 string 类型 kind 字段」的对象。
+ *
+ * 为什么这个判据可靠：
+ *   - legacy 类装饰器只有 1 参 → 不满足 length === 2
+ *   - legacy 方法/属性装饰器第二参是 string 的 key → 不是对象
+ *   - legacy 带 descriptor 的方法 / 参数装饰器是 3 参 → 不满足 length === 2
+ *   - 标准模式第二参恒是带 kind 的对象 → 命中
+ */
+export function isStd(args: unknown[]): boolean {
+    return args.length === 2
+        && typeof args[1] === "object"
+        && args[1] !== null
+        && typeof (args[1] as { kind?: unknown }).kind === "string";
+}
+
+/**
+ * 从标准装饰器参数中解出 (value, context)。
+ * 仅应在 isStd(args) 为 true 时调用。
+ */
+export function getStdArgs(args: unknown[]): [any, StdDecoratorContext] {
+    return [args[0], args[1] as StdDecoratorContext];
+}

package/src/route.decorator.ts

@@ -2,6 +2,8 @@ import * as express from "express";
 import * as multiparty from "multiparty";
 import { expressjwt } from "express-jwt";
 import { getComponent } from "./core.decorator";
+import { isStd, getStdArgs } from "./decorator-utils";
+import { getBindMapping } from "./bind.decorator";
 
 const routerMapper = {
   "get": {},
@@ -26,7 +28,51 @@ function setRouter(app: express.Application) {
 }
 
 function mapperFunction(method: string, value: string) {
-  return (target: any, propertyKey: string) => {
+  return (...args: any[]): any => {
+    if (isStd(args)) {
+      const [methodFn, ctx] = getStdArgs(args);
+      ctx.addInitializer(function (this: any) {
+        const className = this.constructor.name;
+        const propertyKey = String(ctx.name);
+        applyRouteBind(className, propertyKey, methodFn);
+        routerMapper[method][value] = {
+          "path": value,
+          "name": [className, propertyKey].toString(),
+          "target": this.constructor,
+          "propertyKey": propertyKey,
+          "invoker": async (req, res, next) => {
+            const routerBean = getComponent(this.constructor);
+            try {
+              let paramTotal = routerBean[propertyKey].length;
+              if (routerParamsTotal[[className, propertyKey].toString()]) {
+                paramTotal = Math.max(paramTotal, routerParamsTotal[[className, propertyKey].toString()]);
+              }
+              const callArgs = [req, res, next];
+              if (paramTotal > 0) {
+                for (let i = 0; i < paramTotal; i++) {
+                  if (routerParams[[className, propertyKey, i].toString()]) {
+                    callArgs[i] = routerParams[[className, propertyKey, i].toString()](req, res, next);
+                  }
+                }
+              }
+              const testResult = await routerBean[propertyKey].apply(routerBean, callArgs);
+              if (typeof testResult === "object") {
+                res.json(testResult);
+              } else if (typeof testResult !== "undefined") {
+                res.send(testResult);
+              }
+              return testResult;
+            } catch (err) {
+              next(err);
+            }
+          }
+        };
+      });
+      return;
+    }
+    const target = args[0];
+    const propertyKey = args[1] as string;
+    applyRouteBind(target.constructor.name, propertyKey, target[propertyKey]);
     routerMapper[method][value] = {
       "path": value,
       "name": [target.constructor.name, propertyKey].toString(),
@@ -62,7 +108,21 @@ function mapperFunction(method: string, value: string) {
   }
 }
 
-function upload(target: any, propertyKey: string) {
+function upload(...args: any[]): any {
+  if (isStd(args)) {
+    const [, ctx] = getStdArgs(args);
+    ctx.addInitializer(function (this: any) {
+      const key = [this.constructor.name, String(ctx.name)].toString();
+      if (routerMiddleware[key]) {
+        routerMiddleware[key].push(uploadMiddleware);
+      } else {
+        routerMiddleware[key] = [uploadMiddleware];
+      }
+    });
+    return;
+  }
+  const target = args[0];
+  const propertyKey = args[1] as string;
   const key = [target.constructor.name, propertyKey].toString();
   if (routerMiddleware[key]) {
     routerMiddleware[key].push(uploadMiddleware);
@@ -80,7 +140,21 @@ function uploadMiddleware(req, res, next) {
 }
 
 function jwt(jwtConfig) {
-  return (target: any, propertyKey: string) => {
+  return (...args: any[]): any => {
+    if (isStd(args)) {
+      const [, ctx] = getStdArgs(args);
+      ctx.addInitializer(function (this: any) {
+        const key = [this.constructor.name, String(ctx.name)].toString();
+        if (routerMiddleware[key]) {
+          routerMiddleware[key].push(expressjwt(jwtConfig));
+        } else {
+          routerMiddleware[key] = [expressjwt(jwtConfig)];
+        }
+      });
+      return;
+    }
+    const target = args[0];
+    const propertyKey = args[1] as string;
     const key = [target.constructor.name, propertyKey].toString();
     if (routerMiddleware[key]) {
       routerMiddleware[key].push(expressjwt(jwtConfig));
@@ -92,15 +166,34 @@ function jwt(jwtConfig) {
 
 function before(constructorFunction, methodName: string) {
   const targetBean = getComponent(constructorFunction);
-  return function (target, propertyKey: string) {
+  return function (...args: any[]) {
+      if (isStd(args)) {
+        const [, ctx] = getStdArgs(args);
+        const hookKey = String(ctx.name);
+        ctx.addInitializer(function (this: any) {
+          const currentMethod = this[methodName];
+          if (currentMethod && currentMethod.length > 0) {
+            routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+          }
+          Object.assign(this, {
+              [methodName]: function (...innerArgs: any[]) {
+                  this[hookKey](...innerArgs);
+                  return currentMethod.apply(this, innerArgs);
+              }
+          })
+        });
+        return;
+      }
+      const target = args[0];
+      const propertyKey = args[1] as string;
       const currentMethod = targetBean[methodName];
       if(currentMethod.length > 0){
         routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
       }
       Object.assign(targetBean, {
-          [methodName]: function (...args) {
-              target[propertyKey](...args);
-              return currentMethod.apply(targetBean, args);
+          [methodName]: function (...innerArgs) {
+              target[propertyKey](...innerArgs);
+              return currentMethod.apply(targetBean, innerArgs);
           }
       })
   };
@@ -108,14 +201,34 @@ function before(constructorFunction, methodName: string) {
 
 function after(constructorFunction, methodName: string) {
   const targetBean = getComponent(constructorFunction);
-  return function (target, propertyKey: string) {
+  return function (...args: any[]) {
+      if (isStd(args)) {
+        const [, ctx] = getStdArgs(args);
+        const hookKey = String(ctx.name);
+        ctx.addInitializer(function (this: any) {
+          const currentMethod = this[methodName];
+          if (currentMethod && currentMethod.length > 0) {
+            routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
+          }
+          Object.assign(this, {
+              [methodName]: function (...innerArgs: any[]) {
+                  const result = currentMethod.apply(this, innerArgs);
+                  const afterResult = this[hookKey](result);
+                  return afterResult ?? result;
+              }
+          })
+        });
+        return;
+      }
+      const target = args[0];
+      const propertyKey = args[1] as string;
       const currentMethod = targetBean[methodName];
       if(currentMethod.length > 0){
         routerParamsTotal[[constructorFunction.name, methodName].toString()] = currentMethod.length;
       }
       Object.assign(targetBean, {
-          [methodName]: function (...args) {
-              const result = currentMethod.apply(targetBean, args);
+          [methodName]: function (...innerArgs) {
+              const result = currentMethod.apply(targetBean, innerArgs);
               const afterResult = target[propertyKey](result);
               return afterResult ?? result;
           }
@@ -155,6 +268,52 @@ function getParamInFunction(fn: Function, index: number) {
   return result[index] || null;
 }
 
+/** 解析函数参数名列表（供 route @bind 做「参数名 → 索引」映射） */
+function getParamNames(fn: Function): string[] {
+  const code = fn.toString().replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg, '').replace(/=>.*$/mg, '').replace(/=[^,)]+/g, '');
+  const paramsStr = code.slice(code.indexOf('(') + 1, code.indexOf(')'));
+  if (!paramsStr.trim()) return [];
+  return paramsStr.split(',').map(p => {
+    const matched = p.trim().match(/([A-Za-z_$][\w$]*)/);
+    return matched ? matched[1] : p.trim();
+  }).filter(Boolean);
+}
+
+/** 把 route @bind 的「来源字符串」转成参数解析器 */
+function getRouteSourceResolver(source: string, paramName: string) {
+  switch (source) {
+    case "req": return (req, res, next) => req;
+    case "res": return (req, res, next) => res;
+    case "next": return (req, res, next) => next;
+    case "reqBody": return (req, res, next) => req.body;
+    case "reqParam": return (req, res, next) => req.params[paramName];
+    case "reqQuery": return (req, res, next) => req.query[paramName];
+    case "reqForm": return (req, res, next) => req.body[paramName];
+    default: return null;
+  }
+}
+
+/** 读取 @bind 声明，把「参数名 → 来源」转成 routerParams 的「索引 → 解析器」 */
+function applyRouteBind(className: string, propertyKey: string, method: Function) {
+  const bindMapping = getBindMapping(className, propertyKey);
+  if (!bindMapping) return;
+  const paramNames = getParamNames(method);
+  const nameToIndex: Record<string, number> = {};
+  paramNames.forEach((paramName, index) => {
+    if (paramName && nameToIndex[paramName] === undefined) nameToIndex[paramName] = index;
+  });
+  for (const bindName in bindMapping) {
+    const source = bindMapping[bindName];
+    if (typeof source !== "string") continue;   // 跳过 database 的数值映射
+    const index = nameToIndex[bindName];
+    if (index === undefined) continue;
+    const resolver = getRouteSourceResolver(source, bindName);
+    if (resolver) {
+      routerParams[[className, propertyKey, index].toString()] = resolver;
+    }
+  }
+}
+
 function reqQuery(target: any, propertyKey: string, parameterIndex: number) {
   const key = [target.constructor.name, propertyKey, parameterIndex].toString();
   const paramName = getParamInFunction(target[propertyKey], parameterIndex);