midway-fatcms 0.0.16 → 0.0.18

package/dist/libs/crud-pro/utils/MixinUtils.js

@@ -2,90 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MixinUtils = void 0;
 const exceptions_1 = require("../exceptions");
+const idgene_1 = require("./idgene");
 //  至少需要2个字符
 const FIELD_NAME_REG_EXP = /^[a-zA-Z][0-9a-zA-Z_]+$/;
-// ===================== 雪花ID =====================
-const SNOWFLAKE_SEQ_START = 1;
-let snowflakeSeq = SNOWFLAKE_SEQ_START;
-let snowflakeLastTs = -1;
-/**
- * 生成雪花ID（64位整数，JS 中以 string 返回）
- * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
- * - 时间戳：相对于 2024-01-01 00:00:00 的毫秒偏移，可用约 69 年
- * - 机器ID：0-1023，优先取参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低10位
- * - 序列号：0-4095，同一毫秒内自增
- *
- * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
- * @returns 雪花ID字符串
- */
-function generateSnowflakeId(machineId) {
-    const EPOCH = 1704067200000; // 2024-01-01 00:00:00 UTC
-    let mid = Number(machineId);
-    if (mid === undefined || mid === null || isNaN(mid)) {
-        // 优先从环境变量获取，适配多实例部署场景
-        const envMid = typeof process !== 'undefined' && process.env && process.env.SNOWFLAKE_MACHINE_ID
-            ? parseInt(process.env.SNOWFLAKE_MACHINE_ID, 10)
-            : NaN;
-        mid = !isNaN(envMid) ? envMid : (typeof process !== 'undefined' && process.pid ? process.pid & 0x3ff : 0);
-    }
-    mid = Math.abs(mid) & 0x3ff; // 确保在 0-1023 范围
-    let now = Date.now();
-    let ts = now - EPOCH;
-    // 时钟回拨保护：若当前时间戳小于上次，直接沿用上次时间戳继续递增，
-    // 避免 NTP 校正/VM 快照恢复等场景下生成重复 ID，同时不阻塞 CPU
-    if (ts < snowflakeLastTs) {
-        const drift = snowflakeLastTs - ts;
-        if (drift <= 5) {
-            // 小幅回拨，沿用上次时间戳（ID 仅比实际时间快 ≤5ms，不影响唯一性和排序性）
-            ts = snowflakeLastTs;
-        }
-        else {
-            // 大幅回拨，无法安全恢复，抛出异常
-            throw new Error(`Snowflake clock drift detected: ${drift}ms backwards. Refusing to generate ID.`);
-        }
-    }
-    if (ts === snowflakeLastTs) {
-        snowflakeSeq = (snowflakeSeq + 1) & 0xfff; // 0-4095 循环
-        if (snowflakeSeq === 0) {
-            // 本毫秒序列号耗尽，直接推进到下一毫秒（不阻塞CPU忙等待）
-            // ID 的时间戳比实际时间快 ≤1ms，不影响唯一性和排序性
-            ts = snowflakeLastTs + 1;
-            snowflakeSeq = SNOWFLAKE_SEQ_START;
-        }
-    }
-    else {
-        snowflakeSeq = SNOWFLAKE_SEQ_START;
-    }
-    snowflakeLastTs = ts;
-    // 雪花ID超过JS安全整数范围(2^53)，Number运算会丢失精度
-    // 使用 BigInt 做位移拼接，确保 64 位精度完整
-    const id = (BigInt(ts) << BigInt(22)) | (BigInt(mid) << BigInt(12)) | BigInt(snowflakeSeq);
-    return id.toString();
-}
-/**
- * 生成 UUID v4 字符串（纯随机，无外部依赖）
- * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
- * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
- */
-function uuid() {
-    // crypto.getRandomValues 在 Node.js >= 11 和现代浏览器中可用
-    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
-        const bytes = new Uint8Array(16);
-        crypto.getRandomValues(bytes);
-        // 版本位：第6字节高4位设为 0100 (v4)
-        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-        // 变体位：第8字节高2位设为 10
-        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-        const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
-        return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20);
-    }
-    // 降级方案：Math.random
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
 const MixinUtils = {
     isNil(obj) {
         return typeof obj === 'undefined' || obj === null;
@@ -342,7 +261,7 @@ const MixinUtils = {
      * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
      * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
      */
-    uuid: uuid,
+    uuid: idgene_1.uuid,
     /**
      * 生成雪花ID（64位整数，以字符串返回）
      * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
@@ -351,6 +270,7 @@ const MixinUtils = {
      * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
      * @returns 雪花ID字符串
      */
-    generateSnowflakeId: generateSnowflakeId,
+    generateSnowflakeId: idgene_1.generateSnowflakeId,
+    generateSnowflakeIdExt: idgene_1.generateSnowflakeIdExt,
 };
 exports.MixinUtils = MixinUtils;

package/dist/libs/crud-pro/utils/idgene/generateSnowflakeId.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 生成雪花ID（64位整数，JS 中以 string 返回）
+ * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+ * - 时间戳：相对于 2024-01-01 00:00:00 的毫秒偏移，可用约 69 年
+ * - 机器ID：0-1023，优先取参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低10位
+ * - 序列号：0-4095，同一毫秒内自增
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns 雪花ID字符串
+ */
+declare function generateSnowflakeId(machineId?: number): string;
+export { generateSnowflakeId };

package/dist/libs/crud-pro/utils/idgene/generateSnowflakeId.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSnowflakeId = void 0;
+const SNOWFLAKE_SEQ_START = 1;
+let snowflakeSeq = SNOWFLAKE_SEQ_START;
+let snowflakeLastTs = -1;
+/**
+ * 生成雪花ID（64位整数，JS 中以 string 返回）
+ * 结构：1位符号 + 41位时间戳(ms) + 10位机器ID + 12位序列号
+ * - 时间戳：相对于 2024-01-01 00:00:00 的毫秒偏移，可用约 69 年
+ * - 机器ID：0-1023，优先取参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低10位
+ * - 序列号：0-4095，同一毫秒内自增
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns 雪花ID字符串
+ */
+function generateSnowflakeId(machineId) {
+    const EPOCH = 1704067200000; // 2024-01-01 00:00:00 UTC
+    let mid = Number(machineId);
+    if (mid === undefined || mid === null || isNaN(mid)) {
+        // 优先从环境变量获取，适配多实例部署场景
+        const envMid = typeof process !== 'undefined' && process.env && process.env.SNOWFLAKE_MACHINE_ID
+            ? parseInt(process.env.SNOWFLAKE_MACHINE_ID, 10)
+            : NaN;
+        mid = !isNaN(envMid) ? envMid : (typeof process !== 'undefined' && process.pid ? process.pid & 0x3ff : 0);
+    }
+    mid = Math.abs(mid) & 0x3ff; // 确保在 0-1023 范围
+    let now = Date.now();
+    let ts = now - EPOCH;
+    // 时钟回拨保护：若当前时间戳小于上次，直接沿用上次时间戳继续递增，
+    // 避免 NTP 校正/VM 快照恢复等场景下生成重复 ID，同时不阻塞 CPU
+    if (ts < snowflakeLastTs) {
+        const drift = snowflakeLastTs - ts;
+        if (drift <= 5) {
+            // 小幅回拨，沿用上次时间戳（ID 仅比实际时间快 ≤5ms，不影响唯一性和排序性）
+            ts = snowflakeLastTs;
+        }
+        else {
+            // 大幅回拨，无法安全恢复，抛出异常
+            throw new Error(`Snowflake clock drift detected: ${drift}ms backwards. Refusing to generate ID.`);
+        }
+    }
+    if (ts === snowflakeLastTs) {
+        snowflakeSeq = (snowflakeSeq + 1) & 0xfff; // 0-4095 循环
+        if (snowflakeSeq === 0) {
+            // 本毫秒序列号耗尽，直接推进到下一毫秒（不阻塞CPU忙等待）
+            // ID 的时间戳比实际时间快 ≤1ms，不影响唯一性和排序性
+            ts = snowflakeLastTs + 1;
+            snowflakeSeq = SNOWFLAKE_SEQ_START;
+        }
+    }
+    else {
+        snowflakeSeq = SNOWFLAKE_SEQ_START;
+    }
+    snowflakeLastTs = ts;
+    // 雪花ID超过JS安全整数范围(2^53)，Number运算会丢失精度
+    // 使用 BigInt 做位移拼接，确保 64 位精度完整
+    const id = (BigInt(ts) << BigInt(22)) | (BigInt(mid) << BigInt(12)) | BigInt(snowflakeSeq);
+    return id.toString();
+}
+exports.generateSnowflakeId = generateSnowflakeId;

package/dist/libs/crud-pro/utils/idgene/generateSnowflakeIdExt.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 128 位雪花 ID 生成器（独立于 MixinUtils.generateSnowflakeId，原 63 位算法不变）
+ *
+ * 位布局（128 bit，无符号，BigInt 拼接后 Base58 编码返回）：
+ * - 64 bit 时间戳：相对 2024-01-01 00:00:00 UTC 的毫秒偏移
+ * - 16 bit 机器ID：0-65535，优先参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低 16 位
+ * - 48 bit 序列号：同一毫秒内自增，约 2.8e14 个/ms，实际不会耗尽
+ *
+ * 输出：Bitcoin 字母表 Base58（无 0/O/I/l），当前约 21 字符，理论最大 22 字符，建议 VARCHAR(24)
+ */
+declare const EPOCH: bigint;
+/**
+ * 生成 128 位雪花 ID（Base58 字符串）
+ *
+ * @param machineId 机器ID（0-65535），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns Base58 编码的 128 位雪花 ID
+ */
+declare function generateSnowflakeIdExt(machineId?: number): string;
+export { generateSnowflakeIdExt, EPOCH as SNOWFLAKE_EXT_EPOCH };

package/dist/libs/crud-pro/utils/idgene/generateSnowflakeIdExt.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * 128 位雪花 ID 生成器（独立于 MixinUtils.generateSnowflakeId，原 63 位算法不变）
+ *
+ * 位布局（128 bit，无符号，BigInt 拼接后 Base58 编码返回）：
+ * - 64 bit 时间戳：相对 2024-01-01 00:00:00 UTC 的毫秒偏移
+ * - 16 bit 机器ID：0-65535，优先参数 > 环境变量 SNOWFLAKE_MACHINE_ID > process.pid 低 16 位
+ * - 48 bit 序列号：同一毫秒内自增，约 2.8e14 个/ms，实际不会耗尽
+ *
+ * 输出：Bitcoin 字母表 Base58（无 0/O/I/l），当前约 21 字符，理论最大 22 字符，建议 VARCHAR(24)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNOWFLAKE_EXT_EPOCH = exports.generateSnowflakeIdExt = void 0;
+const EPOCH = BigInt(1704067200000); // 2024-01-01 00:00:00 UTC
+exports.SNOWFLAKE_EXT_EPOCH = EPOCH;
+const TS_SHIFT = BigInt(64);
+const MID_SHIFT = BigInt(48);
+const MID_MASK = BigInt(0xffff);
+const SEQ_MASK = BigInt('0xffffffffffff'); // 48 bit
+const SEQ_START = BigInt(1);
+const DRIFT_TOLERANCE = BigInt(5);
+/** Bitcoin Base58 字母表 */
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE58_RADIX = BigInt(58);
+let snowflakeExtSeq = SEQ_START;
+let snowflakeExtLastTs = BigInt(-1);
+/** 无符号 BigInt → Base58 字符串 */
+function encodeBase58(value) {
+    if (value === BigInt(0)) {
+        return BASE58_ALPHABET[0];
+    }
+    let n = value;
+    let result = '';
+    while (n > BigInt(0)) {
+        const rem = Number(n % BASE58_RADIX);
+        result = BASE58_ALPHABET[rem] + result;
+        n = n / BASE58_RADIX;
+    }
+    return result;
+}
+/** 解析机器 ID（16 bit） */
+function resolveMachineId(machineId) {
+    var _a;
+    let mid = Number(machineId);
+    if (machineId === undefined || machineId === null || isNaN(mid)) {
+        const envMid = typeof process !== 'undefined' && ((_a = process.env) === null || _a === void 0 ? void 0 : _a.SNOWFLAKE_MACHINE_ID)
+            ? parseInt(process.env.SNOWFLAKE_MACHINE_ID, 10)
+            : NaN;
+        mid = !isNaN(envMid)
+            ? envMid
+            : typeof process !== 'undefined' && process.pid
+                ? process.pid
+                : 0;
+    }
+    return BigInt(Math.abs(mid)) & MID_MASK;
+}
+/**
+ * 生成 128 位雪花 ID（Base58 字符串）
+ *
+ * @param machineId 机器ID（0-65535），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns Base58 编码的 128 位雪花 ID
+ */
+function generateSnowflakeIdExt(machineId) {
+    const mid = resolveMachineId(machineId);
+    let ts = BigInt(Date.now()) - EPOCH;
+    if (ts < snowflakeExtLastTs) {
+        const drift = snowflakeExtLastTs - ts;
+        if (drift <= DRIFT_TOLERANCE) {
+            ts = snowflakeExtLastTs;
+        }
+        else {
+            throw new Error(`SnowflakeExt clock drift detected: ${drift}ms backwards. Refusing to generate ID.`);
+        }
+    }
+    if (ts === snowflakeExtLastTs) {
+        snowflakeExtSeq = (snowflakeExtSeq + BigInt(1)) & SEQ_MASK;
+        if (snowflakeExtSeq === BigInt(0)) {
+            ts = snowflakeExtLastTs + BigInt(1);
+            snowflakeExtSeq = SEQ_START;
+        }
+    }
+    else {
+        snowflakeExtSeq = SEQ_START;
+    }
+    snowflakeExtLastTs = ts;
+    const id = (ts << TS_SHIFT) | (mid << MID_SHIFT) | snowflakeExtSeq;
+    return encodeBase58(id);
+}
+exports.generateSnowflakeIdExt = generateSnowflakeIdExt;

package/dist/libs/crud-pro/utils/idgene/index.d.ts

@@ -0,0 +1,3 @@
+export { generateSnowflakeId } from './generateSnowflakeId';
+export { generateSnowflakeIdExt, SNOWFLAKE_EXT_EPOCH } from './generateSnowflakeIdExt';
+export { uuid } from './uuid';

package/dist/libs/crud-pro/utils/idgene/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = exports.SNOWFLAKE_EXT_EPOCH = exports.generateSnowflakeIdExt = exports.generateSnowflakeId = void 0;
+var generateSnowflakeId_1 = require("./generateSnowflakeId");
+Object.defineProperty(exports, "generateSnowflakeId", { enumerable: true, get: function () { return generateSnowflakeId_1.generateSnowflakeId; } });
+var generateSnowflakeIdExt_1 = require("./generateSnowflakeIdExt");
+Object.defineProperty(exports, "generateSnowflakeIdExt", { enumerable: true, get: function () { return generateSnowflakeIdExt_1.generateSnowflakeIdExt; } });
+Object.defineProperty(exports, "SNOWFLAKE_EXT_EPOCH", { enumerable: true, get: function () { return generateSnowflakeIdExt_1.SNOWFLAKE_EXT_EPOCH; } });
+var uuid_1 = require("./uuid");
+Object.defineProperty(exports, "uuid", { enumerable: true, get: function () { return uuid_1.uuid; } });

package/dist/libs/crud-pro/utils/idgene/uuid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 生成 UUID v4 字符串（纯随机，无外部依赖）
+ * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+ * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+ */
+declare function uuid(): string;
+export { uuid };

package/dist/libs/crud-pro/utils/idgene/uuid.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = void 0;
+/**
+ * 生成 UUID v4 字符串（纯随机，无外部依赖）
+ * 格式：xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx，其中 y 为 8/9/a/b 之一
+ * @returns 符合 RFC 4122 v4 规范的 UUID 字符串
+ */
+function uuid() {
+    // crypto.getRandomValues 在 Node.js >= 11 和现代浏览器中可用
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        // 版本位：第6字节高4位设为 0100 (v4)
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        // 变体位：第8字节高2位设为 10
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+        return hex.slice(0, 8) + '-' + hex.slice(8, 12) + '-' + hex.slice(12, 16) + '-' + hex.slice(16, 20) + '-' + hex.slice(20);
+    }
+    // 降级方案：Math.random
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+exports.uuid = uuid;

package/dist/libs/crud-pro/utils/pool/SqlServerUtils.js

@@ -4,10 +4,36 @@ exports.getConnectionPool = void 0;
 const mssql_1 = require("mssql");
 const keys_1 = require("../../models/keys");
 const POOL_CACHE_MAP = {};
+const POOL_CONNECTING_MAP = {};
+async function doConnectPool(poolName, poolObj) {
+    // 避免重复连接同一个池
+    if (POOL_CONNECTING_MAP[poolName]) {
+        return POOL_CONNECTING_MAP[poolName];
+    }
+    const connectPromise = poolObj.connect().then((connectedPool) => {
+        console.log(`[crud-pro] SQL Server connection pool "${poolName}" connected successfully.`);
+        return connectedPool;
+    }).catch((err) => {
+        console.error(`[crud-pro] SQL Server connection pool "${poolName}" connect failed:`, err);
+        throw err;
+    }).finally(() => {
+        delete POOL_CONNECTING_MAP[poolName];
+    });
+    POOL_CONNECTING_MAP[poolName] = connectPromise;
+    return connectPromise;
+}
 function getConnectionPool(poolName, poolOptions) {
     let pool = POOL_CACHE_MAP[poolName];
     if (!pool) {
         const poolObj = new mssql_1.ConnectionPool(poolOptions);
+        // 监听连接池错误，避免未捕获的异常导致进程崩溃
+        poolObj.on('error', (err) => {
+            console.error(`[crud-pro] SQL Server connection pool "${poolName}" error:`, err);
+        });
+        // 预连接池，避免首次请求时才建立连接导致延迟
+        doConnectPool(poolName, poolObj).catch(() => {
+            // 错误已在 doConnectPool 中打印，此处无需重复处理
+        });
         pool = {
             dbType: keys_1.SqlDbType.sqlserver,
             poolName: poolName,

package/dist/libs/crud-pro-quick/fixSoftDelete.d.ts

@@ -1,25 +1,9 @@
 import { KeysOfSimpleSQL } from "../../libs/crud-pro/models/keys";
 import { IRequestModel, IVisitor } from "../../libs/crud-pro/interfaces";
 import { IRequestCfgModel2 } from "./models";
-/**
- * 软删除需要的用户信息（最小子集）
- */
-interface ISoftDeleteUserInfo {
-    accountId: string;
-}
-/**
- * 获取当前用户信息的函数类型
- */
-declare type GetCurrentUserFunc = () => ISoftDeleteUserInfo | null | undefined;
 /**
  * 软删除处理函数
  *
- * 当 cfgModel.enableSoftDelete === true 时，自动处理软删除逻辑：
- *
- * 1. INSERT 操作：自动设置 deleted_at = 0
- * 2. DELETE 操作：转为 UPDATE，设置 deleted_at = 时间戳, deleted_by = 当前用户
- * 3. QUERY 操作：自动添加 deleted_at = 0 条件
- *
  * @param oldSqlSimpleName 原始 SQL 类型
  * @param cfgModel 配置模型
  * @param params 请求参数（会被修改）
@@ -27,4 +11,3 @@ declare type GetCurrentUserFunc = () => ISoftDeleteUserInfo | null | undefined;
  */
 declare function fixSoftDelete(oldSqlSimpleName: KeysOfSimpleSQL, cfgModel: IRequestCfgModel2, params: IRequestModel, visitor?: IVisitor): void;
 export { fixSoftDelete, };
-export type { ISoftDeleteUserInfo, GetCurrentUserFunc };

package/dist/libs/crud-pro-quick/fixSoftDelete.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fixSoftDelete = void 0;
 const keys_1 = require("../../libs/crud-pro/models/keys");
+const DateTimeUtils_1 = require("../../libs/crud-pro/utils/DateTimeUtils");
 /**
  * 软删除处理函数
  *
@@ -16,11 +17,7 @@ const keys_1 = require("../../libs/crud-pro/models/keys");
  * @param params 请求参数（会被修改）
  * @param visitor 获取当前用户信息的函数（用于软删除时记录删除人）
  */
-function fixSoftDelete(oldSqlSimpleName, cfgModel, params, visitor) {
-    // 没有开启软删除，不做处理，直接物理删除
-    if (cfgModel.enableSoftDelete !== true) {
-        return;
-    }
+function fixSoftDelete1(oldSqlSimpleName, cfgModel, params, visitor) {
     // INSERT 操作：刚插入的数据，肯定是未删除的
     if (keys_1.KeysOfSimpleSQL.SIMPLE_INSERT === oldSqlSimpleName) {
         if (!params.data) {
@@ -55,4 +52,57 @@ function fixSoftDelete(oldSqlSimpleName, cfgModel, params, visitor) {
         params.condition.deleted_at = 0;
     }
 }
+function fixSoftDelete2(oldSqlSimpleName, cfgModel, params, visitor) {
+    // INSERT 操作：刚插入的数据，肯定是未删除的
+    if (keys_1.KeysOfSimpleSQL.SIMPLE_INSERT === oldSqlSimpleName) {
+        if (!params.data) {
+            params.data = {};
+        }
+        const dataObj = params.data;
+        dataObj.is_deleted = false;
+    }
+    // DELETE 操作：如果是软删除，修改为 UPDATE 语句
+    if (keys_1.KeysOfSimpleSQL.SIMPLE_DELETE === oldSqlSimpleName) {
+        if (!params.condition || Object.keys(params.condition).length === 0) {
+            throw new Error('执行删除操作，必须指定删除条件');
+        }
+        // 在原有 data 对象上添加软删除字段
+        if (!params.data) {
+            params.data = {};
+        }
+        const dataObj = params.data;
+        dataObj.is_deleted = true;
+        dataObj.deleted_at = DateTimeUtils_1.DateTimeUtils.getCurrentTimeString();
+        dataObj.deleted_by = (visitor === null || visitor === void 0 ? void 0 : visitor.accountId) || '';
+        // 改为执行 UPDATE 操作
+        cfgModel.sqlSimpleName = keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE;
+    }
+    // QUERY 操作：强制查询未删除的记录
+    if (keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE === oldSqlSimpleName
+        || keys_1.KeysOfSimpleSQL.SIMPLE_QUERY === oldSqlSimpleName
+        || keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE === oldSqlSimpleName) {
+        if (!params.condition) {
+            params.condition = {};
+        }
+        params.condition.is_deleted = false;
+    }
+}
+/**
+ * 软删除处理函数
+ *
+ * @param oldSqlSimpleName 原始 SQL 类型
+ * @param cfgModel 配置模型
+ * @param params 请求参数（会被修改）
+ * @param visitor 获取当前用户信息的函数（用于软删除时记录删除人）
+ */
+function fixSoftDelete(oldSqlSimpleName, cfgModel, params, visitor) {
+    if (cfgModel.enableSoftDelete === true || cfgModel.enableSoftDelete === 'soft') {
+        fixSoftDelete1(oldSqlSimpleName, cfgModel, params, visitor);
+        return;
+    }
+    if (cfgModel.enableSoftDelete === 'soft2') {
+        fixSoftDelete2(oldSqlSimpleName, cfgModel, params, visitor);
+        return;
+    }
+}
 exports.fixSoftDelete = fixSoftDelete;

package/dist/libs/crud-pro-quick/models.d.ts

@@ -18,6 +18,16 @@ export interface ICommonStandardColumns {
     modified_by?: string;
     modified_at?: number;
 }
+export interface ICommonStandardColumns2 {
+    is_deleted?: boolean | number;
+    deleted_at?: string;
+    deleted_by?: string;
+    created_by?: string;
+    created_at?: number;
+    modified_by?: string;
+    modified_at?: number;
+}
+export declare type TEnableSoftDelete = null | false | true | 'soft' | 'soft2';
 /**
  * 扩展的请求配置模型
  *
@@ -29,5 +39,5 @@ export interface ICommonStandardColumns {
 export interface IRequestCfgModel2 extends IRequestCfgModel {
     enableStandardUpdateCfg?: boolean | string[];
     enableStandardUpdateCfgCondition?: boolean | string[];
-    enableSoftDelete?: boolean;
+    enableSoftDelete?: TEnableSoftDelete;
 }

package/dist/middleware/cacherefresh.middleware.d.ts

@@ -1,47 +1,4 @@
 import { NextFunction, Context } from '@midwayjs/koa';
-import { CacheNameEnum } from '../models/bizmodels';
-import { CacheRefreshCategory } from '../models/CacheRefreshCategory';
-/**
- * 缓存刷新中间件
- *
- * 在路由处理成功完成后，自动触发指定缓存项的刷新。
- * 采用后置刷新模式：先 await next() 让业务逻辑执行完毕，再刷新缓存。
- *
- * 应用场景：
- * 1. manage 增删改操作后自动刷新关联的业务缓存
- * 2. 精准刷新：只刷新与本次操作相关的缓存项，避免全量刷新
- *
- * 使用示例：
- * ```typescript
- * // 刷新全部业务缓存（向后兼容，等同原来的 refreshCache()）
- * @Post('/createRole', { middleware: [checkPermission('write'), refreshCache()] })
- * async createRole() { ... }
- *
- * // 精准刷新：只刷新指定缓存项
- * @Post('/createMenu', { middleware: [checkPermission('write'), refreshCache(CacheNameEnum.GetSysMenusList)] })
- * async createMenu() { ... }
- *
- * // 同时刷新多个缓存项
- * @Post('/createApp', { middleware: [checkPermission('write'), refreshCache([CacheNameEnum.GetSysAppOne, CacheNameEnum.GetSysAppPageOne])] })
- * async createApp() { ... }
- * ```
- *
- * @param cacheName 缓存名称，不传则刷新全部，支持单个或数组
- */
-declare function refreshCache(cacheName?: CacheNameEnum | CacheNameEnum[]): (ctx: Context, next: NextFunction) => Promise<void>;
-/**
- * 缓存类别刷新中间件
- *
- * 通过 CacheRefreshHub 刷新指定类别的缓存（TableMeta / LinkToCustom / ProxyApiRoute 等）。
- * 适用于非 CacheNameEnum 管理的缓存类别。
- *
- * 使用示例：
- * ```typescript
- * @Post('/createProxyApi', { middleware: [checkPermission('write'), refreshCategory(CacheRefreshCategory.ProxyApiRoute)] })
- * async createProxyApi() { ... }
- * ```
- *
- * @param category 缓存类别，支持单个或数组
- */
-declare function refreshCategory(category: CacheRefreshCategory | CacheRefreshCategory[]): (ctx: Context, next: NextFunction) => Promise<void>;
-export { refreshCache, refreshCategory };
+import { BizMemCacheKey } from '../service/base/bizmemcache/BizMemCacheTypes';
+declare function refreshBizMemCache(cacheKey: BizMemCacheKey | BizMemCacheKey[]): (ctx: Context, next: NextFunction) => Promise<void>;
+export { refreshBizMemCache };

package/dist/middleware/cacherefresh.middleware.js

@@ -1,74 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refreshCategory = exports.refreshCache = void 0;
-const CacheServiceFactory_1 = require("../service/base/cache/CacheServiceFactory");
-const CacheRefreshHub_1 = require("../service/base/cache-refresh/CacheRefreshHub");
-/**
- * 缓存刷新中间件
- *
- * 在路由处理成功完成后，自动触发指定缓存项的刷新。
- * 采用后置刷新模式：先 await next() 让业务逻辑执行完毕，再刷新缓存。
- *
- * 应用场景：
- * 1. manage 增删改操作后自动刷新关联的业务缓存
- * 2. 精准刷新：只刷新与本次操作相关的缓存项，避免全量刷新
- *
- * 使用示例：
- * ```typescript
- * // 刷新全部业务缓存（向后兼容，等同原来的 refreshCache()）
- * @Post('/createRole', { middleware: [checkPermission('write'), refreshCache()] })
- * async createRole() { ... }
- *
- * // 精准刷新：只刷新指定缓存项
- * @Post('/createMenu', { middleware: [checkPermission('write'), refreshCache(CacheNameEnum.GetSysMenusList)] })
- * async createMenu() { ... }
- *
- * // 同时刷新多个缓存项
- * @Post('/createApp', { middleware: [checkPermission('write'), refreshCache([CacheNameEnum.GetSysAppOne, CacheNameEnum.GetSysAppPageOne])] })
- * async createApp() { ... }
- * ```
- *
- * @param cacheName 缓存名称，不传则刷新全部，支持单个或数组
- */
-function refreshCache(cacheName) {
-    const cacheNames = cacheName ? (Array.isArray(cacheName) ? cacheName : [cacheName]) : null;
+exports.refreshBizMemCache = void 0;
+const redis_1 = require("@midwayjs/redis");
+const BizMemCacheStore_1 = require("../service/base/bizmemcache/BizMemCacheStore");
+function refreshBizMemCache(cacheKey) {
+    const cacheKeys = Array.isArray(cacheKey) ? cacheKey : [cacheKey];
     return async (ctx, next) => {
         await next();
-        const cacheServiceFactory = await ctx.requestContext.getAsync(CacheServiceFactory_1.CacheServiceFactory);
-        if (cacheNames) {
-            // 精准刷新：只刷新指定的缓存项
-            for (const name of cacheNames) {
-                await cacheServiceFactory.refreshByCacheName(name, ctx);
-            }
-        }
-        else {
-            // 全量刷新：刷新所有已注册的业务缓存
-            await cacheServiceFactory.refreshAllCache(ctx);
-        }
-    };
-}
-exports.refreshCache = refreshCache;
-/**
- * 缓存类别刷新中间件
- *
- * 通过 CacheRefreshHub 刷新指定类别的缓存（TableMeta / LinkToCustom / ProxyApiRoute 等）。
- * 适用于非 CacheNameEnum 管理的缓存类别。
- *
- * 使用示例：
- * ```typescript
- * @Post('/createProxyApi', { middleware: [checkPermission('write'), refreshCategory(CacheRefreshCategory.ProxyApiRoute)] })
- * async createProxyApi() { ... }
- * ```
- *
- * @param category 缓存类别，支持单个或数组
- */
-function refreshCategory(category) {
-    const categories = Array.isArray(category) ? category : [category];
-    return async (ctx, next) => {
-        await next();
-        for (const cat of categories) {
-            await CacheRefreshHub_1.CacheRefreshHub.refresh(cat, ctx);
+        const redisService = await ctx.requestContext.getAsync(redis_1.RedisService);
+        for (const key of cacheKeys) {
+            await BizMemCacheStore_1.bizMemCacheStore.markDirty(key, redisService);
         }
     };
 }
-exports.refreshCategory = refreshCategory;
+exports.refreshBizMemCache = refreshBizMemCache;