befly 3.22.9 → 3.23.0

package/lib/dbParse.js

@@ -39,10 +39,6 @@ function validateWhereObject(where, label, required = false) {
     }
 
     const visitWhereMeta = (currentWhere, currentLabel) => {
-        if (!isPlainObject(currentWhere)) {
-            return;
-        }
-
         for (const [key, value] of Object.entries(currentWhere)) {
             if (key === "$exclude") {
                 if (isNullable(value)) {
@@ -198,42 +194,44 @@ function validateQueryOptions(options, label) {
         });
     }
 
-    if (Array.isArray(options.table)) {
-        if (options.table.length === 0) {
-            throw new Error(`${label}.table 不能为空数组`, {
-                cause: null,
-                code: "validation"
-            });
-        }
+    const tableList = Array.isArray(options.table) ? options.table : [options.table];
+
+    if (Array.isArray(options.table) && tableList.length === 0) {
+        throw new Error(`${label}.table 不能为空数组`, {
+            cause: null,
+            code: "validation"
+        });
+    }
 
-        for (let i = 0; i < options.table.length; i++) {
-            assertNonEmptyString(options.table[i], `${label}.table[${i}]`);
-            parseTableRef(options.table[i]);
+    for (let i = 0; i < tableList.length; i++) {
+        if (Array.isArray(options.table)) {
+            assertNonEmptyString(tableList[i], `${label}.table[${i}]`);
+        } else {
+            assertNonEmptyString(tableList[i], `${label}.table`);
         }
 
+        parseTableRef(tableList[i]);
+    }
+
+    if (Array.isArray(options.table)) {
         if (Array.isArray(options.leftJoin) && options.leftJoin.length > 0) {
-            if (options.table.length !== options.leftJoin.length + 1) {
+            if (tableList.length !== options.leftJoin.length + 1) {
                 throw new Error(`${label}.table 与 ${label}.leftJoin 数量不匹配，要求 table.length = leftJoin.length + 1`, {
                     cause: null,
                     code: "validation"
                 });
             }
-        } else if (options.table.length > 1) {
+        } else if (tableList.length > 1) {
             throw new Error(`${label}.table 为数组时必须配合 leftJoin 使用`, {
                 cause: null,
                 code: "validation"
             });
         }
-    } else {
-        assertNonEmptyString(options.table, `${label}.table`);
-        parseTableRef(options.table);
-
-        if (Array.isArray(options.leftJoin) && options.leftJoin.length > 0) {
-            throw new Error(`${label}.leftJoin 启用时，${label}.table 必须是数组`, {
-                cause: null,
-                code: "validation"
-            });
-        }
+    } else if (Array.isArray(options.leftJoin) && options.leftJoin.length > 0) {
+        throw new Error(`${label}.leftJoin 启用时，${label}.table 必须是数组`, {
+            cause: null,
+            code: "validation"
+        });
     }
 
     if (!isNullable(options.where)) {
@@ -739,6 +737,18 @@ function applyDefaultStateFilter(where = {}, table, hasLeftJoin = false, beflyMo
     return result;
 }
 
+function isBeflySystemTable(table) {
+    return parseTableRef(table).table.startsWith("befly");
+}
+
+function resolveDeleteMode(table, beflyMode = "auto") {
+    if (beflyMode === "manual" && isBeflySystemTable(table)) {
+        return "auto";
+    }
+
+    return beflyMode;
+}
+
 function parseLeftJoinItem(joinTable, joinItem) {
     const parts = joinItem.split(" ");
     return {
@@ -834,25 +844,6 @@ export class DbParse {
         return this._prepareSingleTableWhere(options.table, options.where, true, false, "exists");
     }
 
-    async parseFieldValue(options) {
-        validateNoLeftJoinReadOptions(options, "getFieldValue", "getFieldValue 不支持 leftJoin（请使用 getOne/getList 并自行取字段）");
-        assertSafeFieldName(options.field);
-
-        const readOptions = {
-            table: options.table,
-            fields: [options.field]
-        };
-        if (options.where !== undefined) readOptions.where = options.where;
-        if (options.orderBy !== undefined) readOptions.orderBy = options.orderBy;
-        if (options.page !== undefined) readOptions.page = options.page;
-        if (options.limit !== undefined) readOptions.limit = options.limit;
-
-        return {
-            field: options.field,
-            prepared: await this.parseRead(readOptions, "one")
-        };
-    }
-
     parseInsert(options) {
         assertNonEmptyString(options.table, "insData.table");
         assertPlainObjectValue(options.data, "insData.data");
@@ -889,11 +880,20 @@ export class DbParse {
         const label = force ? "delForce" : "delData";
         assertNonEmptyString(options.table, `${label}.table`);
         validateWhereObject(options.where, `${label}.where`, true);
-        return {
+        const deleteMode = resolveDeleteMode(options.table, this.beflyMode);
+        const result = {
             table: options.table,
             snakeTable: snakeCase(options.table),
-            where: this._prepareSingleTableWhere(options.table, options.where, !force, true, label).where
+            where: this._prepareSingleTableWhere(options.table, options.where, !force, true, label, deleteMode).where,
+            deleteMode: deleteMode
         };
+
+        if (!force && deleteMode === "manual") {
+            assertPlainObjectValue(options.data, "delData.data");
+            result.data = options.data;
+        }
+
+        return result;
     }
 
     parseDelForceBatch(table, ids) {
@@ -989,13 +989,13 @@ export class DbParse {
         };
     }
 
-    _prepareSingleTableWhere(table, where, useDefaultStateFilter, required, label) {
+    _prepareSingleTableWhere(table, where, useDefaultStateFilter, required, label, beflyMode = this.beflyMode) {
         const snakeTable = snakeCase(table);
         const normalizedWhere = whereKeysToSnake(clearDeep(where || {}));
         if (required) {
             assertEffectiveWhere(normalizedWhere, label);
         }
-        const whereWithDefault = useDefaultStateFilter ? applyDefaultStateFilter(normalizedWhere, snakeTable, false, this.beflyMode) : normalizedWhere;
+        const whereWithDefault = useDefaultStateFilter ? applyDefaultStateFilter(normalizedWhere, snakeTable, false, beflyMode) : normalizedWhere;
         return {
             snakeTable: snakeTable,
             where: parseWhereObject(whereWithDefault)

package/lib/dbUtil.js

@@ -34,7 +34,7 @@ export function parseTableRef(tableRef) {
         });
     }
 
-    const parts = trimmed.split(/\s+/).filter((part) => part.length > 0);
+    const parts = trimmed.split(/\s+/);
     if (parts.length > 2) {
         throw new Error(`不支持的表引用格式（包含过多片段）。请使用最简形式：table 或 table alias 或 schema.table 或 schema.table alias (tableRef: ${trimmed})`, {
             cause: null,
@@ -42,27 +42,7 @@ export function parseTableRef(tableRef) {
         });
     }
 
-    const namePart = parts[0];
-    if (!isNonEmptyString(namePart)) {
-        throw new Error(`tableRef 解析失败：缺少表名 (tableRef: ${trimmed})`, {
-            cause: null,
-            code: "validation"
-        });
-    }
-
-    let aliasPart = null;
-    if (parts.length === 2) {
-        const alias = parts[1];
-        if (!isNonEmptyString(alias)) {
-            throw new Error(`tableRef 解析失败：缺少 alias (tableRef: ${trimmed})`, {
-                cause: null,
-                code: "validation"
-            });
-        }
-        aliasPart = alias;
-    }
-
-    const nameSegments = namePart.split(".");
+    const nameSegments = parts[0].split(".");
     if (nameSegments.length > 2) {
         throw new Error(`不支持的表引用格式（schema 层级过深） (tableRef: ${trimmed})`, {
             cause: null,
@@ -71,32 +51,38 @@ export function parseTableRef(tableRef) {
     }
 
     if (nameSegments.length === 2) {
-        const schema = nameSegments[0];
-        const table = nameSegments[1];
-        if (!isNonEmptyString(schema)) {
+        if (!nameSegments[0]) {
             throw new Error(`tableRef 解析失败：schema 为空 (tableRef: ${trimmed})`, {
                 cause: null,
                 code: "validation"
             });
         }
-        if (!isNonEmptyString(table)) {
+        if (!nameSegments[1]) {
             throw new Error(`tableRef 解析失败：table 为空 (tableRef: ${trimmed})`, {
                 cause: null,
                 code: "validation"
             });
         }
-        return { schema: schema, table: table, alias: aliasPart };
+
+        return {
+            schema: nameSegments[0],
+            table: nameSegments[1],
+            alias: parts[1] || null
+        };
     }
 
-    const table = nameSegments[0];
-    if (!isNonEmptyString(table)) {
+    if (!nameSegments[0]) {
         throw new Error(`tableRef 解析失败：table 为空 (tableRef: ${trimmed})`, {
             cause: null,
             code: "validation"
         });
     }
 
-    return { schema: null, table: table, alias: aliasPart };
+    return {
+        schema: null,
+        table: nameSegments[0],
+        alias: parts[1] || null
+    };
 }
 
 function isQuotedIdentPaired(value) {

package/lib/logger.js

@@ -100,12 +100,12 @@ class LogFileSink {
     }
 
     async flushNow() {
-        this.cancelScheduledFlush();
+        this.clearScheduledFlush();
         await this.flush();
     }
 
     async shutdown() {
-        this.cancelScheduledFlush();
+        this.clearScheduledFlush();
         await this.flush();
         await this.closeStream();
     }
@@ -120,24 +120,22 @@ class LogFileSink {
         }, this.flushDelayMs);
     }
 
-    cancelScheduledFlush() {
+    clearScheduledFlush() {
         if (!this.scheduledTimer) return;
         clearTimeout(this.scheduledTimer);
         this.scheduledTimer = null;
     }
 
     async flush() {
-        if (this.flushing) return;
+        if (this.flushing || this.pending.length === 0) return;
         this.flushing = true;
 
         try {
             while (this.pending.length > 0) {
                 const batch = shiftBatchFromPending(this.pending, this.maxBatchBytes);
-                const chunk = batch.chunk;
-                const chunkBytes = Buffer.byteLength(chunk);
-                this.pendingBytes = this.pendingBytes - chunkBytes;
+                this.pendingBytes = this.pendingBytes - batch.bytes;
 
-                const ok = await this.writeChunk(chunk, chunkBytes);
+                const ok = await this.writeChunk(batch.chunk, batch.bytes);
                 if (!ok) {
                     // writer 已禁用/失败：清空剩余 pending
                     this.pending = [];
@@ -267,13 +265,13 @@ export async function flush() {
     // 测试场景：mock logger 不需要 flush
     if (mockInstance) return;
 
-    const sinks = [];
-    if (appFileSink) sinks.push({ flush: () => (appFileSink ? appFileSink.flushNow() : Promise.resolve()) });
-    if (errorFileSink) sinks.push({ flush: () => (errorFileSink ? errorFileSink.flushNow() : Promise.resolve()) });
+    for (const sink of [appFileSink, errorFileSink]) {
+        if (!sink) {
+            continue;
+        }
 
-    for (const item of sinks) {
         try {
-            await item.flush();
+            await sink.flushNow();
         } catch {
             // ignore
         }
@@ -289,13 +287,13 @@ export async function shutdown() {
     const currentAppFileSink = appFileSink;
     const currentErrorFileSink = errorFileSink;
 
-    const sinks = [];
-    if (currentAppFileSink) sinks.push({ shutdown: () => currentAppFileSink.shutdown() });
-    if (currentErrorFileSink) sinks.push({ shutdown: () => currentErrorFileSink.shutdown() });
+    for (const sink of [currentAppFileSink, currentErrorFileSink]) {
+        if (!sink) {
+            continue;
+        }
 
-    for (const item of sinks) {
         try {
-            await item.shutdown();
+            await sink.shutdown();
         } catch {
             // ignore
         }

package/lib/sqlBuilder.js

@@ -45,73 +45,46 @@ export class SqlBuilder {
     _compileOperatorNode(node) {
         const escapedField = escapeField(node.field, this._quoteIdent);
 
-        if (node.operator === "$not") {
-            return { sql: `${escapedField} != ?`, params: [node.value] };
+        switch (node.operator) {
+            case "$not":
+                return { sql: `${escapedField} != ?`, params: [node.value] };
+            case "$in":
+                return {
+                    sql: `${escapedField} IN (${node.value.map(() => "?").join(",")})`,
+                    params: node.value.slice()
+                };
+            case "$notIn":
+                return {
+                    sql: `${escapedField} NOT IN (${node.value.map(() => "?").join(",")})`,
+                    params: node.value.slice()
+                };
+            case "$like":
+                return { sql: `${escapedField} LIKE ?`, params: [`%${String(node.value)}%`] };
+            case "$leftLike":
+                return { sql: `${escapedField} LIKE ?`, params: [`%${String(node.value)}`] };
+            case "$rightLike":
+                return { sql: `${escapedField} LIKE ?`, params: [`${String(node.value)}%`] };
+            case "$notLike":
+                return { sql: `${escapedField} NOT LIKE ?`, params: [node.value] };
+            case "$gt":
+                return { sql: `${escapedField} > ?`, params: [node.value] };
+            case "$gte":
+                return { sql: `${escapedField} >= ?`, params: [node.value] };
+            case "$lt":
+                return { sql: `${escapedField} < ?`, params: [node.value] };
+            case "$lte":
+                return { sql: `${escapedField} <= ?`, params: [node.value] };
+            case "$between":
+                return { sql: `${escapedField} BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
+            case "$notBetween":
+                return { sql: `${escapedField} NOT BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
+            case "$null":
+                return { sql: `${escapedField} IS NULL`, params: [] };
+            case "$notNull":
+                return { sql: `${escapedField} IS NOT NULL`, params: [] };
+            default:
+                return { sql: `${escapedField} = ?`, params: [node.value] };
         }
-
-        if (node.operator === "$in") {
-            return {
-                sql: `${escapedField} IN (${node.value.map(() => "?").join(",")})`,
-                params: node.value.slice()
-            };
-        }
-
-        if (node.operator === "$notIn") {
-            return {
-                sql: `${escapedField} NOT IN (${node.value.map(() => "?").join(",")})`,
-                params: node.value.slice()
-            };
-        }
-
-        if (node.operator === "$like") {
-            return { sql: `${escapedField} LIKE ?`, params: [`%${String(node.value)}%`] };
-        }
-
-        if (node.operator === "$leftLike") {
-            return { sql: `${escapedField} LIKE ?`, params: [`%${String(node.value)}`] };
-        }
-
-        if (node.operator === "$rightLike") {
-            return { sql: `${escapedField} LIKE ?`, params: [`${String(node.value)}%`] };
-        }
-
-        if (node.operator === "$notLike") {
-            return { sql: `${escapedField} NOT LIKE ?`, params: [node.value] };
-        }
-
-        if (node.operator === "$gt") {
-            return { sql: `${escapedField} > ?`, params: [node.value] };
-        }
-
-        if (node.operator === "$gte") {
-            return { sql: `${escapedField} >= ?`, params: [node.value] };
-        }
-
-        if (node.operator === "$lt") {
-            return { sql: `${escapedField} < ?`, params: [node.value] };
-        }
-
-        if (node.operator === "$lte") {
-            return { sql: `${escapedField} <= ?`, params: [node.value] };
-        }
-
-        if (node.operator === "$between") {
-            return { sql: `${escapedField} BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
-        }
-
-        if (node.operator === "$notBetween") {
-            return { sql: `${escapedField} NOT BETWEEN ? AND ?`, params: [node.value[0], node.value[1]] };
-        }
-
-        if (node.operator === "$null") {
-            return { sql: `${escapedField} IS NULL`, params: [] };
-        }
-
-        if (node.operator === "$notNull") {
-            return { sql: `${escapedField} IS NOT NULL`, params: [] };
-        }
-
-        return { sql: `${escapedField} = ?`, params: [node.value] };
     }
 
     _compileWhereNode(node) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.22.9",
-    "gitHead": "6ce876182a5b05c9d18168740c92959535205f10",
+    "version": "3.23.0",
+    "gitHead": "323ac9336929e2beaab435e9865194e22a884c82",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 JavaScript API 接口框架核心引擎",
     "keywords": [
@@ -18,7 +18,6 @@
     "homepage": "https://chensuiyi.me",
     "license": "Apache-2.0",
     "author": "chensuiyi <bimostyle@qq.com>",
-    "main": "./index.js",
     "files": [
         "apis",
         "checks",
@@ -38,6 +37,7 @@
         "README.md"
     ],
     "type": "module",
+    "main": "./index.js",
     "exports": {
         ".": {
             "import": "./index.js",
@@ -52,8 +52,8 @@
         "test": "bun test"
     },
     "dependencies": {
-        "fast-xml-parser": "^5.6.0",
-        "nodemailer": "^8.0.5",
+        "fast-xml-parser": "^5.7.2",
+        "nodemailer": "^8.0.6",
         "pathe": "^2.0.3",
         "ua-parser-js": "^2.0.9",
         "zod": "^4.0.0"

package/scripts/syncDb/diff.js

@@ -7,7 +7,7 @@ import { toSyncDbFieldDef } from "./transform.js";
 
 const SYNC_DB_MANAGED_FIELD_NAMES = new Set(["id", "created_at", "updated_at", "deleted_at", "state"]);
 const SYNC_DB_HEAD_FIELD_NAME = "id";
-const SYNC_DB_TAIL_FIELD_NAMES = ["createdAt", "updatedAt", "deletedAt", "state"];
+const SYNC_DB_TAIL_FIELD_NAMES = ["created_at", "updated_at", "deleted_at", "state"];
 const SYNC_DB_TAIL_FIELD_NAME_SET = new Set(SYNC_DB_TAIL_FIELD_NAMES);
 
 function shouldSkipSyncDbColumn(columnMeta, beflyMode) {
@@ -38,7 +38,7 @@ function sortSyncDbObjectKeys(source) {
         if (key === SYNC_DB_HEAD_FIELD_NAME) {
             continue;
         }
-        if (SYNC_DB_TAIL_FIELD_NAME_SET.has(key)) {
+        if (SYNC_DB_TAIL_FIELD_NAME_SET.has(snakeCase(key))) {
             continue;
         }
 
@@ -46,11 +46,13 @@ function sortSyncDbObjectKeys(source) {
     }
 
     for (const fieldName of SYNC_DB_TAIL_FIELD_NAMES) {
-        if (!Object.hasOwn(source, fieldName)) {
-            continue;
-        }
+        for (const [key, value] of Object.entries(source)) {
+            if (snakeCase(key) !== fieldName) {
+                continue;
+            }
 
-        output[fieldName] = source[fieldName];
+            output[key] = value;
+        }
     }
 
     return output;
@@ -118,19 +120,32 @@ export function buildSyncDbDiff(groupedDbColumns, existingTableMap, beflyMode =
         }
 
         const existingFields = isPlainObject(existing.tableDef) ? existing.tableDef : {};
+        const existingFieldNameByDbColumnName = new Map();
+
+        for (const fieldName of Object.keys(existingFields)) {
+            if (shouldSkipSyncDbFieldName(fieldName, beflyMode)) {
+                continue;
+            }
+
+            existingFieldNameByDbColumnName.set(snakeCase(fieldName), fieldName);
+        }
+
         const missingFields = [];
         const dbFieldNameSet = new Set();
         for (const columnMeta of filteredColumns) {
             const fieldInfo = toSyncDbFieldDef(columnMeta);
-            dbFieldNameSet.add(fieldInfo.fieldName);
-            if (Object.hasOwn(existingFields, fieldInfo.fieldName)) {
+            const dbColumnName = String(columnMeta.columnName || "");
+            const normalizedDbColumnName = dbColumnName.toLowerCase();
+
+            dbFieldNameSet.add(normalizedDbColumnName);
+            if (existingFieldNameByDbColumnName.has(normalizedDbColumnName)) {
                 continue;
             }
 
             missingFields.push({
                 tableName: tableName,
                 tableFileName: tableFileName,
-                dbColumnName: columnMeta.columnName,
+                dbColumnName: dbColumnName,
                 dbDataType: columnMeta.dataType,
                 dbColumnType: columnMeta.columnType,
                 dbCharLength: columnMeta.charLength,
@@ -154,7 +169,7 @@ export function buildSyncDbDiff(groupedDbColumns, existingTableMap, beflyMode =
             if (shouldSkipSyncDbFieldName(fieldName, beflyMode)) {
                 continue;
             }
-            if (dbFieldNameSet.has(fieldName)) {
+            if (dbFieldNameSet.has(snakeCase(fieldName))) {
                 continue;
             }
 

package/scripts/syncDb/transform.js

@@ -1,6 +1,6 @@
 import { DECIMAL_KIND_TYPES, ENUM_KIND_TYPES, FLOAT_KIND_TYPES, INT_KIND_TYPES, JSON_KIND_TYPES, STRING_KIND_TYPES, TEXT_KIND_TYPES } from "../../configs/constConfig.js";
 import { isNonEmptyString, isNumber } from "../../utils/is.js";
-import { camelCase } from "../../utils/util.js";
+import { camelCaseKeepUnderscore } from "../../utils/util.js";
 
 function resolveSyncDbEnumInput(columnType) {
     const matched = /^enum\((.*)\)$/.exec(columnType);
@@ -90,7 +90,7 @@ function resolveSyncDbMaxByColumn(columnMeta) {
 }
 
 export function toSyncDbFieldDef(columnMeta) {
-    const fieldName = camelCase(String(columnMeta.columnName || ""));
+    const fieldName = camelCaseKeepUnderscore(columnMeta.columnName);
     const fieldDisplayName = isNonEmptyString(columnMeta.columnComment) ? String(columnMeta.columnComment).trim() : fieldName;
     const fieldInput = resolveSyncDbInputByColumn(columnMeta);
     const fieldMax = resolveSyncDbMaxByColumn(columnMeta);

package/sync/api.js

@@ -1,3 +1,5 @@
+import { buildPathSyncLists } from "./syncUtil.js";
+
 const API_TABLE_NAME = "beflyApi";
 
 const getApiParentPath = (apiPath) => {
@@ -22,64 +24,45 @@ export async function syncApi(ctx, apis) {
         where: { state$gte: 0 }
     });
 
-    // 给接口根据接口路径进行映射
-    const dbLists = allDbApis.data.lists || [];
-    const existingApiMap = new Map();
-    for (const item of dbLists) {
-        if (!existingApiMap.has(item.path)) {
-            existingApiMap.set(item.path, item);
-        }
-    }
-
-    const insList = [];
-    const updList = [];
-    const scannedPathSet = new Set();
+    const apiDefs = [];
     for (const api of apis) {
-        scannedPathSet.add(api.apiPath);
-
-        const auth = api.auth === false ? "否" : Array.isArray(api.auth) ? api.auth.join(",") : "是";
-        const parentPath = getApiParentPath(api.apiPath);
-        const existing = existingApiMap.get(api.apiPath);
-
-        if (existing) {
-            updList.push({
-                id: existing.id,
-                data: {
-                    name: api.name,
-                    path: api.apiPath,
-                    method: api.method,
-                    parentPath: parentPath,
-                    auth: auth
-                }
-            });
-            continue;
-        }
-
-        insList.push({
+        apiDefs.push({
             name: api.name,
             path: api.apiPath,
             method: api.method,
-            parentPath: parentPath,
-            auth: auth
+            parentPath: getApiParentPath(api.apiPath),
+            auth: api.auth === false ? "否" : Array.isArray(api.auth) ? api.auth.join(",") : "是"
         });
     }
 
-    const delIdList = [];
-    for (const item of dbLists) {
-        if (!scannedPathSet.has(item.path)) {
-            delIdList.push(item.id);
-        }
-    }
+    const syncLists = buildPathSyncLists(
+        allDbApis.data.lists || [],
+        apiDefs,
+        (def) => ({
+            name: def.name,
+            path: def.path,
+            method: def.method,
+            parentPath: def.parentPath,
+            auth: def.auth
+        }),
+        (def) => ({
+            name: def.name,
+            path: def.path,
+            method: def.method,
+            parentPath: def.parentPath,
+            auth: def.auth
+        })
+    );
 
-    if (updList.length > 0) {
-        await ctx.mysql.updBatch(API_TABLE_NAME, updList);
+    if (syncLists.updList.length > 0) {
+        await ctx.mysql.updBatch(API_TABLE_NAME, syncLists.updList);
     }
 
-    if (insList.length > 0) {
-        await ctx.mysql.insBatch(API_TABLE_NAME, insList);
+    if (syncLists.insList.length > 0) {
+        await ctx.mysql.insBatch(API_TABLE_NAME, syncLists.insList);
     }
 
-    if (delIdList.length > 0) {
-        await ctx.mysql.delForceBatch(API_TABLE_NAME, delIdList);
+    if (syncLists.delIds.length > 0) {
+        await ctx.mysql.delForceBatch(API_TABLE_NAME, syncLists.delIds);
     }
 }