befly 3.14.2 → 3.15.0

package/dist/befly.js

@@ -90,8 +90,9 @@ function forOwn(obj, iteratee) {
   if (!isPlainObject(obj)) {
     return;
   }
-  for (const key of Object.keys(obj)) {
-    iteratee(obj[key], key);
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    iteratee(record[key], key);
   }
 }
 function toWordParts(input) {
@@ -559,7 +560,12 @@ class LogFileSink {
           const ok = this.stream.write(chunk);
           if (!ok) {
             await new Promise((resolve) => {
-              this.stream.once("drain", () => resolve());
+              const stream = this.stream;
+              if (!stream) {
+                resolve();
+                return;
+              }
+              stream.once("drain", () => resolve());
             });
           }
           this.streamSizeBytes = this.streamSizeBytes + chunkBytes;
@@ -829,7 +835,8 @@ function createSinkLogger(options) {
   const write = (level, record) => {
     if (level === "debug" && config.debug !== 1)
       return;
-    const sanitizedRecord = sanitizeLogObject(record, sanitizeOptions);
+    const input = isPlainObject(record) ? record : { value: record };
+    const sanitizedRecord = sanitizeLogObject(input, sanitizeOptions);
     const line = buildLogLine(level, sanitizedRecord);
     fileSink.enqueue(line);
     if (consoleSink)
@@ -871,8 +878,8 @@ function metaToObject() {
 }
 function mergeMetaIntoObject(input, meta) {
   const merged = {};
-  for (const [key, value] of Object.entries(input)) {
-    merged[key] = value;
+  for (const key of Object.keys(input)) {
+    merged[key] = input[key];
   }
   const keys = ["requestId", "method", "route", "ip", "now", "durationSinceNowMs", "userId", "roleCode", "nickname", "roleType"];
   for (const key of keys) {
@@ -919,28 +926,27 @@ class LoggerFacade {
   info(input) {
     const record0 = withRequestMetaRecord(toRecord(input));
     const record = this.maybeSanitizeForMock(record0);
-    return getSink("app").info(record);
+    getSink("app").info(record);
   }
   warn(input) {
     const record0 = withRequestMetaRecord(toRecord(input));
     const record = this.maybeSanitizeForMock(record0);
-    return getSink("app").warn(record);
+    getSink("app").warn(record);
   }
   error(input) {
     const record0 = withRequestMetaRecord(toRecord(input));
     const record = this.maybeSanitizeForMock(record0);
-    const ret = getSink("app").error(record);
+    getSink("app").error(record);
     if (mockInstance)
-      return ret;
+      return;
     getSink("error").error(record);
-    return ret;
   }
   debug(input) {
     if (config.debug !== 1)
       return;
     const record0 = withRequestMetaRecord(toRecord(input));
     const record = this.maybeSanitizeForMock(record0);
-    return getSink("app").debug(record);
+    getSink("app").debug(record);
   }
   async flush() {
     await flush();
@@ -1255,12 +1261,20 @@ function normalizeViewDirMeta(input) {
   if (!input || typeof input !== "object") {
     return null;
   }
-  if (typeof input.title !== "string" || !input.title) {
+  const record = input;
+  const title = record["title"];
+  if (typeof title !== "string" || !title) {
     return null;
   }
-  const order = typeof input.order === "number" && Number.isFinite(input.order) && Number.isInteger(input.order) && input.order >= 0 ? input.order : undefined;
+  const orderRaw = record["order"];
+  const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) && Number.isInteger(orderRaw) && orderRaw >= 0 ? orderRaw : undefined;
+  if (order === undefined) {
+    return {
+      title
+    };
+  }
   return {
-    title: input.title,
+    title,
     order
   };
 }
@@ -7446,8 +7460,9 @@ function cloneDeepLoose(value) {
   }
   if (isPlainObject(value)) {
     const out = {};
-    for (const key of Object.keys(value)) {
-      out[key] = cloneDeepLoose(value[key]);
+    const record = value;
+    for (const key of Object.keys(record)) {
+      out[key] = cloneDeepLoose(record[key]);
     }
     return out;
   }
@@ -7458,18 +7473,28 @@ function mergeInto(target, source) {
     return target;
   }
   if (Array.isArray(target) && Array.isArray(source)) {
+    const nextArr = [];
+    for (const item of target) {
+      nextArr.push(cloneDeepLoose(item));
+    }
     for (const item of source) {
-      target.push(cloneDeepLoose(item));
+      nextArr.push(cloneDeepLoose(item));
     }
-    return target;
+    return nextArr;
   }
   if (isPlainObject(target) && isPlainObject(source)) {
-    for (const key of Object.keys(source)) {
-      const srcVal = source[key];
+    const targetRecord = target;
+    const sourceRecord = source;
+    const out = {};
+    for (const key of Object.keys(targetRecord)) {
+      out[key] = cloneDeepLoose(targetRecord[key]);
+    }
+    for (const key of Object.keys(sourceRecord)) {
+      const srcVal = sourceRecord[key];
       if (srcVal === undefined) {
         continue;
       }
-      const curVal = target[key];
+      const curVal = out[key];
       if (Array.isArray(curVal) && Array.isArray(srcVal)) {
         const nextArr = [];
         for (const item of curVal) {
@@ -7478,16 +7503,16 @@ function mergeInto(target, source) {
         for (const item of srcVal) {
           nextArr.push(cloneDeepLoose(item));
         }
-        target[key] = nextArr;
+        out[key] = nextArr;
         continue;
       }
       if (isPlainObject(curVal) && isPlainObject(srcVal)) {
-        target[key] = mergeInto(cloneDeepLoose(curVal), srcVal);
+        out[key] = mergeInto(cloneDeepLoose(curVal), srcVal);
         continue;
       }
-      target[key] = cloneDeepLoose(srcVal);
+      out[key] = cloneDeepLoose(srcVal);
     }
-    return target;
+    return out;
   }
   return cloneDeepLoose(source);
 }
@@ -7571,7 +7596,7 @@ async function loadBeflyConfig(nodeEnv) {
   const envConfig = await importDefault(join(configsDir, `befly.${nodeEnv}.json`), {});
   const config2 = mergeAndConcat(defaultOptions, commonConfig, envConfig);
   config2.nodeEnv = nodeEnv;
-  const redisPrefix = config2?.redis?.prefix;
+  const redisPrefix = config2.redis?.prefix;
   if (typeof redisPrefix === "string") {
     const trimmedPrefix = redisPrefix.trim();
     if (trimmedPrefix.includes(":")) {
@@ -7586,63 +7611,100 @@ init_logger();
 init_util();
 async function checkApi(apis) {
   let hasError = false;
+  const seenPaths = new Set;
   for (const api of apis) {
     try {
-      if (typeof api?.name !== "string" || api.name.trim() === "") {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 name \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" }));
+      if (!isPlainObject(api)) {
+        Logger.warn({ item: api, msg: "\u63A5\u53E3\u5FC5\u987B\u662F\u5BF9\u8C61" });
+        hasError = true;
+        continue;
+      }
+      const record = api;
+      const name = record["name"];
+      if (typeof name !== "string" || name.trim() === "") {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 name \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" }));
         hasError = true;
         continue;
       }
-      if (typeof api?.handler !== "function") {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 handler \u5C5E\u6027\u5FC5\u987B\u662F\u51FD\u6570" }));
+      const handler = record["handler"];
+      if (typeof handler !== "function") {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 handler \u5C5E\u6027\u5FC5\u987B\u662F\u51FD\u6570" }));
         hasError = true;
         continue;
       }
-      if (typeof api?.path !== "string" || api.path.trim() === "") {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
+      const rawPath = record["path"];
+      if (typeof rawPath !== "string" || rawPath.trim() === "") {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
         hasError = true;
       } else {
-        const path = api.path.trim();
+        const path = rawPath.trim();
+        if (seenPaths.has(path)) {
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u91CD\u590D\uFF08\u4E25\u683C\u6A21\u5F0F\u7981\u6B62\u91CD\u590D path\uFF09" }));
+          hasError = true;
+        } else {
+          seenPaths.add(path);
+        }
         if (/^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i.test(path)) {
-          Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u5305\u542B method \u524D\u7F00\uFF0C\u5E94\u4E3A url.pathname\uFF08\u4F8B\u5982 /api/app/xxx\uFF09" }));
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u5305\u542B method \u524D\u7F00\uFF0C\u5E94\u4E3A url.pathname\uFF08\u4F8B\u5982 /api/app/xxx\uFF09" }));
           hasError = true;
         }
         if (!path.startsWith("/api/")) {
-          Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u5FC5\u987B\u4EE5 /api/ \u5F00\u5934" }));
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u5FC5\u987B\u4EE5 /api/ \u5F00\u5934" }));
           hasError = true;
         }
         if (path.includes(" ")) {
-          Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u5305\u542B\u7A7A\u683C" }));
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u5305\u542B\u7A7A\u683C" }));
           hasError = true;
         }
         if (path.includes("/api//")) {
-          Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u51FA\u73B0 /api//\uFF08\u91CD\u590D\u659C\u6760\uFF09" }));
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 path \u4E0D\u5141\u8BB8\u51FA\u73B0 /api//\uFF08\u91CD\u590D\u659C\u6760\uFF09" }));
           hasError = true;
         }
       }
-      if (typeof api?.routePrefix !== "string" || api.routePrefix.trim() === "") {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 routePrefix \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
+      const routePrefix = record["routePrefix"];
+      const routePrefixTrimmed = typeof routePrefix === "string" ? routePrefix.trim() : "";
+      if (routePrefixTrimmed === "") {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 routePrefix \u5C5E\u6027\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
         hasError = true;
+      } else {
+        if (!(routePrefixTrimmed === "/app" || routePrefixTrimmed.startsWith("/addon/"))) {
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 routePrefix \u5FC5\u987B\u662F /app \u6216 /addon/<name>\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
+          hasError = true;
+        }
+        if (typeof rawPath === "string" && rawPath.trim() !== "") {
+          const path = rawPath.trim();
+          const expectedPrefix = `/api${routePrefixTrimmed}/`;
+          if (!path.startsWith(expectedPrefix)) {
+            Logger.warn(Object.assign({}, omit(record, ["handler"]), { expectedPrefix, msg: "\u63A5\u53E3\u7684 path \u4E0E routePrefix \u4E0D\u4E00\u81F4\uFF1A\u5E94\u4EE5 /api${routePrefix}/ \u5F00\u5934\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF09" }));
+            hasError = true;
+          }
+        }
       }
-      if (api.method && !["GET", "POST", "GET,POST", "POST,GET"].includes(String(api.method).toUpperCase())) {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 method \u5C5E\u6027\u5FC5\u987B\u662F\u6709\u6548\u7684 HTTP \u65B9\u6CD5 (GET, POST, GET,POST, POST,GET)" }));
+      const method = record["method"];
+      if (method !== undefined && !["GET", "POST", "GET,POST"].includes(String(method).toUpperCase())) {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 method \u5C5E\u6027\u5FC5\u987B\u662F\u6709\u6548\u7684 HTTP \u65B9\u6CD5 (GET, POST, GET,POST)" }));
         hasError = true;
       }
-      if (api.auth !== undefined && typeof api.auth !== "boolean") {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 auth \u5C5E\u6027\u5FC5\u987B\u662F\u5E03\u5C14\u503C (true=\u9700\u767B\u5F55, false=\u516C\u5F00)" }));
+      const auth = record["auth"];
+      if (auth !== undefined && typeof auth !== "boolean") {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 auth \u5C5E\u6027\u5FC5\u987B\u662F\u5E03\u5C14\u503C (true=\u9700\u767B\u5F55, false=\u516C\u5F00)" }));
         hasError = true;
       }
-      if (api.fields && !isPlainObject(api.fields)) {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 fields \u5C5E\u6027\u5FC5\u987B\u662F\u5BF9\u8C61" }));
+      const fields = record["fields"];
+      if (fields !== undefined && fields !== null && !isPlainObject(fields)) {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 fields \u5C5E\u6027\u5FC5\u987B\u662F\u5BF9\u8C61" }));
         hasError = true;
       }
-      if (api.required && !Array.isArray(api.required)) {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 required \u5C5E\u6027\u5FC5\u987B\u662F\u6570\u7EC4" }));
+      const required = record["required"];
+      if (required !== undefined && !Array.isArray(required)) {
+        Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 required \u5C5E\u6027\u5FC5\u987B\u662F\u6570\u7EC4" }));
         hasError = true;
       }
-      if (api.required && api.required.some((reqItem) => typeof reqItem !== "string")) {
-        Logger.warn(Object.assign({}, omit(api, ["handler"]), { msg: "\u63A5\u53E3\u7684 required \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
-        hasError = true;
+      if (Array.isArray(required)) {
+        if (required.some((reqItem) => typeof reqItem !== "string")) {
+          Logger.warn(Object.assign({}, omit(record, ["handler"]), { msg: "\u63A5\u53E3\u7684 required \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
+          hasError = true;
+        }
       }
     } catch (error) {
       Logger.error({ err: error, item: api, msg: "\u63A5\u53E3\u89E3\u6790\u5931\u8D25" });
@@ -7668,12 +7730,14 @@ async function checkHook(hooks) {
         hasError = true;
         continue;
       }
-      if (typeof hook.moduleName !== "string" || hook.moduleName.trim() === "") {
+      const record = hook;
+      const moduleName = record["moduleName"];
+      if (typeof moduleName !== "string" || moduleName.trim() === "") {
         Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u7684 moduleName \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF0C\u7528\u4E8E deps \u4E0E\u8FD0\u884C\u65F6\u6302\u8F7D\uFF09" }));
         hasError = true;
         continue;
       }
-      const customKeys = hook.customKeys;
+      const customKeys = record["customKeys"];
       if (!Array.isArray(customKeys)) {
         Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u626B\u63CF\u7ED3\u679C\u7F3A\u5C11 customKeys\uFF08\u65E0\u6CD5\u5224\u65AD\u7528\u6237\u5BFC\u51FA\u7684\u5B57\u6BB5\u662F\u5426\u5408\u6CD5\uFF09" }));
         hasError = true;
@@ -7693,16 +7757,17 @@ async function checkHook(hooks) {
       const hasCustomEnable = customKeys.includes("enable");
       const hasCustomDeps = customKeys.includes("deps");
       if (hasCustomEnable) {
-        if (typeof hook.enable !== "boolean") {
+        const enable = record["enable"];
+        if (typeof enable !== "boolean") {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u7684 enable \u5C5E\u6027\u5FC5\u987B\u662F boolean\uFF08true/false\uFF09\uFF0C\u4E0D\u5141\u8BB8 0/1 \u7B49\u5176\u4ED6\u7C7B\u578B" }));
           hasError = true;
           continue;
         }
       } else {
-        hook.enable = true;
+        record["enable"] = true;
       }
-      if (hook.source === "core") {
-        const name = typeof hook.name === "string" ? hook.name : "";
+      if (record["source"] === "core") {
+        const name = typeof record["name"] === "string" ? record["name"] : "";
         if (name === "") {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core \u5185\u7F6E\u94A9\u5B50\u5FC5\u987B\u663E\u5F0F\u8BBE\u7F6E name\uFF08string\uFF09\uFF0C\u7528\u4E8E\u786E\u5B9A\u94A9\u5B50\u540D\u79F0" }));
           hasError = true;
@@ -7713,39 +7778,42 @@ async function checkHook(hooks) {
           hasError = true;
           continue;
         }
-        if (!coreBuiltinNameRegexp.test(hook.moduleName)) {
+        if (!coreBuiltinNameRegexp.test(String(record["moduleName"]))) {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core \u5185\u7F6E\u94A9\u5B50\u7684 moduleName \u5FC5\u987B\u6EE1\u8DB3\u5C0F\u5199\u5B57\u6BCD+\u4E0B\u5212\u7EBF\u683C\u5F0F\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF0C\u4E14\u5FC5\u987B\u4E0E name \u4E00\u81F4\uFF09" }));
           hasError = true;
           continue;
         }
-        if (name !== hook.moduleName) {
+        if (name !== String(record["moduleName"])) {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core \u5185\u7F6E\u94A9\u5B50\u7684 name \u5FC5\u987B\u4E0E moduleName \u5B8C\u5168\u4E00\u81F4" }));
           hasError = true;
           continue;
         }
-        if (typeof hook.filePath !== "string" || !hook.filePath.startsWith(`core:hook:${name}`)) {
+        const filePath = record["filePath"];
+        if (typeof filePath !== "string" || !filePath.startsWith(`core:hook:${name}`)) {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "core \u5185\u7F6E\u94A9\u5B50\u5FC5\u987B\u6765\u81EA\u9759\u6001\u6CE8\u518C\uFF08filePath \u5FC5\u987B\u4EE5 core:hook:<name> \u5F00\u5934\uFF09\uFF0C\u4E0D\u5141\u8BB8\u901A\u8FC7\u626B\u63CF\u76EE\u5F55\u52A0\u8F7D" }));
           hasError = true;
           continue;
         }
       }
       if (hasCustomDeps) {
-        if (!Array.isArray(hook.deps)) {
+        const deps = record["deps"];
+        if (!Array.isArray(deps)) {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u7684 deps \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
           hasError = true;
           continue;
         }
-        if (hook.deps.some((depItem) => typeof depItem !== "string")) {
+        if (deps.some((depItem) => typeof depItem !== "string")) {
           Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u7684 deps \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
           hasError = true;
           continue;
         }
       } else {
-        if (!Array.isArray(hook.deps)) {
-          hook.deps = [];
+        const deps = record["deps"];
+        if (!Array.isArray(deps)) {
+          record["deps"] = [];
         }
       }
-      if (typeof hook.handler !== "function") {
+      if (typeof record["handler"] !== "function") {
         Logger.warn(Object.assign({}, omit(hook, ["handler"]), { msg: "\u94A9\u5B50\u7684 handler \u5C5E\u6027\u5FC5\u987B\u662F\u51FD\u6570" }));
         hasError = true;
         continue;
@@ -7880,12 +7948,14 @@ async function checkPlugin(plugins) {
         hasError = true;
         continue;
       }
-      if (typeof plugin.moduleName !== "string" || plugin.moduleName.trim() === "") {
+      const record = plugin;
+      const moduleName = record["moduleName"];
+      if (typeof moduleName !== "string" || moduleName.trim() === "") {
         Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u7684 moduleName \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF0C\u7528\u4E8E deps \u4E0E\u8FD0\u884C\u65F6\u6302\u8F7D\uFF09" }));
         hasError = true;
         continue;
       }
-      const customKeys = plugin.customKeys;
+      const customKeys = record["customKeys"];
       if (!Array.isArray(customKeys)) {
         Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u626B\u63CF\u7ED3\u679C\u7F3A\u5C11 customKeys\uFF08\u65E0\u6CD5\u5224\u65AD\u7528\u6237\u5BFC\u51FA\u7684\u5B57\u6BB5\u662F\u5426\u5408\u6CD5\uFF09" }));
         hasError = true;
@@ -7905,16 +7975,17 @@ async function checkPlugin(plugins) {
       const hasCustomEnable = customKeys.includes("enable");
       const hasCustomDeps = customKeys.includes("deps");
       if (hasCustomEnable) {
-        if (typeof plugin.enable !== "boolean") {
+        const enable = record["enable"];
+        if (typeof enable !== "boolean") {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u7684 enable \u5C5E\u6027\u5FC5\u987B\u662F boolean\uFF08true/false\uFF09\uFF0C\u4E0D\u5141\u8BB8 0/1 \u7B49\u5176\u4ED6\u7C7B\u578B" }));
           hasError = true;
           continue;
         }
       } else {
-        plugin.enable = true;
+        record["enable"] = true;
       }
-      if (plugin.source === "core") {
-        const name = typeof plugin.name === "string" ? plugin.name : "";
+      if (record["source"] === "core") {
+        const name = typeof record["name"] === "string" ? record["name"] : "";
         if (name === "") {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core \u5185\u7F6E\u63D2\u4EF6\u5FC5\u987B\u663E\u5F0F\u8BBE\u7F6E name\uFF08string\uFF09\uFF0C\u7528\u4E8E\u786E\u5B9A\u63D2\u4EF6\u540D\u79F0" }));
           hasError = true;
@@ -7925,39 +7996,42 @@ async function checkPlugin(plugins) {
           hasError = true;
           continue;
         }
-        if (!coreBuiltinNameRegexp.test(plugin.moduleName)) {
+        if (!coreBuiltinNameRegexp.test(String(record["moduleName"]))) {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core \u5185\u7F6E\u63D2\u4EF6\u7684 moduleName \u5FC5\u987B\u6EE1\u8DB3\u5C0F\u5199\u5B57\u6BCD+\u4E0B\u5212\u7EBF\u683C\u5F0F\uFF08\u7531\u7CFB\u7EDF\u751F\u6210\uFF0C\u4E14\u5FC5\u987B\u4E0E name \u4E00\u81F4\uFF09" }));
           hasError = true;
           continue;
         }
-        if (name !== plugin.moduleName) {
+        if (name !== String(record["moduleName"])) {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core \u5185\u7F6E\u63D2\u4EF6\u7684 name \u5FC5\u987B\u4E0E moduleName \u5B8C\u5168\u4E00\u81F4" }));
           hasError = true;
           continue;
         }
-        if (typeof plugin.filePath !== "string" || !plugin.filePath.startsWith(`core:plugin:${name}`)) {
+        const filePath = record["filePath"];
+        if (typeof filePath !== "string" || !filePath.startsWith(`core:plugin:${name}`)) {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "core \u5185\u7F6E\u63D2\u4EF6\u5FC5\u987B\u6765\u81EA\u9759\u6001\u6CE8\u518C\uFF08filePath \u5FC5\u987B\u4EE5 core:plugin:<name> \u5F00\u5934\uFF09\uFF0C\u4E0D\u5141\u8BB8\u901A\u8FC7\u626B\u63CF\u76EE\u5F55\u52A0\u8F7D" }));
           hasError = true;
           continue;
         }
       }
       if (hasCustomDeps) {
-        if (!Array.isArray(plugin.deps)) {
+        const deps = record["deps"];
+        if (!Array.isArray(deps)) {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u7684 deps \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
           hasError = true;
           continue;
         }
-        if (plugin.deps.some((depItem) => typeof depItem !== "string")) {
+        if (deps.some((depItem) => typeof depItem !== "string")) {
           Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u7684 deps \u5C5E\u6027\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4" }));
           hasError = true;
           continue;
         }
       } else {
-        if (!Array.isArray(plugin.deps)) {
-          plugin.deps = [];
+        const deps = record["deps"];
+        if (!Array.isArray(deps)) {
+          record["deps"] = [];
         }
       }
-      if (typeof plugin.handler !== "function") {
+      if (typeof record["handler"] !== "function") {
         Logger.warn(Object.assign({}, omit(plugin, ["handler"]), { msg: "\u63D2\u4EF6\u7684 handler \u5C5E\u6027\u5FC5\u987B\u662F\u51FD\u6570" }));
         hasError = true;
         continue;
@@ -7975,8 +8049,11 @@ async function checkPlugin(plugins) {
 // checks/checkTable.ts
 init_logger();
 var RESERVED_FIELDS = ["id", "created_at", "updated_at", "deleted_at", "state"];
+var RESERVED_FIELD_SET = new Set(RESERVED_FIELDS);
 var FIELD_TYPES = ["string", "number", "text", "array_string", "array_text", "array_number_string", "array_number_text"];
+var FIELD_TYPE_SET = new Set(FIELD_TYPES);
 var ALLOWED_FIELD_PROPERTIES = ["name", "type", "min", "max", "default", "detail", "index", "unique", "nullable", "unsigned", "regexp"];
+var ALLOWED_FIELD_PROPERTY_SET = new Set(ALLOWED_FIELD_PROPERTIES);
 var LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
 var FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
 var MAX_VARCHAR_LENGTH = 65535;
@@ -8002,13 +8079,13 @@ async function checkTable(tables) {
           hasError = true;
           continue;
         }
-        if (RESERVED_FIELDS.includes(colKey)) {
+        if (RESERVED_FIELD_SET.has(colKey)) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6\u5305\u542B\u4FDD\u7559\u5B57\u6BB5 ${colKey}\uFF0C` + `\u4E0D\u80FD\u5728\u8868\u5B9A\u4E49\u4E2D\u4F7F\u7528\u4EE5\u4E0B\u5B57\u6BB5: ${RESERVED_FIELDS.join(", ")}`);
           hasError = true;
         }
         const field = fieldDef;
         const fieldKeys = Object.keys(field);
-        const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTIES.includes(key));
+        const illegalProps = fieldKeys.filter((key) => !ALLOWED_FIELD_PROPERTY_SET.has(key));
         if (illegalProps.length > 0) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5305\u542B\u975E\u6CD5\u5C5E\u6027: ${illegalProps.join(", ")}\uFF0C` + `\u5141\u8BB8\u7684\u5C5E\u6027\u4E3A: ${ALLOWED_FIELD_PROPERTIES.join(", ")}`);
           hasError = true;
@@ -8060,7 +8137,7 @@ async function checkTable(tables) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5\u540D\u79F0 "${fieldName}" \u683C\u5F0F\u9519\u8BEF\uFF0C` + `\u5FC5\u987B\u4E3A\u4E2D\u6587\u3001\u6570\u5B57\u3001\u5B57\u6BCD\u3001\u4E0B\u5212\u7EBF\u3001\u77ED\u6A2A\u7EBF\u3001\u7A7A\u683C`);
           hasError = true;
         }
-        if (!FIELD_TYPES.includes(fieldType)) {
+        if (!FIELD_TYPE_SET.has(fieldType)) {
           Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u5B57\u6BB5\u7C7B\u578B "${fieldType}" \u683C\u5F0F\u9519\u8BEF\uFF0C` + `\u5FC5\u987B\u4E3A${FIELD_TYPES.join("\u3001")}\u4E4B\u4E00`);
           hasError = true;
         }
@@ -8266,7 +8343,8 @@ class Connect {
       await this.connectSql(config2.db || {});
       await this.connectRedis(config2.redis || {});
     } catch (error) {
-      Logger.error({ env: config2.nodeEnv, err: error, msg: "\u6570\u636E\u5E93\u8FDE\u63A5\u521D\u59CB\u5316\u5931\u8D25" });
+      const env = typeof process?.env?.NODE_ENV === "string" ? "development" : "";
+      Logger.error({ env, err: error, msg: "\u6570\u636E\u5E93\u8FDE\u63A5\u521D\u59CB\u5316\u5931\u8D25" });
       await this.disconnect();
       throw error;
     }
@@ -8320,11 +8398,42 @@ init_logger();
 async function loadApis(apis) {
   const apisMap = new Map;
   for (const api of apis) {
-    if (Object.hasOwn(api, "type") && api.type !== "api") {
-      continue;
-    }
     try {
-      apisMap.set(api.path, api);
+      if (Object.hasOwn(api, "type") && api.type !== "api") {
+        continue;
+      }
+      const record = api;
+      const path = record["path"];
+      const route = {
+        name: record["name"],
+        handler: record["handler"],
+        route: path
+      };
+      const method = record["method"];
+      if (typeof method === "string") {
+        const upperMethod = method.toUpperCase();
+        const normalized = upperMethod === "POST,GET" ? "GET,POST" : upperMethod;
+        route.method = ["GET", "POST", "GET,POST"].includes(normalized) ? normalized : "POST";
+      } else {
+        route.method = "POST";
+      }
+      const auth = record["auth"];
+      if (auth !== undefined) {
+        route.auth = auth;
+      }
+      const fields = record["fields"];
+      if (fields !== undefined) {
+        route.fields = fields;
+      }
+      const required = record["required"];
+      if (required !== undefined) {
+        route.required = required;
+      }
+      const rawBody = record["rawBody"];
+      if (rawBody !== undefined) {
+        route.rawBody = rawBody;
+      }
+      apisMap.set(path, route);
     } catch (error) {
       Logger.error({ err: error, api: api.relativePath, file: api.filePath, msg: "\u63A5\u53E3\u52A0\u8F7D\u5931\u8D25" });
       throw error;
@@ -8345,7 +8454,13 @@ function sortModules(items, options = {}) {
     }
     return camelCase(item.fileName);
   });
-  const getDeps = options.getDeps || ((item) => item.deps);
+  const getDeps = options.getDeps || ((item) => {
+    const deps = item.deps;
+    if (!Array.isArray(deps)) {
+      return [];
+    }
+    return deps.filter((x) => typeof x === "string");
+  });
   const result = [];
   const visited = new Set;
   const visiting = new Set;
@@ -8425,11 +8540,12 @@ function sortModules(items, options = {}) {
 async function loadHooks(hooks) {
   const hooksMap = [];
   const enabledHooks = hooks.filter((item) => {
-    const moduleName = item?.moduleName;
+    const moduleName = item.moduleName;
     if (typeof moduleName !== "string" || moduleName.trim() === "") {
       return false;
     }
-    if (item?.enable === false) {
+    const enable = Object.hasOwn(item, "enable") ? item.enable : undefined;
+    if (enable === false) {
       return false;
     }
     return true;
@@ -8440,12 +8556,18 @@ async function loadHooks(hooks) {
   }
   for (const item of sortedHooks) {
     const hookName = item.moduleName;
-    const hook = item;
+    const depsRaw = Object.hasOwn(item, "deps") ? item.deps : undefined;
+    const deps = Array.isArray(depsRaw) ? depsRaw.filter((x) => typeof x === "string") : [];
+    const handlerRaw = Object.hasOwn(item, "handler") ? item.handler : undefined;
+    if (typeof handlerRaw !== "function") {
+      throw new Error(`Hook '${hookName}' handler \u5FC5\u987B\u662F\u51FD\u6570`);
+    }
+    const handler = handlerRaw;
     hooksMap.push({
       name: hookName,
       enable: true,
-      deps: Array.isArray(hook.deps) ? hook.deps : [],
-      handler: hook.handler
+      deps,
+      handler
     });
   }
   return hooksMap;
@@ -8456,11 +8578,12 @@ init_logger();
 async function loadPlugins(plugins, context) {
   const pluginsMap = [];
   const enabledPlugins = plugins.filter((item) => {
-    const moduleName = item?.moduleName;
+    const moduleName = item.moduleName;
     if (typeof moduleName !== "string" || moduleName.trim() === "") {
       return false;
     }
-    if (item?.enable === false) {
+    const enable = Object.hasOwn(item, "enable") ? item.enable : undefined;
+    if (enable === false) {
       return false;
     }
     return true;
@@ -8471,15 +8594,21 @@ async function loadPlugins(plugins, context) {
   }
   for (const item of sortedPlugins) {
     const pluginName = item.moduleName;
-    const plugin = item;
+    const depsRaw = Object.hasOwn(item, "deps") ? item.deps : undefined;
+    const deps = Array.isArray(depsRaw) ? depsRaw.filter((x) => typeof x === "string") : [];
+    const handlerRaw = Object.hasOwn(item, "handler") ? item.handler : undefined;
+    if (typeof handlerRaw !== "function") {
+      throw new Error(`\u63D2\u4EF6 '${pluginName}' handler \u5FC5\u987B\u662F\u51FD\u6570`);
+    }
+    const handler = handlerRaw;
     try {
-      const pluginInstance = typeof plugin.handler === "function" ? await plugin.handler(context) : {};
+      const pluginInstance = await handler(context);
       context[pluginName] = pluginInstance;
       pluginsMap.push({
         name: pluginName,
         enable: true,
-        deps: Array.isArray(plugin.deps) ? plugin.deps : [],
-        handler: plugin.handler
+        deps,
+        handler
       });
     } catch (error) {
       Logger.error({ err: error, plugin: pluginName, msg: "\u63D2\u4EF6\u521D\u59CB\u5316\u5931\u8D25" });
@@ -8795,28 +8924,40 @@ async function syncApi(ctx, apis) {
     if (api.type !== "api") {
       continue;
     }
-    const auth = api.auth === false || api.auth === 0 ? 0 : 1;
-    const parentPath = getApiParentPath(api.path);
-    apiRouteKeys.add(api.path);
-    const item = allDbApiMap[api.path];
+    const record = api;
+    const path = record["path"];
+    const name = record["name"];
+    const addonNameRaw = record["addonName"];
+    if (typeof path !== "string" || path.trim() === "") {
+      continue;
+    }
+    if (typeof name !== "string" || name.trim() === "") {
+      continue;
+    }
+    const addonName = typeof addonNameRaw === "string" ? addonNameRaw : "";
+    const authRaw = record["auth"];
+    const auth = authRaw === false || authRaw === 0 ? 0 : 1;
+    const parentPath = getApiParentPath(path);
+    apiRouteKeys.add(path);
+    const item = allDbApiMap[path];
     if (item) {
-      const shouldUpdate = api.name !== item.name || api.path !== item.path || api.addonName !== item.addonName || parentPath !== item.parentPath || auth !== item.auth;
+      const shouldUpdate = name !== item.name || path !== item.path || addonName !== item.addonName || parentPath !== item.parentPath || auth !== item.auth;
       if (shouldUpdate) {
         updData.push({
           id: item.id,
-          name: api.name,
-          path: api.path,
+          name,
+          path,
           parentPath,
-          addonName: api.addonName,
+          addonName,
           auth
         });
       }
     } else {
       insData.push({
-        name: api.name,
-        path: api.path,
+        name,
+        path,
         parentPath,
-        addonName: api.addonName,
+        addonName,
         auth
       });
     }
@@ -8956,10 +9097,7 @@ class Cipher {
     }
   }
   static async hashPassword(password, options = {}) {
-    const finalOptions = {
-      algorithm: "bcrypt",
-      ...options
-    };
+    const finalOptions = Object.assign({}, options, { algorithm: "bcrypt" });
     return await Bun.password.hash(password, finalOptions);
   }
   static async verifyPassword(password, hash) {
@@ -9034,8 +9172,8 @@ async function syncDev(ctx, config2 = {}) {
     code: "dev",
     name: "\u5F00\u53D1\u8005\u89D2\u8272",
     description: "\u62E5\u6709\u6240\u6709\u83DC\u5355\u548C\u63A5\u53E3\u6743\u9650\u7684\u5F00\u53D1\u8005\u89D2\u8272",
-    menus: allMenus.data.lists.map((item) => item.path).filter((v) => v),
-    apis: allApis.data.lists.map((item) => item.path).filter((v) => v),
+    menus: allMenus.data.lists.map((item) => item.path).filter((v) => typeof v === "string" && v.length > 0),
+    apis: allApis.data.lists.map((item) => item.path).filter((v) => typeof v === "string" && v.length > 0),
     sort: 0
   };
   if (typeof devRole.data.id === "number") {
@@ -9173,12 +9311,13 @@ function createDisableMenuMatcher(ctx) {
       candidates.push(`/${trimmed}`);
     }
     for (const glob of globs) {
-      const match = glob.match;
+      const match = typeof glob === "object" && glob !== null && "match" in glob ? glob.match : undefined;
       if (typeof match !== "function") {
         throw new Error("syncMenu: \u5F53\u524D Bun \u7248\u672C\u4E0D\u652F\u6301 Bun.Glob.match\uFF0C\u65E0\u6CD5\u6309 disableMenus \u505A glob \u5339\u914D");
       }
+      const matchFn = match;
       for (const candidate of candidates) {
-        if (match.call(glob, candidate)) {
+        if (matchFn.call(glob, candidate)) {
           return true;
         }
       }
@@ -9511,12 +9650,9 @@ class MySqlDialect {
     return { sql: `SHOW COLUMNS FROM ${quotedTable}`, params: [] };
   }
   getTableColumnsFromResult(result) {
-    if (!Array.isArray(result)) {
-      return [];
-    }
     const columnNames = [];
     for (const row of result) {
-      const name = row?.Field;
+      const name = row["Field"];
       if (typeof name === "string" && name.length > 0) {
         columnNames.push(name);
       }
@@ -9557,12 +9693,9 @@ class PostgresDialect {
     return { sql: "SELECT column_name FROM information_schema.columns WHERE table_schema = current_schema() AND table_name = ? ORDER BY ordinal_position", params: [table] };
   }
   getTableColumnsFromResult(result) {
-    if (!Array.isArray(result)) {
-      return [];
-    }
     const columnNames = [];
     for (const row of result) {
-      const name = row?.column_name;
+      const name = row["column_name"];
       if (typeof name === "string" && name.length > 0) {
         columnNames.push(name);
       }
@@ -9598,12 +9731,9 @@ class SqliteDialect {
     return { sql: `PRAGMA table_info(${quotedTable})`, params: [] };
   }
   getTableColumnsFromResult(result) {
-    if (!Array.isArray(result)) {
-      return [];
-    }
     const columnNames = [];
     for (const row of result) {
-      const name = row?.name;
+      const name = row["name"];
       if (typeof name === "string" && name.length > 0) {
         columnNames.push(name);
       }
@@ -9696,10 +9826,11 @@ var syncTable = async (ctx, items) => {
         applyFieldDefaults(fieldDef);
       }
       const existsTable = await tableExistsRuntime(runtime, tableName);
+      const tableFields = tableDefinition;
       if (existsTable) {
-        await modifyTableRuntime(runtime, tableName, tableDefinition);
+        await modifyTableRuntime(runtime, tableName, tableFields);
       } else {
-        await createTable(runtime, tableName, tableDefinition);
+        await createTable(runtime, tableName, tableFields);
       }
       processedTables.push(tableName);
     }
@@ -9832,19 +9963,99 @@ function quoteIdentifier(dbDialect, identifier) {
 function escapeComment(str) {
   return String(str).replace(/"/g, "\\\"");
 }
+function normalizeColumnDefaultValue(value) {
+  if (value === null)
+    return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (Array.isArray(value)) {
+    const items = [];
+    for (const v of value) {
+      items.push(normalizeColumnDefaultValue(v));
+    }
+    return items;
+  }
+  return String(value);
+}
+function isJsonValue(value) {
+  if (value === null)
+    return true;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return true;
+  if (Array.isArray(value)) {
+    return value.every((v) => isJsonValue(v));
+  }
+  if (typeof value === "object") {
+    for (const v of Object.values(value)) {
+      if (v === undefined)
+        continue;
+      if (!isJsonValue(v))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
 function applyFieldDefaults(fieldDef) {
   if (!fieldDef || typeof fieldDef !== "object")
     return;
-  const normalized = normalizeFieldDefinition(fieldDef);
-  fieldDef.detail = normalized.detail;
-  fieldDef.min = normalized.min;
-  fieldDef.max = normalized.max;
-  fieldDef.default = normalized.default;
-  fieldDef.index = normalized.index;
-  fieldDef.unique = normalized.unique;
-  fieldDef.nullable = normalized.nullable;
-  fieldDef.unsigned = normalized.unsigned;
-  fieldDef.regexp = normalized.regexp;
+  const record = fieldDef;
+  const name = record["name"];
+  const type = record["type"];
+  if (typeof name !== "string" || typeof type !== "string")
+    return;
+  const minRaw = record["min"];
+  const maxRaw = record["max"];
+  const defaultRaw = record["default"];
+  const detailRaw = record["detail"];
+  const indexRaw = record["index"];
+  const uniqueRaw = record["unique"];
+  const nullableRaw = record["nullable"];
+  const unsignedRaw = record["unsigned"];
+  const regexpRaw = record["regexp"];
+  const input = {
+    name,
+    type
+  };
+  if (typeof detailRaw === "string") {
+    input.detail = detailRaw;
+  }
+  if (typeof minRaw === "number" || minRaw === null) {
+    input.min = minRaw;
+  }
+  if (typeof maxRaw === "number" || maxRaw === null) {
+    input.max = maxRaw;
+  }
+  if (defaultRaw === null) {
+    input.default = null;
+  } else if (isJsonValue(defaultRaw)) {
+    input.default = defaultRaw;
+  }
+  if (typeof indexRaw === "boolean") {
+    input.index = indexRaw;
+  }
+  if (typeof uniqueRaw === "boolean") {
+    input.unique = uniqueRaw;
+  }
+  if (typeof nullableRaw === "boolean") {
+    input.nullable = nullableRaw;
+  }
+  if (typeof unsignedRaw === "boolean") {
+    input.unsigned = unsignedRaw;
+  }
+  if (typeof regexpRaw === "string" || regexpRaw === null) {
+    input.regexp = regexpRaw;
+  }
+  const normalized = normalizeFieldDefinition(input);
+  record["detail"] = normalized.detail;
+  record["min"] = normalized.min;
+  record["max"] = normalized.max;
+  record["default"] = normalized.default;
+  record["index"] = normalized.index;
+  record["unique"] = normalized.unique;
+  record["nullable"] = normalized.nullable;
+  record["unsigned"] = normalized.unsigned;
+  record["regexp"] = normalized.regexp;
 }
 function isStringOrArrayType(fieldType) {
   return fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string";
@@ -10022,7 +10233,8 @@ function isCompatibleTypeChange(currentType, newType) {
   return false;
 }
 async function tableExistsRuntime(runtime, tableName) {
-  if (!runtime.db)
+  const db = runtime.db;
+  if (!db)
     throw new Error("SQL \u6267\u884C\u5668\u672A\u521D\u59CB\u5316");
   try {
     let schema = undefined;
@@ -10032,7 +10244,7 @@ async function tableExistsRuntime(runtime, tableName) {
       schema = "public";
     }
     const q = getDialectByName(runtime.dbDialect).tableExistsQuery(tableName, schema);
-    const res = await runtime.db.unsafe(q.sql, q.params);
+    const res = await db.unsafe(q.sql, q.params);
     return (res.data?.[0]?.count || 0) > 0;
   } catch (error) {
     const errMsg = String(error?.message || error);
@@ -10044,12 +10256,15 @@ async function tableExistsRuntime(runtime, tableName) {
 }
 async function getTableColumnsRuntime(runtime, tableName) {
   const columns = {};
+  const db = runtime.db;
+  if (!db)
+    throw new Error("SQL \u6267\u884C\u5668\u672A\u521D\u59CB\u5316");
   try {
     if (runtime.dbDialect === "mysql") {
       const q = getSyncTableColumnsInfoQuery({ dialect: "mysql", table: tableName, dbName: runtime.dbName });
-      const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
+      const result = await db.unsafe(q.columns.sql, q.columns.params);
       for (const row of result.data) {
-        const defaultValue = row.COLUMN_DEFAULT;
+        const defaultValue = normalizeColumnDefaultValue(row.COLUMN_DEFAULT);
         columns[row.COLUMN_NAME] = {
           type: row.DATA_TYPE,
           columnType: row.COLUMN_TYPE,
@@ -10062,8 +10277,8 @@ async function getTableColumnsRuntime(runtime, tableName) {
       }
     } else if (runtime.dbDialect === "postgresql") {
       const q = getSyncTableColumnsInfoQuery({ dialect: "postgresql", table: tableName, dbName: runtime.dbName });
-      const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
-      const comments = q.comments ? (await runtime.db.unsafe(q.comments.sql, q.comments.params)).data : [];
+      const result = await db.unsafe(q.columns.sql, q.columns.params);
+      const comments = q.comments ? (await db.unsafe(q.comments.sql, q.comments.params)).data : [];
       const commentMap = {};
       for (const r of comments)
         commentMap[r.column_name] = r.column_comment;
@@ -10074,13 +10289,13 @@ async function getTableColumnsRuntime(runtime, tableName) {
           length: row.character_maximum_length,
           max: row.character_maximum_length,
           nullable: String(row.is_nullable).toUpperCase() === "YES",
-          defaultValue: row.column_default,
+          defaultValue: normalizeColumnDefaultValue(row.column_default),
           comment: commentMap[row.column_name] ?? null
         };
       }
     } else if (runtime.dbDialect === "sqlite") {
       const q = getSyncTableColumnsInfoQuery({ dialect: "sqlite", table: tableName, dbName: runtime.dbName });
-      const result = await runtime.db.unsafe(q.columns.sql, q.columns.params);
+      const result = await db.unsafe(q.columns.sql, q.columns.params);
       for (const row of result.data) {
         let baseType = String(row.type || "").toUpperCase();
         let max = null;
@@ -10101,7 +10316,7 @@ async function getTableColumnsRuntime(runtime, tableName) {
           length: max,
           max,
           nullable: row.notnull === 0,
-          defaultValue: row.dflt_value,
+          defaultValue: normalizeColumnDefaultValue(row.dflt_value),
           comment: null
         };
       }
@@ -10117,10 +10332,13 @@ async function getTableColumnsRuntime(runtime, tableName) {
 }
 async function getTableIndexesRuntime(runtime, tableName) {
   const indexes = {};
+  const db = runtime.db;
+  if (!db)
+    throw new Error("SQL \u6267\u884C\u5668\u672A\u521D\u59CB\u5316");
   try {
     if (runtime.dbDialect === "mysql") {
       const q = getSyncTableIndexesQuery({ dialect: "mysql", table: tableName, dbName: runtime.dbName });
-      const result = await runtime.db.unsafe(q.sql, q.params);
+      const result = await db.unsafe(q.sql, q.params);
       for (const row of result.data) {
         const indexName = row.INDEX_NAME;
         const current = indexes[indexName];
@@ -10132,7 +10350,7 @@ async function getTableIndexesRuntime(runtime, tableName) {
       }
     } else if (runtime.dbDialect === "postgresql") {
       const q = getSyncTableIndexesQuery({ dialect: "postgresql", table: tableName, dbName: runtime.dbName });
-      const result = await runtime.db.unsafe(q.sql, q.params);
+      const result = await db.unsafe(q.sql, q.params);
       for (const row of result.data) {
         const m = /\(([^)]+)\)/.exec(row.indexdef);
         if (m) {
@@ -10143,10 +10361,10 @@ async function getTableIndexesRuntime(runtime, tableName) {
       }
     } else if (runtime.dbDialect === "sqlite") {
       const quotedTable = quoteIdentifier("sqlite", tableName);
-      const list = await runtime.db.unsafe(`PRAGMA index_list(${quotedTable})`);
+      const list = await db.unsafe(`PRAGMA index_list(${quotedTable})`);
       for (const idx of list.data) {
         const quotedIndex = quoteIdentifier("sqlite", idx.name);
-        const info = await runtime.db.unsafe(`PRAGMA index_info(${quotedIndex})`);
+        const info = await db.unsafe(`PRAGMA index_info(${quotedIndex})`);
         const cols = info.data.map((r) => r.name);
         if (cols.length === 1)
           indexes[idx.name] = cols;
@@ -12173,7 +12391,7 @@ var permissionHook = {
     if (ctx.api.auth === false) {
       return;
     }
-    if (!ctx.user || !ctx.user.id) {
+    if (typeof ctx.user.id !== "number") {
       ctx.response = ErrorResponse(ctx, "\u672A\u767B\u5F55", 1, null, null, "auth");
       return;
     }
@@ -12285,28 +12503,75 @@ function getCompiledRegex(pattern, flags) {
 }
 
 // lib/validator.ts
+init_util();
+
 class Validator {
   static validate(data, rules, required = []) {
     const fieldErrors = {};
-    if (!data || typeof data !== "object" || Array.isArray(data)) {
+    if (!isPlainObject(data)) {
       return this.buildResult({ _error: "\u6570\u636E\u5FC5\u987B\u662F\u5BF9\u8C61\u683C\u5F0F" });
     }
-    if (!rules || typeof rules !== "object") {
+    if (!isPlainObject(rules)) {
       return this.buildResult({ _error: "\u9A8C\u8BC1\u89C4\u5219\u5FC5\u987B\u662F\u5BF9\u8C61\u683C\u5F0F" });
     }
+    const dataRecord = data;
+    const rulesRecord = rules;
     for (const field of required) {
-      const value = data[field];
+      const value = dataRecord[field];
       if (value === undefined || value === null) {
-        const label = rules[field]?.name || field;
+        const rawRule = rulesRecord[field];
+        const label = isPlainObject(rawRule) && typeof rawRule["name"] === "string" ? rawRule["name"] : field;
         fieldErrors[field] = `${label}\u4E3A\u5FC5\u586B\u9879`;
       }
     }
-    for (const [field, rule] of Object.entries(rules)) {
+    for (const [field, rawRule] of Object.entries(rulesRecord)) {
       if (fieldErrors[field])
         continue;
-      if (data[field] === undefined && !required.includes(field))
+      if (dataRecord[field] === undefined && !required.includes(field))
+        continue;
+      if (!isPlainObject(rawRule)) {
+        fieldErrors[field] = `${field}\u9A8C\u8BC1\u89C4\u5219\u5FC5\u987B\u662F\u5BF9\u8C61\u683C\u5F0F`;
+        continue;
+      }
+      const ruleName = rawRule["name"];
+      const ruleType = rawRule["type"];
+      if (typeof ruleName !== "string" || typeof ruleType !== "string") {
+        fieldErrors[field] = `${field}\u9A8C\u8BC1\u89C4\u5219\u65E0\u6548`;
         continue;
-      const error = this.checkField(data[field], rule, field);
+      }
+      const rule = {
+        name: ruleName,
+        type: ruleType
+      };
+      const min = rawRule["min"];
+      if (typeof min === "number" || min === null)
+        rule.min = min;
+      const max = rawRule["max"];
+      if (typeof max === "number" || max === null)
+        rule.max = max;
+      const def = rawRule["default"];
+      if (def === null || typeof def === "string" || typeof def === "number" || typeof def === "boolean" || Array.isArray(def) || isPlainObject(def)) {
+        rule.default = def;
+      }
+      const detail = rawRule["detail"];
+      if (typeof detail === "string")
+        rule.detail = detail;
+      const index = rawRule["index"];
+      if (typeof index === "boolean")
+        rule.index = index;
+      const unique = rawRule["unique"];
+      if (typeof unique === "boolean")
+        rule.unique = unique;
+      const nullable = rawRule["nullable"];
+      if (typeof nullable === "boolean")
+        rule.nullable = nullable;
+      const unsigned = rawRule["unsigned"];
+      if (typeof unsigned === "boolean")
+        rule.unsigned = unsigned;
+      const regexp = rawRule["regexp"];
+      if (typeof regexp === "string" || regexp === null)
+        rule.regexp = regexp;
+      const error = this.checkField(dataRecord[field], rule, field);
       if (error)
         fieldErrors[field] = error;
     }
@@ -12392,6 +12657,8 @@ class Validator {
     const regex = this.resolveRegex(regexp);
     switch (type.toLowerCase()) {
       case "number":
+        if (typeof value !== "number")
+          return "\u5FC5\u987B\u662F\u6570\u5B57";
         if (min !== null && value < min)
           return `\u4E0D\u80FD\u5C0F\u4E8E${min}`;
         if (max !== null && max > 0 && value > max)
@@ -12401,6 +12668,8 @@ class Validator {
         break;
       case "string":
       case "text":
+        if (typeof value !== "string")
+          return "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32";
         if (min !== null && value.length < min)
           return `\u957F\u5EA6\u4E0D\u80FD\u5C11\u4E8E${min}\u4E2A\u5B57\u7B26`;
         if (max !== null && max > 0 && value.length > max)
@@ -12412,6 +12681,8 @@ class Validator {
       case "array_text":
       case "array_number_string":
       case "array_number_text":
+        if (!Array.isArray(value))
+          return "\u5FC5\u987B\u662F\u6570\u7EC4";
         if (min !== null && value.length < min)
           return `\u81F3\u5C11\u9700\u8981${min}\u4E2A\u5143\u7D20`;
         if (max !== null && max > 0 && value.length > max)
@@ -12769,8 +13040,9 @@ function convertBigIntFields(arr, fields = ["id", "pid", "sort"]) {
     return arr;
   }
   return arr.map((item) => {
+    const source = item;
     const converted = {};
-    for (const [key, value] of Object.entries(item)) {
+    for (const [key, value] of Object.entries(source)) {
       converted[key] = value;
     }
     for (const [key, value] of Object.entries(converted)) {
@@ -12780,7 +13052,7 @@ function convertBigIntFields(arr, fields = ["id", "pid", "sort"]) {
       const shouldConvert = fields.includes(key) || key.endsWith("Id") || key.endsWith("_id") || key.endsWith("At") || key.endsWith("_at");
       if (shouldConvert && typeof value === "string") {
         const num = Number(value);
-        if (!isNaN(num)) {
+        if (!Number.isNaN(num)) {
           converted[key] = num;
         }
       }
@@ -12839,6 +13111,82 @@ function fieldClear(data, options = {}) {
   return data;
 }
 
+// utils/sqlParams.ts
+function isJsonPrimitive(value) {
+  if (value === null)
+    return true;
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isJsonObject(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  if (value instanceof Date)
+    return false;
+  if (Array.isArray(value))
+    return false;
+  return true;
+}
+function isJsonValue2(value) {
+  if (isJsonPrimitive(value))
+    return true;
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (!isJsonValue2(item))
+        return false;
+    }
+    return true;
+  }
+  if (isJsonObject(value)) {
+    for (const v of Object.values(value)) {
+      if (v === undefined)
+        continue;
+      if (!isJsonValue2(v))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function toSqlParams(params) {
+  if (!Array.isArray(params)) {
+    return [];
+  }
+  const out = [];
+  for (const value of params) {
+    if (value === null) {
+      out.push(null);
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      out.push(value);
+      continue;
+    }
+    if (typeof value === "bigint") {
+      out.push(String(value));
+      continue;
+    }
+    if (value instanceof Date) {
+      out.push(value);
+      continue;
+    }
+    if (isJsonValue2(value)) {
+      out.push(value);
+      continue;
+    }
+    out.push(String(value));
+  }
+  return out;
+}
+
+// utils/sqlResult.ts
+function toNumberFromSql(value) {
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "bigint")
+    return Number(value);
+  return 0;
+}
+
 // lib/dbHelper.ts
 init_util();
 
@@ -13065,7 +13413,7 @@ class DbUtils {
     for (const [key, value] of Object.entries(where)) {
       const newKey = DbUtils.processJoinWhereKey(key);
       if (key === "$or" || key === "$and") {
-        result[newKey] = value.map((item) => DbUtils.processJoinWhere(item));
+        result[newKey] = Array.isArray(value) ? value.map((item) => DbUtils.processJoinWhere(item)) : [];
       } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         result[newKey] = DbUtils.processJoinWhere(value);
       } else {
@@ -13124,7 +13472,7 @@ class DbUtils {
     const result = {};
     for (const [key, value] of Object.entries(where)) {
       if (key === "$or" || key === "$and") {
-        result[key] = value.map((item) => DbUtils.whereKeysToSnake(item));
+        result[key] = Array.isArray(value) ? value.map((item) => DbUtils.whereKeysToSnake(item)) : [];
         continue;
       }
       if (key.includes("$")) {
@@ -13661,13 +14009,20 @@ class SqlBuilder {
       }
       if (key === "$and") {
         if (Array.isArray(value)) {
-          value.forEach((condition) => this._processWhereConditions(condition));
+          value.forEach((condition) => {
+            if (condition && typeof condition === "object" && !Array.isArray(condition)) {
+              this._processWhereConditions(condition);
+            }
+          });
         }
       } else if (key === "$or") {
         if (Array.isArray(value)) {
           const orConditions = [];
           const tempParams = [];
           value.forEach((condition) => {
+            if (!condition || typeof condition !== "object" || Array.isArray(condition)) {
+              return;
+            }
             const tempBuilder = new SqlBuilder({ quoteIdent: this._quoteIdent });
             tempBuilder._processWhereConditions(condition);
             if (tempBuilder._where.length > 0) {
@@ -13912,7 +14267,8 @@ class SqlBuilder {
         throw new Error(SqlBuilderError.INSERT_NEED_AT_LEAST_ONE_FIELD(table));
       }
       for (const field of fields) {
-        this._validateParam(data[field]);
+        const record = data;
+        this._validateParam(record[field]);
       }
       const escapedFields = fields.map((field) => this._escapeField(field));
       const placeholders = fields.map(() => "?").join(", ");
@@ -14049,6 +14405,23 @@ class SqlBuilder {
 
 // lib/dbHelper.ts
 var TABLE_COLUMNS_CACHE_TTL_SECONDS = 3600;
+function hasBegin(sql) {
+  return typeof sql.begin === "function";
+}
+
+class DbSqlError extends Error {
+  originalError;
+  params;
+  duration;
+  sqlInfo;
+  constructor(message, options) {
+    super(message);
+    this.originalError = options.originalError;
+    this.params = options.params;
+    this.duration = options.duration;
+    this.sqlInfo = options.sqlInfo;
+  }
+}
 
 class DbHelper {
   redis;
@@ -14071,7 +14444,7 @@ class DbHelper {
       return columns;
     }
     const query = this.dialect.getTableColumnsQuery(table);
-    const execRes = await this.executeWithConn(query.sql, query.params);
+    const execRes = await this.executeSelect(query.sql, query.params);
     const result = execRes.data;
     if (!result || result.length === 0) {
       throw new Error(`\u8868 ${table} \u4E0D\u5B58\u5728\u6216\u6CA1\u6709\u5B57\u6BB5`);
@@ -14133,6 +14506,12 @@ class DbHelper {
       }
     }
   }
+  async executeSelect(sqlStr, params) {
+    return await this.executeWithConn(sqlStr, params);
+  }
+  async executeRun(sqlStr, params) {
+    return await this.executeWithConn(sqlStr, params);
+  }
   async executeWithConn(sqlStr, params) {
     if (!this.sql) {
       throw new Error("\u6570\u636E\u5E93\u8FDE\u63A5\u672A\u521D\u59CB\u5316");
@@ -14141,7 +14520,7 @@ class DbHelper {
       throw new Error(`executeWithConn \u53EA\u63A5\u53D7\u5B57\u7B26\u4E32\u7C7B\u578B\u7684 SQL\uFF0C\u6536\u5230\u7C7B\u578B: ${typeof sqlStr}\uFF0C\u503C: ${JSON.stringify(sqlStr)}`);
     }
     const startTime = Date.now();
-    const safeParams = Array.isArray(params) ? params : [];
+    const safeParams = toSqlParams(params);
     try {
       let result;
       if (safeParams.length > 0) {
@@ -14161,16 +14540,17 @@ class DbHelper {
       };
     } catch (error) {
       const duration = Date.now() - startTime;
-      const enhancedError = new Error(`SQL\u6267\u884C\u5931\u8D25: ${error.message}`);
-      enhancedError.originalError = error;
-      enhancedError.params = safeParams;
-      enhancedError.duration = duration;
-      enhancedError.sqlInfo = {
-        sql: sqlStr,
+      const msg = error instanceof Error ? error.message : String(error);
+      throw new DbSqlError(`SQL\u6267\u884C\u5931\u8D25: ${msg}`, {
+        originalError: error,
         params: safeParams,
-        duration
-      };
-      throw enhancedError;
+        duration,
+        sqlInfo: {
+          sql: sqlStr,
+          params: safeParams,
+          duration
+        }
+      });
     }
   }
   async unsafe(sqlStr, params) {
@@ -14179,7 +14559,7 @@ class DbHelper {
   async tableExists(tableName) {
     const snakeTableName = snakeCase(tableName);
     const query = this.dialect.tableExistsQuery(snakeTableName);
-    const execRes = await this.executeWithConn(query.sql, query.params);
+    const execRes = await this.executeSelect(query.sql, query.params);
     const exists = (execRes.data?.[0]?.count || 0) > 0;
     return {
       data: exists,
@@ -14192,7 +14572,7 @@ class DbHelper {
     const builder = this.createSqlBuilder().selectRaw("COUNT(*) as count").from(table).where(DbUtils.addDefaultStateFilter(where, tableQualifier, hasJoins));
     this.applyJoins(builder, joins);
     const { sql, params } = builder.toSelectSql();
-    const execRes = await this.executeWithConn(sql, params);
+    const execRes = await this.executeSelect(sql, params);
     const count = execRes.data?.[0]?.count || 0;
     return {
       data: count,
@@ -14205,7 +14585,7 @@ class DbHelper {
     const builder = this.createSqlBuilder().select(fields).from(table).where(DbUtils.addDefaultStateFilter(where, tableQualifier, hasJoins));
     this.applyJoins(builder, joins);
     const { sql, params } = builder.toSelectSql();
-    const execRes = await this.executeWithConn(sql, params);
+    const execRes = await this.executeSelect(sql, params);
     const result = execRes.data;
     const row = result?.[0] || null;
     if (!row) {
@@ -14244,7 +14624,7 @@ class DbHelper {
     const countBuilder = this.createSqlBuilder().selectRaw("COUNT(*) as total").from(prepared.table).where(whereFiltered);
     this.applyJoins(countBuilder, prepared.joins);
     const { sql: countSql, params: countParams } = countBuilder.toSelectSql();
-    const countExecRes = await this.executeWithConn(countSql, countParams);
+    const countExecRes = await this.executeSelect(countSql, countParams);
     const total = countExecRes.data?.[0]?.total || 0;
     if (total === 0) {
       return {
@@ -14267,7 +14647,7 @@ class DbHelper {
       dataBuilder.orderBy(prepared.orderBy);
     }
     const { sql: dataSql, params: dataParams } = dataBuilder.toSelectSql();
-    const dataExecRes = await this.executeWithConn(dataSql, dataParams);
+    const dataExecRes = await this.executeSelect(dataSql, dataParams);
     const list = dataExecRes.data || [];
     const camelList = arrayKeysToCamel(list);
     const deserializedList = camelList.map((item) => DbUtils.deserializeArrayFields(item)).filter((item) => item !== null);
@@ -14306,7 +14686,7 @@ class DbHelper {
     const countBuilder = this.createSqlBuilder().selectRaw("COUNT(*) as total").from(prepared.table).where(whereFiltered);
     this.applyJoins(countBuilder, prepared.joins);
     const { sql: countSql, params: countParams } = countBuilder.toSelectSql();
-    const countExecRes = await this.executeWithConn(countSql, countParams);
+    const countExecRes = await this.executeSelect(countSql, countParams);
     const total = countExecRes.data?.[0]?.total || 0;
     if (total === 0) {
       return {
@@ -14325,7 +14705,7 @@ class DbHelper {
       dataBuilder.orderBy(prepared.orderBy);
     }
     const { sql: dataSql, params: dataParams } = dataBuilder.toSelectSql();
-    const dataExecRes = await this.executeWithConn(dataSql, dataParams);
+    const dataExecRes = await this.executeSelect(dataSql, dataParams);
     const result = dataExecRes.data || [];
     if (result.length >= WARNING_LIMIT) {
       Logger.warn({ table: options.table, count: result.length, total, msg: "getAll \u8FD4\u56DE\u6570\u636E\u8FC7\u591A\uFF0C\u5EFA\u8BAE\u4F7F\u7528 getList \u5206\u9875\u67E5\u8BE2" });
@@ -14361,8 +14741,11 @@ class DbHelper {
     SqlCheck.assertNoUndefinedInRecord(processed, `insData \u63D2\u5165\u6570\u636E (table: ${snakeTable})`);
     const builder = this.createSqlBuilder();
     const { sql, params } = builder.toInsertSql(snakeTable, processed);
-    const execRes = await this.executeWithConn(sql, params);
-    const insertedId = processed["id"] || execRes.data?.lastInsertRowid || 0;
+    const execRes = await this.executeRun(sql, params);
+    const processedId = processed["id"];
+    const processedIdNum = typeof processedId === "number" ? processedId : 0;
+    const lastInsertRowidNum = toNumberFromSql(execRes.data?.lastInsertRowid);
+    const insertedId = processedIdNum || lastInsertRowidNum || 0;
     return {
       data: insertedId,
       sql: execRes.sql
@@ -14397,7 +14780,7 @@ class DbHelper {
     const builder = this.createSqlBuilder();
     const { sql, params } = builder.toInsertSql(snakeTable, processedList);
     try {
-      const execRes = await this.executeWithConn(sql, params);
+      const execRes = await this.executeRun(sql, params);
       return {
         data: ids,
         sql: execRes.sql
@@ -14429,8 +14812,8 @@ class DbHelper {
       ids,
       quoteIdent: this.dialect.quoteIdent.bind(this.dialect)
     });
-    const execRes = await this.executeWithConn(query.sql, query.params);
-    const changes = execRes.data?.changes || 0;
+    const execRes = await this.executeRun(query.sql, query.params);
+    const changes = toNumberFromSql(execRes.data?.changes);
     return {
       data: changes,
       sql: execRes.sql
@@ -14474,8 +14857,8 @@ class DbHelper {
       stateField: "state",
       stateGtZero: true
     });
-    const execRes = await this.executeWithConn(query.sql, query.params);
-    const changes = execRes.data?.changes || 0;
+    const execRes = await this.executeRun(query.sql, query.params);
+    const changes = toNumberFromSql(execRes.data?.changes);
     return {
       data: changes,
       sql: execRes.sql
@@ -14490,8 +14873,8 @@ class DbHelper {
     const whereFiltered = DbUtils.addDefaultStateFilter(snakeWhere, snakeTable, false);
     const builder = this.createSqlBuilder().where(whereFiltered);
     const { sql, params } = builder.toUpdateSql(snakeTable, processed);
-    const execRes = await this.executeWithConn(sql, params);
-    const changes = execRes.data?.changes || 0;
+    const execRes = await this.executeRun(sql, params);
+    const changes = toNumberFromSql(execRes.data?.changes);
     return {
       data: changes,
       sql: execRes.sql
@@ -14512,8 +14895,8 @@ class DbHelper {
     const snakeWhere = DbUtils.whereKeysToSnake(cleanWhere);
     const builder = this.createSqlBuilder().where(snakeWhere);
     const { sql, params } = builder.toDeleteSql(snakeTable);
-    const execRes = await this.executeWithConn(sql, params);
-    const changes = execRes.data?.changes || 0;
+    const execRes = await this.executeRun(sql, params);
+    const changes = toNumberFromSql(execRes.data?.changes);
     return {
       data: changes,
       sql: execRes.sql
@@ -14543,7 +14926,14 @@ class DbHelper {
     if (this.isTransaction) {
       return await callback(this);
     }
-    return await this.sql.begin(async (tx) => {
+    const sql = this.sql;
+    if (!sql) {
+      throw new Error("\u6570\u636E\u5E93\u8FDE\u63A5\u672A\u521D\u59CB\u5316");
+    }
+    if (!hasBegin(sql)) {
+      throw new Error("\u5F53\u524D SQL \u5BA2\u6237\u7AEF\u4E0D\u652F\u6301\u4E8B\u52A1 begin() \u65B9\u6CD5");
+    }
+    return await sql.begin(async (tx) => {
       const trans = new DbHelper({ redis: this.redis, sql: tx, dialect: this.dialect });
       return await callback(trans);
     });
@@ -14552,10 +14942,19 @@ class DbHelper {
     return await this.executeWithConn(sql, params);
   }
   async exists(options) {
-    const { table, where, tableQualifier } = await this.prepareQueryOptions({ ...options, page: 1, limit: 1 });
+    const prepareOptions = {
+      table: options.table,
+      page: 1,
+      limit: 1
+    };
+    if (options.where !== undefined)
+      prepareOptions.where = options.where;
+    if (options.joins !== undefined)
+      prepareOptions.joins = options.joins;
+    const { table, where, tableQualifier } = await this.prepareQueryOptions(prepareOptions);
     const builder = this.createSqlBuilder().selectRaw("COUNT(1) as cnt").from(table).where(DbUtils.addDefaultStateFilter(where, tableQualifier, false)).limit(1);
     const { sql, params } = builder.toSelectSql();
-    const execRes = await this.executeWithConn(sql, params);
+    const execRes = await this.executeSelect(sql, params);
     const exists = (execRes.data?.[0]?.cnt || 0) > 0;
     return {
       data: exists,
@@ -14583,6 +14982,12 @@ class DbHelper {
     oneOptions.fields = [field];
     const oneRes = await this.getOne(oneOptions);
     const result = oneRes.data;
+    if (!isPlainObject(result)) {
+      return {
+        data: null,
+        sql: oneRes.sql
+      };
+    }
     if (Object.hasOwn(result, field)) {
       return {
         data: result[field],
@@ -14628,8 +15033,8 @@ class DbHelper {
     const quotedTable = this.dialect.quoteIdent(snakeTable);
     const quotedField = this.dialect.quoteIdent(snakeField);
     const sql = whereClause ? `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ? WHERE ${whereClause}` : `UPDATE ${quotedTable} SET ${quotedField} = ${quotedField} + ?`;
-    const execRes = await this.executeWithConn(sql, [value, ...whereParams]);
-    const changes = execRes.data?.changes || 0;
+    const execRes = await this.executeRun(sql, [value, ...whereParams]);
+    const changes = toNumberFromSql(execRes.data?.changes);
     return {
       data: changes,
       sql: execRes.sql
@@ -15211,9 +15616,12 @@ var tool_default = toolPlugin;
 // utils/scanCoreBuiltins.ts
 init_util();
 function toCoreBuiltinScanFileResult(type, item) {
-  const name = item.name;
+  const record = isPlainObject(item) ? item : {};
+  const name = typeof record["name"] === "string" ? String(record["name"]) : "";
   const customKeys = isPlainObject(item) ? Object.keys(item) : [];
-  return {
+  const depsRaw = record["deps"];
+  const deps = Array.isArray(depsRaw) ? depsRaw.filter((x) => typeof x === "string") : [];
+  const out = {
     source: "core",
     type,
     sourceName: "\u6838\u5FC3",
@@ -15225,11 +15633,12 @@ function toCoreBuiltinScanFileResult(type, item) {
     fileBaseName: name,
     fileDir: "(builtin)",
     name,
-    enable: item ? item.enable : undefined,
-    deps: Array.isArray(item && item.deps) ? item.deps : [],
-    handler: item ? item.handler : null,
+    enable: record["enable"],
+    deps,
+    handler: record["handler"] ?? null,
     customKeys
   };
+  return out;
 }
 function scanCoreBuiltinPlugins() {
   const plugins = [];
@@ -15344,7 +15753,7 @@ async function scanFiles(dir, source, type, pattern) {
         customKeys: isPlainObject(content) ? Object.keys(content) : []
       };
       if (type === "table") {
-        base["content"] = content;
+        base["content"] = isPlainObject(content) ? content : {};
         results.push(base);
         continue;
       }