befly 3.9.40 → 3.10.1

package/sync/syncDb/table.ts

@@ -1,207 +0,0 @@
-/**
- * syncDb 表操作模块
- *
- * 包含：
- * - 修改表结构
- * - 对比字段变化
- * - 应用变更计划
- */
-
-import type { TablePlan } from "../../types/sync.js";
-import type { FieldDefinition } from "../../types/validate.js";
-import type { SQL } from "bun";
-
-import { snakeCase } from "es-toolkit/string";
-
-import { Logger } from "../../lib/logger.js";
-import { compareFieldDefinition, applyTablePlan } from "./apply.js";
-import { isMySQL, isPG, CHANGE_TYPE_LABELS, getTypeMapping, SYSTEM_INDEX_FIELDS } from "./constants.js";
-import { generateDDLClause, getSystemColumnDef, isCompatibleTypeChange } from "./ddl.js";
-import { logFieldChange } from "./helpers.js";
-import { getTableColumns, getTableIndexes } from "./schema.js";
-import { generateDefaultSql, isStringOrArrayType, resolveDefaultValue } from "./types.js";
-
-/**
- * 同步表结构（对比和应用变更）
- *
- * 主要逻辑：
- * 1. 获取表的现有列和索引信息
- * 2. 对比每个字段的定义变化
- * 3. 生成变更计划（添加/修改/删除列，添加/删除索引）
- * 4. 执行变更 SQL
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义
- * @param force - 是否强制同步（删除多余字段）
- * @param dbName - 数据库名称
- */
-export async function modifyTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, force: boolean = false, dbName?: string): Promise<TablePlan> {
-    const existingColumns = await getTableColumns(sql, tableName, dbName || "");
-    const existingIndexes = await getTableIndexes(sql, tableName, dbName || "");
-    let changed = false;
-
-    const addClauses: string[] = [];
-    const modifyClauses: string[] = [];
-    const defaultClauses: string[] = [];
-    const indexActions: Array<{ action: "create" | "drop"; indexName: string; fieldName: string }> = [];
-
-    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        if (existingColumns[dbFieldName]) {
-            const comparison = compareFieldDefinition(existingColumns[dbFieldName], fieldDef);
-            if (comparison.length > 0) {
-                for (const c of comparison) {
-                    // 使用统一的日志格式函数和常量标签
-                    const changeLabel = CHANGE_TYPE_LABELS[c.type as keyof typeof CHANGE_TYPE_LABELS] || "未知";
-                    logFieldChange(tableName, dbFieldName, c.type, c.current, c.expected, changeLabel);
-                }
-
-                if (isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && fieldDef.max !== null) {
-                    if (existingColumns[dbFieldName].max! > fieldDef.max) {
-                        if (force) {
-                            Logger.warn(`[强制执行] ${tableName}.${dbFieldName} 长度收缩 ${existingColumns[dbFieldName].max} -> ${fieldDef.max}`);
-                        } else {
-                            Logger.warn(`[跳过危险变更] ${tableName}.${dbFieldName} 长度收缩 ${existingColumns[dbFieldName].max} -> ${fieldDef.max} 已被跳过（使用 --force 强制执行）`);
-                        }
-                    }
-                }
-
-                const hasTypeChange = comparison.some((c) => c.type === "datatype");
-                const hasLengthChange = comparison.some((c) => c.type === "length");
-                const onlyDefaultChanged = comparison.every((c) => c.type === "default");
-                const defaultChanged = comparison.some((c) => c.type === "default");
-
-                // 类型变更检查：只允许兼容的宽化型变更（如 INT -> BIGINT）
-                if (hasTypeChange) {
-                    const typeChange = comparison.find((c) => c.type === "datatype");
-                    const currentType = String(typeChange?.current || "").toLowerCase();
-                    const typeMapping = getTypeMapping();
-                    const expectedType = typeMapping[fieldDef.type]?.toLowerCase() || "";
-
-                    if (!isCompatibleTypeChange(currentType, expectedType)) {
-                        const errorMsg = [`禁止字段类型变更: ${tableName}.${dbFieldName}`, `当前类型: ${typeChange?.current}`, `目标类型: ${typeChange?.expected}`, `说明: 仅允许宽化型变更（如 INT->BIGINT, VARCHAR->TEXT），其他类型变更需要手动处理`].join("\n");
-                        throw new Error(errorMsg);
-                    }
-                    Logger.debug(`[兼容类型变更] ${tableName}.${dbFieldName} ${currentType} -> ${expectedType}`);
-                }
-
-                // 默认值变化处理
-                if (defaultChanged) {
-                    // 使用公共函数处理默认值
-                    const actualDefault = resolveDefaultValue(fieldDef.default, fieldDef.type);
-
-                    // 生成 SQL DEFAULT 值（不包含前导空格，因为要用于 ALTER COLUMN）
-                    let v: string | null = null;
-                    if (actualDefault !== "null") {
-                        const defaultSql = generateDefaultSql(actualDefault, fieldDef.type);
-                        // 移除前导空格 ' DEFAULT ' -> 'DEFAULT '
-                        v = defaultSql.trim().replace(/^DEFAULT\s+/, "");
-                    }
-
-                    if (v !== null && v !== "") {
-                        if (isPG()) {
-                            defaultClauses.push(`ALTER COLUMN "${dbFieldName}" SET DEFAULT ${v}`);
-                        } else if (isMySQL() && onlyDefaultChanged) {
-                            // MySQL 的 TEXT/BLOB 不允许 DEFAULT，跳过 text 类型
-                            if (fieldDef.type !== "text") {
-                                defaultClauses.push(`ALTER COLUMN \`${dbFieldName}\` SET DEFAULT ${v}`);
-                            }
-                        }
-                    }
-                }
-
-                // 若不仅仅是默认值变化，继续生成修改子句
-                if (!onlyDefaultChanged) {
-                    let skipModify = false;
-                    if (hasLengthChange && isStringOrArrayType(fieldDef.type) && existingColumns[dbFieldName].max && fieldDef.max !== null) {
-                        const isShrink = existingColumns[dbFieldName].max! > fieldDef.max;
-                        if (isShrink && !force) skipModify = true;
-                    }
-
-                    if (!skipModify) modifyClauses.push(generateDDLClause(fieldKey, fieldDef, false));
-                }
-                changed = true;
-            }
-        } else {
-            // Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
-            addClauses.push(generateDDLClause(fieldKey, fieldDef, true));
-            changed = true;
-        }
-    }
-
-    // 检查并添加缺失的系统字段（created_at, updated_at, deleted_at, state）
-    // 注意：id 是主键，不会缺失；这里只处理可能缺失的其他系统字段
-    const systemFieldNames = ["created_at", "updated_at", "deleted_at", "state"];
-    for (const sysFieldName of systemFieldNames) {
-        if (!existingColumns[sysFieldName]) {
-            const colDef = getSystemColumnDef(sysFieldName);
-            if (colDef) {
-                Logger.debug(`  + 新增系统字段 ${sysFieldName}`);
-                addClauses.push(`ADD COLUMN ${colDef}`);
-                changed = true;
-            }
-        }
-    }
-
-    // 检查系统字段索引（字段存在或即将被添加时才创建索引）
-    for (const sysField of SYSTEM_INDEX_FIELDS) {
-        const idxName = `idx_${sysField}`;
-        // 字段已存在或刚添加到 addClauses 中
-        const fieldWillExist = existingColumns[sysField] || systemFieldNames.includes(sysField);
-        if (fieldWillExist && !existingIndexes[idxName]) {
-            indexActions.push({ action: "create", indexName: idxName, fieldName: sysField });
-            changed = true;
-        }
-    }
-
-    // 检查业务字段索引
-    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const indexName = `idx_${dbFieldName}`;
-        // 如果字段有 unique 约束，跳过创建普通索引（unique 会自动创建唯一索引）
-        if (fieldDef.index && !fieldDef.unique && !existingIndexes[indexName]) {
-            indexActions.push({ action: "create", indexName: indexName, fieldName: dbFieldName });
-            changed = true;
-        } else if (!fieldDef.index && existingIndexes[indexName] && existingIndexes[indexName].length === 1) {
-            indexActions.push({ action: "drop", indexName: indexName, fieldName: dbFieldName });
-            changed = true;
-        }
-    }
-
-    // PG 列注释处理（对比数据库 comment 与字段 name）
-    const commentActions: string[] = [];
-    if (isPG()) {
-        for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-            // 转换字段名为下划线格式
-            const dbFieldName = snakeCase(fieldKey);
-
-            if (existingColumns[dbFieldName]) {
-                const curr = existingColumns[dbFieldName].comment || "";
-                const want = fieldDef.name && fieldDef.name !== "null" ? String(fieldDef.name) : "";
-                if (want !== curr) {
-                    // 防止 SQL 注入：转义单引号
-                    const escapedWant = want.replace(/'/g, "''");
-                    commentActions.push(`COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS ${want ? `'${escapedWant}'` : "NULL"}`);
-                    changed = true;
-                }
-            }
-        }
-    }
-
-    // 仅当存在实际动作时才认为有变更（避免仅日志的收缩跳过被计为修改）
-    changed = addClauses.length > 0 || modifyClauses.length > 0 || defaultClauses.length > 0 || indexActions.length > 0 || commentActions.length > 0;
-
-    const plan = { changed, addClauses, modifyClauses, defaultClauses, indexActions, commentActions };
-
-    // 将计划应用（包含 --plan 情况下仅输出）
-    if (plan.changed) {
-        await applyTablePlan(sql, tableName, fields, plan);
-    }
-
-    return plan;
-}

package/sync/syncDb/tableCreate.ts

@@ -1,163 +0,0 @@
-/**
- * syncDb 表创建模块
- *
- * 包含：
- * - 创建表（包含系统字段和业务字段）
- * - 添加 PostgreSQL 注释
- * - 创建表索引
- *
- * 注意：此模块从 table.ts 中提取，用于解除循环依赖
- */
-import type { FieldDefinition } from "../../types/validate.js";
-import type { SQL } from "bun";
-
-import { snakeCase } from "es-toolkit/string";
-
-import { Logger } from "../../lib/logger.js";
-import { isMySQL, isPG, IS_PLAN, MYSQL_TABLE_CONFIG } from "./constants.js";
-import { buildSystemColumnDefs, buildBusinessColumnDefs, buildIndexSQL } from "./ddl.js";
-import { quoteIdentifier } from "./helpers.js";
-import { getTableIndexes } from "./schema.js";
-
-/**
- * 为 PostgreSQL 表添加列注释（使用字段的 name 作为注释）
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义对象
- */
-async function addPostgresComments(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>): Promise<void> {
-    // 系统字段注释
-    const systemComments = [
-        ["id", "主键ID"],
-        ["created_at", "创建时间"],
-        ["updated_at", "更新时间"],
-        ["deleted_at", "删除时间"],
-        ["state", "状态字段"]
-    ];
-
-    for (const [name, comment] of systemComments) {
-        const stmt = `COMMENT ON COLUMN "${tableName}"."${name}" IS '${comment}'`;
-        if (IS_PLAN) {
-            Logger.debug(`[计划] ${stmt}`);
-        } else {
-            await sql.unsafe(stmt);
-        }
-    }
-
-    // 业务字段注释（使用 fieldDef.name 作为数据库列注释）
-    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        const { name: fieldName } = fieldDef;
-        const stmt = `COMMENT ON COLUMN "${tableName}"."${dbFieldName}" IS '${fieldName}'`;
-        if (IS_PLAN) {
-            Logger.debug(`[计划] ${stmt}`);
-        } else {
-            await sql.unsafe(stmt);
-        }
-    }
-}
-
-/**
- * 创建表的索引（并行执行以提升性能）
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义对象
- * @param systemIndexFields - 系统字段索引列表
- * @param dbName - 数据库名称（用于检查索引是否存在）
- */
-async function createTableIndexes(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[], dbName?: string): Promise<void> {
-    const indexTasks: Promise<void>[] = [];
-
-    // 获取现有索引（MySQL 不支持 IF NOT EXISTS，需要先检查）
-    let existingIndexes: Record<string, string[]> = {};
-    if (isMySQL()) {
-        existingIndexes = await getTableIndexes(sql, tableName, dbName || "");
-    }
-
-    // 系统字段索引
-    for (const sysField of systemIndexFields) {
-        const indexName = `idx_${sysField}`;
-        // MySQL 跳过已存在的索引
-        if (isMySQL() && existingIndexes[indexName]) {
-            continue;
-        }
-        const stmt = buildIndexSQL(tableName, indexName, sysField, "create");
-        if (IS_PLAN) {
-            Logger.debug(`[计划] ${stmt}`);
-        } else {
-            indexTasks.push(sql.unsafe(stmt));
-        }
-    }
-
-    // 业务字段索引
-    for (const [fieldKey, fieldDef] of Object.entries(fields)) {
-        // 转换字段名为下划线格式
-        const dbFieldName = snakeCase(fieldKey);
-
-        if (fieldDef.index === true) {
-            const indexName = `idx_${dbFieldName}`;
-            // MySQL 跳过已存在的索引
-            if (isMySQL() && existingIndexes[indexName]) {
-                continue;
-            }
-            const stmt = buildIndexSQL(tableName, indexName, dbFieldName, "create");
-            if (IS_PLAN) {
-                Logger.debug(`[计划] ${stmt}`);
-            } else {
-                indexTasks.push(sql.unsafe(stmt));
-            }
-        }
-    }
-
-    // 并行执行所有索引创建
-    if (indexTasks.length > 0) {
-        await Promise.all(indexTasks);
-    }
-}
-
-/**
- * 创建表（包含系统字段和业务字段）
- *
- * @param sql - SQL 客户端实例
- * @param tableName - 表名
- * @param fields - 字段定义对象
- * @param systemIndexFields - 系统字段索引列表（可选，默认使用 ['created_at', 'updated_at', 'state']）
- * @param dbName - 数据库名称（用于检查索引是否存在）
- */
-export async function createTable(sql: SQL, tableName: string, fields: Record<string, FieldDefinition>, systemIndexFields: string[] = ["created_at", "updated_at", "state"], dbName?: string): Promise<void> {
-    // 构建列定义
-    const colDefs = [...buildSystemColumnDefs(), ...buildBusinessColumnDefs(fields)];
-
-    // 生成 CREATE TABLE 语句
-    const cols = colDefs.join(",\n            ");
-    const tableQuoted = quoteIdentifier(tableName);
-    const { ENGINE, CHARSET, COLLATE } = MYSQL_TABLE_CONFIG;
-    const createSQL = isMySQL()
-        ? `CREATE TABLE ${tableQuoted} (
-            ${cols}
-        ) ENGINE=${ENGINE} DEFAULT CHARSET=${CHARSET} COLLATE=${COLLATE}`
-        : `CREATE TABLE ${tableQuoted} (
-            ${cols}
-        )`;
-
-    if (IS_PLAN) {
-        Logger.debug(`[计划] ${createSQL.replace(/\n+/g, " ")}`);
-    } else {
-        await sql.unsafe(createSQL);
-    }
-
-    // PostgreSQL: 添加列注释（使用字段 name 作为数据库列注释）
-    if (isPG() && !IS_PLAN) {
-        await addPostgresComments(sql, tableName, fields);
-    } else if (isPG() && IS_PLAN) {
-        // 计划模式也要输出注释语句
-        await addPostgresComments(sql, tableName, fields);
-    }
-
-    // 创建索引
-    await createTableIndexes(sql, tableName, fields, systemIndexFields, dbName);
-}

package/sync/syncDb/types.ts

@@ -1,132 +0,0 @@
-/**
- * syncDb 类型处理模块
- *
- * 包含：
- * - SQL 类型映射和转换
- * - 默认值处理
- * - 类型判断工具
- */
-
-import { isMySQL, getTypeMapping } from "./constants.js";
-
-/**
- * 判断是否为字符串或数组类型（需要长度参数）
- *
- * @param fieldType - 字段类型
- * @returns 是否为字符串或数组类型
- *
- * @example
- * isStringOrArrayType('string') // => true
- * isStringOrArrayType('array_string') // => true
- * isStringOrArrayType('array_number_string') // => true
- * isStringOrArrayType('array_text') // => false
- * isStringOrArrayType('number') // => false
- * isStringOrArrayType('text') // => false
- */
-export function isStringOrArrayType(fieldType: string): boolean {
-    return fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string";
-}
-
-/**
- * 获取 SQL 数据类型
- *
- * @param fieldType - 字段类型（number/string/text/array_string/array_text）
- * @param fieldMax - 最大长度（string/array_string 类型需要）
- * @param unsigned - 是否无符号（仅 MySQL number 类型有效）
- * @returns SQL 类型字符串
- *
- * @example
- * getSqlType('string', 100) // => 'VARCHAR(100)'
- * getSqlType('number', null, true) // => 'BIGINT UNSIGNED'
- * getSqlType('text', null) // => 'MEDIUMTEXT'
- * getSqlType('array_string', 500) // => 'VARCHAR(500)'
- * getSqlType('array_text', null) // => 'MEDIUMTEXT'
- */
-export function getSqlType(fieldType: string, fieldMax: number | null, unsigned: boolean = false): string {
-    const typeMapping = getTypeMapping();
-    if (isStringOrArrayType(fieldType)) {
-        return `${typeMapping[fieldType]}(${fieldMax})`;
-    }
-    // 处理 UNSIGNED 修饰符（仅 MySQL number 类型）
-    const baseType = typeMapping[fieldType] || "TEXT";
-    if (isMySQL() && fieldType === "number" && unsigned) {
-        return `${baseType} UNSIGNED`;
-    }
-    return baseType;
-}
-
-/**
- * 处理默认值：将 null 或 'null' 字符串转换为对应类型的默认值
- *
- * @param fieldDefault - 字段默认值（可能是 null 或 'null' 字符串）
- * @param fieldType - 字段类型（number/string/text/array）
- * @returns 实际默认值
- *
- * @example
- * resolveDefaultValue(null, 'string') // => ''
- * resolveDefaultValue(null, 'number') // => 0
- * resolveDefaultValue('null', 'number') // => 0
- * resolveDefaultValue(null, 'array_string') // => '[]'
- * resolveDefaultValue(null, 'text') // => 'null'
- * resolveDefaultValue(null, 'array_text') // => 'null' (TEXT 不支持默认值)
- * resolveDefaultValue('admin', 'string') // => 'admin'
- * resolveDefaultValue(0, 'number') // => 0
- */
-export function resolveDefaultValue(fieldDefault: any, fieldType: string): any {
-    // null 或字符串 'null' 都表示使用类型默认值
-    if (fieldDefault !== null && fieldDefault !== "null") {
-        return fieldDefault;
-    }
-
-    // null 表示使用类型默认值
-    switch (fieldType) {
-        case "number":
-            return 0;
-        case "string":
-            return "";
-        case "array_string":
-        case "array_number_string":
-            return "[]";
-        case "text":
-        case "array_text":
-        case "array_number_text":
-            // text/array_text/array_number_text 类型不设置默认值（MySQL TEXT 不支持），保持 'null'
-            return "null";
-        default:
-            return fieldDefault;
-    }
-}
-
-/**
- * 生成 SQL DEFAULT 子句
- *
- * @param actualDefault - 实际默认值（已经过 resolveDefaultValue 处理）
- * @param fieldType - 字段类型
- * @returns SQL DEFAULT 子句字符串（包含前导空格），如果不需要则返回空字符串
- *
- * @example
- * generateDefaultSql(0, 'number') // => ' DEFAULT 0'
- * generateDefaultSql('admin', 'string') // => " DEFAULT 'admin'"
- * generateDefaultSql('', 'string') // => " DEFAULT ''"
- * generateDefaultSql('null', 'text') // => ''
- * generateDefaultSql('[]', 'array_text') // => '' (TEXT 类型不能有默认值)
- */
-export function generateDefaultSql(actualDefault: any, fieldType: string): string {
-    // text 和 array_text 类型不设置默认值（MySQL TEXT 类型不支持默认值）
-    if (fieldType === "text" || fieldType === "array_text" || actualDefault === "null") {
-        return "";
-    }
-
-    // 仅 number/string/array_string/array_number_string 类型设置默认值
-    if (fieldType === "number" || fieldType === "string" || fieldType === "array_string" || fieldType === "array_number_string") {
-        if (typeof actualDefault === "number" && !Number.isNaN(actualDefault)) {
-            return ` DEFAULT ${actualDefault}`;
-        } else {
-            // 字符串需要转义单引号：' -> ''
-            const escaped = String(actualDefault).replace(/'/g, "''");
-            return ` DEFAULT '${escaped}'`;
-        }
-    }
-
-    return "";
-}

package/sync/syncDb/version.ts

@@ -1,69 +0,0 @@
-/**
- * syncDb 数据库版本检查模块
- *
- * 包含：
- * - 数据库版本验证（MySQL/PostgreSQL/SQLite）
- */
-
-import type { SQL } from "bun";
-
-import { DB_VERSION_REQUIREMENTS, isMySQL, isPG, isSQLite } from "./constants.js";
-
-/**
- * 数据库版本检查（按方言）
- *
- * 根据当前数据库类型检查版本是否符合最低要求：
- * - MySQL: >= 8.0
- * - PostgreSQL: >= 17
- * - SQLite: >= 3.50.0
- *
- * @param sql - SQL 客户端实例
- * @throws {Error} 如果数据库版本不符合要求或无法获取版本信息
- */
-export async function ensureDbVersion(sql: SQL): Promise<void> {
-    if (!sql) throw new Error("SQL 客户端未初始化");
-
-    if (isMySQL()) {
-        const r = await sql`SELECT VERSION() AS version`;
-        if (!r || r.length === 0 || !r[0]?.version) {
-            throw new Error("无法获取 MySQL 版本信息");
-        }
-        const version = r[0].version;
-        const majorVersion = parseInt(String(version).split(".")[0], 10);
-        if (!Number.isFinite(majorVersion) || majorVersion < DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR) {
-            throw new Error(`此脚本仅支持 MySQL ${DB_VERSION_REQUIREMENTS.MYSQL_MIN_MAJOR}.0+，当前版本: ${version}`);
-        }
-        return;
-    }
-
-    if (isPG()) {
-        const r = await sql`SELECT version() AS version`;
-        if (!r || r.length === 0 || !r[0]?.version) {
-            throw new Error("无法获取 PostgreSQL 版本信息");
-        }
-        const versionText = r[0].version;
-        const m = /PostgreSQL\s+(\d+)/i.exec(versionText);
-        const major = m ? parseInt(m[1], 10) : NaN;
-        if (!Number.isFinite(major) || major < DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR) {
-            throw new Error(`此脚本要求 PostgreSQL >= ${DB_VERSION_REQUIREMENTS.POSTGRES_MIN_MAJOR}，当前: ${versionText}`);
-        }
-        return;
-    }
-
-    if (isSQLite()) {
-        const r = await sql`SELECT sqlite_version() AS version`;
-        if (!r || r.length === 0 || !r[0]?.version) {
-            throw new Error("无法获取 SQLite 版本信息");
-        }
-        const version = r[0].version;
-        // 强制最低版本：SQLite ≥ 3.50.0
-        const [maj, min, patch] = String(version)
-            .split(".")
-            .map((v) => parseInt(v, 10) || 0);
-        const vnum = maj * 10000 + min * 100 + patch; // 3.50.0 -> 35000
-        if (!Number.isFinite(vnum) || vnum < DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION_NUM) {
-            throw new Error(`此脚本要求 SQLite >= ${DB_VERSION_REQUIREMENTS.SQLITE_MIN_VERSION}，当前: ${version}`);
-        }
-        return;
-    }
-}