oak-domain 5.1.31 → 5.1.33

package/lib/types/Trigger.js

@@ -1,16 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CHECKER_PRIORITY_MAP = exports.CHECKER_MAX_PRIORITY = exports.TRIGGER_MAX_PRIORITY = exports.TRIGGER_DEFAULT_PRIORITY = exports.TRIGGER_MIN_PRIORITY = void 0;
+/* ============================================================================
+ * 优先级常量定义
+ *
+ * 触发器按优先级从小到大依次执行，数值越小越先执行。
+ * 合理设置优先级可以控制触发器的执行顺序，确保数据处理的正确性。
+ * ============================================================================ */
 /**
- * 优先级越小，越早执行。定义在1～99之间
+ * 触发器最小优先级（最先执行）
+ * 用于需要最早执行的触发器，如数据预处理
  */
 exports.TRIGGER_MIN_PRIORITY = 1;
+/**
+ * 触发器默认优先级
+ * 未指定优先级时使用此值
+ */
 exports.TRIGGER_DEFAULT_PRIORITY = 25;
+/**
+ * 触发器最大优先级（在普通触发器中最后执行）
+ * 用于依赖其他触发器处理结果的场景
+ */
 exports.TRIGGER_MAX_PRIORITY = 50;
+/**
+ * Checker（检查器）的最大优先级
+ * Checker 优先级范围是 51-99，在所有普通触发器之后执行
+ * 这确保了数据校验在数据处理完成后进行
+ */
 exports.CHECKER_MAX_PRIORITY = 99;
 /**
- * logical可能会更改row和data的值，应当最先执行，data和row不能修改相关的值
- * 允许logicalData去改data中的值
+ * 不同类型 Checker 的默认优先级映射
+ *
+ * 执行顺序（从先到后）：
+ * 1. logicalData (31) - 逻辑数据检查，可修改 data 中的值
+ * 2. logical (33) - 纯逻辑检查
+ * 3. row (51) - 行级检查，检查数据库中已存在的行
+ * 4. relation (56) - 关系检查，检查关联数据
+ * 5. data (61) - 数据完整性检查
+ *
+ * @example
+ * // logicalData 类型可以自动填充默认值
+ * // logical 类型进行业务逻辑校验
+ * // row 类型检查当前行状态是否允许操作
  */
 exports.CHECKER_PRIORITY_MAP = {
     logicalData: 31,

package/lib/utils/SimpleConnector.d.ts

@@ -33,19 +33,19 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
     protected parseAspectResult(response: Response): Promise<{
         result: any;
         opRecords: any;
-        message: string | null;
+        message: string | undefined;
     } | {
         result: ReadableStream<Uint8Array<ArrayBuffer>> | null;
-        message: string | null;
+        message: string | undefined;
         opRecords?: undefined;
     }>;
     callAspect(name: string, params: any, context?: FrontCxt): Promise<{
         result: any;
         opRecords: any;
-        message: string | null;
+        message: string | undefined;
     } | {
         result: ReadableStream<Uint8Array<ArrayBuffer>> | null;
-        message: string | null;
+        message: string | undefined;
         opRecords?: undefined;
     }>;
     getRouter(): string;
@@ -62,7 +62,7 @@ export default class SimpleConnector<ED extends EntityDict & BaseEntityDict, Fro
         aspectName: string;
         data: any;
     };
-    serializeResult(result: any, opRecords: OpRecord<ED>[], headers: IncomingHttpHeaders, body: any, message?: string): Promise<{
+    serializeResult(result: any, opRecords: OpRecord<ED>[], headers: IncomingHttpHeaders, body: any, rawMessage?: string): Promise<{
         body: any;
         headers?: Record<string, any> | undefined;
     }>;

package/lib/utils/SimpleConnector.js

@@ -80,7 +80,8 @@ class SimpleConnector {
         if (response.status > 299) {
             throw new types_1.OakServerProxyException(`网络请求返回status是${response.status}`);
         }
-        const message = response.headers.get('oak-message');
+        const rawMessage = response.headers.get('oak-message');
+        const message = rawMessage ? decodeURIComponent(rawMessage) : undefined;
         const responseType = response.headers.get('Content-Type') || response.headers.get('content-type');
         if (responseType?.toLocaleLowerCase().match(/application\/json/i)) {
             const { exception, result, opRecords } = await response.json();
@@ -188,7 +189,8 @@ class SimpleConnector {
             data: files ? Object.assign({}, body, files) : body,
         };
     }
-    async serializeResult(result, opRecords, headers, body, message) {
+    async serializeResult(result, opRecords, headers, body, rawMessage) {
+        const message = rawMessage ? encodeURIComponent(rawMessage) : undefined;
         if (result instanceof stream_1.Stream || result instanceof Buffer) {
             return {
                 body: result,

package/lib/utils/glob.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 匹配 glob 模式
+ * @param filePath 文件路径（已标准化）
+ * @param pattern glob 模式
+ */
+export declare const matchGlobPattern: (filePath: string, pattern: string) => boolean;
+/**
+ * 展开花括号模式 {a,b,c}
+ */
+export declare const expandBraces: (pattern: string) => string[];
+/**
+ * 分割花括号选项（处理嵌套）
+ */
+export declare const splitBraceOptions: (content: string) => string[];
+/**
+ * 递归匹配路径段
+ */
+export declare const matchSegments: (fileSegs: string[], fileIdx: number, patternSegs: string[], patternIdx: number) => boolean;
+/**
+ * 匹配单个路径段（处理 *, ?, [] 通配符）
+ */
+export declare const matchSegment: (fileSeg: string, patternSeg: string) => boolean;
+/**
+ * 查找匹配的右括号
+ */
+export declare const findClosingBracket: (pattern: string, startIdx: number) => number;
+/**
+ * 匹配字符类 [abc] [a-z] [!abc]
+ */
+export declare const matchCharClass: (char: string, charClass: string) => boolean;

package/lib/utils/glob.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchCharClass = exports.findClosingBracket = exports.matchSegment = exports.matchSegments = exports.splitBraceOptions = exports.expandBraces = exports.matchGlobPattern = void 0;
+/**
+ * 匹配 glob 模式
+ * @param filePath 文件路径（已标准化）
+ * @param pattern glob 模式
+ */
+const matchGlobPattern = (filePath, pattern) => {
+    // 处理花括号展开 {a,b,c}
+    const expandedPatterns = (0, exports.expandBraces)(pattern);
+    // 只要有一个展开的模式匹配就返回 true
+    for (const expandedPattern of expandedPatterns) {
+        const fileSegments = filePath.split('/');
+        const patternSegments = expandedPattern.split('/');
+        if ((0, exports.matchSegments)(fileSegments, 0, patternSegments, 0)) {
+            return true;
+        }
+    }
+    return false;
+};
+exports.matchGlobPattern = matchGlobPattern;
+/**
+ * 展开花括号模式 {a,b,c}
+ */
+const expandBraces = (pattern) => {
+    const result = [];
+    let current = '';
+    let depth = 0;
+    let braceStart = -1;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        // 处理转义
+        if (prevChar === '\\') {
+            current += char;
+            continue;
+        }
+        if (char === '{') {
+            if (depth === 0) {
+                braceStart = current.length;
+            }
+            depth++;
+            current += char;
+        }
+        else if (char === '}' && depth > 0) {
+            depth--;
+            current += char;
+            if (depth === 0) {
+                // 提取花括号内容
+                const braceContent = current.substring(braceStart + 1, current.length - 1);
+                const options = (0, exports.splitBraceOptions)(braceContent);
+                const prefix = current.substring(0, braceStart);
+                const suffix = pattern.substring(i + 1);
+                // 递归展开每个选项
+                for (const option of options) {
+                    const expanded = (0, exports.expandBraces)(prefix + option + suffix);
+                    result.push(...expanded);
+                }
+                return result;
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    return [pattern];
+};
+exports.expandBraces = expandBraces;
+/**
+ * 分割花括号选项（处理嵌套）
+ */
+const splitBraceOptions = (content) => {
+    const options = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        const prevChar = i > 0 ? content[i - 1] : '';
+        if (prevChar === '\\') {
+            current += char;
+            continue;
+        }
+        if (char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            options.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current) {
+        options.push(current);
+    }
+    return options;
+};
+exports.splitBraceOptions = splitBraceOptions;
+/**
+ * 递归匹配路径段
+ */
+const matchSegments = (fileSegs, fileIdx, patternSegs, patternIdx) => {
+    // 都匹配完了，成功
+    if (fileIdx === fileSegs.length && patternIdx === patternSegs.length) {
+        return true;
+    }
+    // pattern 匹配完了但文件路径还有，失败
+    if (patternIdx === patternSegs.length) {
+        return false;
+    }
+    const patternSeg = patternSegs[patternIdx];
+    // 处理 **
+    if (patternSeg === '**') {
+        // ** 可以匹配 0 到多个目录段
+        // 尝试匹配 0 个（跳过 **）
+        if ((0, exports.matchSegments)(fileSegs, fileIdx, patternSegs, patternIdx + 1)) {
+            return true;
+        }
+        // 尝试匹配 1 个或多个（消耗一个文件段，** 保持）
+        if (fileIdx < fileSegs.length) {
+            return (0, exports.matchSegments)(fileSegs, fileIdx + 1, patternSegs, patternIdx);
+        }
+        return false;
+    }
+    // 文件路径匹配完了但 pattern 还有（且不是 **），失败
+    if (fileIdx === fileSegs.length) {
+        return false;
+    }
+    const fileSeg = fileSegs[fileIdx];
+    // 处理普通段（可能包含 *, ?, []）
+    if ((0, exports.matchSegment)(fileSeg, patternSeg)) {
+        return (0, exports.matchSegments)(fileSegs, fileIdx + 1, patternSegs, patternIdx + 1);
+    }
+    return false;
+};
+exports.matchSegments = matchSegments;
+/**
+ * 匹配单个路径段（处理 *, ?, [] 通配符）
+ */
+const matchSegment = (fileSeg, patternSeg) => {
+    let fileIdx = 0;
+    let patternIdx = 0;
+    let starIdx = -1;
+    let matchIdx = 0;
+    while (fileIdx < fileSeg.length) {
+        if (patternIdx < patternSeg.length) {
+            const patternChar = patternSeg[patternIdx];
+            const prevChar = patternIdx > 0 ? patternSeg[patternIdx - 1] : '';
+            // 处理转义字符
+            if (prevChar === '\\') {
+                if (fileSeg[fileIdx] === patternChar) {
+                    fileIdx++;
+                    patternIdx++;
+                    continue;
+                }
+                else {
+                    if (starIdx !== -1) {
+                        patternIdx = starIdx + 1;
+                        matchIdx++;
+                        fileIdx = matchIdx;
+                        continue;
+                    }
+                    return false;
+                }
+            }
+            // 跳过转义符本身
+            if (patternChar === '\\') {
+                patternIdx++;
+                continue;
+            }
+            // 处理 ?
+            if (patternChar === '?') {
+                fileIdx++;
+                patternIdx++;
+                continue;
+            }
+            // 处理 []
+            if (patternChar === '[') {
+                const closeIdx = (0, exports.findClosingBracket)(patternSeg, patternIdx);
+                if (closeIdx !== -1) {
+                    const charClass = patternSeg.substring(patternIdx + 1, closeIdx);
+                    if ((0, exports.matchCharClass)(fileSeg[fileIdx], charClass)) {
+                        fileIdx++;
+                        patternIdx = closeIdx + 1;
+                        continue;
+                    }
+                    else {
+                        if (starIdx !== -1) {
+                            patternIdx = starIdx + 1;
+                            matchIdx++;
+                            fileIdx = matchIdx;
+                            continue;
+                        }
+                        return false;
+                    }
+                }
+            }
+            // 处理 *
+            if (patternChar === '*') {
+                starIdx = patternIdx;
+                matchIdx = fileIdx;
+                patternIdx++;
+                continue;
+            }
+            // 普通字符匹配
+            if (fileSeg[fileIdx] === patternChar) {
+                fileIdx++;
+                patternIdx++;
+                continue;
+            }
+        }
+        // 不匹配，回溯到上一个 *
+        if (starIdx !== -1) {
+            patternIdx = starIdx + 1;
+            matchIdx++;
+            fileIdx = matchIdx;
+            continue;
+        }
+        return false;
+    }
+    // 处理 pattern 末尾的 * 和转义符
+    while (patternIdx < patternSeg.length) {
+        const char = patternSeg[patternIdx];
+        if (char === '*' || char === '\\') {
+            patternIdx++;
+        }
+        else {
+            break;
+        }
+    }
+    return patternIdx === patternSeg.length;
+};
+exports.matchSegment = matchSegment;
+/**
+ * 查找匹配的右括号
+ */
+const findClosingBracket = (pattern, startIdx) => {
+    for (let i = startIdx + 1; i < pattern.length; i++) {
+        if (pattern[i] === ']' && pattern[i - 1] !== '\\') {
+            return i;
+        }
+    }
+    return -1;
+};
+exports.findClosingBracket = findClosingBracket;
+/**
+ * 匹配字符类 [abc] [a-z] [!abc]
+ */
+const matchCharClass = (char, charClass) => {
+    // 处理否定 [!...] 或 [^...]
+    const isNegated = charClass[0] === '!' || charClass[0] === '^';
+    const classContent = isNegated ? charClass.substring(1) : charClass;
+    let matched = false;
+    let i = 0;
+    while (i < classContent.length) {
+        const currentChar = classContent[i];
+        // 处理范围 a-z
+        if (i + 2 < classContent.length && classContent[i + 1] === '-') {
+            const start = currentChar.charCodeAt(0);
+            const end = classContent[i + 2].charCodeAt(0);
+            const charCode = char.charCodeAt(0);
+            if (charCode >= start && charCode <= end) {
+                matched = true;
+                break;
+            }
+            i += 3;
+        }
+        else {
+            // 单个字符
+            if (char === currentChar) {
+                matched = true;
+                break;
+            }
+            i++;
+        }
+    }
+    return isNegated ? !matched : matched;
+};
+exports.matchCharClass = matchCharClass;

package/lib/utils/money.d.ts

@@ -2,5 +2,5 @@ declare const ToCent: (float: number) => number;
 declare const ToYuan: (int: number) => number;
 declare const StringToCent: (value: string, allowNegative?: true) => number | undefined;
 declare const CentToString: (value: number, fixed?: number) => string | undefined;
-declare const ThousandCont: (value: number | string, decimalPlaces?: number) => string | undefined;
+declare const ThousandCont: (value: number | string, decimalPlaces?: number) => string;
 export { ToCent, ToYuan, StringToCent, CentToString, ThousandCont };

package/lib/utils/money.js

@@ -23,29 +23,40 @@ const CentToString = (value, fixed) => {
 };
 exports.CentToString = CentToString;
 const ThousandCont = (value, decimalPlaces) => {
-    let value1 = typeof value === 'number' ? `${value}` : value;
-    const numArr = value1.split('.');
-    value1 = numArr[0];
-    let result = '';
-    while (value1.length > 3) {
-        result = ',' + value1.slice(-3) + result;
-        value1 = value1.slice(0, value1.length - 3);
-    }
-    if (value1) {
-        result = value1 + result;
-    }
-    if (decimalPlaces && decimalPlaces > 0) {
-        if (numArr[1]) {
-            const decimalPart = numArr[1].padEnd(decimalPlaces, '0').slice(0, decimalPlaces);
-            result = result + '.' + decimalPart;
-        }
-        else {
-            result = result + '.' + '0'.repeat(decimalPlaces);
-        }
+    let valueStr = typeof value === 'number' ? value.toString() : value;
+    // 处理负号
+    let isNegative = false;
+    if (valueStr.startsWith('-')) {
+        isNegative = true;
+        valueStr = valueStr.slice(1); // 移除负号
+    }
+    // 分离整数部分和小数部分
+    const [integerPart, decimalPart = ''] = valueStr.split('.');
+    // 千分位格式化整数部分
+    let formattedInteger = '';
+    let remainingInteger = integerPart;
+    while (remainingInteger.length > 3) {
+        formattedInteger = ',' + remainingInteger.slice(-3) + formattedInteger;
+        remainingInteger = remainingInteger.slice(0, remainingInteger.length - 3);
+    }
+    if (remainingInteger) {
+        formattedInteger = remainingInteger + formattedInteger;
+    }
+    // 恢复负号
+    if (isNegative) {
+        formattedInteger = '-' + formattedInteger;
+    }
+    // 处理小数部分
+    let formattedDecimal = '';
+    if (decimalPlaces !== undefined && decimalPlaces > 0) {
+        formattedDecimal = decimalPart.padEnd(decimalPlaces, '0').slice(0, decimalPlaces);
+        return formattedInteger + '.' + formattedDecimal;
+    }
+    else if (decimalPart) {
+        return formattedInteger + '.' + decimalPart;
     }
     else {
-        result = numArr[1] ? result + '.' + numArr[1] : result;
+        return formattedInteger;
     }
-    return result;
 };
 exports.ThousandCont = ThousandCont;

package/lib/utils/url/whatwg-url/lib/urlencoded.d.ts

@@ -1,4 +1,4 @@
-import { Buffer } from 'buffer';
+import { Buffer, WithImplicitCoercion } from 'buffer';
 declare function percentEncode(c: number): string;
 declare function percentDecode(input: Buffer): Buffer<ArrayBuffer>;
 declare function serializeUrlencoded(tuples: any[], encodingOverride?: undefined): string;

package/package.json

@@ -1,14 +1,15 @@
 {
     "name": "oak-domain",
-    "version": "5.1.31",
+    "version": "5.1.33",
     "author": {
         "name": "XuChang"
     },
     "scripts": {
         "make:domain": "ts-node scripts/make.ts",
-        "build": "tsc",
+        "build": "node --stack-size=65500 ./scripts/build.js -p ./tsconfig.json",
+        "test:build": "node --stack-size=65500 ./scripts/build.js -p ./tsconfig.test.json --noEmit",
         "prebuild": "npm run make:domain",
-        "test": "ts-node test/test.ts"
+        "test": "mocha --require ts-node/register test/**.ts"
     },
     "files": [
         "lib/**/*",