befly 3.16.2 → 3.16.5

package/dist/befly.js

@@ -1405,7 +1405,7 @@ function normalizeViewDirMeta(input) {
     return null;
   }
   const orderRaw = record["order"];
-  const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) && Number.isInteger(orderRaw) && orderRaw >= 0 ? orderRaw : undefined;
+  const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) && Number.isInteger(orderRaw) && orderRaw >= 1 ? orderRaw : undefined;
   if (order === undefined) {
     return {
       title
@@ -13921,56 +13921,8 @@ var configPlugin = {
 };
 var config_default = configPlugin;
 
-// utils/convertBigIntFields.ts
-function convertBigIntFields(arr, fields = ["id", "pid", "sort"]) {
-  if (arr === null || arr === undefined) {
-    return arr;
-  }
-  const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
-  const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
-  const convertRecord = (source) => {
-    const converted = {};
-    for (const [key, value] of Object.entries(source)) {
-      converted[key] = value;
-    }
-    for (const [key, value] of Object.entries(converted)) {
-      if (value === undefined || value === null) {
-        continue;
-      }
-      const shouldConvert = fields.includes(key) || key.endsWith("Id") || key.endsWith("_id") || key.endsWith("At") || key.endsWith("_at");
-      if (!shouldConvert) {
-        continue;
-      }
-      let bigintValue = null;
-      if (typeof value === "bigint") {
-        bigintValue = value;
-      } else if (typeof value === "string") {
-        if (!/^-?\d+$/.test(value)) {
-          continue;
-        }
-        try {
-          bigintValue = BigInt(value);
-        } catch {
-          continue;
-        }
-      } else {
-        continue;
-      }
-      if (bigintValue > MAX_SAFE_INTEGER_BIGINT || bigintValue < MIN_SAFE_INTEGER_BIGINT) {
-        throw new Error(`BIGINT \u5B57\u6BB5\u8D85\u51FA JS \u5B89\u5168\u6574\u6570\u8303\u56F4\uFF0C\u8BF7\u6539\u7528 bigint/string \u6216\u8C03\u6574\u5B57\u6BB5\u8BBE\u8BA1 (field: ${key}, value: ${String(value)})`);
-      }
-      converted[key] = Number(bigintValue);
-    }
-    return converted;
-  };
-  if (Array.isArray(arr)) {
-    return arr.map((item) => convertRecord(item));
-  }
-  if (typeof arr === "object") {
-    return convertRecord(arr);
-  }
-  return arr;
-}
+// lib/dbHelper.ts
+init_util();
 
 // utils/fieldClear.ts
 function isObject(val) {
@@ -14022,9 +13974,6 @@ function fieldClear(data, options = {}) {
   return data;
 }
 
-// lib/dbHelper.ts
-init_util();
-
 // lib/dbUtils.ts
 init_util();
 
@@ -14137,6 +14086,73 @@ class SqlCheck {
 
 // lib/dbUtils.ts
 class DbUtils {
+  static 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 = typeof options?.depth === "number" && Number.isFinite(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 (item === undefined || item === null) {
+          continue;
+        }
+        if (arrayObjectKeySet.has(key)) {
+          if (!Array.isArray(item)) {
+            continue;
+          }
+          const arrayChildDepth = remainingDepth;
+          const outList = [];
+          for (const child of item) {
+            if (!child || typeof child !== "object" || Array.isArray(child)) {
+              continue;
+            }
+            const cleaned = clearInternal(child, arrayChildDepth);
+            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);
+  }
   static parseTableRef(tableRef) {
     if (typeof tableRef !== "string") {
       throw new Error(`tableRef \u5FC5\u987B\u662F\u5B57\u7B26\u4E32 (tableRef: ${String(tableRef)})`);
@@ -15283,6 +15299,72 @@ class DbHelper {
   sql = null;
   isTransaction = false;
   idMode;
+  static convertBigIntFields(arr, fields) {
+    if (arr === null || arr === undefined) {
+      return arr;
+    }
+    const defaultFields = ["id", "pid", "sort"];
+    const buildFields = (userFields) => {
+      if (!userFields || userFields.length === 0) {
+        return defaultFields;
+      }
+      const merged = ["id", "pid", "sort"];
+      for (const f of userFields) {
+        if (typeof f !== "string") {
+          continue;
+        }
+        const trimmed = f.trim();
+        if (trimmed.length === 0) {
+          continue;
+        }
+        if (!merged.includes(trimmed)) {
+          merged.push(trimmed);
+        }
+      }
+      return merged;
+    };
+    const effectiveFields = buildFields(fields);
+    const fieldSet = new Set(effectiveFields);
+    const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+    const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+    const convertRecord = (source) => {
+      const converted = {};
+      for (const [key, value] of Object.entries(source)) {
+        let nextValue = value;
+        if (value !== undefined && value !== null) {
+          const shouldConvert = fieldSet.has(key) || key.endsWith("Id") || key.endsWith("_id") || key.endsWith("At") || key.endsWith("_at");
+          if (shouldConvert) {
+            let bigintValue = null;
+            if (typeof value === "bigint") {
+              bigintValue = value;
+            } else if (typeof value === "string") {
+              if (/^-?\d+$/.test(value)) {
+                try {
+                  bigintValue = BigInt(value);
+                } catch {
+                  bigintValue = null;
+                }
+              }
+            }
+            if (bigintValue !== null) {
+              if (bigintValue <= MAX_SAFE_INTEGER_BIGINT && bigintValue >= MIN_SAFE_INTEGER_BIGINT) {
+                nextValue = Number(bigintValue);
+              }
+            }
+          }
+        }
+        converted[key] = nextValue;
+      }
+      return converted;
+    };
+    if (Array.isArray(arr)) {
+      return arr.map((item) => convertRecord(item));
+    }
+    if (typeof arr === "object") {
+      return convertRecord(arr);
+    }
+    return arr;
+  }
   constructor(options) {
     this.redis = options.redis;
     if (typeof options.dbName !== "string" || options.dbName.trim() === "") {
@@ -15313,7 +15395,7 @@ class DbHelper {
     return columnNames;
   }
   async prepareQueryOptions(options) {
-    const cleanWhere = fieldClear(options.where || {}, { excludeValues: [null, undefined] });
+    const cleanWhere = DbUtils.clearDeep(options.where || {});
     const hasJoins = options.joins && options.joins.length > 0;
     if (hasJoins) {
       const processedFields2 = (options.fields || []).map((f) => DbUtils.processJoinField(f));
@@ -15457,7 +15539,7 @@ class DbHelper {
         sql: execRes.sql
       };
     }
-    const convertedList = convertBigIntFields([deserialized]);
+    const convertedList = DbHelper.convertBigIntFields([deserialized], options.bigint);
     const data = convertedList[0] ?? deserialized;
     return {
       data,
@@ -15508,7 +15590,7 @@ class DbHelper {
     const deserializedList = camelList.map((item) => DbUtils.deserializeArrayFields(item)).filter((item) => item !== null);
     return {
       data: {
-        lists: convertBigIntFields(deserializedList),
+        lists: DbHelper.convertBigIntFields(deserializedList, options.bigint),
         total,
         page: prepared.page,
         limit: prepared.limit,
@@ -15530,6 +15612,8 @@ class DbHelper {
     };
     if (options.fields !== undefined)
       prepareOptions.fields = options.fields;
+    if (options.bigint !== undefined)
+      prepareOptions.bigint = options.bigint;
     if (options.where !== undefined)
       prepareOptions.where = options.where;
     if (options.joins !== undefined)
@@ -15570,7 +15654,7 @@ class DbHelper {
     }
     const camelResult = arrayKeysToCamel(result);
     const deserializedList = camelResult.map((item) => DbUtils.deserializeArrayFields(item)).filter((item) => item !== null);
-    const lists = convertBigIntFields(deserializedList);
+    const lists = DbHelper.convertBigIntFields(deserializedList, options.bigint);
     return {
       data: {
         lists,
@@ -15765,7 +15849,7 @@ class DbHelper {
   }
   async updData(options) {
     const { table, data, where } = options;
-    const cleanWhere = fieldClear(where, { excludeValues: [null, undefined] });
+    const cleanWhere = DbUtils.clearDeep(where);
     const snakeTable = snakeCase(table);
     const snakeWhere = DbUtils.whereKeysToSnake(cleanWhere);
     const processed = DbUtils.buildUpdateRow({ data, now: Date.now(), allowState: true });
@@ -15790,7 +15874,7 @@ class DbHelper {
   async delForce(options) {
     const { table, where } = options;
     const snakeTable = snakeCase(table);
-    const cleanWhere = fieldClear(where, { excludeValues: [null, undefined] });
+    const cleanWhere = DbUtils.clearDeep(where);
     const snakeWhere = DbUtils.whereKeysToSnake(cleanWhere);
     const builder = this.createSqlBuilder().where(snakeWhere);
     const { sql, params } = builder.toDeleteSql(snakeTable);
@@ -15855,7 +15939,7 @@ class DbHelper {
       throw new Error(`exists \u4E0D\u652F\u6301 schema.table \u5199\u6CD5\uFF08table: ${rawTable}\uFF09`);
     }
     const snakeTable = snakeCase(rawTable);
-    const cleanWhere = fieldClear(options.where || {}, { excludeValues: [null, undefined] });
+    const cleanWhere = DbUtils.clearDeep(options.where || {});
     const snakeWhere = DbUtils.whereKeysToSnake(cleanWhere);
     const whereFiltered = DbUtils.addDefaultStateFilter(snakeWhere, snakeTable, false);
     const builder = this.createSqlBuilder().selectRaw("COUNT(1) as cnt").from(snakeTable).where(whereFiltered).limit(1);
@@ -15941,7 +16025,7 @@ class DbHelper {
     if (typeof value !== "number" || isNaN(value)) {
       throw new Error(`\u81EA\u589E\u503C\u5FC5\u987B\u662F\u6709\u6548\u7684\u6570\u5B57 (table: ${table}, field: ${field}, value: ${value})`);
     }
-    const cleanWhere = fieldClear(where, { excludeValues: [null, undefined] });
+    const cleanWhere = DbUtils.clearDeep(where);
     const snakeWhere = DbUtils.whereKeysToSnake(cleanWhere);
     const whereFiltered = DbUtils.addDefaultStateFilter(snakeWhere, snakeTable, false);
     const builder = this.createSqlBuilder().where(whereFiltered);