befly 3.20.10 → 3.21.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.20.10",
-    "gitHead": "6cffd9804b01481592d2a4e0eea31db3dbe30854",
+    "version": "3.21.0",
+    "gitHead": "bdc30cd18f3fe6a692d170ae2146ca9ba4e62edc",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
     "keywords": [
@@ -52,8 +52,8 @@
         "test": "bun test"
     },
     "dependencies": {
-        "fast-xml-parser": "^5.5.8",
-        "nodemailer": "^8.0.2",
+        "fast-xml-parser": "^5.5.9",
+        "nodemailer": "^8.0.4",
         "pathe": "^2.0.3",
         "ua-parser-js": "^2.0.9",
         "zod": "^4.0.0"

package/plugins/mysql.js

@@ -4,7 +4,7 @@
  */
 
 import { Connect } from "../lib/connect.js";
-import { DbHelper } from "../lib/dbHelper/index.js";
+import { DbHelper } from "../lib/dbHelper.js";
 import { Logger } from "../lib/logger.js";
 
 /**

package/scripts/syncDb/context.js

@@ -2,7 +2,7 @@ import { mkdir } from "node:fs/promises";
 import { basename, resolve, join } from "node:path";
 
 import { Connect } from "../../lib/connect.js";
-import { DbHelper } from "../../lib/dbHelper/index.js";
+import { DbHelper } from "../../lib/dbHelper.js";
 import { Logger } from "../../lib/logger.js";
 import { importDefault } from "../../utils/importDefault.js";
 import { isNonEmptyString, isPlainObject } from "../../utils/is.js";

package/lib/dbHelper/builders.js

@@ -1,658 +0,0 @@
-import { fieldClear } from "../../utils/fieldClear.js";
-import { isFiniteNumber, isNonEmptyString, isNullable, isPlainObject, isString } from "../../utils/is.js";
-import { arrayKeysToCamel, keysToCamel, keysToSnake, snakeCase } from "../../utils/util.js";
-import { SqlBuilder } from "../sqlBuilder/index.js";
-import { getJoinMainQualifier, normalizeBigIntValues, normalizeTableRef, quoteIdentMySql } from "./util.js";
-import { assertNoExprField, validateAndClassifyFields, validateExcludeFieldsResult, validateQueryOptions, validateTimeIdValue } from "./validate.js";
-
-function shouldExcludeFieldValue(key, value, excludeValueMap) {
-    if (!isPlainObject(excludeValueMap)) {
-        return false;
-    }
-
-    const excludeValues = excludeValueMap[key];
-    if (!Array.isArray(excludeValues) || excludeValues.length === 0) {
-        return false;
-    }
-
-    for (const excludeValue of excludeValues) {
-        if (Object.is(value, excludeValue)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-function mergeExcludeValueMap(parentMap, currentMap) {
-    if (!isPlainObject(parentMap) && !isPlainObject(currentMap)) {
-        return null;
-    }
-
-    const result = {};
-    if (isPlainObject(parentMap)) {
-        for (const [key, value] of Object.entries(parentMap)) {
-            result[key] = value;
-        }
-    }
-    if (isPlainObject(currentMap)) {
-        for (const [key, value] of Object.entries(currentMap)) {
-            result[key] = value;
-        }
-    }
-
-    return result;
-}
-
-export function clearDeep(value, options) {
-    const arrayObjectKeys = Array.isArray(options?.arrayObjectKeys) ? options.arrayObjectKeys : ["$or", "$and"];
-    const arrayObjectKeySet = new Set();
-    for (const key of arrayObjectKeys) {
-        arrayObjectKeySet.add(key);
-    }
-
-    const depthRaw = isFiniteNumber(options?.depth) ? Math.floor(options.depth) : 0;
-    const depth = depthRaw < 0 ? 0 : depthRaw;
-
-    const clearInternal = (input, remainingDepth, inheritedExcludeValueMap) => {
-        if (!input || typeof input !== "object") {
-            return input;
-        }
-
-        if (Array.isArray(input)) {
-            return input;
-        }
-
-        const canRecurse = remainingDepth === 0 || remainingDepth > 1;
-        const childDepth = remainingDepth === 0 ? 0 : remainingDepth - 1;
-        const result = {};
-        const currentExcludeValueMap = mergeExcludeValueMap(inheritedExcludeValueMap, input.$exclude);
-
-        for (const [key, item] of Object.entries(input)) {
-            if (key === "$exclude") {
-                continue;
-            }
-
-            if (isNullable(item)) {
-                continue;
-            }
-
-            if (shouldExcludeFieldValue(key, item, currentExcludeValueMap)) {
-                continue;
-            }
-
-            if (arrayObjectKeySet.has(key)) {
-                if (!Array.isArray(item)) {
-                    continue;
-                }
-
-                const outList = [];
-                for (const child of item) {
-                    if (!child || typeof child !== "object" || Array.isArray(child)) {
-                        continue;
-                    }
-                    const cleaned = clearInternal(child, remainingDepth, currentExcludeValueMap);
-                    if (!cleaned || typeof cleaned !== "object" || Array.isArray(cleaned)) {
-                        continue;
-                    }
-                    if (Object.keys(cleaned).length === 0) {
-                        continue;
-                    }
-                    outList.push(cleaned);
-                }
-
-                if (outList.length > 0) {
-                    result[key] = outList;
-                }
-                continue;
-            }
-
-            if (typeof item === "object" && !Array.isArray(item)) {
-                if (!canRecurse) {
-                    result[key] = item;
-                    continue;
-                }
-
-                const cleanedObj = clearInternal(item, childDepth, currentExcludeValueMap);
-                if (!cleanedObj || typeof cleanedObj !== "object" || Array.isArray(cleanedObj)) {
-                    continue;
-                }
-                if (Object.keys(cleanedObj).length === 0) {
-                    continue;
-                }
-                result[key] = cleanedObj;
-                continue;
-            }
-
-            result[key] = item;
-        }
-
-        return result;
-    };
-
-    return clearInternal(value, depth, options?.excludeValueMap);
-}
-
-export async function fieldsToSnake(table, fields, getTableColumns) {
-    if (!fields || !Array.isArray(fields)) {
-        return ["*"];
-    }
-
-    const classified = validateAndClassifyFields(fields);
-    if (classified.type === "all") {
-        return ["*"];
-    }
-    if (classified.type === "include") {
-        return classified.fields.map((field) => processJoinField(field));
-    }
-    if (classified.type === "exclude") {
-        const allColumns = await getTableColumns(table);
-        const excludeSnakeFields = classified.fields.map((f) => snakeCase(f));
-        const resultFields = allColumns.filter((col) => !excludeSnakeFields.includes(col));
-        validateExcludeFieldsResult(resultFields, table, excludeSnakeFields);
-        return resultFields;
-    }
-    return ["*"];
-}
-
-export function orderByToSnake(orderBy) {
-    return normalizeOrderBy(orderBy, (field) => snakeCase(field));
-}
-
-function normalizeQualifierField(field) {
-    const parts = field.split(".");
-    if (parts.length === 1) {
-        return snakeCase(field);
-    }
-
-    const fieldName = parts[parts.length - 1].trim();
-    const qualifier = parts
-        .slice(0, parts.length - 1)
-        .map((item) => snakeCase(item.trim()))
-        .join(".");
-
-    if (fieldName === "*") {
-        return `${qualifier}.*`;
-    }
-
-    return `${qualifier}.${snakeCase(fieldName)}`;
-}
-
-function normalizeOrderBy(orderBy, mapField) {
-    if (!orderBy || !Array.isArray(orderBy)) {
-        return orderBy;
-    }
-
-    return orderBy.map((item) => {
-        if (!isString(item) || !item.includes("#")) {
-            return item;
-        }
-
-        const parts = item.split("#");
-        if (parts.length !== 2) {
-            return item;
-        }
-
-        return `${mapField(parts[0].trim())}#${parts[1].trim()}`;
-    });
-}
-
-function mapWhereKeys(where, mapKey) {
-    if (!where || typeof where !== "object") {
-        return where;
-    }
-    if (Array.isArray(where)) {
-        return where.map((item) => mapWhereKeys(item, mapKey));
-    }
-
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        if (key === "$or" || key === "$and") {
-            result[key] = Array.isArray(value) ? value.map((item) => mapWhereKeys(item, mapKey)) : [];
-            continue;
-        }
-
-        const normalizedKey = mapKey(key);
-        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-            result[normalizedKey] = mapWhereKeys(value, mapKey);
-            continue;
-        }
-
-        result[normalizedKey] = value;
-    }
-
-    return result;
-}
-
-export function processJoinField(field) {
-    assertNoExprField(field);
-    if (field === "*" || field.startsWith("`")) {
-        return field;
-    }
-
-    if (field.toUpperCase().includes(" AS ")) {
-        const parts = field.split(/\s+AS\s+/i);
-        const fieldPart = parts[0];
-        const aliasPart = parts[1];
-        if (!isString(fieldPart) || !isString(aliasPart)) {
-            return field;
-        }
-        return `${processJoinField(fieldPart.trim())} AS ${aliasPart.trim()}`;
-    }
-
-    return normalizeQualifierField(field);
-}
-
-function processJoinWhereKey(key) {
-    if (key === "$or" || key === "$and") {
-        return key;
-    }
-
-    assertNoExprField(key);
-    if (key.includes("$")) {
-        const lastDollarIndex = key.lastIndexOf("$");
-        const fieldPart = key.substring(0, lastDollarIndex);
-        const operator = key.substring(lastDollarIndex);
-
-        return `${normalizeQualifierField(fieldPart)}${operator}`;
-    }
-
-    return normalizeQualifierField(key);
-}
-
-export function processJoinWhere(where) {
-    return mapWhereKeys(where, processJoinWhereKey);
-}
-
-export function processJoinOrderBy(orderBy) {
-    return normalizeOrderBy(orderBy, processJoinField);
-}
-
-export function parseLeftJoinItem(joinTable, joinItem) {
-    const parts = joinItem.split(" ");
-    return {
-        type: "left",
-        table: normalizeTableRef(joinTable),
-        on: processJoinOn(`${parts[0]} = ${parts[1]}`)
-    };
-}
-
-export function processJoinOn(on) {
-    if (!isString(on)) {
-        return String(on);
-    }
-
-    const raw = String(on);
-    if (!isNonEmptyString(raw)) {
-        return raw;
-    }
-
-    const replaceSegment = (segment) => {
-        return segment.replace(/([a-zA-Z_][a-zA-Z0-9_]*)(\s*\.\s*)([a-zA-Z_][a-zA-Z0-9_]*)/g, (_match, left, dot, right) => {
-            return `${snakeCase(left)}${dot}${snakeCase(right)}`;
-        });
-    };
-
-    let result = "";
-    let buffer = "";
-    let quote = null;
-    let prev = "";
-
-    for (const ch of raw) {
-        if (quote) {
-            result += ch;
-            if (ch === quote && prev !== "\\") {
-                quote = null;
-            }
-            prev = ch;
-            continue;
-        }
-
-        if (ch === "'" || ch === '"' || ch === "`") {
-            if (buffer.length > 0) {
-                result += replaceSegment(buffer);
-                buffer = "";
-            }
-            quote = ch;
-            result += ch;
-            prev = ch;
-            continue;
-        }
-
-        buffer += ch;
-        prev = ch;
-    }
-
-    if (buffer.length > 0) {
-        result += replaceSegment(buffer);
-    }
-
-    return result;
-}
-
-export function addDefaultStateFilter(where = {}, table, hasLeftJoin = false, beflyMode = "auto") {
-    if (beflyMode === "manual") {
-        return where;
-    }
-
-    const hasStateCondition = Object.keys(where).some((key) => key.startsWith("state") || key.includes(".state"));
-    if (hasStateCondition) {
-        return where;
-    }
-
-    if (hasLeftJoin && table) {
-        const result = {};
-        for (const [key, value] of Object.entries(where)) {
-            result[key] = value;
-        }
-        result[`${table}.state$gt`] = 0;
-        return result;
-    }
-
-    const result = {};
-    for (const [key, value] of Object.entries(where)) {
-        result[key] = value;
-    }
-    result.state$gt = 0;
-    return result;
-}
-
-export function whereKeysToSnake(where) {
-    return mapWhereKeys(where, (key) => {
-        assertNoExprField(key);
-        if (key.includes("$")) {
-            const lastDollarIndex = key.lastIndexOf("$");
-            const fieldName = key.substring(0, lastDollarIndex);
-            const operator = key.substring(lastDollarIndex);
-            return `${snakeCase(fieldName)}${operator}`;
-        }
-
-        return snakeCase(key);
-    });
-}
-
-function serializeArrayFields(data) {
-    const serialized = {};
-    for (const [key, value] of Object.entries(data)) {
-        if (isNullable(value)) {
-            serialized[key] = value;
-            continue;
-        }
-        if (Array.isArray(value)) {
-            serialized[key] = JSON.stringify(value);
-            continue;
-        }
-        serialized[key] = value;
-    }
-    return serialized;
-}
-
-export function deserializeArrayFields(data) {
-    if (!data) {
-        return null;
-    }
-    const deserialized = {};
-    for (const [key, value] of Object.entries(data)) {
-        deserialized[key] = value;
-    }
-
-    for (const [key, value] of Object.entries(deserialized)) {
-        if (!isString(value)) {
-            continue;
-        }
-        if (value.startsWith("[") && value.endsWith("]")) {
-            try {
-                const parsed = JSON.parse(value);
-                if (Array.isArray(parsed)) {
-                    deserialized[key] = parsed;
-                }
-            } catch {
-                continue;
-            }
-        }
-    }
-
-    return deserialized;
-}
-
-function cleanAndSnakeAndSerializeWriteData(data, excludeValues = [null, undefined]) {
-    const cleanData = fieldClear(data, { excludeValues: excludeValues });
-    const snakeData = keysToSnake(cleanData);
-    return serializeArrayFields(snakeData);
-}
-
-function cloneRecord(record) {
-    const result = {};
-    for (const [key, value] of Object.entries(record)) {
-        result[key] = value;
-    }
-    return result;
-}
-
-function prepareWriteUserData(data, allowState) {
-    const serializedData = cleanAndSnakeAndSerializeWriteData(data);
-    return stripSystemFieldsForWrite(serializedData, { allowState: allowState });
-}
-
-function stripSystemFieldsForWrite(data, options) {
-    const result = {};
-    for (const [key, value] of Object.entries(data)) {
-        if (key === "id") continue;
-        if (key === "created_at") continue;
-        if (key === "updated_at") continue;
-        if (key === "deleted_at") continue;
-        if (!options.allowState && key === "state") continue;
-        result[key] = value;
-    }
-    return result;
-}
-
-export function buildInsertRow(options) {
-    const result = cloneRecord(prepareWriteUserData(options.data, false));
-
-    if (options.beflyMode === "auto") {
-        validateTimeIdValue(options.id);
-        result["id"] = options.id;
-    }
-
-    if (options.beflyMode !== "manual") {
-        result["created_at"] = options.now;
-        result["updated_at"] = options.now;
-        result["state"] = 1;
-    }
-    return result;
-}
-
-export function buildUpdateRow(options) {
-    const result = cloneRecord(prepareWriteUserData(options.data, options.allowState));
-    if (options.beflyMode !== "manual") {
-        result["updated_at"] = options.now;
-    }
-    return result;
-}
-
-export function buildPartialUpdateData(options) {
-    return prepareWriteUserData(options.data, options.allowState);
-}
-
-export const builderMethods = {
-    createSqlBuilder() {
-        return new SqlBuilder({ quoteIdent: quoteIdentMySql });
-    },
-
-    createListBuilder(prepared, whereFiltered, limit, offset) {
-        const builder = this.createSqlBuilder().select(prepared.fields).from(prepared.table).where(whereFiltered).limit(limit);
-        this.applyLeftJoins(builder, prepared.leftJoins);
-        if (!isNullable(offset)) {
-            builder.offset(offset);
-        }
-        if (prepared.orderBy && prepared.orderBy.length > 0) {
-            builder.orderBy(prepared.orderBy);
-        }
-        return builder;
-    },
-
-    async fetchCount(prepared, whereFiltered, alias) {
-        const builder = this.createSqlBuilder().selectRaw(alias).from(prepared.table).where(whereFiltered);
-        this.applyLeftJoins(builder, prepared.leftJoins);
-        const result = builder.toSelectSql();
-        const executeRes = await this.execute(result.sql, result.params);
-        const countRow = executeRes.data?.[0] || null;
-        const normalizedCountRow = countRow ? normalizeBigIntValues(countRow) : null;
-        const total = normalizedCountRow?.total ?? normalizedCountRow?.count ?? 0;
-        return {
-            total: total,
-            sql: executeRes.sql
-        };
-    },
-
-    normalizeRowData(row) {
-        if (!row) {
-            return {};
-        }
-
-        const camelRow = keysToCamel(row);
-        const deserialized = deserializeArrayFields(camelRow);
-        if (!deserialized) {
-            return {};
-        }
-
-        const convertedList = normalizeBigIntValues([deserialized]);
-        if (convertedList && convertedList.length > 0) {
-            return convertedList[0];
-        }
-
-        return deserialized;
-    },
-
-    normalizeListData(list) {
-        const camelList = arrayKeysToCamel(list);
-        const deserializedList = camelList.map((item) => deserializeArrayFields(item)).filter((item) => item !== null);
-        return normalizeBigIntValues(deserializedList);
-    },
-
-    normalizeLeftJoinOptions(options, cleanWhere) {
-        const processedFields = (options.fields || []).map((field) => processJoinField(field));
-        const mainTableRef = options.table[0];
-        const joinTableRefs = options.table.slice(1);
-        const normalizedTableRef = normalizeTableRef(mainTableRef);
-        const mainQualifier = getJoinMainQualifier(mainTableRef);
-        const leftJoins = options.leftJoin.map((joinItem, index) => parseLeftJoinItem(joinTableRefs[index], joinItem));
-
-        return {
-            table: normalizedTableRef,
-            tableQualifier: mainQualifier,
-            fields: processedFields.length > 0 ? processedFields : ["*"],
-            where: processJoinWhere(cleanWhere),
-            leftJoins: leftJoins,
-            orderBy: processJoinOrderBy(options.orderBy || []),
-            page: options.page || 1,
-            limit: options.limit || 10
-        };
-    },
-
-    async normalizeSingleTableOptions(options, cleanWhere) {
-        const tableRef = Array.isArray(options.table) ? options.table[0] : options.table;
-        const snakeTable = snakeCase(tableRef);
-        const processedFields = await fieldsToSnake(snakeTable, options.fields || [], this.getTableColumns.bind(this));
-
-        return {
-            table: snakeTable,
-            tableQualifier: snakeTable,
-            fields: processedFields,
-            where: whereKeysToSnake(cleanWhere),
-            leftJoins: [],
-            orderBy: orderByToSnake(options.orderBy || []),
-            page: options.page || 1,
-            limit: options.limit || 10
-        };
-    },
-
-    buildQueryOptions(options, defaults) {
-        const output = {
-            table: options.table,
-            page: defaults.page,
-            limit: defaults.limit
-        };
-
-        if (options.fields !== undefined) output.fields = options.fields;
-        if (options.where !== undefined) output.where = options.where;
-        if (options.leftJoin !== undefined) output.leftJoin = options.leftJoin;
-        if (options.orderBy !== undefined) output.orderBy = options.orderBy;
-        return output;
-    },
-
-    resolveFieldValue(record, field) {
-        if (!isPlainObject(record)) {
-            return null;
-        }
-
-        if (Object.hasOwn(record, field)) {
-            return record[field];
-        }
-
-        const camelField = field.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-        if (camelField !== field && Object.hasOwn(record, camelField)) {
-            return record[camelField];
-        }
-
-        const snakeField = field.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-        if (snakeField !== field && Object.hasOwn(record, snakeField)) {
-            return record[snakeField];
-        }
-
-        return null;
-    },
-
-    async getTableColumns(table) {
-        const quotedTable = quoteIdentMySql(table);
-        const executeRes = await this.execute(`SHOW COLUMNS FROM ${quotedTable}`, []);
-        const result = executeRes.data;
-
-        if (!result || result.length === 0) {
-            throw new Error(`表 ${table} 不存在或没有字段`, {
-                cause: null,
-                code: "runtime"
-            });
-        }
-
-        const columnNames = [];
-        for (const row of result) {
-            const record = row;
-            const name = record["Field"];
-            if (isNonEmptyString(name)) {
-                columnNames.push(name);
-            }
-        }
-
-        return columnNames;
-    },
-
-    async prepareQueryOptions(options, label = "queryOptions") {
-        validateQueryOptions(options, label);
-        const cleanWhere = clearDeep(options.where || {});
-        const hasLeftJoin = Array.isArray(options.leftJoin) && options.leftJoin.length > 0;
-
-        if (hasLeftJoin) {
-            return this.normalizeLeftJoinOptions(options, cleanWhere);
-        }
-
-        return await this.normalizeSingleTableOptions(options, cleanWhere);
-    },
-
-    async prepareReadContext(options, label = "queryOptions") {
-        const prepared = await this.prepareQueryOptions(options, label);
-        return {
-            prepared: prepared,
-            whereFiltered: addDefaultStateFilter(prepared.where, prepared.tableQualifier, prepared.leftJoins.length > 0, this.beflyMode)
-        };
-    },
-
-    applyLeftJoins(builder, leftJoins) {
-        if (!leftJoins || leftJoins.length === 0) return;
-
-        for (const join of leftJoins) {
-            builder.leftJoin(join.table, join.on);
-        }
-    }
-};