befly 3.16.1 → 3.16.4

package/dist/befly.js

@@ -504,10 +504,8 @@ import { createWriteStream, existsSync, mkdirSync } from "fs";
 import { stat } from "fs/promises";
 import { hostname as osHostname } from "os";
 import { isAbsolute as nodePathIsAbsolute, join as nodePathJoin, resolve as nodePathResolve } from "path";
-function buildSanitizeOptionsForWrite(writeOptions) {
-  if (!writeOptions)
-    return sanitizeOptions;
-  if (writeOptions.truncate !== false)
+function buildSanitizeOptionsForWriteOptions(writeOptions) {
+  if (!writeOptions || writeOptions.truncate !== false)
     return sanitizeOptions;
   return {
     maxStringLen: 200000,
@@ -809,8 +807,6 @@ async function flush() {
 async function shutdown() {
   if (mockInstance)
     return;
-  const currentInstance = instance;
-  const currentErrorInstance = errorInstance;
   const currentAppFileSink = appFileSink;
   const currentErrorFileSink = errorFileSink;
   const currentAppConsoleSink = appConsoleSink;
@@ -835,12 +831,6 @@ async function shutdown() {
   if (appConsoleSink === currentAppConsoleSink) {
     appConsoleSink = null;
   }
-  if (instance === currentInstance) {
-    instance = null;
-  }
-  if (errorInstance === currentErrorInstance) {
-    errorInstance = null;
-  }
 }
 function resolveLogDir() {
   const rawDir = config.dir || "./logs";
@@ -876,8 +866,6 @@ function configure(cfg) {
       mb = 100;
     config.maxSize = mb;
   }
-  instance = null;
-  errorInstance = null;
   appFileSink = null;
   errorFileSink = null;
   appConsoleSink = null;
@@ -893,35 +881,6 @@ function configure(cfg) {
 function setMockLogger(mock) {
   mockInstance = mock;
 }
-function getSink(kind) {
-  if (mockInstance)
-    return mockInstance;
-  if (kind === "app") {
-    if (instance)
-      return instance;
-  } else {
-    if (errorInstance)
-      return errorInstance;
-  }
-  ensureLogDirExists();
-  const maxSizeMb = typeof config.maxSize === "number" ? config.maxSize : 20;
-  const maxFileBytes = Math.floor(maxSizeMb * 1024 * 1024);
-  if (kind === "app") {
-    if (!appFileSink) {
-      appFileSink = new LogFileSink({ prefix: "app", maxFileBytes });
-    }
-    if (config.console === 1 && !appConsoleSink) {
-      appConsoleSink = createStreamSink("stdout");
-    }
-    instance = createSinkLogger({ fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null });
-    return instance;
-  }
-  if (!errorFileSink) {
-    errorFileSink = new LogFileSink({ prefix: "error", maxFileBytes });
-  }
-  errorInstance = createSinkLogger({ fileSink: errorFileSink, consoleSink: null });
-  return errorInstance;
-}
 function buildBaseFields(level, timeMs) {
   const base = {
     level,
@@ -978,46 +937,39 @@ function safeJsonStringify(obj) {
     }
   }
 }
-function createSinkLogger(options) {
-  const fileSink = options.fileSink;
-  const consoleSink = options.consoleSink;
-  const write = (level, record) => {
-    if (level === "debug" && config.debug !== 1)
-      return;
-    const time = Date.now();
-    const base = buildBaseFields(level, time);
-    const input = isPlainObject(record) ? record : { value: record };
-    let writeOptions = null;
-    if (input && typeof input === "object") {
-      writeOptions = recordWriteOptions.get(input) ?? null;
-      if (writeOptions) {
-        recordWriteOptions.delete(input);
-      }
+function ensureSinksReady(kind) {
+  ensureLogDirExists();
+  const maxSizeMb = typeof config.maxSize === "number" ? config.maxSize : 20;
+  const maxFileBytes = Math.floor(maxSizeMb * 1024 * 1024);
+  if (kind === "app") {
+    if (!appFileSink) {
+      appFileSink = new LogFileSink({ prefix: "app", maxFileBytes });
     }
-    const effectiveSanitizeOptions = buildSanitizeOptionsForWrite(writeOptions);
-    const sanitizedRecord = sanitizeLogObject(input, effectiveSanitizeOptions);
-    const fileLine = buildLogLineWithBase(base, sanitizedRecord);
-    fileSink.enqueue(fileLine);
-    if (consoleSink) {
-      if (!writeOptions || writeOptions.console !== false) {
-        consoleSink.enqueue(fileLine);
-      }
+    if (config.console === 1 && !appConsoleSink) {
+      appConsoleSink = createStreamSink("stdout");
     }
-  };
-  return {
-    info(record) {
-      write("info", record);
-    },
-    warn(record) {
-      write("warn", record);
-    },
-    error(record) {
-      write("error", record);
-    },
-    debug(record) {
-      write("debug", record);
+    return { fileSink: appFileSink, consoleSink: config.console === 1 ? appConsoleSink : null };
+  }
+  if (!errorFileSink) {
+    errorFileSink = new LogFileSink({ prefix: "error", maxFileBytes });
+  }
+  return { fileSink: errorFileSink, consoleSink: null };
+}
+function writeJsonl(kind, level, record, options) {
+  if (level === "debug" && config.debug !== 1)
+    return;
+  const sinks = ensureSinksReady(kind);
+  const time = Date.now();
+  const base = buildBaseFields(level, time);
+  const effectiveSanitizeOptions = buildSanitizeOptionsForWriteOptions(options);
+  const sanitizedRecord = sanitizeLogObject(record, effectiveSanitizeOptions);
+  const fileLine = buildLogLineWithBase(base, sanitizedRecord);
+  sinks.fileSink.enqueue(fileLine);
+  if (sinks.consoleSink) {
+    if (!options || options.console !== false) {
+      sinks.consoleSink.enqueue(fileLine);
     }
-  };
+  }
 }
 function metaToObject() {
   const meta = getCtx();
@@ -1080,48 +1032,59 @@ function withRequestMetaRecord(record) {
 }
 
 class LoggerFacade {
-  maybeSanitizeForMock(record, options) {
-    if (!mockInstance)
-      return record;
-    const effective = buildSanitizeOptionsForWrite(options ? options : null);
-    return sanitizeLogObject(record, effective);
-  }
-  info(input, options) {
+  write(level, input, options) {
+    if (level === "debug" && config.debug !== 1)
+      return;
     const record0 = withRequestMetaRecord(toRecord(input));
-    if (!mockInstance && options && isPlainObject(record0)) {
-      recordWriteOptions.set(record0, options);
+    if (mockInstance) {
+      const effective = buildSanitizeOptionsForWriteOptions(options);
+      const sanitized = sanitizeLogObject(record0, effective);
+      if (level === "info") {
+        mockInstance.info(sanitized);
+      } else if (level === "warn") {
+        mockInstance.warn(sanitized);
+      } else if (level === "error") {
+        mockInstance.error(sanitized);
+      } else {
+        mockInstance.debug(sanitized);
+      }
+      return;
     }
-    const record = this.maybeSanitizeForMock(record0, options);
-    getSink("app").info(record);
+    writeJsonl("app", level, record0, options);
+    if (level === "error") {
+      writeJsonl("error", "error", record0, options);
+    }
+  }
+  info(input, options) {
+    this.write("info", input, options);
   }
   warn(input, options) {
-    const record0 = withRequestMetaRecord(toRecord(input));
-    if (!mockInstance && options && isPlainObject(record0)) {
-      recordWriteOptions.set(record0, options);
-    }
-    const record = this.maybeSanitizeForMock(record0, options);
-    getSink("app").warn(record);
+    this.write("warn", input, options);
   }
   error(input, options) {
-    const record0 = withRequestMetaRecord(toRecord(input));
-    if (!mockInstance && options && isPlainObject(record0)) {
-      recordWriteOptions.set(record0, options);
-    }
-    const record = this.maybeSanitizeForMock(record0, options);
-    getSink("app").error(record);
-    if (mockInstance)
-      return;
-    getSink("error").error(record);
+    this.write("error", input, options);
   }
   debug(input, options) {
-    if (config.debug !== 1)
-      return;
-    const record0 = withRequestMetaRecord(toRecord(input));
-    if (!mockInstance && options && isPlainObject(record0)) {
-      recordWriteOptions.set(record0, options);
-    }
-    const record = this.maybeSanitizeForMock(record0, options);
-    getSink("app").debug(record);
+    this.write("debug", input, options);
+  }
+  printPlainLines(input, options) {
+    const kind = options && options.stream === "stderr" ? "stderr" : "stdout";
+    const stream = kind === "stderr" ? process.stderr : process.stdout;
+    try {
+      if (Array.isArray(input)) {
+        for (const line of input) {
+          stream.write(`${String(line)}
+`);
+        }
+        return;
+      }
+      const parts = String(input).split(`
+`);
+      for (let i = 0;i < parts.length; i = i + 1) {
+        stream.write(`${parts[i]}
+`);
+      }
+    } catch {}
   }
   async flush() {
     await flush();
@@ -1136,7 +1099,7 @@ class LoggerFacade {
     await shutdown();
   }
 }
-var INITIAL_CWD, BUILTIN_SENSITIVE_KEYS, sanitizeOptions, recordWriteOptions, HOSTNAME, instance = null, errorInstance = null, mockInstance = null, appFileSink = null, errorFileSink = null, appConsoleSink = null, config, Logger;
+var INITIAL_CWD, BUILTIN_SENSITIVE_KEYS, sanitizeOptions, HOSTNAME, mockInstance = null, appFileSink = null, errorFileSink = null, appConsoleSink = null, config, Logger;
 var init_logger = __esm(() => {
   init_loggerUtils();
   init_util();
@@ -1151,7 +1114,6 @@ var init_logger = __esm(() => {
     sanitizeObjectKeys: 500,
     sensitiveKeyMatcher: buildSensitiveKeyMatcher({ builtinPatterns: BUILTIN_SENSITIVE_KEYS, userPatterns: [] })
   };
-  recordWriteOptions = new WeakMap;
   HOSTNAME = (() => {
     try {
       return osHostname();
@@ -1443,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
@@ -10707,6 +10669,7 @@ class SyncTable {
         }
       }
       SyncTable.throwIfIncompatibleTypeChanges(incompatibleTypeChanges);
+      const createdTables = [];
       for (const task of tableTasks) {
         const item = task.item;
         const tableName = task.tableName;
@@ -10746,6 +10709,7 @@ class SyncTable {
             }
           } else {
             await SyncTable.createTable(this.db, tableName, tableFields);
+            createdTables.push(tableName);
           }
         } catch (error) {
           const errMsg = String(error?.message || error);
@@ -10768,6 +10732,17 @@ class SyncTable {
           throw error;
         }
       }
+      if (createdTables.length > 0) {
+        const lines = [];
+        lines.push(`\u521B\u5EFA\u8868\u5217\u8868\uFF08\u5171${createdTables.length}\u5F20\uFF09:`);
+        for (const tableName of createdTables) {
+          lines.push(`- ${tableName}`);
+        }
+        const text = lines.join(`
+`);
+        Logger.debug(text, { truncate: false, console: false });
+        Logger.printPlainLines(text, { stream: "stdout" });
+      }
     } catch (error) {
       if (error?.__syncTableLogged === true) {
         throw error;
@@ -11448,7 +11423,6 @@ SQL: ${sqlLine}
             ${cols}
         ) ENGINE=${ENGINE} DEFAULT CHARSET=${CHARSET} COLLATE=${COLLATE}`;
     await db.unsafe(createSQL);
-    Logger.debug(`[\u8868 ${tableName}] + \u521B\u5EFA\u8868\uFF08\u7CFB\u7EDF\u5B57\u6BB5 + \u4E1A\u52A1\u5B57\u6BB5\uFF09`);
     const indexClauses = [];
     for (const sysField of systemIndexFields) {
       const indexName = `idx_${sysField}`;
@@ -13998,6 +13972,9 @@ function convertBigIntFields(arr, fields = ["id", "pid", "sort"]) {
   return arr;
 }
 
+// lib/dbHelper.ts
+init_util();
+
 // utils/fieldClear.ts
 function isObject(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
@@ -14048,9 +14025,6 @@ function fieldClear(data, options = {}) {
   return data;
 }
 
-// lib/dbHelper.ts
-init_util();
-
 // lib/dbUtils.ts
 init_util();
 
@@ -14163,6 +14137,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)})`);
@@ -15339,7 +15380,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));
@@ -15791,7 +15832,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 });
@@ -15816,7 +15857,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);
@@ -15881,7 +15922,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);
@@ -15967,7 +16008,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);
@@ -16905,21 +16946,6 @@ class Befly {
           noLog = true;
         }
       }
-      const writePlainLinesToConsole = (prefix, errName, message) => {
-        const text = String(message || "");
-        const parts = text.split(`
-`);
-        const firstLine = parts.length > 0 ? String(parts[0] || "") : "";
-        const head = `[${prefix}] \u542F\u52A8\u5931\u8D25: ${errName}: ${firstLine}`;
-        try {
-          process.stderr.write(`${head}
-`);
-          for (let i = 1;i < parts.length; i = i + 1) {
-            process.stderr.write(`${parts[i]}
-`);
-          }
-        } catch {}
-      };
       if (!alreadyLogged && multiline) {
         const appName = String(this.config?.appName || "\u9879\u76EE");
         const errName = error instanceof Error && error.name ? error.name : "Error";
@@ -16928,7 +16954,18 @@ class Befly {
           errorKind: kind,
           errorMessage: errMessage
         }, { truncate: false, console: false });
-        writePlainLinesToConsole(appName, errName, errMessage);
+        {
+          const text = String(errMessage || "");
+          const parts = text.split(`
+`);
+          const firstLine = parts.length > 0 ? String(parts[0] || "") : "";
+          const lines = [];
+          lines.push(`[${appName}] \u542F\u52A8\u5931\u8D25: ${errName}: ${firstLine}`);
+          for (let i = 1;i < parts.length; i = i + 1) {
+            lines.push(String(parts[i] || ""));
+          }
+          Logger.printPlainLines(lines, { stream: "stderr" });
+        }
       } else if (alreadyLogged) {
         Logger.error({
           msg: "\u9879\u76EE\u542F\u52A8\u5931\u8D25\uFF08\u4E0B\u5C42\u5DF2\u8BB0\u5F55\uFF09",