befly 3.20.10 → 3.21.0

package/lib/sqlBuilder/index.js

@@ -1,200 +0,0 @@
-/**
- * SQL 构造器 - JavaScript 版本
- * 提供链式 API 构建 SQL 查询
- */
-
-import { resolveQuoteIdent, normalizeLimitValue, normalizeOffsetValue } from "./util.js";
-import { appendJoinItem, appendOrderByItems, appendSelectItems, appendSelectRaw, appendWhereInput, appendWhereRaw, createWhereRoot, setFromValue } from "./parser.js";
-import { compileCount, compileDelete, compileInsert, compileSelect, compileUpdate, compileWhere } from "./compiler.js";
-import { toDeleteInSql, toUpdateCaseByIdSql } from "./batch.js";
-
-function createModel() {
-    return {
-        select: [],
-        from: null,
-        where: createWhereRoot(),
-        joins: [],
-        orderBy: [],
-        limit: null,
-        offset: null
-    };
-}
-
-/**
- * SQL 构建器类
- */
-export class SqlBuilder {
-    _model;
-    _quoteIdent;
-
-    constructor(options) {
-        this._quoteIdent = resolveQuoteIdent(options);
-        this._model = createModel();
-    }
-
-    /**
-     * 重置构建器状态
-     */
-    reset() {
-        this._model = createModel();
-        return this;
-    }
-
-    /**
-     * 获取 WHERE 条件（供 DbHelper 使用）
-     */
-    getWhereConditions() {
-        const result = compileWhere(this._model.where, this._quoteIdent);
-        return { sql: result.sql, params: result.params };
-    }
-
-    /**
-     * SELECT 字段
-     */
-    select(fields = "*") {
-        appendSelectItems(this._model.select, fields);
-        return this;
-    }
-
-    /**
-     * SELECT 原始表达式（不做转义）
-     */
-    selectRaw(expr) {
-        appendSelectRaw(this._model.select, expr);
-        return this;
-    }
-
-    /**
-     * FROM 表名
-     */
-    from(table) {
-        setFromValue(this._model, table, false);
-        return this;
-    }
-
-    /**
-     * FROM 原始表达式（不做转义）
-     */
-    fromRaw(tableExpr) {
-        setFromValue(this._model, tableExpr, true);
-        return this;
-    }
-
-    /**
-     * WHERE 条件
-     */
-    where(conditionOrField, value) {
-        appendWhereInput(this._model.where, conditionOrField, value);
-        return this;
-    }
-
-    /**
-     * WHERE 原始片段（不做转义），可附带参数。
-     */
-    whereRaw(sql, params) {
-        appendWhereRaw(this._model.where, sql, params);
-        return this;
-    }
-
-    /**
-     * LEFT JOIN
-     */
-    leftJoin(table, on) {
-        appendJoinItem(this._model.joins, "left", table, on);
-        return this;
-    }
-
-    /**
-     * RIGHT JOIN
-     */
-    rightJoin(table, on) {
-        appendJoinItem(this._model.joins, "right", table, on);
-        return this;
-    }
-
-    /**
-     * INNER JOIN
-     */
-    innerJoin(table, on) {
-        appendJoinItem(this._model.joins, "inner", table, on);
-        return this;
-    }
-
-    /**
-     * ORDER BY
-     * @param fields - 格式为 ["field#ASC", "field2#DESC"]
-     */
-    orderBy(fields) {
-        appendOrderByItems(this._model.orderBy, fields);
-        return this;
-    }
-
-    /**
-     * LIMIT
-     */
-    limit(count, offset) {
-        const result = normalizeLimitValue(count, offset);
-        this._model.limit = result.limitValue;
-        this._model.offset = result.offsetValue;
-        return this;
-    }
-
-    /**
-     * OFFSET
-     */
-    offset(count) {
-        const offsetValue = normalizeOffsetValue(count);
-        this._model.offset = offsetValue;
-        return this;
-    }
-
-    /**
-     * 构建 SELECT 查询
-     */
-    toSelectSql() {
-        return compileSelect(this._model, this._quoteIdent);
-    }
-
-    /**
-     * 构建 INSERT 查询
-     */
-    toInsertSql(table, data) {
-        return compileInsert(table, data, this._quoteIdent);
-    }
-
-    /**
-     * 构建 UPDATE 查询
-     */
-    toUpdateSql(table, data) {
-        return compileUpdate(this._model, table, data, this._quoteIdent);
-    }
-
-    /**
-     * 构建 DELETE 查询
-     */
-    toDeleteSql(table) {
-        return compileDelete(this._model, table, this._quoteIdent);
-    }
-
-    /**
-     * 构建 COUNT 查询
-     */
-    toCountSql() {
-        return compileCount(this._model, this._quoteIdent);
-    }
-
-    static toDeleteInSql(options) {
-        return toDeleteInSql(options);
-    }
-
-    static toUpdateCaseByIdSql(options) {
-        return toUpdateCaseByIdSql(options);
-    }
-}
-
-/**
- * 创建新的 SQL 构建器实例
- */
-export function createQueryBuilder() {
-    return new SqlBuilder();
-}

package/lib/sqlBuilder/parser.js

@@ -1,305 +0,0 @@
-import { validateParam } from "./util.js";
-import { isNonEmptyString, isString } from "../../utils/is.js";
-
-export function createWhereRoot() {
-    return { type: "group", join: "AND", items: [] };
-}
-
-export function appendSelectItems(list, fields) {
-    if (Array.isArray(fields)) {
-        for (const field of fields) {
-            list.push({ type: "field", value: field });
-        }
-        return;
-    }
-
-    if (isString(fields)) {
-        list.push({ type: "field", value: fields });
-        return;
-    }
-
-    throw new Error("SELECT 字段必须是字符串或数组", {
-        cause: null,
-        code: "validation"
-    });
-}
-
-export function appendSelectRaw(list, expr) {
-    if (!isNonEmptyString(expr)) {
-        throw new Error(`selectRaw 需要非空字符串 (expr: ${String(expr)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    list.push({ type: "raw", value: expr });
-}
-
-export function setFromValue(state, table, isRaw) {
-    if (!isNonEmptyString(table)) {
-        const err = isRaw ? `fromRaw 需要非空字符串 (tableExpr: ${String(table)})` : `FROM 表名必须是非空字符串 (table: ${String(table)})`;
-        throw new Error(err, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    state.from = { type: isRaw ? "raw" : "table", value: table.trim() };
-}
-
-export function appendJoinItem(list, joinType, table, on) {
-    if (!isString(table) || !isString(on)) {
-        throw new Error(`JOIN 表名和条件必须是字符串 (table: ${String(table)}, on: ${String(on)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    list.push({ type: joinType, table: table, on: on });
-}
-
-export function appendOrderByItems(list, fields) {
-    if (!Array.isArray(fields)) {
-        throw new Error('orderBy 必须是字符串数组，格式为 "字段#方向"', {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (const item of fields) {
-        if (!isString(item) || !item.includes("#")) {
-            throw new Error(`orderBy 字段必须是 "字段#方向" 格式的字符串（例如："name#ASC", "id#DESC"） (item: ${String(item)})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const parts = item.split("#");
-        if (parts.length !== 2) {
-            throw new Error(`orderBy 字段必须是 "字段#方向" 格式的字符串（例如："name#ASC", "id#DESC"） (item: ${String(item)})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        const fieldName = parts[0];
-        const direction = parts[1];
-        const cleanField = fieldName.trim();
-        const cleanDir = direction.trim().toUpperCase();
-
-        if (!cleanField) {
-            throw new Error(`orderBy 中字段名不能为空 (item: ${item})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        if (!["ASC", "DESC"].includes(cleanDir)) {
-            throw new Error(`ORDER BY 方向必须是 ASC 或 DESC (direction: ${cleanDir})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-
-        list.push({ field: cleanField, dir: cleanDir });
-    }
-}
-
-export function appendWhereInput(root, conditionOrField, value) {
-    if (conditionOrField && typeof conditionOrField === "object" && !Array.isArray(conditionOrField)) {
-        appendWhereObject(root, conditionOrField);
-        return;
-    }
-
-    if (isString(conditionOrField)) {
-        if (value === undefined) {
-            throw new Error("where(field, value) 不允许省略 value。若需传入原始 WHERE，请使用 whereRaw", {
-                cause: null,
-                code: "validation"
-            });
-        }
-        appendWhereNode(root, buildOperatorNode(conditionOrField, "=", value));
-    }
-}
-
-export function appendWhereRaw(root, sql, params) {
-    if (!isNonEmptyString(sql)) {
-        throw new Error(`whereRaw 需要非空字符串 (sql: ${String(sql)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const paramList = Array.isArray(params) ? params : [];
-    for (const param of paramList) {
-        validateParam(param);
-    }
-
-    root.items.push({ type: "raw", sql: sql, params: paramList });
-}
-
-function appendWhereNode(root, node) {
-    if (node) {
-        root.items.push(node);
-    }
-}
-
-function appendWhereObject(root, whereObj) {
-    const node = parseWhereObject(whereObj);
-    if (node.items.length > 0) {
-        root.items.push(node);
-    }
-}
-
-function parseWhereObject(whereObj) {
-    if (!whereObj || typeof whereObj !== "object") {
-        return { type: "group", join: "AND", items: [] };
-    }
-
-    const group = { type: "group", join: "AND", items: [] };
-
-    for (const [key, value] of Object.entries(whereObj)) {
-        if (value === undefined) {
-            continue;
-        }
-
-        if (key === "$and") {
-            appendAndConditions(group, value);
-            continue;
-        }
-
-        if (key === "$or") {
-            appendOrConditions(group, value);
-            continue;
-        }
-
-        appendFieldCondition(group, key, value);
-    }
-
-    return group;
-}
-
-function appendAndConditions(group, value) {
-    if (!Array.isArray(value)) {
-        return;
-    }
-
-    for (const condition of value) {
-        if (!condition || typeof condition !== "object" || Array.isArray(condition)) {
-            continue;
-        }
-
-        const sub = parseWhereObject(condition);
-        if (sub.items.length === 0) {
-            continue;
-        }
-
-        if (sub.join === "AND") {
-            for (const item of sub.items) {
-                group.items.push(item);
-            }
-            continue;
-        }
-
-        group.items.push(sub);
-    }
-}
-
-function appendOrConditions(group, value) {
-    if (!Array.isArray(value)) {
-        return;
-    }
-
-    const orGroup = { type: "group", join: "OR", items: [] };
-    for (const condition of value) {
-        if (!condition || typeof condition !== "object" || Array.isArray(condition)) {
-            continue;
-        }
-
-        const sub = parseWhereObject(condition);
-        if (sub.items.length > 0) {
-            orGroup.items.push(sub);
-        }
-    }
-
-    if (orGroup.items.length > 0) {
-        group.items.push(orGroup);
-    }
-}
-
-function appendFieldCondition(group, key, value) {
-    if (key.includes("$")) {
-        const lastDollarIndex = key.lastIndexOf("$");
-        appendWhereNode(group, buildOperatorNode(key.substring(0, lastDollarIndex), `$${key.substring(lastDollarIndex + 1)}`, value));
-        return;
-    }
-
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        for (const [operator, operatorValue] of Object.entries(value)) {
-            appendWhereNode(group, buildOperatorNode(key, operator, operatorValue));
-        }
-        return;
-    }
-
-    appendWhereNode(group, buildOperatorNode(key, "=", value));
-}
-
-function buildArrayOperatorNode(fieldName, operator, value, errorFactory, emptyMessage) {
-    if (!Array.isArray(value)) {
-        throw new Error(errorFactory(operator), {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (value.length === 0) {
-        throw new Error(emptyMessage, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    return { type: "op", field: fieldName, operator: operator, value: value };
-}
-
-function buildRangeOrNullOperatorNode(fieldName, operator, value) {
-    if (operator === "$between" || operator === "$notBetween") {
-        if (Array.isArray(value) && value.length === 2) {
-            return { type: "op", field: fieldName, operator: operator, value: value };
-        }
-        return null;
-    }
-
-    if (value === true) {
-        return { type: "op", field: fieldName, operator: operator, value: value };
-    }
-
-    return null;
-}
-
-function buildOperatorNode(fieldName, operator, value) {
-    switch (operator) {
-        case "$in":
-            return buildArrayOperatorNode(fieldName, operator, value, (currentOperator) => `$in 操作符的值必须是数组 (operator: ${currentOperator})`, "$in 操作符的数组不能为空。提示：空数组会导致查询永远不匹配任何记录，这通常不是预期行为。请检查查询条件或移除该字段。");
-        case "$nin":
-        case "$notIn":
-            return buildArrayOperatorNode(fieldName, operator, value, (currentOperator) => `$nin/$notIn 操作符的值必须是数组 (operator: ${currentOperator})`, "$nin/$notIn 操作符的数组不能为空。提示：空数组会导致查询匹配所有记录，这通常不是预期行为。请检查查询条件或移除该字段。");
-        case "$between":
-        case "$notBetween":
-        case "$null":
-        case "$notNull":
-            return buildRangeOrNullOperatorNode(fieldName, operator, value);
-        case "$like":
-        case "like":
-        case "$leftLike":
-        case "leftLike":
-        case "$rightLike":
-        case "rightLike":
-            if (isString(value) && value.trim() === "") {
-                return null;
-            }
-            validateParam(value);
-            return { type: "op", field: fieldName, operator: operator, value: value };
-        default:
-            validateParam(value);
-            return { type: "op", field: fieldName, operator: operator, value: value };
-    }
-}