befly 3.17.0 → 3.17.3

package/lib/dbHelper/builders.js

@@ -0,0 +1,698 @@
+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 { convertBigIntFields, quoteIdentMySql } from "./context.js";
+import { getJoinMainQualifier, normalizeTableRef } from "./util.js";
+import { assertNoExprField, validateAndClassifyFields, validateExcludeFieldsResult, validateQueryOptions, validateTimeIdValue } from "./validate.js";
+
+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) => {
+        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 = {};
+
+        for (const [key, item] of Object.entries(input)) {
+            if (isNullable(item)) {
+                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);
+                    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);
+                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);
+}
+
+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) {
+    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;
+        }
+
+        const field = parts[0];
+        const direction = parts[1];
+        if (!isString(field) || !isString(direction)) {
+            return item;
+        }
+
+        return `${snakeCase(field.trim())}#${direction.trim()}`;
+    });
+}
+
+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()}`;
+    }
+
+    if (field.includes(".")) {
+        const parts = field.split(".");
+        if (parts.length < 2) {
+            return snakeCase(field);
+        }
+        if (parts.some((p) => !isNonEmptyString(p))) {
+            return field;
+        }
+
+        const fieldName = parts[parts.length - 1];
+        const tableName = parts.slice(0, parts.length - 1).join(".");
+        if (!isString(fieldName) || !isString(tableName)) {
+            return snakeCase(field);
+        }
+
+        const normalizedTableName = tableName
+            .split(".")
+            .map((item) => {
+                const trimmed = item.trim();
+                if (!trimmed) {
+                    return trimmed;
+                }
+                return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
+            })
+            .join(".");
+
+        return `${normalizedTableName}.${snakeCase(fieldName)}`;
+    }
+
+    return snakeCase(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);
+
+        if (fieldPart.includes(".")) {
+            const parts = fieldPart.split(".");
+            if (parts.length < 2) {
+                return `${snakeCase(fieldPart)}${operator}`;
+            }
+            if (parts.some((p) => !isNonEmptyString(p))) {
+                return `${snakeCase(fieldPart)}${operator}`;
+            }
+
+            const fieldName = parts[parts.length - 1];
+            const tableName = parts.slice(0, parts.length - 1).join(".");
+            if (!isString(fieldName) || !isString(tableName)) {
+                return `${snakeCase(fieldPart)}${operator}`;
+            }
+
+            const normalizedTableName = tableName
+                .split(".")
+                .map((item) => {
+                    const trimmed = item.trim();
+                    if (!trimmed) {
+                        return trimmed;
+                    }
+                    return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
+                })
+                .join(".");
+            return `${normalizedTableName}.${snakeCase(fieldName)}${operator}`;
+        }
+
+        return `${snakeCase(fieldPart)}${operator}`;
+    }
+
+    if (key.includes(".")) {
+        const parts = key.split(".");
+        if (parts.length < 2) {
+            return snakeCase(key);
+        }
+        if (parts.some((p) => !isNonEmptyString(p))) {
+            return snakeCase(key);
+        }
+
+        const fieldName = parts[parts.length - 1];
+        const tableName = parts.slice(0, parts.length - 1).join(".");
+        if (!isString(fieldName) || !isString(tableName)) {
+            return snakeCase(key);
+        }
+
+        const normalizedTableName = tableName
+            .split(".")
+            .map((item) => {
+                const trimmed = item.trim();
+                if (!trimmed) {
+                    return trimmed;
+                }
+                return /[A-Z]/.test(trimmed) ? snakeCase(trimmed) : trimmed;
+            })
+            .join(".");
+        return `${normalizedTableName}.${snakeCase(fieldName)}`;
+    }
+
+    return snakeCase(key);
+}
+
+export function processJoinWhere(where) {
+    if (!where || typeof where !== "object") {
+        return where;
+    }
+    if (Array.isArray(where)) {
+        return where.map((item) => processJoinWhere(item));
+    }
+
+    const result = {};
+    for (const [key, value] of Object.entries(where)) {
+        const newKey = processJoinWhereKey(key);
+        if (key === "$or" || key === "$and") {
+            result[newKey] = Array.isArray(value) ? value.map((item) => processJoinWhere(item)) : [];
+        } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            result[newKey] = processJoinWhere(value);
+        } else {
+            result[newKey] = value;
+        }
+    }
+
+    return result;
+}
+
+export function processJoinOrderBy(orderBy) {
+    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;
+        }
+
+        const field = parts[0];
+        const direction = parts[1];
+        if (!isString(field) || !isString(direction)) {
+            return item;
+        }
+
+        return `${processJoinField(field.trim())}#${direction.trim()}`;
+    });
+}
+
+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, hasJoins = false) {
+    const hasStateCondition = Object.keys(where).some((key) => key.startsWith("state") || key.includes(".state"));
+    if (hasStateCondition) {
+        return where;
+    }
+
+    if (hasJoins && 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) {
+    if (!where || typeof where !== "object") {
+        return where;
+    }
+    if (Array.isArray(where)) {
+        return where.map((item) => whereKeysToSnake(item));
+    }
+
+    const result = {};
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "$or" || key === "$and") {
+            result[key] = Array.isArray(value) ? value.map((item) => whereKeysToSnake(item)) : [];
+            continue;
+        }
+
+        assertNoExprField(key);
+        if (key.includes("$")) {
+            const lastDollarIndex = key.lastIndexOf("$");
+            const fieldName = key.substring(0, lastDollarIndex);
+            const operator = key.substring(lastDollarIndex);
+            result[snakeCase(fieldName) + operator] = value;
+            continue;
+        }
+
+        const snakeKey = snakeCase(key);
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            result[snakeKey] = whereKeysToSnake(value);
+        } else {
+            result[snakeKey] = value;
+        }
+    }
+
+    return result;
+}
+
+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 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 serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
+    const userData = stripSystemFieldsForWrite(serializedData, { allowState: false });
+
+    const result = {};
+    for (const [key, value] of Object.entries(userData)) {
+        result[key] = value;
+    }
+
+    if (options.idMode === "timeId") {
+        validateTimeIdValue(options.id);
+        result["id"] = options.id;
+    }
+
+    result["created_at"] = options.now;
+    result["updated_at"] = options.now;
+    result["state"] = 1;
+    return result;
+}
+
+export function buildUpdateRow(options) {
+    const serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
+    const userData = stripSystemFieldsForWrite(serializedData, { allowState: options.allowState });
+
+    const result = {};
+    for (const [key, value] of Object.entries(userData)) {
+        result[key] = value;
+    }
+    result["updated_at"] = options.now;
+    return result;
+}
+
+export function buildPartialUpdateData(options) {
+    const serializedData = cleanAndSnakeAndSerializeWriteData(options.data);
+    return stripSystemFieldsForWrite(serializedData, { allowState: 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.applyJoins(builder, prepared.joins);
+        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.applyJoins(builder, prepared.joins);
+        const result = builder.toSelectSql();
+        const executeRes = await this.execute(result.sql, result.params);
+        const total = executeRes.data?.[0]?.total || executeRes.data?.[0]?.count || 0;
+        return {
+            total: total,
+            sql: executeRes.sql
+        };
+    },
+
+    normalizeRowData(row, bigintFields) {
+        if (!row) {
+            return {};
+        }
+
+        const camelRow = keysToCamel(row);
+        const deserialized = deserializeArrayFields(camelRow);
+        if (!deserialized) {
+            return {};
+        }
+
+        const convertedList = convertBigIntFields([deserialized], bigintFields);
+        if (convertedList && convertedList.length > 0) {
+            return convertedList[0];
+        }
+
+        return deserialized;
+    },
+
+    normalizeListData(list, bigintFields) {
+        const camelList = arrayKeysToCamel(list);
+        const deserializedList = camelList.map((item) => deserializeArrayFields(item)).filter((item) => item !== null);
+        return convertBigIntFields(deserializedList, bigintFields);
+    },
+
+    normalizeJoinOptions(options, cleanWhere) {
+        const processedFields = (options.fields || []).map((field) => processJoinField(field));
+        const normalizedTableRef = normalizeTableRef(options.table);
+        const mainQualifier = getJoinMainQualifier(options.table);
+
+        return {
+            table: normalizedTableRef,
+            tableQualifier: mainQualifier,
+            fields: processedFields.length > 0 ? processedFields : ["*"],
+            where: processJoinWhere(cleanWhere),
+            joins: options.joins,
+            orderBy: processJoinOrderBy(options.orderBy || []),
+            page: options.page || 1,
+            limit: options.limit || 10
+        };
+    },
+
+    async normalizeSingleTableOptions(options, cleanWhere) {
+        const snakeTable = snakeCase(options.table);
+        const processedFields = await fieldsToSnake(snakeTable, options.fields || [], this.getTableColumns.bind(this));
+
+        return {
+            table: snakeTable,
+            tableQualifier: snakeTable,
+            fields: processedFields,
+            where: whereKeysToSnake(cleanWhere),
+            joins: undefined,
+            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.bigint !== undefined) output.bigint = options.bigint;
+        if (options.where !== undefined) output.where = options.where;
+        if (options.joins !== undefined) output.joins = options.joins;
+        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 hasJoins = options.joins && options.joins.length > 0;
+
+        if (hasJoins) {
+            return this.normalizeJoinOptions(options, cleanWhere);
+        }
+
+        return await this.normalizeSingleTableOptions(options, cleanWhere);
+    },
+
+    applyJoins(builder, joins) {
+        if (!joins || joins.length === 0) return;
+
+        for (const join of joins) {
+            const processedTable = normalizeTableRef(join.table);
+            const processedOn = processJoinOn(join.on);
+            const type = join.type || "left";
+
+            switch (type) {
+                case "inner":
+                    builder.innerJoin(processedTable, processedOn);
+                    break;
+                case "right":
+                    builder.rightJoin(processedTable, processedOn);
+                    break;
+                case "left":
+                default:
+                    builder.leftJoin(processedTable, processedOn);
+                    break;
+            }
+        }
+    }
+};