befly 3.14.1 → 3.14.2

package/dist/befly.js

@@ -8100,10 +8100,10 @@ async function checkTable(tables) {
             hasError = true;
           }
         } else if (fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
-          if (fieldMax !== undefined && (fieldMax === null || typeof fieldMax !== "number")) {
-            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${fieldType} \u7C7B\u578B\uFF0C` + `\u6700\u5927\u957F\u5EA6\u5FC5\u987B\u4E3A\u6570\u5B57\uFF0C\u5F53\u524D\u4E3A "${fieldMax}"`);
+          if (fieldMax === undefined || fieldMax === null || typeof fieldMax !== "number") {
+            Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u4E3A ${fieldType} \u7C7B\u578B\uFF0C` + `\u5FC5\u987B\u8BBE\u7F6E max \u4E14\u7C7B\u578B\u4E3A\u6570\u5B57\uFF1B\u5176\u4E2D array_*_string \u7684 max \u8868\u793A\u5355\u4E2A\u5143\u7D20\u957F\u5EA6\uFF0C\u5F53\u524D\u4E3A "${fieldMax}"`);
             hasError = true;
-          } else if (fieldMax !== undefined && fieldMax > MAX_VARCHAR_LENGTH) {
+          } else if (fieldMax > MAX_VARCHAR_LENGTH) {
             Logger.warn(`${tablePrefix}${fileName} \u6587\u4EF6 ${colKey} \u6700\u5927\u957F\u5EA6 ${fieldMax} \u8D8A\u754C\uFF0C` + `${fieldType} \u7C7B\u578B\u957F\u5EA6\u5FC5\u987B\u5728 1..${MAX_VARCHAR_LENGTH} \u8303\u56F4\u5185`);
             hasError = true;
           }
@@ -8317,46 +8317,14 @@ init_logger();
 
 // loader/loadApis.ts
 init_logger();
-
-// configs/presetFields.ts
-var presetFields = {
-  "@id": { name: "ID", type: "number", min: 1, max: null },
-  "@page": { name: "\u9875\u7801", type: "number", min: 1, max: 9999, default: 1 },
-  "@limit": { name: "\u6BCF\u9875\u6570\u91CF", type: "number", min: 1, max: 100, default: 30 },
-  "@keyword": { name: "\u5173\u952E\u8BCD", type: "string", min: 0, max: 50 },
-  "@state": { name: "\u72B6\u6001", type: "number", regex: "^[0-2]$" }
-};
-
-// utils/processAtSymbol.ts
-function processAtSymbol(fields, apiName, path) {
-  if (!fields || typeof fields !== "object")
-    return fields;
-  const processed = {};
-  for (const [key, value] of Object.entries(fields)) {
-    if (typeof value === "string" && value.startsWith("@")) {
-      if (presetFields[value]) {
-        processed[key] = presetFields[value];
-        continue;
-      }
-      const validKeys = Object.keys(presetFields).join(", ");
-      throw new Error(`API [${apiName}] (${path}) \u5B57\u6BB5 [${key}] \u5F15\u7528\u4E86\u672A\u5B9A\u4E49\u7684\u9884\u8BBE\u5B57\u6BB5 "${value}"\u3002\u53EF\u7528\u7684\u9884\u8BBE\u5B57\u6BB5\u6709: ${validKeys}`);
-    }
-    processed[key] = value;
-  }
-  return processed;
-}
-
-// loader/loadApis.ts
 async function loadApis(apis) {
   const apisMap = new Map;
   for (const api of apis) {
-    if (api.type !== "api") {
+    if (Object.hasOwn(api, "type") && api.type !== "api") {
       continue;
     }
     try {
-      const apiRoute = api;
-      apiRoute.fields = processAtSymbol(apiRoute.fields || {}, apiRoute.name, apiRoute.path);
-      apisMap.set(apiRoute.path, apiRoute);
+      apisMap.set(api.path, api);
     } catch (error) {
       Logger.error({ err: error, api: api.relativePath, file: api.filePath, msg: "\u63A5\u53E3\u52A0\u8F7D\u5931\u8D25" });
       throw error;
@@ -9070,7 +9038,7 @@ async function syncDev(ctx, config2 = {}) {
     apis: allApis.data.lists.map((item) => item.path).filter((v) => v),
     sort: 0
   };
-  if (devRole.data) {
+  if (typeof devRole.data.id === "number") {
     await ctx.db.updData({
       table: "addon_admin_role",
       where: { code: "dev" },
@@ -9100,7 +9068,7 @@ async function syncDev(ctx, config2 = {}) {
     table: "addon_admin_admin",
     where: { username: "dev" }
   });
-  if (devAdmin.data) {
+  if (typeof devAdmin.data.id === "number") {
     await ctx.db.updData({
       table: "addon_admin_admin",
       where: { username: "dev" },
@@ -9652,6 +9620,25 @@ class SqliteDialect {
 
 // sync/syncTable.ts
 init_logger();
+
+// utils/normalizeFieldDefinition.ts
+function normalizeFieldDefinition(fieldDef) {
+  return {
+    name: fieldDef.name,
+    type: fieldDef.type,
+    detail: fieldDef.detail ?? "",
+    min: fieldDef.min ?? null,
+    max: fieldDef.max ?? null,
+    default: fieldDef.default ?? null,
+    index: fieldDef.index ?? false,
+    unique: fieldDef.unique ?? false,
+    nullable: fieldDef.nullable ?? false,
+    unsigned: fieldDef.unsigned ?? false,
+    regexp: fieldDef.regexp ?? null
+  };
+}
+
+// sync/syncTable.ts
 init_util();
 var syncTable = async (ctx, items) => {
   try {
@@ -9846,15 +9833,18 @@ function escapeComment(str) {
   return String(str).replace(/"/g, "\\\"");
 }
 function applyFieldDefaults(fieldDef) {
-  fieldDef.detail = fieldDef.detail ?? "";
-  fieldDef.min = fieldDef.min ?? 0;
-  fieldDef.max = fieldDef.max ?? (fieldDef.type === "number" ? Number.MAX_SAFE_INTEGER : 100);
-  fieldDef.default = fieldDef.default ?? null;
-  fieldDef.index = fieldDef.index ?? false;
-  fieldDef.unique = fieldDef.unique ?? false;
-  fieldDef.nullable = fieldDef.nullable ?? false;
-  fieldDef.unsigned = fieldDef.unsigned ?? true;
-  fieldDef.regexp = fieldDef.regexp ?? null;
+  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;
 }
 function isStringOrArrayType(fieldType) {
   return fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string";
@@ -9953,15 +9943,16 @@ function buildSystemColumnDefs(dbDialect) {
 function buildBusinessColumnDefs(dbDialect, fields) {
   const colDefs = [];
   for (const [fieldKey, fieldDef] of Object.entries(fields)) {
+    const normalized = normalizeFieldDefinition(fieldDef);
     const dbFieldName = snakeCase(fieldKey);
     const colQuoted = quoteIdentifier(dbDialect, dbFieldName);
-    const sqlType = getSqlType(dbDialect, fieldDef.type, fieldDef.max, fieldDef.unsigned);
-    const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-    const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
-    const uniqueSql = fieldDef.unique ? " UNIQUE" : "";
-    const nullableSql = fieldDef.nullable ? " NULL" : " NOT NULL";
+    const sqlType = getSqlType(dbDialect, normalized.type, normalized.max, normalized.unsigned);
+    const actualDefault = resolveDefaultValue(normalized.default, normalized.type);
+    const defaultSql = generateDefaultSql(actualDefault, normalized.type);
+    const uniqueSql = normalized.unique ? " UNIQUE" : "";
+    const nullableSql = normalized.nullable ? " NULL" : " NOT NULL";
     if (dbDialect === "mysql") {
-      colDefs.push(`${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(fieldDef.name)}"`);
+      colDefs.push(`${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(normalized.name)}"`);
     } else {
       colDefs.push(`${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql}`);
     }
@@ -9971,13 +9962,14 @@ function buildBusinessColumnDefs(dbDialect, fields) {
 function generateDDLClause(dbDialect, fieldKey, fieldDef, isAdd = false) {
   const dbFieldName = snakeCase(fieldKey);
   const colQuoted = quoteIdentifier(dbDialect, dbFieldName);
-  const sqlType = getSqlType(dbDialect, fieldDef.type, fieldDef.max, fieldDef.unsigned);
-  const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-  const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
-  const uniqueSql = fieldDef.unique ? " UNIQUE" : "";
-  const nullableSql = fieldDef.nullable ? " NULL" : " NOT NULL";
+  const normalized = normalizeFieldDefinition(fieldDef);
+  const sqlType = getSqlType(dbDialect, normalized.type, normalized.max, normalized.unsigned);
+  const actualDefault = resolveDefaultValue(normalized.default, normalized.type);
+  const defaultSql = generateDefaultSql(actualDefault, normalized.type);
+  const uniqueSql = normalized.unique ? " UNIQUE" : "";
+  const nullableSql = normalized.nullable ? " NULL" : " NOT NULL";
   if (dbDialect === "mysql") {
-    return `${isAdd ? "ADD COLUMN" : "MODIFY COLUMN"} ${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(fieldDef.name)}"`;
+    return `${isAdd ? "ADD COLUMN" : "MODIFY COLUMN"} ${colQuoted} ${sqlType}${uniqueSql}${nullableSql}${defaultSql} COMMENT "${escapeComment(normalized.name)}"`;
   }
   if (dbDialect === "postgresql") {
     if (isAdd)
@@ -10218,29 +10210,31 @@ async function ensureDbVersion(dbDialect, db) {
 }
 function compareFieldDefinition(dbDialect, existingColumn, fieldDef) {
   const changes = [];
-  if (dbDialect !== "sqlite" && isStringOrArrayType(fieldDef.type)) {
-    if (existingColumn.max !== fieldDef.max) {
+  const normalized = normalizeFieldDefinition(fieldDef);
+  if (dbDialect !== "sqlite" && isStringOrArrayType(normalized.type)) {
+    const expectedMax = normalized.max;
+    if (expectedMax !== null && existingColumn.max !== expectedMax) {
       changes.push({
         type: "length",
         current: existingColumn.max,
-        expected: fieldDef.max
+        expected: expectedMax
       });
     }
   }
   if (dbDialect !== "sqlite") {
     const currentComment = existingColumn.comment || "";
-    if (currentComment !== fieldDef.name) {
+    if (currentComment !== normalized.name) {
       changes.push({
         type: "comment",
         current: currentComment,
-        expected: fieldDef.name
+        expected: normalized.name
       });
     }
   }
   const typeMapping = getTypeMapping(dbDialect);
-  const mapped = typeMapping[fieldDef.type];
+  const mapped = typeMapping[normalized.type];
   if (typeof mapped !== "string") {
-    throw new Error(`\u672A\u77E5\u5B57\u6BB5\u7C7B\u578B\u6620\u5C04\uFF1Adialect=${dbDialect} type=${String(fieldDef.type)}`);
+    throw new Error(`\u672A\u77E5\u5B57\u6BB5\u7C7B\u578B\u6620\u5C04\uFF1Adialect=${dbDialect} type=${String(normalized.type)}`);
   }
   const expectedType = mapped.toLowerCase();
   const currentType = existingColumn.type.toLowerCase();
@@ -10251,7 +10245,7 @@ function compareFieldDefinition(dbDialect, existingColumn, fieldDef) {
       expected: expectedType
     });
   }
-  const expectedNullable = fieldDef.nullable;
+  const expectedNullable = normalized.nullable;
   if (existingColumn.nullable !== expectedNullable) {
     changes.push({
       type: "nullable",
@@ -10259,7 +10253,7 @@ function compareFieldDefinition(dbDialect, existingColumn, fieldDef) {
       expected: expectedNullable
     });
   }
-  const expectedDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
+  const expectedDefault = resolveDefaultValue(normalized.default, normalized.type);
   if (String(existingColumn.defaultValue) !== String(expectedDefault)) {
     changes.push({
       type: "default",
@@ -10419,7 +10413,7 @@ async function modifyTableRuntime(runtime, tableName, fields) {
           const changeLabel = CHANGE_TYPE_LABELS[c.type] || "\u672A\u77E5";
           Logger.debug(`  ~ \u4FEE\u6539 ${dbFieldName} ${changeLabel}: ${c.current} -> ${c.expected}`);
         }
-        if (isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && fieldDef.max !== null) {
+        if (isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && typeof fieldDef.max === "number") {
           if (existingColumns[dbFieldName].max > fieldDef.max) {
             Logger.warn(`[\u8DF3\u8FC7\u5371\u9669\u53D8\u66F4] ${tableName}.${dbFieldName} \u957F\u5EA6\u6536\u7F29 ${existingColumns[dbFieldName].max} -> ${fieldDef.max} \u5DF2\u88AB\u8DF3\u8FC7\uFF08\u9700\u624B\u52A8\u5904\u7406\uFF09`);
           }
@@ -10441,7 +10435,7 @@ async function modifyTableRuntime(runtime, tableName, fields) {
           Logger.debug(`[\u517C\u5BB9\u7C7B\u578B\u53D8\u66F4] ${tableName}.${dbFieldName} ${currentType} -> ${expectedType}`);
         }
         if (defaultChanged) {
-          const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
+          const actualDefault = resolveDefaultValue(fieldDef.default ?? null, fieldDef.type);
           let v = null;
           if (actualDefault !== "null") {
             const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
@@ -10461,7 +10455,7 @@ async function modifyTableRuntime(runtime, tableName, fields) {
         }
         if (!onlyDefaultChanged) {
           let skipModify = false;
-          if (hasLengthChange && isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && fieldDef.max !== null) {
+          if (hasLengthChange && isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && typeof fieldDef.max === "number") {
             const isShrink = existingColumns[dbFieldName].max > fieldDef.max;
             if (isShrink)
               skipModify = true;
@@ -12319,7 +12313,9 @@ class Validator {
     return this.buildResult(fieldErrors);
   }
   static single(value, fieldDef) {
-    const { type, default: defaultValue } = fieldDef;
+    const normalized = normalizeFieldDefinition(fieldDef);
+    const type = normalized.type;
+    const defaultValue = normalized.default;
     if (value === undefined || value === null || value === "") {
       return { value: this.defaultFor(type, defaultValue), error: null };
     }
@@ -12388,7 +12384,11 @@ class Validator {
     }
   }
   static checkRule(value, fieldDef) {
-    const { type, min, max, regexp } = fieldDef;
+    const normalized = normalizeFieldDefinition(fieldDef);
+    const type = normalized.type;
+    const min = normalized.min;
+    const max = normalized.max;
+    const regexp = normalized.regexp;
     const regex = this.resolveRegex(regexp);
     switch (type.toLowerCase()) {
       case "number":
@@ -12490,6 +12490,7 @@ var validatorHook = {
       const rawBody = isPlainObject(ctx.body) ? ctx.body : {};
       const nextBody = {};
       for (const [field, fieldDef] of Object.entries(ctx.api.fields)) {
+        const normalized = normalizeFieldDefinition(fieldDef);
         let value = rawBody[field];
         if (value === undefined) {
           const snakeField = snakeCase(field);
@@ -12497,8 +12498,8 @@ var validatorHook = {
             value = rawBody[snakeField];
           }
         }
-        if (value === undefined && fieldDef?.default !== undefined && fieldDef?.default !== null) {
-          value = fieldDef.default;
+        if (value === undefined && normalized.default !== null) {
+          value = normalized.default;
         }
         if (value !== undefined) {
           nextBody[field] = value;
@@ -14209,7 +14210,7 @@ class DbHelper {
     const row = result?.[0] || null;
     if (!row) {
       return {
-        data: null,
+        data: {},
         sql: execRes.sql
       };
     }
@@ -14217,7 +14218,7 @@ class DbHelper {
     const deserialized = DbUtils.deserializeArrayFields(camelRow);
     if (!deserialized) {
       return {
-        data: null,
+        data: {},
         sql: execRes.sql
       };
     }
@@ -14562,36 +14563,41 @@ class DbHelper {
     };
   }
   async getFieldValue(options) {
-    const { field, ...queryOptions } = options;
+    const field = options.field;
     if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(field)) {
       throw new Error(`\u65E0\u6548\u7684\u5B57\u6BB5\u540D: ${field}\uFF0C\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF`);
     }
-    const oneRes = await this.getOne({
-      ...queryOptions,
-      fields: [field]
-    });
+    const oneOptions = {
+      table: options.table
+    };
+    if (options.where !== undefined)
+      oneOptions.where = options.where;
+    if (options.joins !== undefined)
+      oneOptions.joins = options.joins;
+    if (options.orderBy !== undefined)
+      oneOptions.orderBy = options.orderBy;
+    if (options.page !== undefined)
+      oneOptions.page = options.page;
+    if (options.limit !== undefined)
+      oneOptions.limit = options.limit;
+    oneOptions.fields = [field];
+    const oneRes = await this.getOne(oneOptions);
     const result = oneRes.data;
-    if (!result) {
-      return {
-        data: null,
-        sql: oneRes.sql
-      };
-    }
-    if (field in result) {
+    if (Object.hasOwn(result, field)) {
       return {
         data: result[field],
         sql: oneRes.sql
       };
     }
     const camelField = field.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-    if (camelField !== field && camelField in result) {
+    if (camelField !== field && Object.hasOwn(result, camelField)) {
       return {
         data: result[camelField],
         sql: oneRes.sql
       };
     }
     const snakeField = field.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-    if (snakeField !== field && snakeField in result) {
+    if (snakeField !== field && Object.hasOwn(result, snakeField)) {
       return {
         data: result[snakeField],
         sql: oneRes.sql