befly 3.20.10 → 3.21.0

package/lib/dbHelper/validate.js

@@ -1,695 +0,0 @@
-import { isFiniteNumber, isNonEmptyString, isNullable, isPlainObject, isString } from "../../utils/is.js";
-import { snakeCase } from "../../utils/util.js";
-
-function validateJoinFieldRef(value, label) {
-    if (!isNonEmptyString(value)) {
-        throw new Error(`${label} 不能为空`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const parts = value.split(".").map((item) => item.trim());
-    if (parts.length !== 2 || !isNonEmptyString(parts[0]) || !isNonEmptyString(parts[1])) {
-        throw new Error(`${label} 必须是 alias.field 格式`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-function parseLeftJoinEquality(joinItem) {
-    if (!isNonEmptyString(joinItem)) {
-        return null;
-    }
-
-    const match = joinItem.match(/^([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*) ([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)$/);
-    if (!match) {
-        return null;
-    }
-
-    return {
-        left: match[1],
-        right: match[2]
-    };
-}
-
-function assertNonEmptyString(value, label) {
-    if (!isNonEmptyString(value)) {
-        throw new Error(`${label} 必须是非空字符串`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-function assertPlainObjectValue(value, label) {
-    if (!isPlainObject(value)) {
-        throw new Error(`${label} 必须是对象`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateWhereObject(where, label, required = false) {
-    if (isNullable(where)) {
-        if (required) {
-            throw new Error(`${label} 必须是对象`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        return;
-    }
-
-    if (!isPlainObject(where)) {
-        throw new Error(`${label} 必须是对象`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    validateWhereMeta(where, label);
-}
-
-function validateExcludeRules(excludeRules, label) {
-    if (isNullable(excludeRules)) {
-        return;
-    }
-
-    if (!isPlainObject(excludeRules)) {
-        throw new Error(`${label} 必须是对象`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (const [key, value] of Object.entries(excludeRules)) {
-        assertNonEmptyString(key, `${label} 的字段名`);
-        if (!Array.isArray(value)) {
-            throw new Error(`${label}.${key} 必须是数组`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-}
-
-function validateWhereMeta(where, label) {
-    if (!isPlainObject(where)) {
-        return;
-    }
-
-    for (const [key, value] of Object.entries(where)) {
-        if (key === "$exclude") {
-            validateExcludeRules(value, `${label}.$exclude`);
-            continue;
-        }
-
-        if ((key === "$or" || key === "$and") && Array.isArray(value)) {
-            for (let i = 0; i < value.length; i++) {
-                if (isPlainObject(value[i])) {
-                    validateWhereMeta(value[i], `${label}.${key}[${i}]`);
-                }
-            }
-            continue;
-        }
-
-        if (isPlainObject(value)) {
-            validateWhereMeta(value, `${label}.${key}`);
-        }
-    }
-}
-
-function validateOrderByItems(orderBy, label) {
-    if (!Array.isArray(orderBy)) {
-        throw new Error(`${label} 必须是数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (const item of orderBy) {
-        if (!isString(item) || !item.includes("#")) {
-            throw new Error(`${label} 字段必须是 "字段#方向" 格式的字符串`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const parts = item.split("#");
-        if (parts.length !== 2) {
-            throw new Error(`${label} 字段必须是 "字段#方向" 格式的字符串`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const field = isString(parts[0]) ? parts[0].trim() : "";
-        const direction = isString(parts[1]) ? parts[1].trim().toUpperCase() : "";
-        if (!field) {
-            throw new Error(`${label} 中字段名不能为空`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        if (direction !== "ASC" && direction !== "DESC") {
-            throw new Error(`${label} 方向必须是 ASC 或 DESC`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-}
-
-function validateLeftJoinItems(leftJoin, label) {
-    if (!Array.isArray(leftJoin)) {
-        throw new Error(`${label} 必须是数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (let i = 0; i < leftJoin.length; i++) {
-        const joinItem = leftJoin[i];
-        if (!isNonEmptyString(joinItem)) {
-            throw new Error(`${label}[${i}] 必须是非空字符串`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const parsed = parseLeftJoinEquality(joinItem);
-        if (!parsed) {
-            throw new Error(`${label}[${i}] 必须是 "left.field right.field" 格式（空格表示等于）`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        validateJoinFieldRef(parsed.left, `${label}[${i}] 左侧字段`);
-        validateJoinFieldRef(parsed.right, `${label}[${i}] 右侧字段`);
-    }
-}
-
-function validateQueryTableOption(table, leftJoin, label) {
-    if (Array.isArray(table)) {
-        if (table.length === 0) {
-            throw new Error(`${label}.table 不能为空数组`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        for (let i = 0; i < table.length; i++) {
-            assertNonEmptyString(table[i], `${label}.table[${i}]`);
-            parseTableRef(table[i]);
-        }
-
-        if (Array.isArray(leftJoin) && leftJoin.length > 0) {
-            if (table.length !== leftJoin.length + 1) {
-                throw new Error(`${label}.table 与 ${label}.leftJoin 数量不匹配，要求 table.length = leftJoin.length + 1`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-            return;
-        }
-
-        if (table.length > 1) {
-            throw new Error(`${label}.table 为数组时必须配合 leftJoin 使用`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        return;
-    }
-
-    assertNonEmptyString(table, `${label}.table`);
-    parseTableRef(table);
-
-    if (Array.isArray(leftJoin) && leftJoin.length > 0) {
-        throw new Error(`${label}.leftJoin 启用时，${label}.table 必须是数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-function validateLegacyJoinOptions(options, label) {
-    const legacyJoinKeys = ["joins", "innerJoin", "rightJoin"];
-    for (const key of legacyJoinKeys) {
-        if (!isNullable(options[key])) {
-            throw new Error(`${label} 仅支持 leftJoin，${label}.${key} 已废弃`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-}
-
-export function validateQueryOptions(options, label) {
-    if (!isPlainObject(options)) {
-        throw new Error(`${label} 必须是对象`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    validateQueryTableOption(options.table, options.leftJoin, label);
-
-    if (!isNullable(options.where)) {
-        validateWhereObject(options.where, `${label}.where`);
-    }
-
-    if (!isNullable(options.fields) && !Array.isArray(options.fields)) {
-        throw new Error(`${label}.fields 必须是数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (!isNullable(options.orderBy)) {
-        validateOrderByItems(options.orderBy, `${label}.orderBy`);
-    }
-
-    validateLegacyJoinOptions(options, label);
-
-    if (!isNullable(options.leftJoin)) {
-        validateLeftJoinItems(options.leftJoin, `${label}.leftJoin`);
-    }
-
-    if (!isNullable(options.page) && (!isFiniteNumber(options.page) || Math.floor(options.page) !== options.page)) {
-        throw new Error(`${label}.page 必须是整数`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (!isNullable(options.limit) && (!isFiniteNumber(options.limit) || Math.floor(options.limit) !== options.limit)) {
-        throw new Error(`${label}.limit 必须是整数`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-function validateBatchDataList(dataList, label) {
-    if (!Array.isArray(dataList)) {
-        throw new Error(`${label} 必须是数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (let i = 0; i < dataList.length; i++) {
-        if (!isPlainObject(dataList[i])) {
-            throw new Error(`${label}[${i}] 必须是对象`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-}
-
-export function validateTableName(table, label) {
-    assertNonEmptyString(table, label);
-}
-
-export function validateTableWhereOptions(options, label, required = false) {
-    validateTableName(options.table, `${label}.table`);
-    validateWhereObject(options.where, `${label}.where`, required);
-}
-
-export function validateTableDataOptions(options, label) {
-    validateTableName(options.table, `${label}.table`);
-    assertPlainObjectValue(options.data, `${label}.data`);
-}
-
-export function validateTableBatchDataOptions(table, dataList, label) {
-    validateTableName(table, `${label}.table`);
-    validateBatchDataList(dataList, `${label}.dataList`);
-}
-
-export function validateNoLeftJoinReadOptions(options, label, joinErrorMessage) {
-    validateTableName(options.table, `${label}.table`);
-    validateWhereObject(options.where, `${label}.where`, false);
-    validateNoLeftJoin(options.leftJoin, joinErrorMessage);
-    validateLegacyJoinOptions(options, label);
-    validateSimpleTableName(options.table, label);
-}
-
-export function validateIncrementOptions(table, field, where, value, label) {
-    validateTableName(table, `${label}.table`);
-    validateWhereObject(where, `${label}.where`, true);
-    validateSafeFieldName(snakeCase(table));
-    validateSafeFieldName(snakeCase(field));
-    validateIncrementValue(table, field, value);
-}
-
-export function validateSimpleTableName(rawTable, label) {
-    if (Array.isArray(rawTable)) {
-        throw new Error(`${label}.table 不支持数组`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const table = isString(rawTable) ? rawTable.trim() : "";
-    if (!table) {
-        throw new Error(`${label}.table 不能为空`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (table.includes(" ")) {
-        throw new Error(`${label} 不支持别名表写法（table: ${table}）`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (table.includes(".")) {
-        throw new Error(`${label} 不支持 schema.table 写法（table: ${table}）`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateSafeFieldName(field) {
-    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field)) {
-        throw new Error(`无效的字段名: ${field}，只允许字母、数字和下划线`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validatePageLimitRange(prepared, rawTable) {
-    if (prepared.page < 1 || prepared.page > 10000) {
-        throw new Error(`页码必须在 1 到 10000 之间 (table: ${rawTable}, page: ${prepared.page}, limit: ${prepared.limit})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (prepared.limit < 1 || prepared.limit > 100000) {
-        throw new Error(`每页数量必须在 1 到 100000 之间 (table: ${rawTable}, page: ${prepared.page}, limit: ${prepared.limit})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateNoLeftJoin(leftJoin, message) {
-    if (Array.isArray(leftJoin) && leftJoin.length > 0) {
-        throw new Error(message, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateIncrementValue(table, field, value) {
-    if (typeof value !== "number" || isNaN(value)) {
-        throw new Error(`自增值必须是有效的数字 (table: ${table}, field: ${field}, value: ${value})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateExecuteSql(sql) {
-    if (!isString(sql)) {
-        throw new Error(`execute 只接受字符串类型的 SQL，收到类型: ${typeof sql}，值: ${JSON.stringify(sql)}`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateExcludeFieldsResult(resultFields, table, excludeSnakeFields) {
-    if (resultFields.length === 0) {
-        throw new Error(`排除字段后没有剩余字段可查询。表: ${table}, 排除: ${excludeSnakeFields.join(", ")}`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateTimeIdValue(id) {
-    if (!Number.isFinite(id) || id <= 0) {
-        throw new Error(`buildInsertRow(timeId) 失败：id 必须为 > 0 的有限 number (id: ${String(id)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function validateInsertBatchSize(count, maxBatchSize) {
-    if (count > maxBatchSize) {
-        throw new Error(`批量插入数量 ${count} 超过最大限制 ${maxBatchSize}`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function assertNoExprField(field) {
-    if (!isString(field)) {
-        return;
-    }
-    if (!isNonEmptyString(field)) {
-        return;
-    }
-    const trimmed = field.trim();
-    if (trimmed.includes("(") || trimmed.includes(")")) {
-        throw new Error(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-export function assertNoUndefinedInRecord(row, label) {
-    for (const [key, value] of Object.entries(row)) {
-        if (value === undefined) {
-            throw new Error(`${label} 存在 undefined 字段值 (field: ${key})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-}
-
-export function assertBatchInsertRowsConsistent(rows, options) {
-    if (!Array.isArray(rows)) {
-        throw new Error("批量插入 rows 必须是数组", {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (rows.length === 0) {
-        throw new Error(`插入数据不能为空 (table: ${options.table})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const first = rows[0];
-    if (!first || typeof first !== "object" || Array.isArray(first)) {
-        throw new Error(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: 0)`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const fields = Object.keys(first);
-    if (fields.length === 0) {
-        throw new Error(`插入数据必须至少有一个字段 (table: ${options.table})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const fieldSet = new Set(fields);
-    for (let i = 0; i < rows.length; i++) {
-        const row = rows[i];
-        if (!row || typeof row !== "object" || Array.isArray(row)) {
-            throw new Error(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: ${i})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const rowKeys = Object.keys(row);
-        if (rowKeys.length !== fields.length) {
-            throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        for (const key of rowKeys) {
-            if (!fieldSet.has(key)) {
-                throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i}, extraField: ${key})`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-        }
-
-        for (const field of fields) {
-            if (!(field in row)) {
-                throw new Error(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-            if (row[field] === undefined) {
-                throw new Error(`批量插入字段值不能为 undefined (table: ${options.table}, rowIndex: ${i}, field: ${field})`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-        }
-    }
-
-    return fields;
-}
-
-export function parseTableRef(tableRef) {
-    if (!isString(tableRef)) {
-        throw new Error(`tableRef 必须是字符串 (tableRef: ${String(tableRef)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const trimmed = tableRef.trim();
-    if (!isNonEmptyString(tableRef)) {
-        throw new Error("tableRef 不能为空", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const parts = trimmed.split(/\s+/).filter((p) => p.length > 0);
-    if (parts.length === 0) {
-        throw new Error("tableRef 不能为空", {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (parts.length > 2) {
-        throw new Error(`不支持的表引用格式（包含过多片段）。请使用最简形式：table 或 table alias 或 schema.table 或 schema.table alias (tableRef: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const namePart = parts[0];
-    if (!isNonEmptyString(namePart)) {
-        throw new Error(`tableRef 解析失败：缺少表名 (tableRef: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    let aliasPart = null;
-    if (parts.length === 2) {
-        const alias = parts[1];
-        if (!isNonEmptyString(alias)) {
-            throw new Error(`tableRef 解析失败：缺少 alias (tableRef: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        aliasPart = alias;
-    }
-
-    const nameSegments = namePart.split(".");
-    if (nameSegments.length > 2) {
-        throw new Error(`不支持的表引用格式（schema 层级过深） (tableRef: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (nameSegments.length === 2) {
-        const schema = nameSegments[0];
-        const table = nameSegments[1];
-        if (!isNonEmptyString(schema)) {
-            throw new Error(`tableRef 解析失败：schema 为空 (tableRef: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        if (!isNonEmptyString(table)) {
-            throw new Error(`tableRef 解析失败：table 为空 (tableRef: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        return { schema: schema, table: table, alias: aliasPart };
-    }
-
-    const table = nameSegments[0];
-    if (!isNonEmptyString(table)) {
-        throw new Error(`tableRef 解析失败：table 为空 (tableRef: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    return { schema: null, table: table, alias: aliasPart };
-}
-
-export function validateGeneratedBatchId(id, table, index) {
-    if (typeof id !== "number") {
-        throw new Error(`批量插入生成 ID 失败：ids[${index}] 不是 number (table: ${table})`, {
-            cause: null,
-            code: "runtime"
-        });
-    }
-}
-
-export function validateAndClassifyFields(fields) {
-    if (!fields || fields.length === 0) {
-        return { type: "all", fields: [] };
-    }
-
-    if (fields.some((f) => f === "*")) {
-        throw new Error("fields 不支持 * 星号，请使用空数组 [] 或不传参数表示查询所有字段", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (fields.some((f) => !isNonEmptyString(f))) {
-        throw new Error("fields 不能包含空字符串或无效值", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (const rawField of fields) {
-        const checkField = rawField.startsWith("!") ? rawField.substring(1) : rawField;
-        assertNoExprField(checkField);
-    }
-
-    const includeFields = fields.filter((f) => !f.startsWith("!"));
-    const excludeFields = fields.filter((f) => f.startsWith("!"));
-
-    if (includeFields.length > 0 && excludeFields.length === 0) {
-        return { type: "include", fields: includeFields };
-    }
-    if (excludeFields.length > 0 && includeFields.length === 0) {
-        return { type: "exclude", fields: excludeFields.map((f) => f.substring(1)) };
-    }
-
-    throw new Error('fields 不能同时包含普通字段和排除字段（! 开头）。只能使用以下3种方式之一：\n1. 空数组 [] 或不传（查询所有）\n2. 全部指定字段 ["id", "name"]\n3. 全部排除字段 ["!password", "!token"]', {
-        cause: null,
-        code: "validation"
-    });
-}