befly 3.20.8 → 3.20.9

package/lib/sqlBuilder/check.js

@@ -1,63 +1,22 @@
-import { isMinLengthString, isNonEmptyString } from "../../utils/is.js";
+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) {
-            throw new Error(`${label} 不能为 undefined`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-
-    static startsWithQuote(value) {
-        const trimmed = value.trim();
-        return trimmed.startsWith("`") || trimmed.startsWith('"');
-    }
-
-    static isQuotedIdentPaired(value) {
-        const trimmed = value.trim();
-        if (!isMinLengthString(trimmed, 2)) {
-            return false;
-        }
-        const first = trimmed[0];
-        const last = trimmed[trimmed.length - 1];
-        if (first === "`" && last === "`") {
-            return true;
-        }
-        if (first === '"' && last === '"') {
-            return true;
-        }
-        return false;
-    }
-
-    static assertPairedQuotedIdentIfStartsWithQuote(value, label) {
-        if (SqlCheck.startsWithQuote(value) && !SqlCheck.isQuotedIdentPaired(value)) {
-            throw new Error(`${label} 引用不完整，请使用成对的 \`...\` 或 "..." (value: ${value})`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`${label} 不能为 undefined`);
         }
     }
 
     static assertSafeIdentifierPart(part, kind) {
         if (!SqlCheck.SAFE_IDENTIFIER_RE.test(part)) {
-            throw new Error(`无效的 ${kind} 标识符: ${part}`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-    }
-
-    static assertSafeAlias(aliasPart) {
-        if (SqlCheck.isQuotedIdentPaired(aliasPart)) {
-            return;
-        }
-        if (!SqlCheck.SAFE_IDENTIFIER_RE.test(aliasPart)) {
-            throw new Error(`无效的字段别名: ${aliasPart}`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`无效的 ${kind} 标识符: ${part}`);
         }
     }
 
@@ -67,41 +26,26 @@ export class SqlCheck {
         }
         const trimmed = field.trim();
         if (trimmed.includes("(") || trimmed.includes(")")) {
-            throw new Error(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`字段包含函数/表达式，请使用 selectRaw/whereRaw (field: ${trimmed})`);
         }
     }
 
     static assertBatchInsertRowsConsistent(rows, options) {
         if (!Array.isArray(rows)) {
-            throw new Error("批量插入 rows 必须是数组", {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation("批量插入 rows 必须是数组");
         }
         if (rows.length === 0) {
-            throw new Error(`插入数据不能为空 (table: ${options.table})`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`插入数据不能为空 (table: ${options.table})`);
         }
 
         const first = rows[0];
         if (!first || typeof first !== "object" || Array.isArray(first)) {
-            throw new Error(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: 0)`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: 0)`);
         }
 
         const fields = Object.keys(first);
         if (fields.length === 0) {
-            throw new Error(`插入数据必须至少有一个字段 (table: ${options.table})`, {
-                cause: null,
-                code: "validation"
-            });
+            throwValidation(`插入数据必须至少有一个字段 (table: ${options.table})`);
         }
 
         const fieldSet = new Set(fields);
@@ -109,35 +53,23 @@ export class SqlCheck {
         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"
-                });
+                throwValidation(`批量插入的每一行必须是对象 (table: ${options.table}, rowIndex: ${i})`);
             }
 
             const rowKeys = Object.keys(row);
             if (rowKeys.length !== fields.length) {
-                throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i})`, {
-                    cause: null,
-                    code: "validation"
-                });
+                throwValidation(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i})`);
             }
 
             for (const key of rowKeys) {
                 if (!fieldSet.has(key)) {
-                    throw new Error(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i}, extraField: ${key})`, {
-                        cause: null,
-                        code: "validation"
-                    });
+                    throwValidation(`批量插入每行字段必须一致 (table: ${options.table}, rowIndex: ${i}, extraField: ${key})`);
                 }
             }
 
             for (const field of fields) {
                 if (!(field in row)) {
-                    throw new Error(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`, {
-                        cause: null,
-                        code: "validation"
-                    });
+                    throwValidation(`批量插入缺少字段 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
                 }
                 SqlCheck.assertNoUndefinedParam(row[field], `批量插入字段值 (table: ${options.table}, rowIndex: ${i}, field: ${field})`);
             }

package/lib/sqlBuilder/compiler.js

@@ -1,119 +1,124 @@
 import { SqlCheck } from "./check.js";
-import { SqlErrors } from "./errors.js";
 import { escapeField, escapeTable, validateParam } from "./util.js";
 import { isString } from "../../utils/is.js";
 
-export function compileSelect(model, quoteIdent) {
-    let sql = "SELECT ";
-    const params = [];
-
-    if (model.select.length > 0) {
-        const fields = model.select.map((item) => {
-            if (item.type === "raw") {
-                return item.value;
-            }
-            return escapeField(item.value, quoteIdent);
-        });
-        sql += fields.join(", ");
-    } else {
-        sql += "*";
+function pushParams(target, source) {
+    for (const param of source) {
+        target.push(param);
     }
+}
 
+function compileFromSql(model, quoteIdent, errorMessage) {
     if (!model.from) {
-        throw new Error(SqlErrors.FROM_REQUIRED, {
+        throw new Error(errorMessage, {
             cause: null,
             code: "validation"
         });
     }
 
-    const fromSql = model.from.type === "raw" ? model.from.value : escapeTable(model.from.value, quoteIdent);
-    sql += ` FROM ${fromSql}`;
-
-    if (model.joins.length > 0) {
-        const joinSql = model.joins
-            .map((join) => {
-                const joinTable = escapeTable(join.table, quoteIdent);
-                const joinType = join.type.toUpperCase();
-                return `${joinType} JOIN ${joinTable} ON ${join.on}`;
-            })
-            .join(" ");
-        sql += ` ${joinSql}`;
-    }
+    return model.from.type === "raw" ? model.from.value : escapeTable(model.from.value, quoteIdent);
+}
 
-    const whereResult = compileWhere(model.where, quoteIdent);
-    if (whereResult.sql) {
-        sql += ` WHERE ${whereResult.sql}`;
-        for (const param of whereResult.params) {
-            params.push(param);
-        }
+function compileJoinSql(model, quoteIdent) {
+    if (model.joins.length === 0) {
+        return "";
     }
 
-    if (model.orderBy.length > 0) {
-        const orderSql = model.orderBy
-            .map((item) => {
-                const escapedField = escapeField(item.field, quoteIdent);
-                return `${escapedField} ${item.dir}`;
-            })
-            .join(", ");
-        sql += ` ORDER BY ${orderSql}`;
+    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;
     }
 
-    if (model.limit !== null) {
-        sql += ` LIMIT ${model.limit}`;
-        if (model.offset !== null) {
-            sql += ` OFFSET ${model.offset}`;
-        }
+    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 };
 }
 
-export function compileCount(model, quoteIdent) {
-    let sql = "SELECT COUNT(*) as total";
-    const params = [];
+function compileOrderBySql(orderBy, quoteIdent) {
+    if (orderBy.length === 0) {
+        return "";
+    }
 
-    if (!model.from) {
-        throw new Error(SqlErrors.COUNT_NEED_FROM, {
-            cause: null,
-            code: "validation"
-        });
+    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;
     }
 
-    const fromSql = model.from.type === "raw" ? model.from.value : escapeTable(model.from.value, quoteIdent);
-    sql += ` FROM ${fromSql}`;
-
-    if (model.joins.length > 0) {
-        const joinSql = model.joins
-            .map((join) => {
-                const joinTable = escapeTable(join.table, quoteIdent);
-                const joinType = join.type.toUpperCase();
-                return `${joinType} JOIN ${joinTable} ON ${join.on}`;
-            })
-            .join(" ");
-        sql += ` ${joinSql}`;
+    let result = `${sql} LIMIT ${model.limit}`;
+    if (model.offset !== null) {
+        result += ` OFFSET ${model.offset}`;
     }
 
-    const whereResult = compileWhere(model.where, quoteIdent);
-    if (whereResult.sql) {
-        sql += ` WHERE ${whereResult.sql}`;
-        for (const param of whereResult.params) {
-            params.push(param);
-        }
+    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}`;
     }
 
-    return { sql: sql, params: params };
+    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(SqlErrors.INSERT_NEED_TABLE(table), {
+        throw new Error(`INSERT 需要表名 (table: ${String(table)})`, {
             cause: null,
             code: "validation"
         });
     }
 
     if (!data || typeof data !== "object") {
-        throw new Error(SqlErrors.INSERT_NEED_DATA(table, data), {
+        throw new Error(`INSERT 需要数据 (table: ${String(table)}, data: ${JSON.stringify(data)})`, {
             cause: null,
             code: "validation"
         });
@@ -144,7 +149,7 @@ export function compileInsert(table, data, quoteIdent) {
 
     const fields = Object.keys(data);
     if (fields.length === 0) {
-        throw new Error(SqlErrors.INSERT_NEED_AT_LEAST_ONE_FIELD(table), {
+        throw new Error(`插入数据必须至少有一个字段 (table: ${table})`, {
             cause: null,
             code: "validation"
         });
@@ -167,14 +172,14 @@ export function compileInsert(table, data, quoteIdent) {
 
 export function compileUpdate(model, table, data, quoteIdent) {
     if (!table || !isString(table)) {
-        throw new Error(SqlErrors.UPDATE_NEED_TABLE, {
+        throw new Error("UPDATE 需要表名", {
             cause: null,
             code: "validation"
         });
     }
 
     if (!data || typeof data !== "object" || Array.isArray(data)) {
-        throw new Error(SqlErrors.UPDATE_NEED_OBJECT, {
+        throw new Error("UPDATE 需要数据对象", {
             cause: null,
             code: "validation"
         });
@@ -182,7 +187,7 @@ export function compileUpdate(model, table, data, quoteIdent) {
 
     const fields = Object.keys(data);
     if (fields.length === 0) {
-        throw new Error(SqlErrors.UPDATE_NEED_AT_LEAST_ONE_FIELD, {
+        throw new Error("更新数据必须至少有一个字段", {
             cause: null,
             code: "validation"
         });
@@ -200,11 +205,9 @@ export function compileUpdate(model, table, data, quoteIdent) {
     const whereResult = compileWhere(model.where, quoteIdent);
     if (whereResult.sql) {
         sql += ` WHERE ${whereResult.sql}`;
-        for (const param of whereResult.params) {
-            params.push(param);
-        }
+        pushParams(params, whereResult.params);
     } else {
-        throw new Error(SqlErrors.UPDATE_NEED_WHERE, {
+        throw new Error("为安全起见，UPDATE 需要 WHERE 条件", {
             cause: null,
             code: "validation"
         });
@@ -215,7 +218,7 @@ export function compileUpdate(model, table, data, quoteIdent) {
 
 export function compileDelete(model, table, quoteIdent) {
     if (!table || !isString(table)) {
-        throw new Error(SqlErrors.DELETE_NEED_TABLE, {
+        throw new Error("DELETE 需要表名", {
             cause: null,
             code: "validation"
         });
@@ -228,7 +231,7 @@ export function compileDelete(model, table, quoteIdent) {
     if (whereResult.sql) {
         sql += ` WHERE ${whereResult.sql}`;
     } else {
-        throw new Error(SqlErrors.DELETE_NEED_WHERE, {
+        throw new Error("为安全起见，DELETE 需要 WHERE 条件", {
             cause: null,
             code: "validation"
         });
@@ -269,9 +272,7 @@ export function compileWhere(node, quoteIdent) {
                 clause = `(${clause})`;
             }
             parts.push(clause);
-            for (const param of built.params) {
-                params.push(param);
-            }
+            pushParams(params, built.params);
         }
         return { sql: parts.join(` ${node.join} `), params: params };
     }