befly 2.0.12 → 2.1.0

package/scripts/syncDb.js

@@ -0,0 +1,367 @@
+/**
+ * 数据库表结构同步脚本 - 仅支持 MySQL 8.0+
+ */
+
+import path from 'node:path';
+import { SQL } from 'bun';
+import { Env } from '../config/env.js';
+import { Logger } from '../utils/logger.js';
+import { parseFieldRule } from '../utils/util.js';
+import { __dirtables, getProjectDir } from '../system.js';
+import tableCheck from '../checks/table.js';
+
+const typeMapping = {
+    number: 'BIGINT',
+    string: 'VARCHAR',
+    text: 'MEDIUMTEXT',
+    array: 'VARCHAR'
+};
+
+// 获取字段的SQL定义
+const getColumnDefinition = (fieldName, rule) => {
+    const [fieldDisplayName, fieldType, fieldMin, fieldMaxLength, fieldDefaultValue, fieldHasIndex] = parseFieldRule(rule);
+
+    let sqlType = typeMapping[fieldType];
+    if (!sqlType) throw new Error(`不支持的数据类型: ${fieldType}`);
+
+    // 根据字段类型设置SQL类型和长度
+    if (fieldType === 'string' || fieldType === 'array') {
+        const maxLength = parseInt(fieldMaxLength);
+        sqlType = `VARCHAR(${maxLength})`;
+    }
+
+    let columnDef = `\`${fieldName}\` ${sqlType} NOT NULL`;
+
+    // 设置默认值：如果第5个属性为null或字段类型为text，则不设置默认值
+    if (fieldDefaultValue && fieldDefaultValue !== 'null' && fieldType !== 'text') {
+        if (fieldType === 'number') {
+            columnDef += ` DEFAULT ${fieldDefaultValue}`;
+        } else {
+            columnDef += ` DEFAULT "${fieldDefaultValue.replace(/"/g, '\\"')}"`;
+        }
+    } else if (fieldType === 'string' || fieldType === 'array') {
+        columnDef += ` DEFAULT ""`;
+    } else if (fieldType === 'number') {
+        columnDef += ` DEFAULT 0`;
+    }
+    // text类型不设置默认值
+
+    // 添加字段注释（使用第1个属性作为字段显示名称）
+    if (fieldDisplayName && fieldDisplayName !== 'null') {
+        columnDef += ` COMMENT "${fieldDisplayName.replace(/"/g, '\\"')}"`;
+    }
+
+    return columnDef;
+};
+
+// 通用执行器：将 '?' 占位符转换为 Bun SQL 的 $1, $2 并执行
+const toDollarParams = (query, params) => {
+    if (!params || params.length === 0) return query;
+    let i = 0;
+    return query.replace(/\?/g, () => `$${++i}`);
+};
+
+const exec = async (client, query, params = []) => {
+    if (params.length > 0) {
+        return await client.unsafe(toDollarParams(query, params), params);
+    }
+    return await client.unsafe(query);
+};
+
+// 获取表的现有列信息
+const getTableColumns = async (client, tableName) => {
+    const result = await exec(
+        client,
+        `SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_TYPE
+         FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? ORDER BY ORDINAL_POSITION`,
+        [Env.MYSQL_DB || 'test', tableName]
+    );
+
+    const columns = {};
+    result.forEach((row) => {
+        columns[row.COLUMN_NAME] = {
+            type: row.DATA_TYPE,
+            columnType: row.COLUMN_TYPE,
+            length: row.CHARACTER_MAXIMUM_LENGTH,
+            nullable: row.IS_NULLABLE === 'YES',
+            defaultValue: row.COLUMN_DEFAULT,
+            comment: row.COLUMN_COMMENT
+        };
+    });
+    return columns;
+};
+
+// 获取表的现有索引信息
+const getTableIndexes = async (client, tableName) => {
+    const result = await exec(
+        client,
+        `SELECT INDEX_NAME, COLUMN_NAME FROM information_schema.STATISTICS
+         WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND INDEX_NAME != 'PRIMARY' ORDER BY INDEX_NAME`,
+        [Env.MYSQL_DB || 'test', tableName]
+    );
+
+    const indexes = {};
+    result.forEach((row) => {
+        if (!indexes[row.INDEX_NAME]) indexes[row.INDEX_NAME] = [];
+        indexes[row.INDEX_NAME].push(row.COLUMN_NAME);
+    });
+    return indexes;
+};
+
+// 管理索引
+const manageIndex = async (client, tableName, indexName, fieldName, action) => {
+    const sql = action === 'create' ? `CREATE INDEX \`${indexName}\` ON \`${tableName}\` (\`${fieldName}\`)` : `DROP INDEX \`${indexName}\` ON \`${tableName}\``;
+
+    try {
+        await exec(client, sql);
+        Logger.info(`表 ${tableName} 索引 ${indexName} ${action === 'create' ? '创建' : '删除'}成功`);
+    } catch (error) {
+        Logger.error(`${action === 'create' ? '创建' : '删除'}索引失败: ${error.message}`);
+        throw error;
+    }
+};
+
+// 创建表
+const createTable = async (client, tableName, fields) => {
+    const columns = [
+        //
+        '`id` BIGINT PRIMARY KEY COMMENT "主键ID"',
+        '`created_at` BIGINT NOT NULL DEFAULT 0 COMMENT "创建时间"',
+        '`updated_at` BIGINT NOT NULL DEFAULT 0 COMMENT "更新时间"',
+        '`deleted_at` BIGINT NOT NULL DEFAULT 0 COMMENT "删除时间"',
+        '`state` BIGINT NOT NULL DEFAULT 0 COMMENT "状态字段"'
+    ];
+
+    const indexes = [
+        //
+        'INDEX `idx_created_at` (`created_at`)',
+        'INDEX `idx_updated_at` (`updated_at`)',
+        'INDEX `idx_state` (`state`)'
+    ];
+
+    // 添加自定义字段和索引
+    for (const [fieldName, rule] of Object.entries(fields)) {
+        columns.push(getColumnDefinition(fieldName, rule));
+
+        // 使用第6个属性判断是否设置索引
+        const ruleParts = parseFieldRule(rule);
+        const fieldHasIndex = ruleParts[5]; // 第6个属性
+        if (fieldHasIndex === '1') {
+            indexes.push(`INDEX \`idx_${fieldName}\` (\`${fieldName}\`)`);
+        }
+    }
+
+    const createTableSQL = `
+        CREATE TABLE \`${tableName}\` (
+            ${columns.join(',\n            ')},
+            ${indexes.join(',\n            ')}
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+    `;
+
+    await exec(client, createTableSQL);
+    Logger.info(`表 ${tableName} 创建成功`);
+};
+
+// 比较字段定义变化
+const compareFieldDefinition = (existingColumn, newRule, fieldName) => {
+    const ruleParts = parseFieldRule(newRule);
+    const [fieldDisplayName, fieldType, fieldMin, fieldMaxLength, fieldDefaultValue] = ruleParts;
+    const changes = [];
+
+    // 检查长度变化（string和array类型）
+    if (fieldType === 'string' || fieldType === 'array') {
+        if (fieldMaxLength === 'null') {
+            throw new Error(`string/array 类型字段的最大长度未设置，必须指定最大长度`);
+        }
+        const newMaxLength = parseInt(fieldMaxLength);
+        if (existingColumn.length !== newMaxLength) {
+            changes.push({ type: 'length', current: existingColumn.length, new: newMaxLength });
+        }
+    }
+
+    // 检查注释变化（使用第1个属性作为字段显示名称）
+    if (fieldDisplayName && fieldDisplayName !== 'null') {
+        const currentComment = existingColumn.comment || '';
+        if (currentComment !== fieldDisplayName) {
+            changes.push({ type: 'comment', current: currentComment, new: fieldDisplayName });
+        }
+    }
+
+    // 检查数据类型变化
+    const expectedDbType = {
+        number: 'bigint',
+        string: 'varchar',
+        text: 'mediumtext',
+        array: 'varchar'
+    }[fieldType];
+
+    if (existingColumn.type.toLowerCase() !== expectedDbType) {
+        changes.push({ type: 'datatype', current: existingColumn.type, new: expectedDbType });
+    }
+
+    return { hasChanges: changes.length > 0, changes };
+};
+
+// 生成DDL语句
+const generateDDL = (tableName, fieldName, rule, isAdd = false) => {
+    const columnDef = getColumnDefinition(fieldName, rule);
+    const operation = isAdd ? 'ADD COLUMN' : 'MODIFY COLUMN';
+    return `ALTER TABLE \`${tableName}\` ${operation} ${columnDef}, ALGORITHM=INSTANT, LOCK=NONE`;
+};
+
+// 安全执行DDL语句
+const executeDDLSafely = async (client, sql) => {
+    try {
+        await exec(client, sql);
+        return true;
+    } catch (error) {
+        // INSTANT失败时尝试INPLACE
+        if (sql.includes('ALGORITHM=INSTANT')) {
+            const inplaceSql = sql.replace('ALGORITHM=INSTANT', 'ALGORITHM=INPLACE');
+            try {
+                await exec(client, inplaceSql);
+                return true;
+            } catch (inplaceError) {
+                // 最后尝试传统DDL
+                const traditionSql = sql.split(',')[0]; // 移除ALGORITHM和LOCK参数
+                await exec(client, traditionSql);
+                return true;
+            }
+        } else {
+            throw error;
+        }
+    }
+};
+
+// 同步表结构
+const syncTable = async (client, tableName, fields) => {
+    const existingColumns = await getTableColumns(client, tableName);
+    const existingIndexes = await getTableIndexes(client, tableName);
+    const systemFields = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'];
+
+    // 同步字段
+    for (const [fieldName, rule] of Object.entries(fields)) {
+        if (existingColumns[fieldName]) {
+            const comparison = compareFieldDefinition(existingColumns[fieldName], rule, fieldName);
+            if (comparison.hasChanges) {
+                const sql = generateDDL(tableName, fieldName, rule);
+                await executeDDLSafely(client, sql);
+                Logger.info(`字段 ${tableName}.${fieldName} 更新成功`);
+            }
+        } else {
+            const sql = generateDDL(tableName, fieldName, rule, true);
+            await executeDDLSafely(client, sql);
+            Logger.info(`字段 ${tableName}.${fieldName} 添加成功`);
+        }
+    }
+
+    // 同步索引
+    for (const [fieldName, rule] of Object.entries(fields)) {
+        const ruleParts = parseFieldRule(rule);
+        const fieldHasIndex = ruleParts[5]; // 使用第6个属性判断是否设置索引
+        const indexName = `idx_${fieldName}`;
+
+        if (fieldHasIndex === '1' && !existingIndexes[indexName]) {
+            await manageIndex(client, tableName, indexName, fieldName, 'create');
+        } else if (fieldHasIndex !== '1' && existingIndexes[indexName] && existingIndexes[indexName].length === 1) {
+            await manageIndex(client, tableName, indexName, fieldName, 'drop');
+        }
+    }
+};
+
+// 主同步函数
+const SyncDb = async () => {
+    let client = null;
+
+    try {
+        Logger.info('开始数据库表结构同步...');
+
+        // 验证表定义文件
+        const tableValidationResult = await tableCheck();
+        if (!tableValidationResult) {
+            throw new Error('表定义验证失败');
+        }
+
+        // 建立数据库连接并检查版本（Bun SQL）
+        const url = `mysql://${encodeURIComponent(Env.MYSQL_USER || 'root')}:${encodeURIComponent(Env.MYSQL_PASSWORD || 'root')}@${Env.MYSQL_HOST || '127.0.0.1'}:${Env.MYSQL_PORT || 3306}/${Env.MYSQL_DB || 'test'}`;
+        client = new SQL({ url, max: 1, bigint: true });
+        const result = await client`SELECT VERSION() AS version`;
+        const version = result[0].version;
+
+        if (version.toLowerCase().includes('mariadb')) {
+            throw new Error('此脚本仅支持 MySQL 8.0+，不支持 MariaDB');
+        }
+
+        const majorVersion = parseInt(version.split('.')[0]);
+        if (majorVersion < 8) {
+            throw new Error(`此脚本仅支持 MySQL 8.0+，当前版本: ${version}`);
+        }
+
+        Logger.info(`MySQL 版本检查通过: ${version}`);
+
+        // 扫描并处理表文件
+        const tablesGlob = new Bun.Glob('*.json');
+        const directories = [__dirtables, getProjectDir('tables')];
+        let processedCount = 0;
+        let createdTables = 0;
+        let modifiedTables = 0;
+
+        for (const dir of directories) {
+            try {
+                for await (const file of tablesGlob.scan({ cwd: dir, absolute: true, onlyFiles: true })) {
+                    const tableName = path.basename(file, '.json');
+                    const tableDefinition = await Bun.file(file).json();
+                    const result = await exec(client, 'SELECT COUNT(*) as count FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?', [Env.MYSQL_DB || 'test', tableName]);
+                    const exists = result[0].count > 0;
+
+                    if (exists) {
+                        await syncTable(client, tableName, tableDefinition);
+                    } else {
+                        await createTable(client, tableName, tableDefinition);
+                    }
+
+                    Logger.info(`表 ${tableName} 处理完成`);
+                    exists ? modifiedTables++ : createdTables++;
+                    processedCount++;
+                }
+            } catch (error) {
+                Logger.warn(`扫描目录 ${dir} 出错: ${error.message}`);
+            }
+        }
+
+        // 显示统计信息
+        Logger.info(`同步完成 - 总计: ${processedCount}, 新建: ${createdTables}, 修改: ${modifiedTables}`);
+
+        if (processedCount === 0) {
+            Logger.warn('没有找到任何表定义文件');
+        }
+    } catch (error) {
+        Logger.error(`数据库同步失败: ${error.message}`);
+        Logger.error(`错误详情: ${error.stack}`);
+        if (error.code) {
+            Logger.error(`错误代码: ${error.code}`);
+        }
+        if (error.errno) {
+            Logger.error(`错误编号: ${error.errno}`);
+        }
+        process.exit(1);
+    } finally {
+        if (client) {
+            try {
+                await client.close();
+            } catch (error) {
+                Logger.warn('关闭数据库连接时出错:', error.message);
+            }
+        }
+    }
+};
+
+// 如果直接运行此脚本
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('dbSync.js')) {
+    SyncDb().catch((error) => {
+        console.error('❌ 数据库同步失败:', error);
+        process.exit(1);
+    });
+}
+
+export { SyncDb };

package/system.js

@@ -0,0 +1,118 @@
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve, relative } from 'node:path';
+
+/**
+ * Befly 框架系统路径定义
+ * 提供统一的路径变量，供整个框架使用
+ */
+
+// 当前文件的路径信息
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Befly 框架根目录
+const __dirroot = __dirname;
+
+// 各个重要目录的路径
+const __dirscript = join(__dirroot, 'scripts');
+const __dirbin = join(__dirroot, 'bin');
+const __dirutils = join(__dirroot, 'utils');
+const __dirconfig = join(__dirroot, 'config');
+const __dirtables = join(__dirroot, 'tables');
+const __dirchecks = join(__dirroot, 'checks');
+const __dirapis = join(__dirroot, 'apis');
+const __dirplugins = join(__dirroot, 'plugins');
+const __dirlibs = join(__dirroot, 'libs');
+const __dirtests = join(__dirroot, 'tests');
+
+// 获取项目根目录（befly 框架的使用方项目）
+const getProjectRoot = () => {
+    return process.cwd();
+};
+
+// 获取项目中的特定目录
+const getProjectDir = (subdir = '') => {
+    return subdir ? join(getProjectRoot(), subdir) : getProjectRoot();
+};
+
+// 创建路径解析器，基于 befly 根目录
+const resolveBeflyPath = (...paths) => {
+    return resolve(__dirroot, ...paths);
+};
+
+// 创建路径解析器，基于项目根目录
+const resolveProjectPath = (...paths) => {
+    return resolve(getProjectRoot(), ...paths);
+};
+
+// 获取相对于 befly 根目录的相对路径
+const getRelativeBeflyPath = (targetPath) => {
+    return relative(__dirroot, targetPath);
+};
+
+// 获取相对于项目根目录的相对路径
+const getRelativeProjectPath = (targetPath) => {
+    return relative(getProjectRoot(), targetPath);
+};
+
+// 导出所有路径变量和工具函数
+export {
+    // 基础路径变量
+    __filename,
+    __dirname,
+    __dirroot,
+
+    // Befly 框架目录
+    __dirscript,
+    __dirbin,
+    __dirutils,
+    __dirconfig,
+    __dirtables,
+    __dirchecks,
+    __dirapis,
+    __dirplugins,
+    __dirlibs,
+    __dirtests,
+
+    // 项目路径工具函数
+    getProjectRoot,
+    getProjectDir,
+
+    // 路径解析工具函数
+    resolveBeflyPath,
+    resolveProjectPath,
+    getRelativeBeflyPath,
+    getRelativeProjectPath
+};
+
+// 默认导出包含所有路径信息的对象
+export default {
+    // 基础路径变量
+    __filename,
+    __dirname,
+    __dirroot,
+
+    // Befly 框架目录
+    paths: {
+        script: __dirscript,
+        bin: __dirbin,
+        utils: __dirutils,
+        config: __dirconfig,
+        tables: __dirtables,
+        checks: __dirchecks,
+        apis: __dirapis,
+        plugins: __dirplugins,
+        libs: __dirlibs,
+        tests: __dirtests
+    },
+
+    // 工具函数
+    utils: {
+        getProjectRoot,
+        getProjectDir,
+        resolveBeflyPath,
+        resolveProjectPath,
+        getRelativeBeflyPath,
+        getRelativeProjectPath
+    }
+};

package/tables/common.json

@@ -0,0 +1,16 @@
+{
+    "email": "邮箱⚡string⚡5⚡100⚡null⚡1⚡^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
+    "phone": "手机号⚡string⚡11⚡11⚡null⚡1⚡^1[3-9]\\d{9}$",
+    "page": "页码⚡number⚡1⚡9999⚡1⚡0⚡null",
+    "limit": "每页数量⚡number⚡1⚡100⚡10⚡0⚡null",
+    "title": "标题⚡string⚡1⚡200⚡null⚡0⚡null",
+    "description": "描述⚡string⚡0⚡500⚡null⚡0⚡null",
+    "keyword": "关键词⚡string⚡1⚡50⚡null⚡1⚡null",
+    "status": "状态⚡string⚡1⚡20⚡active⚡1⚡^(active|inactive|pending|suspended)$",
+    "enabled": "启用状态⚡number⚡0⚡1⚡1⚡0⚡^(0|1)$",
+    "date": "日期⚡string⚡10⚡10⚡null⚡0⚡^\\d{4}-\\d{2}-\\d{2}$",
+    "datetime": "日期时间⚡string⚡19⚡25⚡null⚡0⚡^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}",
+    "filename": "文件名⚡string⚡1⚡255⚡null⚡0⚡null",
+    "url": "网址⚡string⚡5⚡500⚡null⚡0⚡^https?://",
+    "tag": "标签⚡array⚡0⚡10⚡[]⚡0⚡null"
+}

package/tables/tool.json

@@ -0,0 +1,6 @@
+{
+    "filename": "文件名⚡string⚡1⚡255⚡null⚡1⚡null",
+    "content": "内容⚡string⚡0⚡1000000⚡null⚡0⚡null",
+    "type": "类型⚡string⚡0⚡50⚡file⚡1⚡^(file|folder|link)$",
+    "path": "路径⚡string⚡1⚡500⚡null⚡0⚡null"
+}

package/utils/util.js

@@ -1,5 +1,19 @@
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
+import { Env } from '../config/env.js';
+
+export const setCorsOptions = (req) => {
+    return {
+        headers: {
+            'Access-Control-Allow-Origin': Env.ALLOWED_ORIGIN || req.headers.get('origin') || '*',
+            'Access-Control-Allow-Methods': Env.ALLOWED_METHODS || 'GET, POST, PUT, DELETE, OPTIONS',
+            'Access-Control-Allow-Headers': Env.ALLOWED_HEADERS || 'Content-Type, Authorization, authorization, token',
+            'Access-Control-Expose-Headers': Env.EXPOSE_HEADERS || 'Content-Range, X-Content-Range, Authorization, authorization, token',
+            'Access-Control-Max-Age': Env.MAX_AGE || 86400,
+            'Access-Control-Allow-Credentials': Env.ALLOW_CREDENTIALS || 'true'
+        }
+    };
+};
 
 export const sortPlugins = (plugins) => {
     const result = [];
@@ -53,6 +67,23 @@ export const formatDate = (date = new Date(), format = 'YYYY-MM-DD HH:mm:ss') =>
     return format.replace('YYYY', year).replace('MM', month).replace('DD', day).replace('HH', hour).replace('mm', minute).replace('ss', second);
 };
 
+/**
+ * 计算时间差并返回带单位的字符串
+ * @param {number} startTime - 开始时间（Bun.nanoseconds()返回值）
+ * @param {number} endTime - 结束时间（可选，默认为当前时间）
+ * @returns {string} 时间差（如果小于1秒返回"xx 毫秒"，否则返回"xx 秒"）
+ */
+export const calculateElapsedTime = (startTime, endTime = Bun.nanoseconds()) => {
+    const elapsedMs = (endTime - startTime) / 1_000_000;
+
+    if (elapsedMs < 1000) {
+        return `${elapsedMs.toFixed(2)} 毫秒`;
+    } else {
+        const elapsedSeconds = elapsedMs / 1000;
+        return `${elapsedSeconds.toFixed(2)} 秒`;
+    }
+};
+
 // 类型判断
 export const isType = (value, type) => {
     const actualType = Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
@@ -191,3 +222,95 @@ export const filterLogFields = (body, excludeFields = '') => {
     }
     return filtered;
 };
+
+// 验证字段名称是否为中文、数字、字母
+const validateFieldName = (name) => {
+    const nameRegex = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/;
+    return nameRegex.test(name);
+};
+
+// 验证字段类型是否为指定的四种类型之一
+const validateFieldType = (type) => {
+    const validTypes = ['string', 'number', 'text', 'array'];
+    return validTypes.includes(type);
+};
+
+// 验证最小值/最大值是否为null或数字
+const validateMinMax = (value) => {
+    return value === 'null' || (!isNaN(parseFloat(value)) && isFinite(parseFloat(value)));
+};
+
+// 验证默认值是否为null、字符串或数字
+const validateDefaultValue = (value) => {
+    if (value === 'null') return true;
+    // 检查是否为数字
+    if (!isNaN(parseFloat(value)) && isFinite(parseFloat(value))) return true;
+    // 其他情况视为字符串，都是有效的
+    return true;
+};
+
+// 验证索引标识是否为0或1
+const validateIndex = (value) => {
+    return value === '0' || value === '1';
+};
+
+// 验证正则表达式是否有效
+const validateRegex = (value) => {
+    if (value === 'null') return true;
+    try {
+        new RegExp(value);
+        return true;
+    } catch (e) {
+        return false;
+    }
+};
+
+// 专门用于处理⚡分隔的字段规则
+export const parseFieldRule = (rule) => {
+    const allParts = rule.split('⚡');
+
+    // 必须包含7个部分：显示名⚡类型⚡最小值⚡最大值⚡默认值⚡是否索引⚡正则约束
+    if (allParts.length !== 7) {
+        throw new Error(`字段规则格式错误，必须包含7个部分，当前包含${allParts.length}个部分`);
+    }
+
+    // 验证各个部分的格式
+    const [name, type, minValue, maxValue, defaultValue, isIndex, regexConstraint] = allParts;
+
+    // 第1个值：名称必须为中文、数字、字母
+    if (!validateFieldName(name)) {
+        throw new Error(`字段名称 "${name}" 格式错误，必须为中文、数字、字母`);
+    }
+
+    // 第2个值：字段类型必须为string,number,text,array之一
+    if (!validateFieldType(type)) {
+        throw new Error(`字段类型 "${type}" 格式错误，必须为string、number、text、array之一`);
+    }
+
+    // 第3个值：最小值必须为null或数字
+    if (!validateMinMax(minValue)) {
+        throw new Error(`最小值 "${minValue}" 格式错误，必须为null或数字`);
+    }
+
+    // 第4个值：最大值必须为null或数字
+    if (!validateMinMax(maxValue)) {
+        throw new Error(`最大值 "${maxValue}" 格式错误，必须为null或数字`);
+    }
+
+    // 第5个值：默认值必须为null、字符串或数字
+    if (!validateDefaultValue(defaultValue)) {
+        throw new Error(`默认值 "${defaultValue}" 格式错误，必须为null、字符串或数字`);
+    }
+
+    // 第6个值：是否创建索引必须为0或1
+    if (!validateIndex(isIndex)) {
+        throw new Error(`索引标识 "${isIndex}" 格式错误，必须为0或1`);
+    }
+
+    // 第7个值：必须为null或正则表达式
+    if (!validateRegex(regexConstraint)) {
+        throw new Error(`正则约束 "${regexConstraint}" 格式错误，必须为null或有效的正则表达式`);
+    }
+
+    return allParts;
+};