midway-fatcms 0.0.17 → 0.0.19

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,27 @@
+/**
+ * 128 位雪花 ID 生成器（优化版）
+ *
+ * 位布局（128 bit，无符号，BigInt 拼接后 Base58 编码返回）：
+ * - 41 bit 时间戳：相对 2024-01-01 00:00:00 UTC 的毫秒偏移，可用约 69 年（至 ~2093 年）
+ * - 10 bit 机器ID：0-1023，与标准 64 位雪花 ID 一致，优先参数 > 环境变量 > process.pid
+ * - 77 bit 序列号：同一毫秒内自增，2^77 ≈ 1.5×10²³，无需考虑耗尽
+ *
+ * 输出：Bitcoin 字母表 Base58（无 0/O/I/l），左填充 '1' 至恒定 22 字符，建议 VARCHAR(24)
+ * 时间戳在高位，ID 随时间单调递增，适合做数据库主键。
+ * 2^128-1 < 58^22，故 22 字符足以覆盖全部 128 位取值范围。
+ */
+declare const EPOCH: bigint;
+/**
+ * 生成 128 位雪花 ID（Base58 字符串，恒定 22 字符）
+ *
+ * 位布局：41 bit 时间戳 | 10 bit 机器ID | 77 bit 序列号
+ * 时间戳采用 41 bit（与标准 64 位雪花 ID 一致），毫秒精度，可用约 69 年。
+ * 机器ID 采用 10 bit（0-1023），与标准 64 位雪花 ID 一致，防止多机 ID 冲突。
+ * 时间戳在高位，ID 随时间单调递增，适合做数据库主键。
+ * Base58 输出左填充 '1'（零字符）至 22 字符，保证长度恒定且不破坏字典序排序。
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns Base58 编码的 128 位雪花 ID（恒定 22 字符）
+ */
+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,96 @@
+"use strict";
+/**
+ * 128 位雪花 ID 生成器（优化版）
+ *
+ * 位布局（128 bit，无符号，BigInt 拼接后 Base58 编码返回）：
+ * - 41 bit 时间戳：相对 2024-01-01 00:00:00 UTC 的毫秒偏移，可用约 69 年（至 ~2093 年）
+ * - 10 bit 机器ID：0-1023，与标准 64 位雪花 ID 一致，优先参数 > 环境变量 > process.pid
+ * - 77 bit 序列号：同一毫秒内自增，2^77 ≈ 1.5×10²³，无需考虑耗尽
+ *
+ * 输出：Bitcoin 字母表 Base58（无 0/O/I/l），左填充 '1' 至恒定 22 字符，建议 VARCHAR(24)
+ * 时间戳在高位，ID 随时间单调递增，适合做数据库主键。
+ * 2^128-1 < 58^22，故 22 字符足以覆盖全部 128 位取值范围。
+ */
+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_BITS = BigInt(41);
+const MID_BITS = BigInt(10);
+const SEQ_BITS = BigInt(77);
+const TS_MASK = (BigInt(1) << TS_BITS) - BigInt(1); // 41 bit
+const MID_MASK = (BigInt(1) << MID_BITS) - BigInt(1); // 10 bit
+const SEQ_MASK = (BigInt(1) << SEQ_BITS) - BigInt(1); // 77 bit
+const PAD_LENGTH = 22;
+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（10 bit，0-1023） */
+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 字符串，恒定 22 字符）
+ *
+ * 位布局：41 bit 时间戳 | 10 bit 机器ID | 77 bit 序列号
+ * 时间戳采用 41 bit（与标准 64 位雪花 ID 一致），毫秒精度，可用约 69 年。
+ * 机器ID 采用 10 bit（0-1023），与标准 64 位雪花 ID 一致，防止多机 ID 冲突。
+ * 时间戳在高位，ID 随时间单调递增，适合做数据库主键。
+ * Base58 输出左填充 '1'（零字符）至 22 字符，保证长度恒定且不破坏字典序排序。
+ *
+ * @param machineId 机器ID（0-1023），不传则依次从环境变量 SNOWFLAKE_MACHINE_ID、process.pid 获取
+ * @returns Base58 编码的 128 位雪花 ID（恒定 22 字符）
+ */
+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;
+    }
+    else {
+        snowflakeExtSeq = SEQ_START;
+    }
+    snowflakeExtLastTs = ts;
+    const id = ((ts & TS_MASK) << (MID_BITS + SEQ_BITS)) | (mid << SEQ_BITS) | snowflakeExtSeq;
+    return encodeBase58(id).padStart(PAD_LENGTH, BASE58_ALPHABET[0]);
+}
+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-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/service/SysAppService.d.ts

@@ -6,7 +6,4 @@ export declare class SysAppService extends BaseService {
     }): Promise<Record<string, any>>;
     getSysAppOne(app_code: string): Promise<Record<string, any>>;
     deletePrivateField(parsedAppInfo: any): any;
-    removeSysAppOneCache(app_code: string): Promise<void>;
-    removeSysAppPageCache(): Promise<void>;
-    removeSysAppCacheByCondition({ condition }: any): Promise<void>;
 }

package/dist/service/SysAppService.js

@@ -46,21 +46,6 @@ let SysAppService = class SysAppService extends BaseService_1.BaseService {
         delete parsedAppInfo2.std_crud_tbl;
         return parsedAppInfo2;
     }
-    async removeSysAppOneCache(app_code) {
-        if (!app_code || typeof app_code !== 'string') {
-            throw new Error('[removeSysAppOneCache] app_code required');
-        }
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('sysAppCacheObj', this.redisService);
-    }
-    async removeSysAppPageCache() {
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('sysAppPageCacheObj', this.redisService);
-    }
-    async removeSysAppCacheByCondition({ condition }) {
-        if (!condition) {
-            throw new Error('[removeSysAppCacheByCondition] condition required');
-        }
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('sysAppCacheObj', this.redisService);
-    }
 };
 SysAppService = __decorate([
     (0, core_1.Provide)()

package/dist/service/SysConfigService.d.ts

@@ -1,5 +1,4 @@
 import { BaseService } from './base/BaseService';
 export declare class SysConfigService extends BaseService {
     getSysConfigOne(config_code: string): Promise<Record<string, any>>;
-    removeSysConfigOneCache(config_code: string): Promise<void>;
 }

package/dist/service/SysConfigService.js

@@ -19,12 +19,6 @@ let SysConfigService = class SysConfigService extends BaseService_1.BaseService
         const sysConfigCodeMap = ((_a = BizMemCacheStore_1.bizMemCacheStore.getSysConfig()) === null || _a === void 0 ? void 0 : _a.sysConfigCodeMap) || {};
         return sysConfigCodeMap[config_code];
     }
-    async removeSysConfigOneCache(config_code) {
-        if (!config_code || typeof config_code !== 'string') {
-            throw new Error('[removeSysConfigOneCache] config_code required');
-        }
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('sysConfgCacheObj', this.redisService);
-    }
 };
 SysConfigService = __decorate([
     (0, core_1.Provide)()

package/dist/service/SysDictDataService.d.ts

@@ -1,6 +1,4 @@
 import { BaseService } from './base/BaseService';
 export declare class SysDictDataService extends BaseService {
     getDataDictItemsByDictCode(dict_code: string): Promise<any[]>;
-    removeCacheByDictItemId(dict_item_id: string): Promise<void>;
-    removeCacheByDictCode(dict_code: string): Promise<void>;
 }

package/dist/service/SysDictDataService.js

@@ -19,18 +19,6 @@ let SysDictDataService = class SysDictDataService extends BaseService_1.BaseServ
         const dictCodeMap = ((_a = BizMemCacheStore_1.bizMemCacheStore.getDataDictItem()) === null || _a === void 0 ? void 0 : _a.dictCodeMap) || {};
         return dictCodeMap[dict_code] || [];
     }
-    async removeCacheByDictItemId(dict_item_id) {
-        if (!dict_item_id) {
-            throw new Error('[removeCacheByDictItemId] dict_item_id required');
-        }
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('dataDictItemCacheObj', this.redisService);
-    }
-    async removeCacheByDictCode(dict_code) {
-        if (!dict_code || typeof dict_code !== 'string') {
-            throw new Error('[removeCacheByDictCode] dict_code required');
-        }
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('dataDictItemCacheObj', this.redisService);
-    }
 };
 SysDictDataService = __decorate([
     (0, core_1.Provide)()

package/dist/service/SysMenuService.d.ts

@@ -43,6 +43,5 @@ export declare class SysMenuService extends BaseService {
      * @returns
      */
     getCachedMenusList(): Promise<SysMenus[]>;
-    removeSysMenuCache(): Promise<void>;
 }
 export {};

package/dist/service/SysMenuService.js

@@ -19,9 +19,6 @@ let SysMenuService = class SysMenuService extends BaseService_1.BaseService {
         var _a;
         return ((_a = BizMemCacheStore_1.bizMemCacheStore.getSysMenu()) === null || _a === void 0 ? void 0 : _a.sysMenuList) || [];
     }
-    async removeSysMenuCache() {
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('sysMenuCacheObj', this.redisService);
-    }
 };
 SysMenuService = __decorate([
     (0, core_1.Provide)()

package/dist/service/WorkbenchService.d.ts

@@ -4,7 +4,6 @@ import { IWorkbenchEntity } from '../models/SystemEntities';
 export declare class WorkbenchService extends BaseService {
     ctx: Context;
     private fatcmsTargetWorkbenchCode;
-    clearCache(): Promise<void>;
     private getWorkbenchCachedObj;
     /**
      * 获取所有站点列表

package/dist/service/WorkbenchService.js

@@ -19,9 +19,6 @@ const AsyncTaskModel_1 = require("../models/AsyncTaskModel");
 const format_url_1 = require("../libs/utils/format-url");
 const BizMemCacheStore_1 = require("../service/base/bizmemcache/BizMemCacheStore");
 let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService {
-    async clearCache() {
-        await BizMemCacheStore_1.bizMemCacheStore.markDirty('workbenchCachedObj', this.redisService);
-    }
     getWorkbenchCachedObj() {
         return BizMemCacheStore_1.bizMemCacheStore.getWorkbench();
     }

package/dist/service/base/bizmemcache/BizMemCacheService.js

@@ -35,8 +35,10 @@ let BizMemCacheService = class BizMemCacheService extends BaseService_1.BaseServ
         await this.reloadIfRedisChanged('crudMethodCacheObj', () => this.loadCrudMethodCacheObj());
     }
     async reloadIfRedisChanged(key, loader) {
-        const redisTime = Number(await this.redisService.get(BizMemCacheStore_1.bizMemCacheStore.getRedisKey(key))) || 0;
-        if (redisTime !== BizMemCacheStore_1.bizMemCacheStore.getLastTime(key)) {
+        const redisTimeStr = await this.redisService.get(BizMemCacheStore_1.bizMemCacheStore.getRedisKey(key));
+        const redisTime = Number(redisTimeStr) || 0;
+        const memTime = BizMemCacheStore_1.bizMemCacheStore.getLastTime(key);
+        if (redisTime !== memTime) {
             await loader();
             BizMemCacheStore_1.bizMemCacheStore.setLastTime(key, redisTime);
         }