befly 3.20.11 → 3.21.0

package/lib/sqlBuilder/util.js

@@ -1,273 +0,0 @@
-import { isNullable, isString } from "../../utils/is.js";
-import { SqlCheck } from "./check.js";
-
-function isQuotedIdentPaired(value) {
-    const trimmed = value.trim();
-    if (trimmed.length < 2) {
-        return false;
-    }
-
-    const first = trimmed[0];
-    const last = trimmed[trimmed.length - 1];
-    return (first === "`" && last === "`") || (first === '"' && last === '"');
-}
-
-function startsWithIdentifierQuote(value) {
-    const trimmed = value.trim();
-    return trimmed.startsWith("`") || trimmed.startsWith('"');
-}
-
-function assertPairedQuotedIdent(value, label) {
-    if (startsWithIdentifierQuote(value) && !isQuotedIdentPaired(value)) {
-        throw new Error(`${label} 引用不完整，请使用成对的 \`...\` 或 "..." (value: ${value})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-}
-
-function escapeIdentifierPart(part, kind, quoteIdent, unpairedErrorFactory) {
-    if (isQuotedIdent(part)) {
-        return part;
-    }
-
-    if (startsWithQuote(part)) {
-        throw new Error(unpairedErrorFactory(part), {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    SqlCheck.assertSafeIdentifierPart(part, kind);
-    return quoteIdent(part);
-}
-
-export function resolveQuoteIdent(options) {
-    if (options && options.quoteIdent) {
-        return options.quoteIdent;
-    }
-
-    return (identifier) => {
-        if (!isString(identifier)) {
-            throw new Error(`quoteIdent 需要字符串类型标识符 (identifier: ${String(identifier)})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const trimmed = identifier.trim();
-        if (!trimmed) {
-            throw new Error("SQL 标识符不能为空", {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const escaped = trimmed.replace(/`/g, "``");
-        return `\`${escaped}\``;
-    };
-}
-
-export function isQuotedIdent(value) {
-    return isQuotedIdentPaired(value);
-}
-
-export function startsWithQuote(value) {
-    return startsWithIdentifierQuote(value);
-}
-
-export function escapeField(field, quoteIdent) {
-    if (!isString(field)) {
-        return field;
-    }
-
-    const trimmed = field.trim();
-
-    assertPairedQuotedIdent(trimmed, "字段标识符");
-
-    if (trimmed === "*" || isQuotedIdent(trimmed)) {
-        return trimmed;
-    }
-
-    try {
-        SqlCheck.assertNoExprField(trimmed);
-    } catch {
-        throw new Error(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (trimmed.toUpperCase().includes(" AS ")) {
-        const parts = trimmed.split(/\s+AS\s+/i);
-        if (parts.length !== 2) {
-            throw new Error(`字段格式非法，请使用简单字段名或安全引用，复杂表达式请使用 selectRaw/whereRaw (field: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const fieldPart = parts[0];
-        const aliasPart = parts[1];
-        const cleanFieldPart = fieldPart.trim();
-        const cleanAliasPart = aliasPart.trim();
-        if (!isQuotedIdent(cleanAliasPart)) {
-            if (!SqlCheck.SAFE_IDENTIFIER_RE.test(cleanAliasPart)) {
-                throw new Error(`无效的字段别名: ${cleanAliasPart}`, {
-                    cause: null,
-                    code: "validation"
-                });
-            }
-        }
-        return `${escapeField(cleanFieldPart, quoteIdent)} AS ${cleanAliasPart}`;
-    }
-
-    if (trimmed.includes(".")) {
-        const parts = trimmed.split(".");
-        return parts
-            .map((part) => {
-                const cleanPart = part.trim();
-                if (cleanPart === "*" || isQuotedIdent(cleanPart)) {
-                    return cleanPart;
-                }
-                assertPairedQuotedIdent(cleanPart, "字段标识符");
-                return quoteIdent(cleanPart);
-            })
-            .join(".");
-    }
-
-    return quoteIdent(trimmed);
-}
-
-export function escapeTable(table, quoteIdent) {
-    if (!isString(table)) {
-        return table;
-    }
-
-    const trimmed = table.trim();
-
-    if (isQuotedIdent(trimmed)) {
-        return trimmed;
-    }
-
-    const parts = trimmed.split(/\s+/).filter((p) => p.length > 0);
-    if (parts.length === 0) {
-        throw new Error("FROM 表名不能为空", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (parts.length > 2) {
-        throw new Error(`不支持的表引用格式（包含过多片段）。请使用 fromRaw 显式传入复杂表达式 (table: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const namePart = parts[0].trim();
-
-    const aliasPart = parts.length === 2 ? parts[1].trim() : null;
-
-    const nameSegments = namePart.split(".");
-    if (nameSegments.length > 2) {
-        throw new Error(`不支持的表引用格式（schema 层级过深）。请使用 fromRaw (table: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    let escapedName = "";
-    if (nameSegments.length === 2) {
-        const schemaRaw = nameSegments[0];
-        const tableNameRaw = nameSegments[1];
-        const schema = schemaRaw.trim();
-        const tableName = tableNameRaw.trim();
-
-        const escapedSchema = escapeIdentifierPart(schema, "schema", quoteIdent, (part) => `schema 标识符引用不完整，请使用成对的 \`...\` 或 "..." (schema: ${part})`);
-        const escapedTableName = escapeIdentifierPart(tableName, "table", quoteIdent, (part) => `table 标识符引用不完整，请使用成对的 \`...\` 或 "..." (table: ${part})`);
-
-        escapedName = `${escapedSchema}.${escapedTableName}`;
-    } else {
-        const tableNameRaw = nameSegments[0];
-        const tableName = tableNameRaw.trim();
-
-        escapedName = escapeIdentifierPart(tableName, "table", quoteIdent, (part) => `table 标识符引用不完整，请使用成对的 \`...\` 或 "..." (table: ${part})`);
-    }
-
-    if (aliasPart) {
-        SqlCheck.assertSafeIdentifierPart(aliasPart, "alias");
-        return `${escapedName} ${aliasPart}`;
-    }
-
-    return escapedName;
-}
-
-export function validateParam(value) {
-    SqlCheck.assertNoUndefinedParam(value, "SQL 参数值");
-}
-
-export function normalizeLimitValue(count, offset) {
-    if (typeof count !== "number" || count < 0) {
-        throw new Error(`LIMIT 数量必须是非负数 (count: ${String(count)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    const limitValue = Math.floor(count);
-
-    let offsetValue = null;
-    if (!isNullable(offset)) {
-        if (typeof offset !== "number" || offset < 0) {
-            throw new Error(`OFFSET 必须是非负数 (offset: ${String(offset)})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        offsetValue = Math.floor(offset);
-    }
-
-    return { limitValue: limitValue, offsetValue: offsetValue };
-}
-
-export function normalizeOffsetValue(count) {
-    if (typeof count !== "number" || count < 0) {
-        throw new Error(`OFFSET 必须是非负数 (count: ${String(count)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    return Math.floor(count);
-}
-
-export function toSqlParams(params) {
-    if (isNullable(params)) {
-        return [];
-    }
-
-    if (!Array.isArray(params)) {
-        throw new Error(`SQL 参数必须是数组，当前类型: ${typeof params}`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const out = [];
-    for (const value of params) {
-        if (value === undefined) {
-            throw new Error("SQL 参数不能为 undefined", {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        if (typeof value === "bigint") {
-            out.push(value.toString());
-            continue;
-        }
-
-        out.push(value);
-    }
-
-    return out;
-}