befly 3.20.10 → 3.21.0

package/lib/sqlBuilder/batch.js

@@ -1,114 +0,0 @@
-import { isNonEmptyString } from "../../utils/is.js";
-import { SqlCheck } from "./check.js";
-
-export function toDeleteInSql(options) {
-    if (!isNonEmptyString(options.table)) {
-        throw new Error(`toDeleteInSql 需要非空表名 (table: ${String(options.table)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (!isNonEmptyString(options.idField)) {
-        throw new Error(`toDeleteInSql 需要非空 idField (idField: ${String(options.idField)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (!Array.isArray(options.ids)) {
-        throw new Error("toDeleteInSql 需要 ids 数组", {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (options.ids.length === 0) {
-        return { sql: "", params: [] };
-    }
-
-    const placeholders = options.ids.map(() => "?").join(",");
-    const sql = `DELETE FROM ${options.quoteIdent(options.table)} WHERE ${options.quoteIdent(options.idField)} IN (${placeholders})`;
-    const params = [];
-    for (const id of options.ids) {
-        params.push(id);
-    }
-    return { sql: sql, params: params };
-}
-
-export function toUpdateCaseByIdSql(options) {
-    if (!isNonEmptyString(options.table)) {
-        throw new Error(`toUpdateCaseByIdSql 需要非空表名 (table: ${String(options.table)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (!isNonEmptyString(options.idField)) {
-        throw new Error(`toUpdateCaseByIdSql 需要非空 idField (idField: ${String(options.idField)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (!Array.isArray(options.rows)) {
-        throw new Error("toUpdateCaseByIdSql 需要 rows 数组", {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (options.rows.length === 0) {
-        return { sql: "", params: [] };
-    }
-    if (!Array.isArray(options.fields)) {
-        throw new Error("toUpdateCaseByIdSql 需要 fields 数组", {
-            cause: null,
-            code: "validation"
-        });
-    }
-    if (options.fields.length === 0) {
-        return { sql: "", params: [] };
-    }
-
-    const ids = options.rows.map((row) => row.id);
-    const placeholders = ids.map(() => "?").join(",");
-
-    const setSqlList = [];
-    const args = [];
-
-    const quotedId = options.quoteIdent(options.idField);
-
-    for (const field of options.fields) {
-        const whenList = [];
-
-        for (const row of options.rows) {
-            if (!(field in row.data)) {
-                continue;
-            }
-
-            whenList.push("WHEN ? THEN ?");
-            args.push(row.id);
-            const value = row.data[field];
-            SqlCheck.assertNoUndefinedParam(value, "SQL 参数值");
-            args.push(value);
-        }
-
-        if (whenList.length === 0) {
-            continue;
-        }
-
-        const quotedField = options.quoteIdent(field);
-        setSqlList.push(`${quotedField} = CASE ${quotedId} ${whenList.join(" ")} ELSE ${quotedField} END`);
-    }
-
-    if (isNonEmptyString(options.updatedAtField)) {
-        setSqlList.push(`${options.quoteIdent(options.updatedAtField)} = ?`);
-        args.push(options.updatedAtValue);
-    }
-
-    for (const id of ids) {
-        args.push(id);
-    }
-
-    let sql = `UPDATE ${options.quoteIdent(options.table)} SET ${setSqlList.join(", ")} WHERE ${quotedId} IN (${placeholders})`;
-    if (options.stateGtZero && options.stateField) {
-        sql += ` AND ${options.quoteIdent(options.stateField)} > 0`;
-    }
-
-    return { sql: sql, params: args };
-}

package/lib/sqlBuilder/check.js

@@ -1,82 +0,0 @@
-import { isNonEmptyString } from "../../utils/is.js";
-
-function throwValidation(message) {
-    throw new Error(message, {
-        cause: null,
-        code: "validation"
-    });
-}
-
-export class SqlCheck {
-    static assertNoUndefinedParam(value, label) {
-        if (value === undefined) {
-            throwValidation(`${label} 不能为 undefined`);
-        }
-    }
-
-    static assertSafeIdentifierPart(part, kind) {
-        if (!SqlCheck.SAFE_IDENTIFIER_RE.test(part)) {
-            throwValidation(`无效的 ${kind} 标识符: ${part}`);
-        }
-    }
-
-    static assertNoExprField(field) {
-        if (!isNonEmptyString(field)) {
-            return;
-        }
-        const trimmed = field.trim();
-        if (trimmed.includes("(") || trimmed.includes(")")) {
-            throwValidation(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`);
-        }
-    }
-
-    static assertBatchInsertRowsConsistent(rows, options) {
-        if (!Array.isArray(rows)) {
-            throwValidation("批量插入 rows 必须是数组");
-        }
-        if (rows.length === 0) {
-            throwValidation(`插入数据不能为空 (table: ${options.table})`);
-        }
-
-        const first = rows[0];
-        if (!first || typeof first !== "object" || Array.isArray(first)) {
-            throwValidation(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: 0)`);
-        }
-
-        const fields = Object.keys(first);
-        if (fields.length === 0) {
-            throwValidation(`插入数据必须至少有一个字段 (table: ${options.table})`);
-        }
-
-        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)) {
-                throwValidation(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: ${i})`);
-            }
-
-            const rowKeys = Object.keys(row);
-            if (rowKeys.length !== fields.length) {
-                throwValidation(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i})`);
-            }
-
-            for (const key of rowKeys) {
-                if (!fieldSet.has(key)) {
-                    throwValidation(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i}, extraField: ${key})`);
-                }
-            }
-
-            for (const field of fields) {
-                if (!(field in row)) {
-                    throwValidation(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
-                }
-                SqlCheck.assertNoUndefinedParam(row[field], `批量插入字段值 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
-            }
-        }
-
-        return fields;
-    }
-}
-
-SqlCheck.SAFE_IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;

package/lib/sqlBuilder/compiler.js

@@ -1,360 +0,0 @@
-import { SqlCheck } from "./check.js";
-import { escapeField, escapeTable, validateParam } from "./util.js";
-import { isString } from "../../utils/is.js";
-
-function pushParams(target, source) {
-    for (const param of source) {
-        target.push(param);
-    }
-}
-
-function compileFromSql(model, quoteIdent, errorMessage) {
-    if (!model.from) {
-        throw new Error(errorMessage, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    return model.from.type === "raw" ? model.from.value : escapeTable(model.from.value, quoteIdent);
-}
-
-function compileJoinSql(model, quoteIdent) {
-    if (model.joins.length === 0) {
-        return "";
-    }
-
-    return model.joins
-        .map((join) => {
-            const joinTable = escapeTable(join.table, quoteIdent);
-            const joinType = join.type.toUpperCase();
-            return `${joinType} JOIN ${joinTable} ON ${join.on}`;
-        })
-        .join(" ");
-}
-
-function appendCompiledWhere(sql, params, whereNode, quoteIdent) {
-    const whereResult = compileWhere(whereNode, quoteIdent);
-    if (!whereResult.sql) {
-        return sql;
-    }
-
-    pushParams(params, whereResult.params);
-    return `${sql} WHERE ${whereResult.sql}`;
-}
-
-function compileReadBaseSql(model, quoteIdent, headSql, fromErrorMessage) {
-    const params = [];
-    let sql = `${headSql} FROM ${compileFromSql(model, quoteIdent, fromErrorMessage)}`;
-
-    const joinSql = compileJoinSql(model, quoteIdent);
-    if (joinSql) {
-        sql += ` ${joinSql}`;
-    }
-
-    sql = appendCompiledWhere(sql, params, model.where, quoteIdent);
-    return { sql: sql, params: params };
-}
-
-function compileOrderBySql(orderBy, quoteIdent) {
-    if (orderBy.length === 0) {
-        return "";
-    }
-
-    return orderBy
-        .map((item) => {
-            const escapedField = escapeField(item.field, quoteIdent);
-            return `${escapedField} ${item.dir}`;
-        })
-        .join(", ");
-}
-
-function appendLimitSql(sql, model) {
-    if (model.limit === null) {
-        return sql;
-    }
-
-    let result = `${sql} LIMIT ${model.limit}`;
-    if (model.offset !== null) {
-        result += ` OFFSET ${model.offset}`;
-    }
-
-    return result;
-}
-
-export function compileSelect(model, quoteIdent) {
-    const selectSql =
-        model.select.length > 0
-            ? model.select
-                  .map((item) => {
-                      if (item.type === "raw") {
-                          return item.value;
-                      }
-                      return escapeField(item.value, quoteIdent);
-                  })
-                  .join(", ")
-            : "*";
-
-    const result = compileReadBaseSql(model, quoteIdent, `SELECT ${selectSql}`, "FROM 表名是必需的");
-    const orderSql = compileOrderBySql(model.orderBy, quoteIdent);
-    if (orderSql) {
-        result.sql += ` ORDER BY ${orderSql}`;
-    }
-
-    result.sql = appendLimitSql(result.sql, model);
-    return result;
-}
-
-export function compileCount(model, quoteIdent) {
-    return compileReadBaseSql(model, quoteIdent, "SELECT COUNT(*) as total", "COUNT 需要 FROM 表名");
-}
-
-export function compileInsert(table, data, quoteIdent) {
-    if (!table || !isString(table)) {
-        throw new Error(`INSERT 需要表名 (table: ${String(table)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (!data || typeof data !== "object") {
-        throw new Error(`INSERT 需要数据 (table: ${String(table)}, data: ${JSON.stringify(data)})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const escapedTable = escapeTable(table, quoteIdent);
-
-    if (Array.isArray(data)) {
-        const fields = SqlCheck.assertBatchInsertRowsConsistent(data, { table: table });
-
-        const escapedFields = fields.map((field) => escapeField(field, quoteIdent));
-        const placeholders = fields.map(() => "?").join(", ");
-        const values = data.map(() => `(${placeholders})`).join(", ");
-
-        const sql = `INSERT INTO ${escapedTable} (${escapedFields.join(", ")}) VALUES ${values}`;
-        const params = [];
-        for (let i = 0; i < data.length; i++) {
-            const row = data[i];
-            for (const field of fields) {
-                const value = row[field];
-                validateParam(value);
-                params.push(value);
-            }
-        }
-
-        return { sql: sql, params: params };
-    }
-
-    const fields = Object.keys(data);
-    if (fields.length === 0) {
-        throw new Error(`插入数据必须至少有一个字段 (table: ${table})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    for (const field of fields) {
-        validateParam(data[field]);
-    }
-
-    const escapedFields = fields.map((field) => escapeField(field, quoteIdent));
-    const placeholders = fields.map(() => "?").join(", ");
-    const sql = `INSERT INTO ${escapedTable} (${escapedFields.join(", ")}) VALUES (${placeholders})`;
-    const params = [];
-    for (const field of fields) {
-        params.push(data[field]);
-    }
-
-    return { sql: sql, params: params };
-}
-
-export function compileUpdate(model, table, data, quoteIdent) {
-    if (!table || !isString(table)) {
-        throw new Error("UPDATE 需要表名", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
-        throw new Error("UPDATE 需要数据对象", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const fields = Object.keys(data);
-    if (fields.length === 0) {
-        throw new Error("更新数据必须至少有一个字段", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const escapedTable = escapeTable(table, quoteIdent);
-    const setFields = fields.map((field) => `${escapeField(field, quoteIdent)} = ?`);
-    const params = [];
-    for (const value of Object.values(data)) {
-        params.push(value);
-    }
-
-    let sql = `UPDATE ${escapedTable} SET ${setFields.join(", ")}`;
-
-    const whereResult = compileWhere(model.where, quoteIdent);
-    if (whereResult.sql) {
-        sql += ` WHERE ${whereResult.sql}`;
-        pushParams(params, whereResult.params);
-    } else {
-        throw new Error("为安全起见，UPDATE 需要 WHERE 条件", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    return { sql: sql, params: params };
-}
-
-export function compileDelete(model, table, quoteIdent) {
-    if (!table || !isString(table)) {
-        throw new Error("DELETE 需要表名", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    const escapedTable = escapeTable(table, quoteIdent);
-    let sql = `DELETE FROM ${escapedTable}`;
-
-    const whereResult = compileWhere(model.where, quoteIdent);
-    if (whereResult.sql) {
-        sql += ` WHERE ${whereResult.sql}`;
-    } else {
-        throw new Error("为安全起见，DELETE 需要 WHERE 条件", {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    return { sql: sql, params: whereResult.params };
-}
-
-export function compileWhere(node, quoteIdent) {
-    if (!node) {
-        return { sql: "", params: [] };
-    }
-
-    if (node.type === "raw") {
-        const params = Array.isArray(node.params) ? node.params.slice() : [];
-        return { sql: node.sql, params: params };
-    }
-
-    if (node.type === "op") {
-        return compileOperatorNode(node, quoteIdent);
-    }
-
-    if (node.type === "group") {
-        if (!node.items || node.items.length === 0) {
-            return { sql: "", params: [] };
-        }
-        const parts = [];
-        const params = [];
-        for (const item of node.items) {
-            const built = compileWhere(item, quoteIdent);
-            if (!built.sql) {
-                continue;
-            }
-            let clause = built.sql;
-            if (node.join === "OR") {
-                clause = `(${clause})`;
-            } else if (item.type === "group" && item.join === "OR") {
-                clause = `(${clause})`;
-            }
-            parts.push(clause);
-            pushParams(params, built.params);
-        }
-        return { sql: parts.join(` ${node.join} `), params: params };
-    }
-
-    return { sql: "", params: [] };
-}
-
-function compileOperatorNode(node, quoteIdent) {
-    const escapedField = escapeField(node.field, quoteIdent);
-    const operator = node.operator;
-
-    const buildLikeParam = (value, mode) => {
-        validateParam(value);
-        const text = String(value);
-
-        if (mode === "left") {
-            return `%${text}`;
-        }
-
-        if (mode === "right") {
-            return `${text}%`;
-        }
-
-        return `%${text}%`;
-    };
-
-    switch (operator) {
-        case "$ne":
-        case "$not":
-            validateParam(node.value);
-            return { sql: `${escapedField} != ?`, params: [node.value] };
-        case "$in": {
-            const placeholders = node.value.map(() => "?").join(",");
-            const params = [];
-            for (const item of node.value) {
-                params.push(item);
-            }
-            return { sql: `${escapedField} IN (${placeholders})`, params: params };
-        }
-        case "$nin":
-        case "$notIn": {
-            const placeholders = node.value.map(() => "?").join(",");
-            const params = [];
-            for (const item of node.value) {
-                params.push(item);
-            }
-            return { sql: `${escapedField} NOT IN (${placeholders})`, params: params };
-        }
-        case "$like":
-        case "like":
-            return { sql: `${escapedField} LIKE ?`, params: [buildLikeParam(node.value, "both")] };
-        case "$leftLike":
-        case "leftLike":
-            return { sql: `${escapedField} LIKE ?`, params: [buildLikeParam(node.value, "left")] };
-        case "$rightLike":
-        case "rightLike":
-            return { sql: `${escapedField} LIKE ?`, params: [buildLikeParam(node.value, "right")] };
-        case "$notLike":
-            validateParam(node.value);
-            return { sql: `${escapedField} NOT LIKE ?`, params: [node.value] };
-        case "$gt":
-            validateParam(node.value);
-            return { sql: `${escapedField} > ?`, params: [node.value] };
-        case "$gte":
-            validateParam(node.value);
-            return { sql: `${escapedField} >= ?`, params: [node.value] };
-        case "$lt":
-            validateParam(node.value);
-            return { sql: `${escapedField} < ?`, params: [node.value] };
-        case "$lte":
-            validateParam(node.value);
-            return { sql: `${escapedField} <= ?`, params: [node.value] };
-        case "$between":
-            return { sql: `${escapedField} BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
-        case "$notBetween":
-            return { sql: `${escapedField} NOT BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
-        case "$null":
-            return { sql: `${escapedField} IS NULL`, params: [] };
-        case "$notNull":
-            return { sql: `${escapedField} IS NOT NULL`, params: [] };
-        default:
-            validateParam(node.value);
-            return { sql: `${escapedField} = ?`, params: [node.value] };
-    }
-}