befly 2.1.0 → 2.2.0

package/utils/sqlManager.js

@@ -0,0 +1,471 @@
+import { Env } from '../config/env.js';
+import { Logger } from './logger.js';
+import { createQueryBuilder } from './sqlBuilder.js';
+
+// 数据库管理器（从 plugins/db.js 提取）
+export class SqlManager {
+    // 私有属性
+    #sql;
+    #befly;
+
+    constructor(client, befly) {
+        this.#sql = client;
+        this.#befly = befly;
+    }
+
+    // 原始连接池访问（兼容占位）
+    get pool() {
+        return {
+            activeConnections: () => 0,
+            totalConnections: () => 0,
+            idleConnections: () => 0,
+            taskQueueSize: () => 0
+        };
+    }
+
+    // 创建查询构造器
+    query() {
+        return createQueryBuilder();
+    }
+
+    // 私有方法：通用数据处理函数 - 自动添加ID、时间戳和状态
+    async #processDataForInsert(data) {
+        const now = Date.now();
+        const genId = async () => (this.#befly?.redis?.genTimeID ? await this.#befly.redis.genTimeID() : now);
+
+        if (Array.isArray(data)) {
+            return await Promise.all(
+                data.map(async (item) => ({
+                    ...item,
+                    id: await genId(),
+                    state: 0,
+                    created_at: now,
+                    updated_at: now
+                }))
+            );
+        } else {
+            return {
+                ...data,
+                id: await genId(),
+                state: 0,
+                created_at: now,
+                updated_at: now
+            };
+        }
+    }
+
+    // 私有方法：添加默认的state过滤条件
+    #addDefaultStateFilter(where = {}) {
+        const hasStateCondition = Object.keys(where).some((key) => key === 'state' || key.startsWith('state$'));
+        if (!hasStateCondition) return { ...where, state$ne: 2 };
+        return where;
+    }
+
+    // 私有方法：执行 SQL（支持传入事务连接对象）
+    async #executeWithConn(query, params = [], conn = null) {
+        if (!query || typeof query !== 'string') {
+            throw new Error('SQL 语句是必需的');
+        }
+
+        const isSelectLike = /^\s*(with|select|show|desc|explain)\b/i.test(query);
+        const isWriteLike = /^\s*(insert|update|delete|replace)\b/i.test(query);
+        const client = conn || this.#sql;
+        try {
+            if (Env.MYSQL_DEBUG === 1) {
+                Logger.debug('执行SQL:', { sql: query, params });
+            }
+            // 读查询
+            if (isSelectLike) {
+                if (params && params.length > 0) {
+                    return await client.unsafe(query, params);
+                } else {
+                    return await client.unsafe(query);
+                }
+            }
+
+            // 写查询
+            if (isWriteLike) {
+                const runOn = conn ? client : await this.#sql.reserve();
+                try {
+                    if (params && params.length > 0) {
+                        await runOn.unsafe(query, params);
+                    } else {
+                        await runOn.unsafe(query);
+                    }
+                    const [{ affectedRows }] = await runOn`SELECT ROW_COUNT() AS affectedRows`;
+                    const [{ insertId }] = await runOn`SELECT LAST_INSERT_ID() AS insertId`;
+                    return { affectedRows: Number(affectedRows) || 0, insertId: Number(insertId) || 0 };
+                } finally {
+                    if (!conn && runOn && typeof runOn.release === 'function') runOn.release();
+                }
+            }
+
+            // 其他（DDL等）
+            if (params && params.length > 0) {
+                return await client.unsafe(query, params);
+            } else {
+                return await client.unsafe(query);
+            }
+        } catch (error) {
+            Logger.error('SQL 执行失败:', { sql: query, params, error: error.message });
+            throw error;
+        }
+    }
+
+    // 私有方法：获取单条记录详情（支持传入连接对象）
+    async #getDetailWithConn(table, options = {}, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+
+        const { where = {}, fields = '*', leftJoins = [] } = typeof options === 'object' && !Array.isArray(options) ? options : { where: options };
+
+        try {
+            const filteredWhere = this.#addDefaultStateFilter(where);
+            const builder = createQueryBuilder().select(fields).from(table).where(filteredWhere).limit(1);
+
+            leftJoins.forEach((join) => {
+                if (typeof join === 'string') {
+                    const parts = join.split(' ON ');
+                    if (parts.length === 2) builder.leftJoin(parts[0].trim(), parts[1].trim());
+                } else if (join && typeof join === 'object' && join.table && join.on) {
+                    builder.leftJoin(join.table, join.on);
+                }
+            });
+
+            const { sql: q, params } = builder.toSelectSql();
+            const result = await this.#executeWithConn(q, params, conn);
+            return result[0] || null;
+        } catch (error) {
+            Logger.error('getDetail 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：获取列表（支持传入连接对象）
+    async #getListWithConn(table, options = {}, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+
+        const { where = {}, fields = '*', leftJoins = [], orderBy = [], groupBy = [], having = [], page = 1, pageSize = 10 } = options;
+
+        try {
+            const filteredWhere = this.#addDefaultStateFilter(where);
+            const builder = createQueryBuilder().select(fields).from(table).where(filteredWhere);
+
+            leftJoins.forEach((join) => {
+                if (typeof join === 'string') {
+                    const parts = join.split(' ON ');
+                    if (parts.length === 2) builder.leftJoin(parts[0].trim(), parts[1].trim());
+                } else if (join && typeof join === 'object' && join.table && join.on) {
+                    builder.leftJoin(join.table, join.on);
+                }
+            });
+
+            if (Array.isArray(groupBy) && groupBy.length > 0) builder.groupBy(groupBy);
+            if (Array.isArray(having) && having.length > 0) having.forEach((h) => builder.having(h));
+            if (Array.isArray(orderBy) && orderBy.length > 0) builder.orderBy(orderBy);
+
+            const numPage = parseInt(page) || 1;
+            const numPageSize = parseInt(pageSize) || 10;
+            if (numPage > 0 && numPageSize > 0) {
+                const offset = (numPage - 1) * numPageSize;
+                builder.limit(numPageSize, offset);
+            }
+
+            const { sql: q, params } = builder.toSelectSql();
+            const rows = await this.#executeWithConn(q, params, conn);
+
+            let total = 0;
+            if (numPage > 0 && numPageSize > 0) {
+                const countBuilder = createQueryBuilder().from(table).where(filteredWhere);
+                leftJoins.forEach((join) => {
+                    if (typeof join === 'string') {
+                        const parts = join.split(' ON ');
+                        if (parts.length === 2) countBuilder.leftJoin(parts[0].trim(), parts[1].trim());
+                    } else if (join && typeof join === 'object' && join.table && join.on) {
+                        countBuilder.leftJoin(join.table, join.on);
+                    }
+                });
+
+                const { sql: countSql, params: countParams } = countBuilder.toCountSql();
+                const countResult = await this.#executeWithConn(countSql, countParams, conn);
+                total = countResult[0]?.total || 0;
+            }
+
+            return {
+                rows: Array.isArray(rows) ? rows : [],
+                total,
+                page: numPage,
+                pageSize: numPageSize
+            };
+        } catch (error) {
+            Logger.error('getList 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：获取所有记录（支持传入连接对象）
+    async #getAllWithConn(table, options = {}, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+
+        const { where = {}, fields = '*', leftJoins = [], orderBy = [] } = typeof options === 'object' && !Array.isArray(options) ? options : { where: options };
+
+        try {
+            const filteredWhere = this.#addDefaultStateFilter(where);
+            const builder = createQueryBuilder().select(fields).from(table).where(filteredWhere);
+
+            leftJoins.forEach((join) => {
+                if (typeof join === 'string') {
+                    const parts = join.split(' ON ');
+                    if (parts.length === 2) builder.leftJoin(parts[0].trim(), parts[1].trim());
+                } else if (join && typeof join === 'object' && join.table && join.on) {
+                    builder.leftJoin(join.table, join.on);
+                }
+            });
+
+            if (Array.isArray(orderBy) && orderBy.length > 0) builder.orderBy(orderBy);
+
+            const { sql: q, params } = builder.toSelectSql();
+            const result = await this.#executeWithConn(q, params, conn);
+            return Array.isArray(result) ? result : [];
+        } catch (error) {
+            Logger.error('getAll 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：插入数据（支持传入连接对象）
+    async #insDataWithConn(table, data, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        if (!data) {
+            throw new Error('插入数据是必需的');
+        }
+        try {
+            const processedData = await this.#processDataForInsert(data);
+            const builder = createQueryBuilder();
+            const { sql: q, params } = builder.toInsertSql(table, processedData);
+            return await this.#executeWithConn(q, params, conn);
+        } catch (error) {
+            Logger.error('insData 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：更新数据（支持传入连接对象）
+    async #updDataWithConn(table, data, where, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        if (!data || typeof data !== 'object') {
+            throw new Error('更新数据是必需的');
+        }
+        if (!where) {
+            throw new Error('更新操作需要 WHERE 条件');
+        }
+        try {
+            const filteredData = Object.fromEntries(Object.entries(data).filter(([key, value]) => value !== undefined && !['id', 'created_at', 'deleted_at'].includes(key)));
+            const updateData = { ...filteredData, updated_at: Date.now() };
+            const builder = createQueryBuilder().where(where);
+            const { sql: q, params } = builder.toUpdateSql(table, updateData);
+            return await this.#executeWithConn(q, params, conn);
+        } catch (error) {
+            Logger.error('updData 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：删除数据（支持传入连接对象）
+    async #delDataWithConn(table, where, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        if (!where) {
+            throw new Error('删除操作需要 WHERE 条件');
+        }
+        try {
+            const builder = createQueryBuilder().where(where);
+            const { sql: q, params } = builder.toDeleteSql(table);
+            return await this.#executeWithConn(q, params, conn);
+        } catch (error) {
+            Logger.error('delData 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：软删除数据（支持传入连接对象）
+    async #delData2WithConn(table, where, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        if (!where) {
+            throw new Error('软删除操作需要 WHERE 条件');
+        }
+        try {
+            const updateData = { state: 2, updated_at: Date.now() };
+            const builder = createQueryBuilder().where(where);
+            const { sql: q, params } = builder.toUpdateSql(table, updateData);
+            return await this.#executeWithConn(q, params, conn);
+        } catch (error) {
+            Logger.error('delData2 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：批量插入（支持传入连接对象）
+    async #insBatchWithConn(table, dataArray, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        if (!Array.isArray(dataArray) || dataArray.length === 0) {
+            throw new Error('批量插入数据不能为空');
+        }
+        try {
+            const processedDataArray = await this.#processDataForInsert(dataArray);
+            const builder = createQueryBuilder();
+            const { sql: q, params } = builder.toInsertSql(table, processedDataArray);
+            return await this.#executeWithConn(q, params, conn);
+        } catch (error) {
+            Logger.error('insBatch 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 私有方法：获取记录总数（支持传入连接对象）
+    async #getCountWithConn(table, options = {}, conn = null) {
+        if (!table || typeof table !== 'string') {
+            throw new Error('表名是必需的');
+        }
+        const { where = {}, leftJoins = [] } = typeof options === 'object' && !Array.isArray(options) ? options : { where: options };
+        try {
+            const filteredWhere = this.#addDefaultStateFilter(where);
+            const builder = createQueryBuilder().from(table).where(filteredWhere);
+
+            leftJoins.forEach((join) => {
+                if (typeof join === 'string') {
+                    const parts = join.split(' ON ');
+                    if (parts.length === 2) builder.leftJoin(parts[0].trim(), parts[1].trim());
+                } else if (join && typeof join === 'object' && join.table && join.on) {
+                    builder.leftJoin(join.table, join.on);
+                }
+            });
+
+            const { sql: q, params } = builder.toCountSql();
+            const result = await this.#executeWithConn(q, params, conn);
+            return result[0]?.total || 0;
+        } catch (error) {
+            Logger.error('getCount 执行失败:', error);
+            throw error;
+        }
+    }
+
+    // 执行原始 SQL - 核心方法
+    async execute(sql, params = []) {
+        return await this.#executeWithConn(sql, params);
+    }
+
+    // 获取单条记录详情
+    async getDetail(table, options = {}) {
+        return await this.#getDetailWithConn(table, options);
+    }
+
+    // 获取列表（支持分页）
+    async getList(table, options = {}) {
+        return await this.#getListWithConn(table, options);
+    }
+
+    // 获取所有记录
+    async getAll(table, options = {}) {
+        return await this.#getAllWithConn(table, options);
+    }
+
+    // 插入数据 - 增强版
+    async insData(table, data) {
+        return await this.#insDataWithConn(table, data);
+    }
+
+    // 更新数据 - 增强版
+    async updData(table, data, where) {
+        return await this.#updDataWithConn(table, data, where);
+    }
+
+    // 删除数据
+    async delData(table, where) {
+        return await this.#delDataWithConn(table, where);
+    }
+
+    // 软删除数据
+    async delData2(table, where) {
+        return await this.#delData2WithConn(table, where);
+    }
+
+    // 批量插入 - 增强版
+    async insBatch(table, dataArray) {
+        return await this.#insBatchWithConn(table, dataArray);
+    }
+
+    // 获取记录总数
+    async getCount(table, options = {}) {
+        return await this.#getCountWithConn(table, options);
+    }
+
+    // 事务处理
+    async trans(callback) {
+        if (typeof callback !== 'function') {
+            throw new Error('事务回调函数是必需的');
+        }
+        try {
+            const result = await this.#sql.begin(async (tx) => {
+                const txMethods = {
+                    query: async (query, params = []) => this.#executeWithConn(query, params, tx),
+                    execute: async (query, params = []) => this.#executeWithConn(query, params, tx),
+
+                    getDetail: async (table, options = {}) => this.#getDetailWithConn(table, options, tx),
+                    getList: async (table, options = {}) => this.#getListWithConn(table, options, tx),
+                    getAll: async (table, options = {}) => this.#getAllWithConn(table, options, tx),
+                    insData: async (table, data) => this.#insDataWithConn(table, data, tx),
+                    updData: async (table, data, where) => this.#updDataWithConn(table, data, where, tx),
+                    delData: async (table, where) => this.#delDataWithConn(table, where, tx),
+                    delData2: async (table, where) => this.#delData2WithConn(table, where, tx),
+                    getCount: async (table, options = {}) => this.#getCountWithConn(table, options, tx),
+                    insBatch: async (table, dataArray) => this.#insBatchWithConn(table, dataArray, tx)
+                };
+                return await callback(txMethods);
+            });
+            return result;
+        } catch (error) {
+            Logger.info('事务已回滚');
+            throw error;
+        }
+    }
+
+    // 获取连接池状态
+    getPoolStatus() {
+        return {
+            activeConnections: 0,
+            totalConnections: 0,
+            idleConnections: 0,
+            taskQueueSize: 0
+        };
+    }
+
+    // 关闭连接池
+    async close() {
+        if (this.#sql) {
+            try {
+                await this.#sql.close();
+                Logger.info('数据库连接已关闭');
+            } catch (error) {
+                Logger.error('关闭数据库连接失败:', error);
+                throw error;
+            }
+        }
+    }
+}
+
+export default SqlManager;

package/utils/tool.js

@@ -0,0 +1,31 @@
+import { omitFields } from './index.js';
+
+// 工具类：通过构造函数注入 befly
+export class Tool {
+    constructor(befly) {
+        this.befly = befly;
+    }
+
+    async updData(data, now = Date.now()) {
+        const cleaned = omitFields(data ?? {}, ['id', 'created_at', 'deleted_at'], [undefined]);
+        return { ...cleaned, updated_at: now };
+    }
+
+    async insData(data, now = Date.now()) {
+        const genId = async () => await this.befly.redis.genTimeID();
+
+        if (Array.isArray(data)) {
+            return await Promise.all(
+                data.map(async (item) => ({
+                    ...omitFields(item ?? {}, [], [undefined]),
+                    id: await genId(),
+                    created_at: now,
+                    updated_at: now
+                }))
+            );
+        } else {
+            const cleaned = omitFields(data ?? {}, [], [undefined]);
+            return { ...cleaned, id: await genId(), created_at: now, updated_at: now };
+        }
+    }
+}

package/utils/validate.js

@@ -1,96 +1,6 @@
-import { isType } from './util.js';
-
-// 验证字段名称是否为中文、数字、字母
-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;
-    }
-};
-
-// 专门用于处理⚡分隔的字段规则
-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或有效的正则表达式`);
-    }
+import { isType, parseFieldRule } from './index.js';
 
-    return allParts;
-};
+// 移除本文件重复实现，统一复用 index.js 导出的校验函数与 parseFieldRule
 
 /**
  * 验证器类

package/.gitignore

@@ -1,94 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-esdata
-data
-.cache
-lab
-labs
-cache
-.VSCodeCounter
-oclif.manifest.json
-dist
-report.html
-dist-ssr
-*.local
-.vscode-test/
-*.vsix
-out
-CHANGELOG.md
-note.md
-.changeset
-addons2
-pnpm-lock.yaml
-bun.lock
-other
-
-# Editor directories and files
-.vscode/*
-.cache
-.yicode/auto-imports.d.ts
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-node_modules
-jspm_packages
-
-# Optional npm cache directory
-.npm
-
-# Optional REPL history
-.node_repl_history
-
-# 0x
-profile-*
-
-# mac files
-.DS_Store
-
-# vim swap files
-*.swp
-
-# webstorm
-.idea
-
-# vscode
-.vscode
-*code-workspace
-
-# clinic
-profile*
-*clinic*
-*flamegraph*
-logs