befly 3.0.0 → 3.0.1

package/utils/tableHelper.ts

@@ -1,167 +0,0 @@
-/**
- * Befly 表定义工具
- * 提供表字段规则解析功能
- */
-
-import path from 'node:path';
-import { existsSync, readFileSync } from 'node:fs';
-import { getProjectDir } from '../system.js';
-import { getAddonDir } from './addonHelper.js';
-import type { ParsedFieldRule } from '../types/common.js';
-
-/**
- * 解析字段规则字符串（以 | 分隔）
- * 用于解析表定义中的字段规则
- *
- * 规则格式：字段名|类型|最小值|最大值|默认值|索引|正则
- * 注意：只分割前6个|，第7个|之后的所有内容（包括|）都属于正则表达式
- *
- * @param rule - 字段规则字符串
- * @returns 解析后的字段规则对象
- *
- * @example
- * parseRule('用户名|string|2|50|null|1|null')
- * // {
- * //   name: '用户名',
- * //   type: 'string',
- * //   min: 2,
- * //   max: 50,
- * //   default: 'null',
- * //   index: 1,
- * //   regex: null
- * // }
- *
- * parseRule('年龄|number|0|150|18|0|null')
- * // {
- * //   name: '年龄',
- * //   type: 'number',
- * //   min: 0,
- * //   max: 150,
- * //   default: 18,
- * //   index: 0,
- * //   regex: null
- * // }
- *
- * parseRule('状态|string|1|20|active|1|^(active|inactive|pending)$')
- * // 正则表达式中的 | 会被保留
- */
-export const parseRule = (rule: string): ParsedFieldRule => {
-    // 手动分割前6个|，剩余部分作为正则表达式
-    // 这样可以确保正则表达式中的|不会被分割
-    const parts: string[] = [];
-    let currentPart = '';
-    let pipeCount = 0;
-
-    for (let i = 0; i < rule.length; i++) {
-        if (rule[i] === '|' && pipeCount < 6) {
-            parts.push(currentPart);
-            currentPart = '';
-            pipeCount++;
-        } else {
-            currentPart += rule[i];
-        }
-    }
-    // 添加最后一部分（正则表达式）
-    parts.push(currentPart);
-
-    const [fieldName = '', fieldType = 'string', fieldMinStr = 'null', fieldMaxStr = 'null', fieldDefaultStr = 'null', fieldIndexStr = '0', fieldRegx = 'null'] = parts;
-
-    const fieldIndex = Number(fieldIndexStr) as 0 | 1;
-    const fieldMin = fieldMinStr !== 'null' ? Number(fieldMinStr) : null;
-    const fieldMax = fieldMaxStr !== 'null' ? Number(fieldMaxStr) : null;
-
-    let fieldDefault: any = fieldDefaultStr;
-    if (fieldType === 'number' && fieldDefaultStr !== 'null') {
-        fieldDefault = Number(fieldDefaultStr);
-    }
-
-    return {
-        name: fieldName,
-        type: fieldType as 'string' | 'number' | 'text' | 'array',
-        min: fieldMin,
-        max: fieldMax,
-        default: fieldDefault,
-        index: fieldIndex,
-        regex: fieldRegx !== 'null' ? fieldRegx : null
-    };
-};
-
-/**
- * 从表定义中加载字段
- * @param tableName - 表名
- * @param options - 可选配置
- * @returns 字段定义对象
- */
-export function loadTableFields(
-    tableName: string,
-    options?: {
-        source?: 'core' | 'project' | 'addon';
-        addonName?: string;
-    }
-): Record<string, string> {
-    const source = options?.source || 'project';
-    const addonName = options?.addonName || '';
-
-    let tableFilePath: string;
-
-    // 根据来源确定表定义文件路径
-    if (source === 'core') {
-        tableFilePath = path.join(import.meta.dir, '../tables', `${tableName}.json`);
-    } else if (source === 'addon') {
-        if (!addonName) {
-            throw new Error('addon 来源必须提供 addonName 参数');
-        }
-        tableFilePath = path.join(getAddonDir(addonName, 'tables'), `${tableName}.json`);
-    } else {
-        tableFilePath = path.join(getProjectDir('tables'), `${tableName}.json`);
-    }
-
-    // 检查文件是否存在
-    if (!existsSync(tableFilePath)) {
-        throw new Error(`表定义文件不存在: ${tableFilePath}`);
-    }
-
-    try {
-        // 读取并解析 JSON 文件
-        const fileContent = readFileSync(tableFilePath, 'utf-8');
-        const fields = JSON.parse(fileContent);
-
-        // 验证是否为对象
-        if (typeof fields !== 'object' || fields === null || Array.isArray(fields)) {
-            throw new Error(`表定义文件格式错误: ${tableFilePath}`);
-        }
-
-        return fields;
-    } catch (error: any) {
-        throw new Error(`加载表定义失败 (${tableName}): ${error.message}`);
-    }
-}
-
-/**
- * 从表定义中选择部分字段
- * @param tableName - 表名
- * @param fieldNames - 要选择的字段名数组
- * @param options - 可选配置
- * @returns 选择的字段定义对象
- */
-export function pickTableFields(
-    tableName: string,
-    fieldNames: string[],
-    options?: {
-        source?: 'core' | 'project' | 'addon';
-        addonName?: string;
-    }
-): Record<string, string> {
-    const allFields = loadTableFields(tableName, options);
-    const pickedFields: Record<string, string> = {};
-
-    for (const fieldName of fieldNames) {
-        if (fieldName in allFields) {
-            pickedFields[fieldName] = allFields[fieldName];
-        } else {
-            throw new Error(`表 ${tableName} 中不存在字段: ${fieldName}`);
-        }
-    }
-
-    return pickedFields;
-}

package/utils/tool.ts

@@ -1,230 +0,0 @@
-/**
- * Tool 工具类 - TypeScript 版本
- * 提供数据处理的便捷方法
- */
-
-import { omitFields } from './index.js';
-import type { BeflyContext } from '../types/befly.js';
-
-/**
- * 数据对象类型
- */
-type DataObject = Record<string, any>;
-
-/**
- * 工具类：通过构造函数注入 befly
- */
-export class Tool {
-    private befly: BeflyContext;
-
-    /**
-     * 构造函数
-     * @param befly - Befly 上下文
-     */
-    constructor(befly: BeflyContext) {
-        this.befly = befly;
-    }
-
-    /**
-     * 处理更新数据
-     * - 移除 id、created_at、deleted_at 字段
-     * - 添加 updated_at 时间戳
-     * @param data - 原始数据
-     * @returns 处理后的数据
-     */
-    async updData(data: DataObject): Promise<DataObject> {
-        const now = Date.now();
-        const cleaned = omitFields(data ?? {}, ['id', 'created_at', 'deleted_at'], [undefined]);
-        return { ...cleaned, updated_at: now };
-    }
-
-    /**
-     * 处理插入数据
-     * - 生成唯一 ID
-     * - 添加 created_at 和 updated_at 时间戳
-     * - 移除 undefined 字段
-     * @param data - 原始数据（支持单个对象或数组）
-     * @returns 处理后的数据
-     */
-    async insData(data: DataObject | DataObject[]): Promise<DataObject | DataObject[]> {
-        const now = Date.now();
-        const genId = async (): Promise<number> => 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,
-                    state: 0
-                }))
-            );
-        } else {
-            const cleaned = omitFields(data ?? {}, [], [undefined]);
-            return {
-                ...cleaned,
-                id: await genId(),
-                created_at: now,
-                updated_at: now,
-                state: 0
-            };
-        }
-    }
-
-    /**
-     * 处理删除数据（软删除）
-     * - 设置 deleted_at 时间戳
-     * - 添加 updated_at 时间戳
-     * @returns 处理后的数据
-     */
-    async delData(): Promise<DataObject> {
-        const now = Date.now();
-        return {
-            deleted_at: now,
-            updated_at: now,
-            state: 1
-        };
-    }
-
-    /**
-     * 批量生成 ID
-     * @param count - 生成数量
-     * @returns ID 数组
-     */
-    async genIds(count: number): Promise<number[]> {
-        const ids: number[] = [];
-        for (let i = 0; i < count; i++) {
-            ids.push(await this.befly.redis.genTimeID());
-        }
-        return ids;
-    }
-
-    /**
-     * 清理数据对象
-     * - 移除 undefined、null、空字符串
-     * @param data - 原始数据
-     * @param removeNull - 是否移除 null
-     * @param removeEmptyString - 是否移除空字符串
-     * @returns 清理后的数据
-     */
-    cleanData(data: DataObject, removeNull: boolean = true, removeEmptyString: boolean = true): DataObject {
-        const result: DataObject = {};
-
-        for (const [key, value] of Object.entries(data)) {
-            // 跳过 undefined
-            if (value === undefined) continue;
-
-            // 跳过 null（如果配置）
-            if (removeNull && value === null) continue;
-
-            // 跳过空字符串（如果配置）
-            if (removeEmptyString && value === '') continue;
-
-            result[key] = value;
-        }
-
-        return result;
-    }
-
-    /**
-     * 合并数据对象（深度合并）
-     * @param target - 目标对象
-     * @param sources - 源对象（可多个）
-     * @returns 合并后的对象
-     */
-    mergeData(target: DataObject, ...sources: DataObject[]): DataObject {
-        const result = { ...target };
-
-        for (const source of sources) {
-            for (const [key, value] of Object.entries(source)) {
-                if (value !== undefined) {
-                    result[key] = value;
-                }
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * 提取指定字段
-     * @param data - 原始数据
-     * @param fields - 字段列表
-     * @returns 提取后的数据
-     */
-    pickFields(data: DataObject, fields: string[]): DataObject {
-        const result: DataObject = {};
-
-        for (const field of fields) {
-            if (field in data) {
-                result[field] = data[field];
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * 排除指定字段
-     * @param data - 原始数据
-     * @param fields - 字段列表
-     * @returns 排除后的数据
-     */
-    omitFields(data: DataObject, fields: string[]): DataObject {
-        const result = { ...data };
-
-        for (const field of fields) {
-            delete result[field];
-        }
-
-        return result;
-    }
-
-    /**
-     * 重命名字段
-     * @param data - 原始数据
-     * @param mapping - 字段映射 { oldKey: newKey }
-     * @returns 重命名后的数据
-     */
-    renameFields(data: DataObject, mapping: Record<string, string>): DataObject {
-        const result = { ...data };
-
-        for (const [oldKey, newKey] of Object.entries(mapping)) {
-            if (oldKey in result) {
-                result[newKey] = result[oldKey];
-                delete result[oldKey];
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * 转换字段类型
-     * @param data - 原始数据
-     * @param conversions - 转换规则 { field: 'number' | 'string' | 'boolean' }
-     * @returns 转换后的数据
-     */
-    convertFields(data: DataObject, conversions: Record<string, 'number' | 'string' | 'boolean'>): DataObject {
-        const result = { ...data };
-
-        for (const [field, type] of Object.entries(conversions)) {
-            if (field in result && result[field] !== null && result[field] !== undefined) {
-                switch (type) {
-                    case 'number':
-                        result[field] = Number(result[field]);
-                        break;
-                    case 'string':
-                        result[field] = String(result[field]);
-                        break;
-                    case 'boolean':
-                        result[field] = Boolean(result[field]);
-                        break;
-                }
-            }
-        }
-
-        return result;
-    }
-}

package/utils/typeHelper.ts

@@ -1,101 +0,0 @@
-/**
- * Befly 类型判断工具
- * 提供各种类型检查和判断功能
- */
-
-/**
- * 类型判断
- * @param value - 要判断的值
- * @param type - 期望的类型
- * @returns 是否匹配指定类型
- *
- * @example
- * isType(123, 'number') // true
- * isType('hello', 'string') // true
- * isType([], 'array') // true
- * isType({}, 'object') // true
- * isType(null, 'null') // true
- * isType(undefined, 'undefined') // true
- * isType(NaN, 'nan') // true
- * isType(42, 'integer') // true
- * isType(3.14, 'float') // true
- * isType(10, 'positive') // true
- * isType(-5, 'negative') // true
- * isType(0, 'zero') // true
- * isType('', 'empty') // true
- * isType(null, 'empty') // true
- * isType(true, 'truthy') // true
- * isType(false, 'falsy') // true
- * isType('str', 'primitive') // true
- * isType({}, 'reference') // true
- */
-export const isType = (value: any, type: string): boolean => {
-    const actualType = Object.prototype.toString.call(value).slice(8, -1).toLowerCase();
-    const expectedType = String(type).toLowerCase();
-
-    // 语义类型单独处理
-    switch (expectedType) {
-        case 'function':
-            return typeof value === 'function';
-        case 'nan':
-            return typeof value === 'number' && Number.isNaN(value);
-        case 'empty':
-            return value === '' || value === null || value === undefined;
-        case 'integer':
-            return Number.isInteger(value);
-        case 'float':
-            return typeof value === 'number' && !Number.isInteger(value) && !Number.isNaN(value);
-        case 'positive':
-            return typeof value === 'number' && value > 0;
-        case 'negative':
-            return typeof value === 'number' && value < 0;
-        case 'zero':
-            return value === 0;
-        case 'truthy':
-            return !!value;
-        case 'falsy':
-            return !value;
-        case 'primitive':
-            return value !== Object(value);
-        case 'reference':
-            return value === Object(value);
-        default:
-            return actualType === expectedType;
-    }
-};
-
-/**
- * 判断是否为空对象
- * @param obj - 要判断的值
- * @returns 是否为空对象
- *
- * @example
- * isEmptyObject({}) // true
- * isEmptyObject({ a: 1 }) // false
- * isEmptyObject([]) // false
- * isEmptyObject(null) // false
- */
-export const isEmptyObject = (obj: any): boolean => {
-    if (!isType(obj, 'object')) {
-        return false;
-    }
-    return Object.keys(obj).length === 0;
-};
-
-/**
- * 判断是否为空数组
- * @param arr - 要判断的值
- * @returns 是否为空数组
- *
- * @example
- * isEmptyArray([]) // true
- * isEmptyArray([1, 2]) // false
- * isEmptyArray({}) // false
- * isEmptyArray(null) // false
- */
-export const isEmptyArray = (arr: any): boolean => {
-    if (!isType(arr, 'array')) {
-        return false;
-    }
-    return arr.length === 0;
-};