wok-server 0.6.0 → 0.7.0

package/dist/mysql/manager/ops/upsert.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertWithUpdater = exports.upsertMany = exports.upsert = void 0;
+const utils_1 = require("../utils");
+const insert_1 = require("./insert");
+const update_1 = require("./update");
+/**
+ * Upsert 单条数据
+ * 如果主键冲突则更新，否则插入
+ * @param config
+ * @param connection
+ * @param table
+ * @param data
+ * @returns
+ */
+async function upsert(config, connection, table, data) {
+    let columnsSet = new Set();
+    if (data[table.id]) {
+        columnsSet.add(table.id);
+    }
+    table.columns.forEach(col => columnsSet.add(col));
+    const now = new Date();
+    const nowTimestamp = now.getTime();
+    if (table.createdDate) {
+        const createdData = table.createdDate.type === 'date' ? now : nowTimestamp;
+        data[table.createdDate.column] = createdData;
+        columnsSet.add(table.createdDate.column);
+    }
+    if (table.updatedDate) {
+        const updatedDate = table.updatedDate.type === 'date' ? now : nowTimestamp;
+        data[table.updatedDate.column] = updatedDate;
+        columnsSet.add(table.updatedDate.column);
+    }
+    const columns = Array.from(columnsSet);
+    // 构建 insert values
+    const fragList = [];
+    const insertValues = [];
+    for (const col of columns) {
+        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
+        fragList.push(frag);
+        insertValues.push(...vs);
+    }
+    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${fragList.join(',')})`;
+    // 构建 on duplicate key update（排除 id）
+    const updateColumns = columns.filter(col => col !== table.id);
+    const updateFragments = [];
+    const updateValues = [];
+    for (const col of updateColumns) {
+        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
+        updateFragments.push(`?? = ${frag}`);
+        updateValues.push(col, ...vs);
+    }
+    const updateSql = ` on duplicate key update ${updateFragments.join(',')}`;
+    const sql = insertSql + updateSql;
+    const values = [table.tableName, ...columns, ...insertValues, ...updateValues];
+    const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
+    const packet = res;
+    if (packet.insertId && (data[table.id] === undefined || data[table.id] === null)) {
+        data[table.id] = packet.insertId;
+    }
+    return data;
+}
+exports.upsert = upsert;
+/**
+ * Upsert 多条数据
+ * 如果主键冲突则更新，否则插入
+ * @param config
+ * @param connection
+ * @param table
+ * @param list
+ * @returns 影响的行数
+ */
+async function upsertMany(config, connection, table, list) {
+    if (!list.length) {
+        return 0;
+    }
+    let columnsSet = new Set();
+    if (list[0][table.id]) {
+        columnsSet.add(table.id);
+    }
+    table.columns.forEach(col => columnsSet.add(col));
+    const now = new Date();
+    const nowTimestamp = now.getTime();
+    let createdData = undefined;
+    if (table.createdDate) {
+        createdData = table.createdDate.type === 'date' ? now : nowTimestamp;
+        columnsSet.add(table.createdDate.column);
+    }
+    let updatedDate = undefined;
+    if (table.updatedDate) {
+        updatedDate = table.updatedDate.type === 'date' ? now : nowTimestamp;
+        columnsSet.add(table.updatedDate.column);
+    }
+    const columns = Array.from(columnsSet);
+    let sql = `insert into ??(${columns.map(() => '??').join(',')}) values`;
+    const values = [table.tableName, ...columns];
+    list.forEach((data, idx) => {
+        if (idx > 0) {
+            sql += ',';
+        }
+        const fragList = [];
+        const rowValues = [];
+        if (table.createdDate) {
+            data[table.createdDate.column] = createdData;
+        }
+        if (table.updatedDate) {
+            data[table.updatedDate.column] = updatedDate;
+        }
+        for (const col of columns) {
+            const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
+            fragList.push(frag);
+            rowValues.push(...vs);
+        }
+        sql += `(${fragList.join(',')})`;
+        values.push(...rowValues);
+    });
+    const updateColumns = columns.filter(col => col !== table.id);
+    sql += ` on duplicate key update ${updateColumns.map(() => '?? = values(??)').join(',')}`;
+    updateColumns.forEach(col => values.push(col, col));
+    const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
+    const packet = res;
+    return packet.affectedRows;
+}
+exports.upsertMany = upsertMany;
+/**
+ * Upsert 单条数据（支持自定义更新器）
+ * 如果主键冲突则按自定义逻辑更新，否则插入
+ * @param config
+ * @param connection
+ * @param table
+ * @param data 插入的数据
+ * @param updater 冲突时的更新器
+ * @returns
+ */
+async function upsertWithUpdater(config, connection, table, data, updater) {
+    let columnsSet = new Set();
+    if (data[table.id]) {
+        columnsSet.add(table.id);
+    }
+    table.columns.forEach(col => {
+        if (data[col] !== undefined) {
+            columnsSet.add(col);
+        }
+    });
+    const now = new Date();
+    const nowTimestamp = now.getTime();
+    if (table.createdDate) {
+        const createdData = table.createdDate.type === 'date' ? now : nowTimestamp;
+        data[table.createdDate.column] = createdData;
+        columnsSet.add(table.createdDate.column);
+    }
+    if (table.updatedDate) {
+        const updatedDate = table.updatedDate.type === 'date' ? now : nowTimestamp;
+        data[table.updatedDate.column] = updatedDate;
+        columnsSet.add(table.updatedDate.column);
+    }
+    const columns = Array.from(columnsSet);
+    // 构建 insert values
+    const fragList = [];
+    const insertValues = [];
+    for (const col of columns) {
+        const { frag, values: vs } = (0, insert_1.processInsertValue)(data[col]);
+        fragList.push(frag);
+        insertValues.push(...vs);
+    }
+    const insertSql = `insert into ??(${columns.map(() => '??').join(',')}) values(${fragList.join(',')})`;
+    const convertRes = (0, update_1.updatorToSql)(table, updater);
+    const updateSql = ` on duplicate key update ${convertRes.sql}`;
+    const sql = insertSql + updateSql;
+    const values = [table.tableName, ...columns, ...insertValues, ...convertRes.values];
+    const res = await (0, utils_1.promiseQuery)(config, connection, sql, values);
+    const packet = res;
+    if (packet.insertId && (data[table.id] === undefined || data[table.id] === null)) {
+        data[table.id] = packet.insertId;
+    }
+    return data;
+}
+exports.upsertWithUpdater = upsertWithUpdater;

package/dist/mysql/manager/ops/utils.js

@@ -6,6 +6,10 @@ exports.processColumnValue = void 0;
  * @param value
  */
 function processColumnValue(value) {
+    // undefined/null 返回 null，mysql2 会正确处理为 SQL NULL
+    if (value === undefined || value === null) {
+        return null;
+    }
     // date 类型 typeof 也是 object ，先排除
     if (value instanceof Date) {
         return value;

package/documentation/en/mysql.md

@@ -227,12 +227,32 @@ await manager.insert(tableUser, {
   nickname: '小明',
   balance: 1
 })
+// Insert with expressions
+await manager.insert(tableUser, {
+  id: 'in002',
+  nickname: '小红',
+  balance: ['expr', '?? * ?', ['score', 2]],
+  createAt: ['now']
+})
 // Batch insert
 await manager.insertMany(tableUser, [
   { id: 'im001', nickname: '张飞', balance: 0 },
   { id: 'im002', nickname: '关羽', balance: 2 },
   { id: 'im003', nickname: '刘备', balance: 5 }
 ])
+// Upsert single record, update on conflict
+await manager.upsert(tableUser, { id: 'us001', nickname: '赵云', balance: 10 })
+// Batch upsert
+await manager.upsertMany(tableUser, [
+  { id: 'us002', nickname: '马超', balance: 20 },
+  { id: 'us003', nickname: '黄忠', balance: 30 }
+])
+// Upsert with custom updater (e.g., increment balance on conflict)
+await manager.upsertWithUpdater(
+  tableUser,
+  { id: 'us001', nickname: '赵云', balance: 10 },
+  { balance: ['inc', 5], nickname: '赵云-updated' }
+)
 // Query first matching record by condition
 const user = await manager.findFirst(tableUser, c =>
   c.like('nickname', 'ff0%').gt('balance', 75).lt('balance', 77)
@@ -253,6 +273,18 @@ await manager.find({
   limit: 10,
   orderBy: [['balance', 'asc']]
 })
+// Custom order by expression: balance * 2 desc
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ff0%'),
+  orderBy: [['expr', '?? * ?', ['balance', 2], 'desc']]
+})
+// Custom criteria expression: balance * 2 > 50
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('id', 'critex%').expr('?? * ? > ?', ['balance', 2, 50]),
+  orderBy: [['balance', 'asc']]
+})
 // Count matching records
 const count = await manager.count(tableUser, c => c.like('id', 'c00%').like('nickname', '李%'))
 // Paginated query
@@ -295,6 +327,9 @@ await manager.modify(`update user set nickname='无名' where nickname='佚名'`
 | findFirst       | Query first matching record                                                 |
 | insert          | Insert record                                                               |
 | insertMany      | Insert multiple records at once                                             |
+| upsert          | Insert record, update on duplicate key                                      |
+| upsertMany      | Batch upsert                                                                |
+| upsertWithUpdater | Upsert single record with custom updater for conflicts                      |
 | update          | Update record, requires complete information                                 |
 | partialUpdate   | Partial update, only provide id and fields to update                        |
 | updateOne       | Update only first matching record, only supports equality conditions        |
@@ -303,9 +338,88 @@ await manager.modify(`update user set nickname='无名' where nickname='佚名'`
 | findSelect      | Conditional query with specified fields. Same as find but with select param |
 | count           | Count matching records. Dangerous operation, use strict conditions          |
 | paginate        | Paginated query. Dangerous operation, based on find and count               |
+| paginateSelect  | Paginated query with specified fields, based on findSelect and count        |
 | query           | Custom SQL query, returns record list, supports prepared statements         |
 | modify          | Execute custom SQL, returns affected rows, supports prepared statements     |
 
+### Insert Expressions
+
+Starting from version 0.7.0, `insert`, `insertMany`, `upsert` and other insert methods accept `InsertValue` type,
+allowing expressions in the VALUES clause:
+
+```ts
+await manager.insert(tableUser, {
+  id: 'in001',
+  nickname: '小明',
+  // Set to NOW()
+  createAt: ['now'],
+  // Resolve conflict: set field to the array ['setNull'] (not the setNull operation)
+  extra: ['set', ['setNull']],
+  // Custom expression: balance = score * 2
+  balance: ['expr', '?? * ?', ['score', 2]],
+  // Expression without parameters
+  balance2: ['expr', 'RAND() * 100']
+})
+```
+
+### Order By Expressions
+
+Starting from version 0.7.0, the `orderBy` parameter is upgraded to `OrderBy<T>` type, supporting custom
+expression-based ordering in addition to regular column ordering. This type is backward-compatible.
+
+```ts
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ob%'),
+  // Regular column ordering (backward-compatible)
+  orderBy: [['balance', 'asc']]
+})
+
+// Custom expression ordering: balance * 2 desc
+// SQL: ORDER BY `balance` * 2 desc
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ob%'),
+  orderBy: [['expr', '?? * ?', ['balance', 2], 'desc']]
+})
+
+// Order by name length: CHAR_LENGTH(name) desc
+// SQL: ORDER BY CHAR_LENGTH(`name`) desc
+await manager.find({
+  table: tableBook,
+  criteria: c => c.like('name', 'ob%'),
+  orderBy: [['expr', 'CHAR_LENGTH(??)', ['name'], 'desc']]
+})
+
+// Mixed: regular column + expression
+orderBy: [
+  ['active', 'asc'],
+  ['expr', '?? * ?', ['balance', 2], 'desc']
+]
+// SQL: ORDER BY `active` asc , `balance` * 2 desc
+```
+
+### Criteria Expressions
+
+Starting from version 0.7.0, `MysqlCriteria` adds an `expr()` method for inserting custom SQL expressions
+in the WHERE clause:
+
+```ts
+// balance * 2 > 50
+// SQL: where ... and `balance` * 2 > 50
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('id', 'critex%').expr('?? * ? > ?', ['balance', 2, 50])
+})
+
+// Full-text search
+// SQL: where ... and MATCH(`title`, `content`) AGAINST (? IN BOOLEAN MODE)
+await manager.find({
+  table: tableBook,
+  criteria: c => c.expr('MATCH(??, ??) AGAINST(? IN BOOLEAN MODE)', ['title', 'content', keyword])
+})
+```
+
 ### JSON Type
 
 Version 0.2.0 adds limited support for JSON types. You can insert and query normally, and filtering conditions partially support MySQL's JSON-related functions.
@@ -427,24 +541,40 @@ The partialUpdate and updateMany methods support partial field modifications and
 await manager.updateMany(tableUser, c => c.between('balance', 23, 24), {
   // Increase balance by 2
   balance: ['inc', 2],
+  // Increase visits by 1 (default increment)
+  visits: ['inc'],
   // Set consume_type to null
-  consume_type: ['setNull']
+  consume_type: ['setNull'],
+  // Set to NOW()
+  last_login_at: ['now'],
+  // NULL-safe string concatenation: col = CONCAT(IFNULL(col, ''), ?)
+  nickname: ['concat', '-suffix'],
+  // Custom expression: score = score * 2
+  score: ['expr', '?? * ?', ['score', 2]]
 })
 ```
 
-Setting a field to null directly also works, but requires TypeScript type support:
+> **Note**: `['func']` has been removed in 0.7.0. Use `['expr']` instead.
+> E.g., `['func', 'NOW()']` → `['expr', 'NOW()']`.
+
+**Starting from version 0.7.0**, `null` is treated the same as `undefined` and will be ignored during updates. **To set a field to NULL, you must use `['setNull']`**.
 
 ```ts
 interface User {
   id: string
-  // Include null in role type
   role: string | null
 }
 
+// Correct: Use ['setNull'] to set field to NULL
+await manager.partialUpdate(tableUser, {
+  id: '001',
+  role: ['setNull']
+})
+
+// Wrong: Starting from 0.7.0, null is ignored and won't update the field
 await manager.partialUpdate(tableUser, {
   id: '001',
-  // Equivalent to role: ['setNull']
-  role: null
+  role: null  // This operation will not take effect
 })
 ```
 

package/documentation/zh-cn/mysql.md

@@ -228,12 +228,32 @@ await manager.insert(tableUser, {
   nickname: '小明',
   balance: 1
 })
+// 插入时使用表达式
+await manager.insert(tableUser, {
+  id: 'in002',
+  nickname: '小红',
+  balance: ['expr', '?? * ?', ['score', 2]],
+  createAt: ['now']
+})
 // 批量插入
 await manager.insertMany(tableUser, [
   { id: 'im001', nickname: '张飞', balance: 0 },
   { id: 'im002', nickname: '关羽', balance: 2 },
   { id: 'im003', nickname: '刘备', balance: 5 }
 ])
+// Upsert 单条，id 冲突则更新
+await manager.upsert(tableUser, { id: 'us001', nickname: '赵云', balance: 10 })
+// Upsert 批量
+await manager.upsertMany(tableUser, [
+  { id: 'us002', nickname: '马超', balance: 20 },
+  { id: 'us003', nickname: '黄忠', balance: 30 }
+])
+// Upsert 单条，冲突时自定义更新（如递增余额）
+await manager.upsertWithUpdater(
+  tableUser,
+  { id: 'us001', nickname: '赵云', balance: 10 },
+  { balance: ['inc', 5], nickname: '赵云-updated' }
+)
 // 根据指定的条件查询第一条符合的记录
 const user = await manager.findFirst(tableUser, c =>
   c.like('nickname', 'ff0%').gt('balance', 75).lt('balance', 77)
@@ -254,6 +274,18 @@ await manager.find({
   limit: 10,
   orderBy: [['balance', 'asc']]
 })
+// 自定义排序表达式：按 balance * 2 降序
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ff0%'),
+  orderBy: [['expr', '?? * ?', ['balance', 2], 'desc']]
+})
+// 自定义查询条件表达式：balance * 2 > 50
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('id', 'critex%').expr('?? * ? > ?', ['balance', 2, 50]),
+  orderBy: [['balance', 'asc']]
+})
 // 统计符合条件的记录数量
 const count = await manager.count(tableUser, c => c.like('id', 'c00%').like('nickname', '李%'))
 // 分页查询
@@ -294,18 +326,99 @@ await manager.modify(`update user set nickname='无名' where nickname='佚名'`
 | deleteMany    | 按指定条件删除，危险操作，建议尽可能设置 limit 参数来限制数量                       |
 | findAll       | 查询表下所有记录，危险操作，建议只对数据量非常小的表使用                            |
 | findFirst     | 查询符合条件的第一条记录                                                            |
-| insert        | 插入记录                                                                            |
-| insertMany    | 一次性插入多条记录                                                                  |
-| update        | 更新记录，需要完整信息                                                              |
-| partialUpdate | 局部更新，只提供 id 和需要更新的字段信息                                            |
-| updateOne     | 只更新指定条件的第一条记录，必须是相等条件，不支持范围条件                          |
-| updateMany    | 更新所有符合条件的记录，危险操作，建议对条件严加限制，控制受影响的范围              |
-| find          | 按条件查询所有符合条件的记录，危险操作，建议尽可能设置 limit 参数来限制数量         |
-| findSelect    | 指定字段进行条件查询,与 find 唯一的不同的是多一个参数 select 可以用来指定要返回的列 |
-| count         | 统计符合条件的记录数量，危险操作，建议严格限制条件，注意索引的利用                  |
-| paginate      | 分页查询 ，危险操作，基于 find 和 count                                             |
-| query         | 自定义 sql 查询，返回记录列表，支持预编译 sql                                       |
-| modify        | 执行自定义 sql，返回操作记录数 ，支持预编译 sql                                     |
+| insert          | 插入记录                                                                            |
+| insertMany      | 一次性插入多条记录                                                                  |
+| upsert          | 插入记录，主键冲突则更新                                                            |
+| upsertMany      | 批量 upsert                                                                         |
+| upsertWithUpdater | upsert 单条，主键冲突时使用自定义更新器（Updater）                                  |
+| update          | 更新记录，需要完整信息                                                              |
+| partialUpdate   | 局部更新，只提供 id 和需要更新的字段信息                                            |
+| updateOne       | 只更新指定条件的第一条记录，必须是相等条件，不支持范围条件                          |
+| updateMany      | 更新所有符合条件的记录，危险操作，建议对条件严加限制，控制受影响的范围              |
+| find            | 按条件查询所有符合条件的记录，危险操作，建议尽可能设置 limit 参数来限制数量         |
+| findSelect      | 指定字段进行条件查询,与 find 唯一的不同的是多一个参数 select 可以用来指定要返回的列 |
+| count           | 统计符合条件的记录数量，危险操作，建议严格限制条件，注意索引的利用                  |
+| paginate        | 分页查询 ，危险操作，基于 find 和 count                                             |
+| paginateSelect  | 指定字段进行分页查询，在 paginate 基础上增加了 select 参数                          |
+| query           | 自定义 sql 查询，返回记录列表，支持预编译 sql                                       |
+| modify          | 执行自定义 sql，返回操作记录数 ，支持预编译 sql                                     |
+
+### 插入表达式
+
+从 0.7.0 版本开始，`insert`、`insertMany`、`upsert` 等插入方法的 data 参数支持 `InsertValue` 类型，
+可以在 VALUES 子句中使用表达式：
+
+```ts
+await manager.insert(tableUser, {
+  id: 'in001',
+  nickname: '小明',
+  // 设置为 NOW()
+  createAt: ['now'],
+  // 解决冲突：将字段设置为 ['setNull'] 这个数组值（而非执行 setNull 操作）
+  extra: ['set', ['setNull']],
+  // 自定义表达式：balance = score * 2
+  balance: ['expr', '?? * ?', ['score', 2]],
+  // 无参数表达式
+  balance2: ['expr', 'RAND() * 100']
+})
+```
+
+### 排序表达式
+
+从 0.7.0 版本开始，`orderBy` 参数升级为 `OrderBy<T>` 类型，除了普通列排序外，还支持自定义表达式排序。
+该类型向后兼容，原有的列排序写法不受影响：
+
+```ts
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ob%'),
+  // 普通列排序（与旧版兼容）
+  orderBy: [['balance', 'asc']]
+})
+
+// 自定义表达式排序：按 balance * 2 降序
+// SQL: ORDER BY `balance` * 2 desc
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('nickname', 'ob%'),
+  orderBy: [['expr', '?? * ?', ['balance', 2], 'desc']]
+})
+
+// 按名称长度排序：CHAR_LENGTH(name) desc
+// SQL: ORDER BY CHAR_LENGTH(`name`) desc
+await manager.find({
+  table: tableBook,
+  criteria: c => c.like('name', 'ob%'),
+  orderBy: [['expr', 'CHAR_LENGTH(??)', ['name'], 'desc']]
+})
+
+// 混合使用：普通列 + 表达式
+orderBy: [
+  ['active', 'asc'],
+  ['expr', '?? * ?', ['balance', 2], 'desc']
+]
+// SQL: ORDER BY `active` asc , `balance` * 2 desc
+```
+
+### 条件表达式
+
+从 0.7.0 版本开始，`MysqlCriteria` 新增 `expr()` 方法，可在 WHERE 子句中插入自定义 SQL 表达式：
+
+```ts
+// balance * 2 > 50
+// SQL: where ... and `balance` * 2 > 50
+await manager.find({
+  table: tableUser,
+  criteria: c => c.like('id', 'critex%').expr('?? * ? > ?', ['balance', 2, 50])
+})
+
+// 全文搜索
+// SQL: where ... and MATCH(`title`, `content`) AGAINST (? IN BOOLEAN MODE)
+await manager.find({
+  table: tableBook,
+  criteria: c => c.expr('MATCH(??, ??) AGAINST(? IN BOOLEAN MODE)', ['title', 'content', keyword])
+})
+```
 
 ### json 类型
 
@@ -431,24 +544,40 @@ partialUpdate 和 updateMany 方法支持局部修改一些字段，并且支持
 await manager.updateMany(tableUser, c => c.between('balance', 23, 24), {
   // 将 balance 增加 2
   balance: ['inc', 2],
+  // 将 balance 增加 1（省略第二个参数，默认 +1）
+  visits: ['inc'],
   // 将 consume_type 置空
-  consume_type:['setNull']
+  consume_type: ['setNull'],
+  // 设置为 NOW()
+  last_login_at: ['now'],
+  // NULL 安全的字符串追加：col = CONCAT(IFNULL(col, ''), ?)
+  nickname: ['concat', '-suffix'],
+  // 自定义表达式：score = score * 2
+  score: ['expr', '?? * ?', ['score', 2]]
 })
 ```
 
-如果将一个字段的值设置为 null 也可以置空，但是这要求设置 ts 类型支持。
+> **注意**：0.7.0 版本已移除 `['func']`，请使用 `['expr']` 替代。
+> 如 `['func', 'NOW()']` → `['expr', 'NOW()']`。
+
+从 **0.7.0 版本**开始，`null` 和 `undefined` 一样会被忽略更新。**如需将字段设置为 NULL，必须使用 `['setNull']`**。
 
 ```ts
 interface User {
   id: string
-  // 将 role 的类型设置包含 null
   role: string | null
 }
 
+// 正确：使用 ['setNull'] 将字段置空
+await manager.partialUpdate(tableUser, {
+  id: '001',
+  role: ['setNull']
+})
+
+// 错误：0.7.0 版本开始，null 会被忽略，不会更新字段
 await manager.partialUpdate(tableUser, {
   id: '001',
-  // 等同于 role:['setNull']
-  role: null
+  role: null  // 此操作不会生效
 })
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wok-server",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "packageManager": "pnpm@8.9.0",
   "description": "一个基于 NodeJs 和 TypeScript 的后端框架，轻量级、克制、简洁。A lightweight, restrained, and concise backend framework based on Node.js and TypeScript.",
   "scripts": {
@@ -21,6 +21,7 @@
     "documentation/",
     "skills/",
     "src/",
+    "README.en.md",
     "README.md"
   ],
   "author": "peak",