befly 3.20.11 → 3.21.0

package/lib/dbHelper/dataOps.js

@@ -1,578 +0,0 @@
-import { isNumber } from "../../utils/is.js";
-import { snakeCase } from "../../utils/util.js";
-import { Logger } from "../logger.js";
-import { SqlBuilder } from "../sqlBuilder/index.js";
-import { normalizeSqlMetaNumber, quoteIdentMySql } from "./util.js";
-import { addDefaultStateFilter, buildInsertRow, buildPartialUpdateData, buildUpdateRow, clearDeep, whereKeysToSnake } from "./builders.js";
-import { assertBatchInsertRowsConsistent, assertNoUndefinedInRecord, validateGeneratedBatchId, validateIncrementOptions, validateInsertBatchSize, validateNoLeftJoinReadOptions, validatePageLimitRange, validateSafeFieldName, validateTableBatchDataOptions, validateTableDataOptions, validateTableName, validateTableWhereOptions } from "./validate.js";
-
-export const dataOpsMethods = {
-    prepareSingleTableWhere(table, where, useDefaultStateFilter = true) {
-        const snakeTable = snakeCase(table);
-        const snakeWhere = whereKeysToSnake(clearDeep(where || {}));
-
-        return {
-            snakeTable: snakeTable,
-            whereFiltered: useDefaultStateFilter ? addDefaultStateFilter(snakeWhere, snakeTable, false, this.beflyMode) : snakeWhere
-        };
-    },
-
-    async createInsertRows(table, snakeTable, dataList, now) {
-        if (this.beflyMode === "manual") {
-            return {
-                ids: [],
-                processedList: dataList.map((data) =>
-                    buildInsertRow({
-                        data: data,
-                        now: now,
-                        beflyMode: this.beflyMode
-                    })
-                )
-            };
-        }
-
-        const ids = [];
-        try {
-            for (let i = 0; i < dataList.length; i++) {
-                ids.push(await this.redis.genTimeID());
-            }
-        } catch (error) {
-            if (dataList.length === 1) {
-                throw new Error(`生成 ID 失败，Redis 可能不可用 (table: ${table})`, {
-                    cause: error,
-                    code: "runtime",
-                    subsystem: "db",
-                    operation: "genTimeId",
-                    table: table
-                });
-            }
-            throw error;
-        }
-
-        const processedList = dataList.map((data, index) => {
-            const id = ids[index];
-            if (dataList.length > 1) {
-                validateGeneratedBatchId(id, snakeTable, index);
-            }
-
-            return buildInsertRow({
-                data: data,
-                id: id,
-                now: now,
-                beflyMode: this.beflyMode
-            });
-        });
-
-        return {
-            ids: ids,
-            processedList: processedList
-        };
-    },
-
-    resolveInsertedData(table, count, executeRes, generatedIds, operation) {
-        const lastInsertRowidNum = normalizeSqlMetaNumber(executeRes.data?.lastInsertRowid);
-
-        if (this.beflyMode === "manual") {
-            if (lastInsertRowidNum <= 0) {
-                throw new Error(operation === "insBatch" ? `批量插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})` : `插入失败：beflyMode=manual 时无法获取 lastInsertRowid (table: ${table})`, {
-                    cause: null,
-                    code: "runtime"
-                });
-            }
-
-            if (count === 1) {
-                return lastInsertRowidNum;
-            }
-
-            const outIds = [];
-            for (let i = 0; i < count; i++) {
-                outIds.push(lastInsertRowidNum + i);
-            }
-            return outIds;
-        }
-
-        if (count === 1) {
-            const generatedId = generatedIds[0];
-            return (isNumber(generatedId) ? generatedId : 0) || lastInsertRowidNum || 0;
-        }
-
-        return generatedIds;
-    },
-
-    // 读取操作
-    async getCount(options) {
-        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getCount.options");
-        const result = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as count");
-
-        return {
-            data: result.total,
-            sql: result.sql
-        };
-    },
-
-    async getOne(options) {
-        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getOne.options");
-        const builder = this.createSqlBuilder().select(prepared.fields).from(prepared.table).where(whereFiltered);
-        this.applyLeftJoins(builder, prepared.leftJoins);
-
-        const { sql, params } = builder.toSelectSql();
-        const executeRes = await this.execute(sql, params);
-        const result = executeRes.data;
-
-        const data = this.normalizeRowData(result?.[0] || null);
-        return {
-            data: data,
-            sql: executeRes.sql
-        };
-    },
-
-    async getDetail(options) {
-        return await this.getOne(options);
-    },
-
-    async getList(options) {
-        const { prepared, whereFiltered } = await this.prepareReadContext(options, "getList.options");
-        validatePageLimitRange(prepared, options.table);
-        const countResult = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as total");
-        const total = countResult.total;
-
-        const offset = (prepared.page - 1) * prepared.limit;
-        const dataBuilder = this.createListBuilder(prepared, whereFiltered, prepared.limit, offset);
-        const { sql: dataSql, params: dataParams } = dataBuilder.toSelectSql();
-
-        if (total === 0) {
-            return {
-                data: {
-                    lists: [],
-                    total: 0,
-                    page: prepared.page,
-                    limit: prepared.limit,
-                    pages: 0
-                },
-                sql: {
-                    count: countResult.sql,
-                    data: {
-                        sql: dataSql,
-                        params: dataParams,
-                        duration: 0
-                    }
-                }
-            };
-        }
-        const listExecuteRes = await this.execute(dataSql, dataParams);
-        const list = listExecuteRes.data || [];
-
-        return {
-            data: {
-                lists: this.normalizeListData(list),
-                total: total,
-                page: prepared.page,
-                limit: prepared.limit,
-                pages: Math.ceil(total / prepared.limit)
-            },
-            sql: {
-                count: countResult.sql,
-                data: listExecuteRes.sql
-            }
-        };
-    },
-
-    async getAll(options) {
-        const MAX_LIMIT = 100000;
-        const WARNING_LIMIT = 10000;
-        const prepareOptions = this.buildQueryOptions(options, { page: 1, limit: 10 });
-        const { prepared, whereFiltered } = await this.prepareReadContext(prepareOptions, "getAll.options");
-        const countResult = await this.fetchCount(prepared, whereFiltered, "COUNT(*) as total");
-        const total = countResult.total;
-
-        if (total === 0) {
-            return {
-                data: {
-                    lists: [],
-                    total: 0
-                },
-                sql: {
-                    count: countResult.sql
-                }
-            };
-        }
-
-        const dataBuilder = this.createListBuilder(prepared, whereFiltered, MAX_LIMIT, null);
-
-        const { sql: dataSql, params: dataParams } = dataBuilder.toSelectSql();
-        const listExecuteRes = await this.execute(dataSql, dataParams);
-        const result = listExecuteRes.data || [];
-
-        if (result.length >= WARNING_LIMIT) {
-            Logger.warn("getAll 返回数据过多，建议使用 getList 分页查询", { table: options.table, count: result.length, total: total });
-        }
-
-        if (result.length >= MAX_LIMIT) {
-            Logger.warn(`getAll 达到最大限制 ${MAX_LIMIT}，实际总数 ${total}，只返回前 ${MAX_LIMIT} 条`, { table: options.table, limit: MAX_LIMIT, total: total });
-        }
-
-        const lists = this.normalizeListData(result);
-
-        return {
-            data: {
-                lists: lists,
-                total: total
-            },
-            sql: {
-                count: countResult.sql,
-                data: listExecuteRes.sql
-            }
-        };
-    },
-
-    async exists(options) {
-        validateNoLeftJoinReadOptions(options, "exists", "exists 不支持 leftJoin（请使用显式 query 或拆分查询）");
-        const prepared = this.prepareSingleTableWhere(options.table, options.where, true);
-
-        const builder = this.createSqlBuilder().selectRaw("COUNT(1) as cnt").from(prepared.snakeTable).where(prepared.whereFiltered).limit(1);
-        const { sql, params } = builder.toSelectSql();
-        const executeRes = await this.execute(sql, params);
-        const exists = (executeRes.data?.[0]?.cnt || 0) > 0;
-        return { data: exists, sql: executeRes.sql };
-    },
-
-    async getFieldValue(options) {
-        validateNoLeftJoinReadOptions(options, "getFieldValue", "getFieldValue 不支持 leftJoin（请使用 getOne/getList 并自行取字段）");
-        const field = options.field;
-        validateSafeFieldName(field);
-
-        const oneOptions = {
-            table: options.table
-        };
-        if (options.where !== undefined) oneOptions.where = options.where;
-        if (options.leftJoin !== undefined) oneOptions.leftJoin = options.leftJoin;
-        if (options.orderBy !== undefined) oneOptions.orderBy = options.orderBy;
-        if (options.page !== undefined) oneOptions.page = options.page;
-        if (options.limit !== undefined) oneOptions.limit = options.limit;
-        oneOptions.fields = [field];
-
-        const oneRes = await this.getOne(oneOptions);
-
-        const result = oneRes.data;
-        const value = this.resolveFieldValue(result, field);
-        return {
-            data: value,
-            sql: oneRes.sql
-        };
-    },
-
-    // 写入操作
-
-    async insData(options) {
-        validateTableDataOptions(options, "insData");
-        const { table, data } = options;
-        const snakeTable = snakeCase(table);
-        const now = Date.now();
-        const insertRows = await this.createInsertRows(table, snakeTable, [data], now);
-        const processed = insertRows.processedList[0];
-
-        assertNoUndefinedInRecord(processed, `insData 插入数据 (table: ${snakeTable})`);
-
-        const builder = this.createSqlBuilder();
-        const { sql, params } = builder.toInsertSql(snakeTable, processed);
-        const executeRes = await this.execute(sql, params);
-
-        return {
-            data: this.resolveInsertedData(table, 1, executeRes, insertRows.ids, "insData"),
-            sql: executeRes.sql
-        };
-    },
-
-    async insBatch(table, dataList) {
-        validateTableBatchDataOptions(table, dataList, "insBatch");
-        if (dataList.length === 0) {
-            return {
-                data: [],
-                sql: { sql: "", params: [], duration: 0 }
-            };
-        }
-
-        const MAX_BATCH_SIZE = 1000;
-        validateInsertBatchSize(dataList.length, MAX_BATCH_SIZE);
-
-        const snakeTable = snakeCase(table);
-        const now = Date.now();
-        const insertRows = await this.createInsertRows(table, snakeTable, dataList, now);
-        const processedList = insertRows.processedList;
-
-        const insertFields = assertBatchInsertRowsConsistent(processedList, { table: snakeTable });
-        const builder = this.createSqlBuilder();
-        const { sql, params } = builder.toInsertSql(snakeTable, processedList);
-
-        try {
-            const executeRes = await this.execute(sql, params);
-            return {
-                data: this.resolveInsertedData(table, dataList.length, executeRes, insertRows.ids, "insBatch"),
-                sql: executeRes.sql
-            };
-        } catch (error) {
-            Logger.error("批量插入失败", error, {
-                table: table,
-                snakeTable: snakeTable,
-                count: dataList.length,
-                fields: insertFields
-            });
-            throw new Error("批量插入失败", {
-                cause: error,
-                code: "runtime",
-                subsystem: "sql",
-                operation: "insBatch",
-                table: table,
-                snakeTable: snakeTable,
-                count: dataList.length,
-                fields: insertFields
-            });
-        }
-    },
-
-    async delForceBatch(table, ids) {
-        validateTableName(table, "delForceBatch.table");
-        if (ids.length === 0) {
-            return {
-                data: 0,
-                sql: { sql: "", params: [], duration: 0 }
-            };
-        }
-
-        const snakeTable = snakeCase(table);
-
-        const query = SqlBuilder.toDeleteInSql({
-            table: snakeTable,
-            idField: "id",
-            ids: ids,
-            quoteIdent: quoteIdentMySql
-        });
-        const executeRes = await this.execute(query.sql, query.params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async updBatch(table, dataList) {
-        validateTableBatchDataOptions(table, dataList, "updBatch");
-        if (dataList.length === 0) {
-            return {
-                data: 0,
-                sql: { sql: "", params: [], duration: 0 }
-            };
-        }
-
-        const snakeTable = snakeCase(table);
-        const now = Date.now();
-
-        const processedList = [];
-        const fieldSet = new Set();
-
-        for (const item of dataList) {
-            const userData = buildPartialUpdateData({ data: item.data, allowState: true });
-
-            for (const key of Object.keys(userData)) {
-                fieldSet.add(key);
-            }
-
-            processedList.push({ id: item.id, data: userData });
-        }
-
-        const fields = Array.from(fieldSet).sort();
-        if (fields.length === 0) {
-            return {
-                data: 0,
-                sql: { sql: "", params: [], duration: 0 }
-            };
-        }
-
-        const query = SqlBuilder.toUpdateCaseByIdSql({
-            table: snakeTable,
-            idField: "id",
-            rows: processedList,
-            fields: fields,
-            quoteIdent: quoteIdentMySql,
-            updatedAtField: this.beflyMode === "auto" ? "updated_at" : "",
-            updatedAtValue: this.beflyMode === "auto" ? now : null,
-            stateField: "state",
-            stateGtZero: this.beflyMode === "auto"
-        });
-
-        const executeRes = await this.execute(query.sql, query.params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async updData(options) {
-        validateTableDataOptions(options, "updData");
-        validateTableWhereOptions(options, "updData", true);
-        const { table, data, where } = options;
-        const prepared = this.prepareSingleTableWhere(table, where, true);
-
-        const processed = buildUpdateRow({ data: data, now: Date.now(), allowState: true, beflyMode: this.beflyMode });
-        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
-        const { sql, params } = builder.toUpdateSql(prepared.snakeTable, processed);
-
-        const executeRes = await this.execute(sql, params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async delData(options) {
-        validateTableWhereOptions(options, "delData", true);
-        const { table, where } = options;
-        const prepared = this.prepareSingleTableWhere(table, where, true);
-        const now = Date.now();
-        const processed = {
-            state: 0,
-            deleted_at: now
-        };
-
-        if (this.beflyMode === "auto") {
-            processed.updated_at = now;
-        }
-
-        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
-        const { sql, params } = builder.toUpdateSql(prepared.snakeTable, processed);
-        const executeRes = await this.execute(sql, params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async delForce(options) {
-        validateTableWhereOptions(options, "delForce", true);
-        const { table, where } = options;
-
-        const prepared = this.prepareSingleTableWhere(table, where, false);
-
-        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
-        const { sql, params } = builder.toDeleteSql(prepared.snakeTable);
-
-        const executeRes = await this.execute(sql, params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async disableData(options) {
-        validateTableWhereOptions(options, "disableData", true);
-        const { table, where } = options;
-
-        return await this.updData({
-            table: table,
-            data: {
-                state: 2
-            },
-            where: where
-        });
-    },
-
-    async enableData(options) {
-        validateTableWhereOptions(options, "enableData", true);
-        const { table, where } = options;
-
-        return await this.updData({
-            table: table,
-            data: {
-                state: 1
-            },
-            where: where
-        });
-    },
-
-    async increment(table, field, where, value = 1) {
-        validateIncrementOptions(table, field, where, value, "increment");
-        const prepared = this.prepareSingleTableWhere(table, where, true);
-        const snakeField = snakeCase(field);
-
-        const builder = this.createSqlBuilder().where(prepared.whereFiltered);
-        const { sql: whereClause, params: whereParams } = builder.getWhereConditions();
-
-        const quotedTable = quoteIdentMySql(prepared.snakeTable);
-        const quotedField = quoteIdentMySql(snakeField);
-        const sql = whereClause ? `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ? WHERE ${whereClause}` : `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ?`;
-
-        const params = [value];
-        for (const param of whereParams) {
-            params.push(param);
-        }
-
-        const executeRes = await this.execute(sql, params);
-        const changes = normalizeSqlMetaNumber(executeRes.data?.affectedRows);
-        return {
-            data: changes,
-            sql: executeRes.sql
-        };
-    },
-
-    async decrement(table, field, where, value = 1) {
-        return await this.increment(table, field, where, -value);
-    },
-
-    async trans(callback) {
-        const abortMark = "__beflyTransAbort";
-
-        if (this.isTransaction) {
-            const result = await callback(this);
-            if (result?.code !== undefined && result.code !== 0) {
-                const abortError = new Error("TRANSACTION_ABORT", {
-                    cause: null,
-                    code: "runtime"
-                });
-                abortError[abortMark] = true;
-                abortError.payload = result;
-                throw abortError;
-            }
-            return result;
-        }
-
-        if (typeof this.sql?.begin !== "function") {
-            throw new Error("不支持事务 begin() 方法", {
-                cause: null,
-                code: "runtime"
-            });
-        }
-
-        try {
-            return await this.sql.begin(async (tx) => {
-                const trans = new this.constructor({
-                    redis: this.redis,
-                    dbName: this.dbName,
-                    sql: tx,
-                    isTransaction: true,
-                    beflyMode: this.beflyMode
-                });
-                const result = await callback(trans);
-                if (result?.code !== undefined && result.code !== 0) {
-                    const abortError = new Error("TRANSACTION_ABORT", {
-                        cause: null,
-                        code: "runtime"
-                    });
-                    abortError[abortMark] = true;
-                    abortError.payload = result;
-                    throw abortError;
-                }
-                return result;
-            });
-        } catch (error) {
-            if (error && error[abortMark] === true) {
-                return error.payload;
-            }
-            throw error;
-        }
-    }
-};

package/lib/dbHelper/execute.js

@@ -1,128 +0,0 @@
-import { toSqlParams } from "../sqlBuilder/util.js";
-import { snakeCase } from "../../utils/util.js";
-import { validateExecuteSql } from "./validate.js";
-
-function safeStringify(value) {
-    try {
-        return JSON.stringify(value);
-    } catch {
-        try {
-            return String(value);
-        } catch {
-            return "[Unserializable]";
-        }
-    }
-}
-
-function getExecuteErrorMessage(error) {
-    if (error instanceof Error && typeof error.message === "string" && error.message.trim().length > 0) {
-        return error.message.trim();
-    }
-
-    if (!error || typeof error !== "object") {
-        return String(error);
-    }
-
-    const message = typeof error.message === "string" && error.message.trim().length > 0 ? error.message.trim() : typeof error.sqlMessage === "string" && error.sqlMessage.trim().length > 0 ? error.sqlMessage.trim() : "";
-    const detail = {};
-
-    if (typeof error.code === "string" && error.code.trim().length > 0) {
-        detail.code = error.code;
-    }
-    if (typeof error.errno === "number") {
-        detail.errno = error.errno;
-    }
-    if (typeof error.sqlState === "string" && error.sqlState.trim().length > 0) {
-        detail.sqlState = error.sqlState;
-    }
-    if (typeof error.sqlMessage === "string" && error.sqlMessage.trim().length > 0) {
-        detail.sqlMessage = error.sqlMessage;
-    }
-    if (typeof error.detail === "string" && error.detail.trim().length > 0) {
-        detail.detail = error.detail;
-    }
-
-    const detailText = Object.keys(detail).length > 0 ? safeStringify(detail) : safeStringify(error);
-    if (message && detailText && detailText !== "{}") {
-        return `${message} | ${detailText}`;
-    }
-    if (message) {
-        return message;
-    }
-    return detailText;
-}
-
-export const executeMethods = {
-    async execute(sql, params) {
-        if (!this.sql) {
-            throw new Error("数据库连接未初始化", {
-                cause: null,
-                code: "runtime"
-            });
-        }
-
-        validateExecuteSql(sql);
-
-        const startTime = Date.now();
-        const safeParams = toSqlParams(params);
-
-        try {
-            let queryResult;
-            // Bun 事件循环 bug workaround：
-            // 当事件循环中只有一个 I/O 源（SQL socket）时，Bun 会走单源快速路径，
-            // 在 I/O 回调内直接唤醒 JS Promise，跳过正常调度，导致 SQL 连接状态
-            // 未完全重置，下一条查询的 Promise resolver 永久丢失（远程 TCP 连接必现）。
-            // 预注册一个 timer 使事件循环中同时存在两种事件源，强制 Bun 走正常多源调度路径。
-            // timer 时长无关紧要，查询完成后会被 clearTimeout 清理。
-            const _timer = setTimeout(() => {}, 2147483647);
-            const queryPromise = safeParams.length > 0 ? this.sql.unsafe(sql, safeParams) : this.sql.unsafe(sql);
-            try {
-                queryResult = await queryPromise;
-            } finally {
-                clearTimeout(_timer);
-            }
-
-            const duration = Date.now() - startTime;
-
-            return {
-                data: queryResult,
-                sql: {
-                    sql: sql,
-                    params: safeParams,
-                    duration: duration
-                }
-            };
-        } catch (error) {
-            const duration = Date.now() - startTime;
-            const msg = getExecuteErrorMessage(error);
-            const sqlInfo = {
-                sql: sql,
-                params: safeParams,
-                duration: duration
-            };
-            const wrappedError = new Error(`SQL执行失败: ${msg}`, {
-                cause: error
-            });
-
-            wrappedError.code = "runtime";
-            wrappedError.subsystem = "sql";
-            wrappedError.operation = "execute";
-            wrappedError.params = safeParams;
-            wrappedError.duration = duration;
-            wrappedError.sqlInfo = sqlInfo;
-
-            throw wrappedError;
-        }
-    },
-
-    async tableExists(tableName) {
-        const snakeTableName = snakeCase(tableName);
-        const executeRes = await this.execute("SELECT COUNT(*) as count FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?", [snakeTableName]);
-        const exists = (executeRes.data?.[0]?.count || 0) > 0;
-
-        return {
-            data: exists,
-            sql: executeRes.sql
-        };
-    }
-};