typespeed 2.4.10 → 2.5.0

package/.github/workflows/test.yml

@@ -21,10 +21,10 @@ jobs:
         ports:
           - 5672
     steps:
-      - uses: actions/setup-node@v1
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
-          node-version: 16
-      - uses: actions/checkout@v2
+          node-version: 22
       - name: Setup MySQL
         run: |
           sudo /etc/init.d/mysql start
@@ -32,12 +32,12 @@ jobs:
           CREATE TABLE `user` (`id` int(11) NOT NULL AUTO_INCREMENT,`name` varchar(100) DEFAULT NULL,PRIMARY KEY (`id`)) \
           ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;SHOW TABLES;' -uroot -proot
       - name: 'Cache node_modules'
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: ~/.npm
-          key: ${{ runner.os }}-node-v18-${{ hashFiles('**/package.json') }}
+          key: ${{ runner.os }}-node-v22-${{ hashFiles('**/package.json') }}
           restore-keys: |
-            ${{ runner.os }}-node-v18-
+            ${{ runner.os }}-node-v22-
       - name: Install Dependencies
         run: npm install
       - name: Run Tests with Coverage

package/CHANGELOG.md

@@ -0,0 +1,75 @@
+# Changelog
+
+typespeed 版本演进记录。本文件 2026-09-06 从 git 历史反推建立；git 最早提交 2022-09-18（ch01）。
+
+## 2.5.x
+
+- **2.5.0**：装饰器双轨——支持 TC39 标准装饰器（Stage 2.7），legacy 装饰器零破坏。单份源码运行时双签名感知（`isStd` 判据），覆盖 core/route/database 三族 + 入口 `app`/`value`；新增方法级 `@bind` 装饰器（route 参数名→来源、database 占位符→索引，替代标准模式删除的参数装饰器）；`@autoware`/`@resource`/`@bean` 支持显式 token（标准模式无 `design:type`）；类型声明宽松化；新增标准模式示例 `introduction/decorator-next/` + `isStd` 单测（2026-09-07）
+
+## 2.4.x
+
+- **2.4.11**：README 四入口、CI 修复（action 升 v4、node 22）、CHANGELOG 建立、getRootPath 兼容 Node22/mocha（2026-09-06）
+- **2.4.10**：升级 jsonwebtoken 和 mysql2 库（2024-05-07）
+- **2.4.9**：修复 SocketIO、MQ、Redis 等对象获取不准确问题（2024-04-22）
+- **2.4.8**：修复 socket.io 未从 bean 工厂获取装饰类的问题；修复 select 返回值不为 null 的问题（2024-04-22）
+- **2.4.7**：logx 日志模块（2024-04-21）
+- **2.4.6**：修复 redis 实例错误问题（2024-03-17）
+- **2.4.5**：版本发布（2023-12-14）
+- **2.4.4**：版本发布（2023-12-01）
+- **2.4.3**：`@redisSubscriber` 装饰器在无 redis 配置时抛异常；修复生成 dist 目录问题；getRootPath 兼容 Windows（2023-11-15）
+- **2.4.2**：修复 database where 条件 AND 匹配超过 2 个时拼装出错的问题（2023-10-23）
+- **2.4.1**：补充 introduction 目录的装饰器允许配置（2023-08-04）
+- **2.4.0**：socket.io 完成——disconnect / handshake（connected）/ 房间示例 / 全部测试用例（2023-08-04）
+
+## 2.3.x（2023-06 ~ 2023-07）
+
+- **2.3.6**：增加应用目录路径配置（2023-07-06）
+- **2.3.5**：增加 redis 订阅模式（需开启两个 redis 实例）；增加 zranking / zrevranking 返回排名与分数的 Map，方便开发排行榜逻辑（2023-06-29）
+- **2.3.4**：CI 完善——限制只有 main 分支执行测试、调整测试 node 版本为 16、增加覆盖率 badge；改正 MQ 测试方法（2023-06-28）
+- **2.3.3**：修复 jwt 拦截器问题；fixed d.ts
+- **2.3.2**：start 增加 callback 参数；修改拦截器逻辑
+- **2.3.1**：版本发布
+- **2.3.0**：测试体系搭建——首个测试程序、cookie / session 测试、second page 测试（header / 文件上传 / jwt）、数据库读写测试（修正 resultType 问题）、测试程序增加 rabbitmq 配置
+
+## 2.2.x
+
+- **2.2.1**：修改并增加测试逻辑
+- **2.2.0**：express 返回 listen 对象方便停止服务；修改 core 获取应用程序 main 地址的方式，使通过其他方式启动的程序也能正常获得应用地址；更新获取应用程序路径方法（第一层引入时检查堆栈）
+
+## 2.1.x
+
+- **2.1.3**：去除无关依赖
+- **2.1.2**：升级 consolidate；`@reqParam` / `@reqQuery` 可省略参数直接使用参数名
+- **2.1.1**：版本发布
+- **2.1.0**：去除实验相关代码，更新引用地址
+
+## 2.0.x
+
+- **2.0.23**：增加 9 个请求方法的注释
+- **2.0.22**：完成 9 个请求参数的赋值装饰器；解决路由方法参数个数统计问题（before / after 一并处理）；增加全局权限认证方法，完成全局认证类测试（JWT）
+- **2.0.21**：增加 debug 日志打印
+- **2.0.20**：增加 README 内容
+- **2.0.19**：修正 README 内一个图标失效问题
+- **2.0.18**：增加导出内容的注释
+- **2.0.17 / 2.0.16**：版本发布
+- **2.0.15**：添加 d.ts 文件并去除自动生成的
+- **2.0.14**：将 rabbitmq 整合
+- **2.0.13**：初始情况 rabbitmq 不监听；解决 async / await 问题；初步完成 mq 装饰器与发送
+- **2.0.12**：增加 Rabbit MQ 的测试
+- **2.0.11 / 2.0.10 / 2.0.9 / 2.0.8 / 2.0.7**：发布与 package.json 脚本调整
+- **2.0.6**：修正 command 命令出错问题；补充装饰器介绍示例代码、访问器装饰器、入门材料
+- **2.0.5 / 2.0.4**：版本发布
+- **2.0.3**：修正 command 命令出错问题；更新脚手架的模板文件以避免 tsc 编译
+- **2.0.2**：增加脚手架（typespeed 命令行）
+- **2.0.1**：首个 2.0 发布（调整 npm 发布脚本、统一载入入口）
+
+## 早期原型期（2022-09 起，v2.0 之前）
+
+基于 ch01 / ch02 系列实验提交（`685ee1b` 起）的框架核心能力开发：
+
+- **装饰器体系**：`@start` / `@app` / `@bean` / `@log` / 注入 / 参数注入（autoware / inject 调整）
+- **AOP**：before / after 拦截完成
+- **Web 路由**：修饰器路由、路由中间件（basicAuth / jwt / upload 先后顺序处理）、404 与 500 错误页面、async / await 支持
+- **数据层**：Insert / Update / Delete / Select 完成；SQL 参数注入（`?` 编号绑定）；ResultType 标记查询结果类型；ORM 化（Model 继承：findAll / findOne / create / delete / findCount / update / incr / decr）；分页查询；nodeCache 缓存（新增/修改时按版本号刷新）
+- **基础设施**：静态资源、favicon、compression、cookies、session（Redis 存储）、文件上传（multiparty + 路由中间件）、多模版引擎（consolidate）、配置系统（全局配置 + 覆盖）、读写库（主从）接入
+- **集成**：Redis 一般使用（避免启动连不上报错）、schedule 定时器、外部载入结构调整（统一载入入口）

package/README.md

@@ -1,32 +1,74 @@
 # TypeSpeed Framework
 
-[![typescript](https://badgen.net/badge/icon/TypeScript?icon=typescript&label)](https://www.npmjs.com/package/typespeed)
-[![npm](https://badgen.net/npm/v/typespeed?color=cyan)](https://www.npmjs.com/package/typespeed)
-[![downloads](https://badgen.net/npm/dt/typespeed?color=pink)](https://www.npmjs.com/package/typespeed)
-[![license](https://badgen.net/github/license/speedphp/typespeed)](https://github.com/SpeedPHP/typespeed/blob/main/LICENSE)
-[![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/speedphp/typespeed/test.yml)](https://github.com/SpeedPHP/typespeed/commits/main)
-[![Codecov](https://img.shields.io/codecov/c/github/speedphp/typespeed)
-](https://codecov.io/gh/SpeedPHP/typespeed)
+
+
+![typescript](https://badgen.net/badge/icon/TypeScript?icon=typescript\&label)
+
+
+
+![npm](https://badgen.net/npm/v/typespeed?color=cyan)
+
+
+
+![downloads](https://badgen.net/npm/dt/typespeed?color=pink)
+
+
+
+![license](https://badgen.net/github/license/speedphp/typespeed)
+
+
+
+![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/speedphp/typespeed/test.yml)
+
+
+
+![Codecov](https://img.shields.io/codecov/c/github/speedphp/typespeed)
+
+### 资料体系
+
+TypeSpeed 不只提供一个框架，还配有完整的「书 + 视频 + 双源码」学习资料：
+
+
+
+* **书**：《TypeScript 框架开发实践（微课视频版）》（曾振中 著，清华大学出版社）——[京东购买](https://item.jd.com/14275373.html)
+
+* **视频课程**：随书微课视频（每节配套源码快照见 ts-practice）
+
+* **附书源码・ts-book**：[https://github.com/speedphp/ts-book](https://github.com/speedphp/ts-book)—— 按章组织（chapter01 \~ chapter06），每章含可运行示例
+
+* **视频代码・ts-practice**：[https://github.com/speedphp/ts-practice](https://github.com/speedphp/ts-practice)—— 按书籍章节号打 tag（如 `4.10.4` = 第 4 章第 10 节第 4 步），每节视频对应一份可跑源码快照
 
 ### 特点
 
-- 遵循 MIT 许可的开源项目。
-- 提供 31 个 TypeScript 装饰器，这些装饰器构成了完整的 Web 框架功能，包括对象管理、Web 路由、数据库操作等。
-- 通过命令行脚手架，可以快速创建项目，零配置启动。
-- 基于依赖注入、AOP、中间件和启动扫描等编程理念开发实现。
-- 底层采用 ExpressJS 实现，提供稳定、快速的 Web 服务。
-- 框架提供了两种风格不同却各具优点的数据操作模式。
+
+
+* 遵循 MIT 许可的开源项目。
+
+* 提供 31 个 TypeScript 装饰器，这些装饰器构成了完整的 Web 框架功能，包括对象管理、Web 路由、数据库操作等。
+
+* 通过命令行脚手架，可以快速创建项目，零配置启动。
+
+* 基于依赖注入、AOP、中间件和启动扫描等编程理念开发实现。
+
+* 底层采用 ExpressJS 实现，提供稳定、快速的 Web 服务。
+
+* 框架提供了两种风格不同却各具优点的数据操作模式。
 
 ### 安装
 
 TypeSpeed 环境要求 NodeJS 16+，TypeScript 运行时。
 
-```sh
+
+
+```
 npm install typespeed -g
 ```
+
 ### 使用
 
-```sh
+
+
+```
 typespeed new blog
 
 cd ./blog

package/app/src/test-bind.class.ts

@@ -0,0 +1,41 @@
+import { component, getMapping, bind, resource, autoware, bean, insert } from "../../src/typespeed";
+import UserModel from "./user-model.class";
+
+class TestBean {
+    name = "test-bean";
+}
+
+@component
+export default class TestBind {
+
+    @bean(TestBean)
+    getBeanInstance() { return new TestBean(); }
+
+    @autoware(TestBean)
+    private autowired: TestBean;
+
+    @resource(UserModel, "user")
+    private userModel: UserModel;
+
+    @getMapping("/bind/param/:id")
+    @bind({ id: "reqParam", name: "reqQuery" })
+    async bindParam(id: string, name: string) {
+        return { id, name };
+    }
+
+    @getMapping("/bind/token")
+    async bindToken(req, res) {
+        res.send(this.autowired.name + "|" + (this.userModel ? "model-ok" : "model-null"));
+    }
+
+    @getMapping("/bind/db")
+    async bindDb(req, res) {
+        const id = req.query.id || 1;
+        const newId = await this.addRowByBind("bind name " + id, id);
+        res.send("bind insert: " + newId);
+    }
+
+    @insert("Insert into `user` (id, name) values (#{id}, #{name})")
+    @bind({ name: 0, id: 1 })
+    private async addRowByBind(newName: string, id: number) { }
+}

package/dist/bind.decorator.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBindMapping = exports.bind = void 0;
+const decorator_utils_1 = require("./decorator-utils");
+/**
+ * 方法级参数绑定注册表：key = `[className, methodName]`，value = 绑定声明。
+ * 标准装饰器删除了参数装饰器，@bind 是方法级替代（legacy 模式同样可用）。
+ * 按 value 类型区分两种语义：
+ *   - database 场景：{ SQL占位符名: 参数索引 }（值为 number）
+ *   - route 场景：{ 参数名: 请求来源 }（值为 string，如 "reqParam" / "reqBody" / "reqQuery"）
+ */
+const bindParamMap = new Map();
+/**
+ * @bind 方法级参数绑定装饰器。
+ *
+ * database 散参绑定（对象传参已是主路径，@bind 作散参补充）：
+ * ```
+ * @insert("Insert into `user` (id, name) values (#{id}, #{name})")
+ * @bind({ name: 0, id: 1 })
+ * async addRow(newName: string, id: number) { }
+ * ```
+ *
+ * route 参数绑定（替代 req/res/reqBody/reqParam/reqQuery/reqForm 参数装饰器）：
+ * ```
+ * @getMapping("/user/:id")
+ * @bind({ id: "reqParam", body: "reqBody", q: "reqQuery" })
+ * async getUser(id: string, body: any, q: string) { }
+ * ```
+ */
+function bind(mapping) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const methodName = String(ctx.name);
+            ctx.addInitializer(function () {
+                bindParamMap.set([this.constructor.name, methodName].toString(), mapping);
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
+        bindParamMap.set([target.constructor.name, propertyKey].toString(), mapping);
+    };
+}
+exports.bind = bind;
+/** 读取某方法上的 @bind 声明（route/database 内部使用） */
+function getBindMapping(className, methodName) {
+    return bindParamMap.get([className, methodName].toString());
+}
+exports.getBindMapping = getBindMapping;

package/dist/core.decorator.js

@@ -4,10 +4,19 @@ exports.schedule = exports.getComponent = exports.getBean = exports.autoware = e
 require("reflect-metadata");
 const cron = require("cron");
 const log_factory_class_1 = require("./factory/log-factory.class");
+const decorator_utils_1 = require("./decorator-utils");
 const resourceObjects = new Map();
 const beanMapper = new Map();
 const objectMapper = new Map();
-function component(constructorFunction) {
+function component(...args) {
+    if ((0, decorator_utils_1.isStd)(args)) {
+        const [ctor, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+        ctx.addInitializer(function () {
+            objectMapper.set(this.name, new this());
+        });
+        return;
+    }
+    const constructorFunction = args[0];
     objectMapper.set(constructorFunction.name, new constructorFunction());
 }
 exports.component = component;
@@ -15,45 +24,114 @@ function getComponent(constructorFunction) {
     return objectMapper.get(constructorFunction.name);
 }
 exports.getComponent = getComponent;
-function bean(target, propertyKey) {
-    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) {
+    if (args.length >= 2) {
+        // 直接装饰器形式：@bean（无 token，走 legacy design:returntype）
+        return beanWithToken(undefined)(...args);
+    }
+    // 工厂形式：@bean(Token)（显式返回类型 token，标准模式必需）
+    return beanWithToken(args[0]);
 }
 exports.bean = bean;
+function beanWithToken(token) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const key = String(ctx.name);
+            ctx.addInitializer(function () {
+                beanMapper.set(token ? token.name : key, {
+                    "target": this, "propertyKey": key,
+                    "factory": this[key]()
+                });
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
+        let returnType = token || Reflect.getMetadata("design:returntype", target, propertyKey);
+        beanMapper.set(returnType.name, {
+            "target": target, "propertyKey": propertyKey,
+            "factory": target[propertyKey]()
+        });
+    };
+}
 function getBean(mappingClass) {
     const bean = beanMapper.get(mappingClass.name);
     return bean["factory"];
 }
 exports.getBean = getBean;
-function autoware(target, propertyKey) {
-    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) {
+    if (args.length >= 2) {
+        // 直接装饰器形式：@autoware（无 token，走 legacy design:type）
+        return autowareWithToken(undefined)(...args);
+    }
+    // 工厂形式：@autoware(Token)（显式 token，标准模式必需）
+    return autowareWithToken(args[0]);
+}
+exports.autoware = autoware;
+function autowareWithToken(token) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            // 标准 field 装饰器：标准模式无 design:type，有 token 才能注入。
+            return (initialValue) => {
+                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];
+        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) {
+    if (args.length > 0 && typeof args[0] === "function") {
+        return [args[0], args.slice(1)];
+    }
+    return [undefined, args];
 }
-exports.autoware = autoware;
 function resource(...args) {
-    return (target, propertyKey) => {
-        const type = Reflect.getMetadata("design:type", target, propertyKey);
+    const [token, initArgs] = extractTokenAndArgs(args);
+    return (...decoratorArgs) => {
+        if ((0, decorator_utils_1.isStd)(decoratorArgs)) {
+            // 标准 field 装饰器：标准模式无 design:type，需显式 token。
+            return (initialValue) => {
+                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];
+        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];
             }
@@ -93,7 +171,16 @@ function error(message, ...optionalParams) {
 }
 exports.error = error;
 function schedule(cronTime) {
-    return (target, propertyKey) => {
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                new cron.CronJob(cronTime, this[String(ctx.name)]).start();
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         new cron.CronJob(cronTime, target[propertyKey]).start();
     };
 }

package/dist/database.decorator.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Model = exports.cache = exports.resultType = exports.param = exports.select = exports.remove = exports.update = exports.insert = void 0;
 const core_decorator_1 = require("./core.decorator");
+const decorator_utils_1 = require("./decorator-utils");
+const bind_decorator_1 = require("./bind.decorator");
 const cache_factory_class_1 = require("./factory/cache-factory.class");
 const data_source_factory_class_1 = require("./factory/data-source-factory.class");
 const paramMetadataKey = Symbol('param');
@@ -10,9 +12,24 @@ const cacheDefindMap = new Map();
 const tableVersionMap = new Map();
 let cacheBean;
 function insert(sql) {
-    return (target, propertyKey, descriptor) => {
-        descriptor.value = async (...args) => {
-            const result = await queryForExecute(sql, args, target, propertyKey);
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const propertyKey = String(ctx.name);
+            return async function (...callArgs) {
+                const result = 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];
+        const descriptor = args[2];
+        descriptor.value = async (...callArgs) => {
+            const result = 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) {
 }
 exports.insert = insert;
 function update(sql) {
-    return (target, propertyKey, descriptor) => {
-        descriptor.value = async (...args) => {
-            const result = await queryForExecute(sql, args, target, propertyKey);
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const propertyKey = String(ctx.name);
+            return async function (...callArgs) {
+                const result = 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];
+        const descriptor = args[2];
+        descriptor.value = async (...callArgs) => {
+            const result = 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) {
 }
 exports.update = update;
 function remove(sql) {
-    return (target, propertyKey, descriptor) => {
-        descriptor.value = async (...args) => {
-            const result = await queryForExecute(sql, args, target, propertyKey);
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const propertyKey = String(ctx.name);
+            return async function (...callArgs) {
+                const result = 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];
+        const descriptor = args[2];
+        descriptor.value = async (...callArgs) => {
+            const result = 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,35 @@ function remove(sql) {
 }
 exports.remove = remove;
 function select(sql) {
-    return (target, propertyKey, descriptor) => {
-        descriptor.value = async (...args) => {
-            const [newSql, sqlValues] = convertSQLParams(sql, target, propertyKey, args);
+    return (...args) => {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            const propertyKey = String(ctx.name);
+            return async function (...callArgs) {
+                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];
+        const descriptor = args[2];
+        descriptor.value = async (...callArgs) => {
+            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);
@@ -73,7 +146,16 @@ function select(sql) {
 }
 exports.select = select;
 function resultType(dataClass) {
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                resultTypeMap.set([this.constructor.name, String(ctx.name)].toString(), dataClass);
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         resultTypeMap.set([target.constructor.name, propertyKey].toString(), dataClass);
         //never return
     };
@@ -125,8 +207,17 @@ function convertSQLParams(decoratorSQL, target, propertyKey, args) {
             argsVal = new Map(Object.getOwnPropertyNames(args[0]).map((valName) => [valName, args[0][valName]]));
         }
         else {
-            const existingParameters = Reflect.getOwnMetadata(paramMetadataKey, target, propertyKey);
-            argsVal = new Map(existingParameters.map(([argName, argIdx]) => [argName, args[argIdx]]));
+            // 优先 @param（legacy reflect-metadata），否则回退 @bind（方法级声明，标准模式）
+            let existingParameters = Reflect.getOwnMetadata(paramMetadataKey, target, propertyKey);
+            if (!existingParameters) {
+                const bindMapping = (0, bind_decorator_1.getBindMapping)(target.constructor.name, propertyKey);
+                if (bindMapping) {
+                    existingParameters = Object.entries(bindMapping)
+                        .filter(([, value]) => typeof value === "number")
+                        .map(([name, value]) => [name, value]);
+                }
+            }
+            argsVal = new Map((existingParameters || []).map(([argName, argIdx]) => [argName, args[argIdx]]));
         }
         const regExp = /#{(\w+)}/;
         let match;
@@ -139,7 +230,22 @@ function convertSQLParams(decoratorSQL, target, propertyKey, args) {
     return [decoratorSQL, queryValues];
 }
 function cache(ttl) {
-    return function (target, propertyKey) {
+    return function (...args) {
+        if ((0, decorator_utils_1.isStd)(args)) {
+            const [, ctx] = (0, decorator_utils_1.getStdArgs)(args);
+            ctx.addInitializer(function () {
+                cacheDefindMap.set([this.constructor.name, String(ctx.name)].toString(), ttl);
+                if (cacheBean == null) {
+                    const cacheFactory = (0, core_decorator_1.getBean)(cache_factory_class_1.default);
+                    if (cacheFactory || cacheFactory["factory"]) {
+                        cacheBean = cacheFactory["factory"];
+                    }
+                }
+            });
+            return;
+        }
+        const target = args[0];
+        const propertyKey = args[1];
         cacheDefindMap.set([target.constructor.name, propertyKey].toString(), ttl);
         if (cacheBean == null) {
             const cacheFactory = (0, core_decorator_1.getBean)(cache_factory_class_1.default);