befly-tpl 3.10.46 → 3.10.47

package/README.md

@@ -37,10 +37,10 @@ bunx befly init
 
 ```typescript
 // main.ts
-import { Befly } from 'befly';
+import { Befly } from "befly";
 
 const app = new Befly({
-    appName: 'My API',
+    appName: "My API",
     appPort: 3000
 });
 
@@ -57,15 +57,15 @@ bun run main.ts
 
 ```typescript
 // apis/user/hello.ts
-import type { ApiRoute } from 'befly/types/index';
+import type { ApiRoute } from "befly/types/api";
 
 export default {
-    name: '问候接口',
+    name: "问候接口",
     auth: false, // 公开接口
     fields: {},
     handler: async (befly, ctx) => {
         return {
-            msg: 'Hello, Befly!',
+            msg: "Hello, Befly!",
             data: {
                 timestamp: Date.now()
             }
@@ -81,26 +81,27 @@ export default {
 ### TypeScript 全面支持
 
 ```typescript
-import type { ApiRoute, BeflyContext } from 'befly/types/index';
-import type { User } from './types/models';
+import type { ApiRoute } from "befly/types/api";
+import type { BeflyContext } from "befly/types/befly";
+import type { User } from "./types/models";
 
 export default {
-    name: '获取用户',
+    name: "获取用户",
     auth: true,
     fields: {
-        id: '用户ID|number|1|999999|null|1|null'
+        id: "用户ID|number|1|999999|null|1|null"
     },
-    required: ['id'],
+    required: ["id"],
     handler: async (befly: BeflyContext, ctx) => {
         const { id } = ctx.body;
 
         // 类型安全的数据库查询
         const user = await befly.db.getOne<User>({
-            table: 'user',
+            table: "user",
             where: { id }
         });
 
-        return { msg: '查询成功', data: user };
+        return { msg: "查询成功", data: user };
     }
 } as ApiRoute;
 ```
@@ -110,40 +111,40 @@ export default {
 ```typescript
 // 查询单条
 const user = await befly.db.getOne<User>({
-    table: 'user',
+    table: "user",
     where: { id: 1 }
 });
 
 // 分页列表
 const result = await befly.db.getList<Product>({
-    table: 'product',
-    where: { category: 'electronics' },
+    table: "product",
+    where: { category: "electronics" },
     page: 1,
     limit: 10,
-    orderBy: ['createdAt#DESC']
+    orderBy: ["createdAt#DESC"]
 });
 
 // 插入数据
 await befly.db.insData({
-    table: 'user',
+    table: "user",
     data: {
-        username: 'john',
-        email: 'john@example.com'
+        username: "john",
+        email: "john@example.com"
     }
 });
 
 // 更新数据
 await befly.db.updData({
-    table: 'user',
+    table: "user",
     where: { id: 1 },
     data: {
-        nickname: 'John Doe'
+        nickname: "John Doe"
     }
 });
 
 // 删除数据
 await befly.db.delData({
-    table: 'user',
+    table: "user",
     where: { id: 1 }
 });
 ```
@@ -164,9 +165,7 @@ await befly.db.delData({
 
 同步到数据库：
 
-```bash
-bun run scripts/syncDb.ts
-```
+请参考：`befly` 的同步文档：`packages/core/docs/reference/sync.md`（`syncDb` / `syncAll` 等同步流程说明）。
 
 ## 🗄️ 数据库配置
 

package/apis/test/hi.ts

@@ -1,7 +1,15 @@
+/**
+ * 示例 / 测试接口
+ *
+ * 注意：本文件仅用于模板演示与本地测试，不建议在生产环境启用或依赖其行为。
+ */
+
+import type { BeflyContext } from "befly/types/befly";
+
 export default {
-    name: '测试接口',
-    handler: async (befly, ctx) => {
+    name: "测试接口",
+    handler: async (befly: BeflyContext) => {
         // 返回成功信息
-        return befly.tool.Yes('测试成功');
+        return befly.tool.Yes("测试成功");
     }
 };

package/main.ts

@@ -1,4 +1,4 @@
-import { Befly } from 'befly';
+import { Befly } from "befly";
 
 export const app = new Befly();
 

package/package.json

@@ -1,39 +1,38 @@
 {
     "name": "befly-tpl",
-    "version": "3.10.46",
-    "description": "Befly 3.0 TypeScript Template",
+    "version": "3.10.47",
     "private": false,
-    "publishConfig": {
-        "access": "public",
-        "registry": "https://registry.npmjs.org"
-    },
-    "scripts": {
-        "dev": "NODE_ENV=development bun run main.ts",
-        "start": "NODE_ENV=production bun run main.ts",
-        "pm2": "bun --bun pm2 start pm2.config.cjs",
-        "test": "bun test"
-    },
+    "description": "Befly 3.0 TypeScript Template",
+    "type": "module",
     "files": [
-        "apis",
-        "tables",
-        "tests",
-        "main.ts",
         ".npmrc",
-        "bunfig.toml",
         "LICENSE",
+        "README.md",
+        "apis",
+        "bunfig.toml",
         "main.ts",
         "package.json",
         "pm2.config.cjs",
-        "README.md",
+        "tables",
+        "tests",
         "tsconfig.json"
     ],
-    "type": "module",
+    "scripts": {
+        "dev": "NODE_ENV=development bun run main.ts",
+        "start": "NODE_ENV=production bun run main.ts",
+        "pm2": "bun --bun pm2 start pm2.config.cjs",
+        "test": "bun test"
+    },
     "dependencies": {
-        "@befly-addon/admin": "^1.1.30",
-        "befly": "^3.9.38"
+        "@befly-addon/admin": "^1.1.31",
+        "befly": "^3.9.39"
     },
     "engines": {
         "bun": ">=1.3.0"
     },
-    "gitHead": "8cb371928961c63d6c3c416c6dd667f8fe285376"
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    },
+    "gitHead": "d42bf60ba6b8b11fef7e759fa008ada075829772"
 }

package/pm2.config.cjs

@@ -1,26 +1,26 @@
 module.exports = {
     apps: [
         {
-            name: 'befly',
-            script: 'main.ts',
-            interpreter: 'bun',
+            name: "befly",
+            script: "main.ts",
+            interpreter: "bun",
 
             // 集群模式配置
             instances: 2, // 实例数量，可设置为 'max' 使用所有 CPU
-            exec_mode: 'cluster', // 集群模式
+            exec_mode: "cluster", // 集群模式
 
             // 自动重启配置
             autorestart: true,
             watch: false,
-            max_memory_restart: '500M', // 内存超过 500M 自动重启
+            max_memory_restart: "500M", // 内存超过 500M 自动重启
 
             // 日志配置
-            log_date_format: 'YYYY-MM-DD HH:mm:ss',
+            log_date_format: "YYYY-MM-DD HH:mm:ss",
             merge_logs: true,
 
             // 从 .env.production 动态加载的环境变量（使用 Bun API）
             env: {
-                NODE_ENV: 'production'
+                NODE_ENV: "production"
             }
         }
     ]

package/tests/fields-exclude.test.ts

@@ -3,11 +3,11 @@
  * 验证 fields 的3种写法：空数组、全部包含、全部排除
  */
 
-import { Befly } from 'befly';
+import { Befly } from "befly";
 
 async function testFieldsExclude() {
     // 强制启用数据库
-    process.env.DATABASE_ENABLE = '1';
+    process.env.DATABASE_ENABLE = "1";
 
     // 创建 Befly 实例
     const befly = new Befly();
@@ -19,100 +19,100 @@ async function testFieldsExclude() {
     const db = befly.appContext.db;
     const redis = befly.appContext.redis;
 
-    console.log('\n========== 测试开始 ==========\n');
+    console.log("\n========== 测试开始 ==========\n");
 
     try {
         // 测试1：空数组（查询所有字段）
-        console.log('【测试1】空数组 - 查询所有字段');
+        console.log("【测试1】空数组 - 查询所有字段");
         const result1 = await db.getOne({
-            table: 'addon_admin_user',
+            table: "addon_admin_user",
             fields: [],
             where: { id: 1 }
         });
-        console.log('结果字段数:', Object.keys(result1 || {}).length);
-        console.log('字段列表:', Object.keys(result1 || {}).join(', '));
+        console.log("结果字段数:", Object.keys(result1 || {}).length);
+        console.log("字段列表:", Object.keys(result1 || {}).join(", "));
 
         // 测试2：指定包含字段
-        console.log('\n【测试2】指定包含字段 - 只查询 id, name, email');
+        console.log("\n【测试2】指定包含字段 - 只查询 id, name, email");
         const result2 = await db.getOne({
-            table: 'addon_admin_user',
-            fields: ['id', 'name', 'email'],
+            table: "addon_admin_user",
+            fields: ["id", "name", "email"],
             where: { id: 1 }
         });
-        console.log('结果字段数:', Object.keys(result2 || {}).length);
-        console.log('字段列表:', Object.keys(result2 || {}).join(', '));
+        console.log("结果字段数:", Object.keys(result2 || {}).length);
+        console.log("字段列表:", Object.keys(result2 || {}).join(", "));
 
         // 测试3：排除字段（排除敏感字段）
-        console.log('\n【测试3】排除字段 - 排除 password, salt');
+        console.log("\n【测试3】排除字段 - 排除 password, salt");
         const result3 = await db.getOne({
-            table: 'addon_admin_user',
-            fields: ['!password', '!salt'],
+            table: "addon_admin_user",
+            fields: ["!password", "!salt"],
             where: { id: 1 }
         });
-        console.log('结果字段数:', Object.keys(result3 || {}).length);
-        console.log('字段列表:', Object.keys(result3 || {}).join(', '));
-        console.log('是否包含 password:', 'password' in (result3 || {}));
-        console.log('是否包含 salt:', 'salt' in (result3 || {}));
+        console.log("结果字段数:", Object.keys(result3 || {}).length);
+        console.log("字段列表:", Object.keys(result3 || {}).join(", "));
+        console.log("是否包含 password:", "password" in (result3 || {}));
+        console.log("是否包含 salt:", "salt" in (result3 || {}));
 
         // 测试4：getList 支持排除字段
-        console.log('\n【测试4】getList - 排除字段');
+        console.log("\n【测试4】getList - 排除字段");
         const result4 = await db.getList({
-            table: 'addon_admin_user',
-            fields: ['!password', '!salt'],
+            table: "addon_admin_user",
+            fields: ["!password", "!salt"],
             page: 1,
             limit: 2
         });
-        console.log('查询到记录数:', result4.lists.length);
+        console.log("查询到记录数:", result4.lists.length);
         if (result4.lists.length > 0) {
-            console.log('第一条记录字段:', Object.keys(result4.lists[0]).join(', '));
-            console.log('是否包含 password:', 'password' in result4.lists[0]);
+            console.log("第一条记录字段:", Object.keys(result4.lists[0]).join(", "));
+            console.log("是否包含 password:", "password" in result4.lists[0]);
         }
 
         // 测试5：getAll 支持排除字段
-        console.log('\n【测试5】getAll - 排除字段');
+        console.log("\n【测试5】getAll - 排除字段");
         const result5 = await db.getAll({
-            table: 'addon_admin_user',
-            fields: ['!password', '!salt']
+            table: "addon_admin_user",
+            fields: ["!password", "!salt"]
         });
-        console.log('查询到记录数:', result5.length);
+        console.log("查询到记录数:", result5.length);
         if (result5.length > 0) {
-            console.log('第一条记录字段:', Object.keys(result5[0]).join(', '));
-            console.log('是否包含 password:', 'password' in result5[0]);
+            console.log("第一条记录字段:", Object.keys(result5[0]).join(", "));
+            console.log("是否包含 password:", "password" in result5[0]);
         }
 
         // 测试6：混用检测（应该报错）
-        console.log('\n【测试6】混用检测 - 应该抛出错误');
+        console.log("\n【测试6】混用检测 - 应该抛出错误");
         try {
             await db.getOne({
-                table: 'addon_admin_user',
-                fields: ['id', '!password'],
+                table: "addon_admin_user",
+                fields: ["id", "!password"],
                 where: { id: 1 }
             });
-            console.log('❌ 没有抛出错误（不符合预期）');
+            console.log("❌ 没有抛出错误（不符合预期）");
         } catch (error: any) {
-            console.log('✅ 成功捕获错误:', error.message);
+            console.log("✅ 成功捕获错误:", error.message);
         }
 
         // 测试7：星号检测（应该报错）
-        console.log('\n【测试7】星号检测 - 应该抛出错误');
+        console.log("\n【测试7】星号检测 - 应该抛出错误");
         try {
             await db.getOne({
-                table: 'addon_admin_user',
-                fields: ['*'],
+                table: "addon_admin_user",
+                fields: ["*"],
                 where: { id: 1 }
             });
-            console.log('❌ 没有抛出错误（不符合预期）');
+            console.log("❌ 没有抛出错误（不符合预期）");
         } catch (error: any) {
-            console.log('✅ 成功捕获错误:', error.message);
+            console.log("✅ 成功捕获错误:", error.message);
         }
 
         // 测试8：缓存性能测试
-        console.log('\n【测试8】缓存性能测试 - 多次查询相同表');
+        console.log("\n【测试8】缓存性能测试 - 多次查询相同表");
         const start = Date.now();
         for (let i = 0; i < 5; i++) {
             await db.getOne({
-                table: 'addon_admin_user',
-                fields: ['!password', '!salt'],
+                table: "addon_admin_user",
+                fields: ["!password", "!salt"],
                 where: { id: 1 }
             });
         }
@@ -120,9 +120,9 @@ async function testFieldsExclude() {
         console.log(`5次查询总耗时: ${duration}ms`);
         console.log(`平均耗时: ${(duration / 5).toFixed(2)}ms`);
 
-        console.log('\n========== 测试完成 ==========\n');
+        console.log("\n========== 测试完成 ==========\n");
     } catch (error: any) {
-        console.error('\n❌ 测试失败:', error.message);
+        console.error("\n❌ 测试失败:", error.message);
         console.error(error.stack);
     } finally {
         // 关闭服务器和连接

package/tsconfig.json

@@ -1,4 +1,5 @@
 {
+    "extends": "../../tsconfig.base.json",
     "compilerOptions": {
         "target": "ESNext",
         "module": "ESNext",
@@ -8,7 +9,7 @@
         "noEmit": true,
         "strict": true,
         "skipLibCheck": true,
-        "types": ["bun-types"],
+        "types": ["bun"],
         "baseUrl": ".",
         "paths": {
             "befly": ["../core/main.ts"],
@@ -19,5 +20,5 @@
         "forceConsistentCasingInFileNames": true
     },
     "include": ["**/*.ts", "**/*.d.ts"],
-    "exclude": ["node_modules", "data", "logs"]
+    "exclude": ["node_modules", "data", "logs", "tests"]
 }

package/apis/test/typedExample.ts

@@ -1,149 +0,0 @@
-/**
- * DbHelper 泛型类型使用示例
- *
- * 本文件演示如何使用类型安全的数据库操作
- * 通过扩展 DatabaseTables 接口，可以获得完整的类型推断和智能提示
- */
-
-import type { BaseTable, TypedWhereConditions } from 'befly/types/table';
-
-// ============================================
-// 步骤 1: 定义表类型
-// ============================================
-
-/**
- * 用户表类型定义
- * 只需定义业务字段，系统字段（id, state, createdAt 等）由 BaseTable 自动添加
- */
-interface UserFields {
-    email: string;
-    username: string;
-    password: string;
-    nickname: string | null;
-    avatar: string | null;
-    roleId: number;
-    lastLoginAt: number | null;
-}
-
-/**
- * 完整的用户表类型（包含系统字段）
- */
-type UserTable = BaseTable<UserFields>;
-
-// ============================================
-// 步骤 2: 扩展 DatabaseTables（可选，推荐）
-// ============================================
-
-/**
- * 在项目的 types/index.d.ts 中添加以下声明：
- *
- * declare module 'befly/types/table' {
- *   interface DatabaseTables {
- *     user: BaseTable<{
- *       email: string;
- *       username: string;
- *       password: string;
- *       nickname: string | null;
- *       avatar: string | null;
- *       roleId: number;
- *       lastLoginAt: number | null;
- *     }>;
- *   }
- * }
- *
- * 扩展后，db.getOne({ table: 'user' }) 的返回类型会自动推断
- */
-
-// ============================================
-// 步骤 3: 在 API 中使用类型安全的数据库操作
-// ============================================
-
-export default {
-    name: '类型安全示例',
-    auth: false,
-    handler: async (befly, ctx) => {
-        // ----------------------------------------
-        // 示例 1: 类型安全的 WHERE 条件
-        // ----------------------------------------
-
-        // 定义类型安全的查询条件
-        const where: TypedWhereConditions<UserTable> = {
-            state: 1, // 精确匹配
-            roleId$in: [1, 2, 3], // IN 数组（必须是 number[]）
-            email$like: '%@gmail.com', // LIKE 匹配（必须是 string）
-            lastLoginAt$gte: Date.now() - 86400000 // 大于等于（必须是 number）
-            // roleId$in: 'invalid',               // ❌ 类型错误：应为 number[]
-            // email$like: 123,                    // ❌ 类型错误：应为 string
-        };
-
-        // ----------------------------------------
-        // 示例 2: 使用泛型指定返回类型
-        // ----------------------------------------
-
-        // 方式 A: 手动指定泛型
-        const user = await befly.db.getOne<UserTable>({
-            table: 'user',
-            where: { id: ctx.body.id }
-        });
-
-        if (user) {
-            // 有完整的类型提示
-            const email = user.email; // string
-            const createdAt = user.createdAt; // number（系统字段）
-            const nickname = user.nickname; // string | null
-        }
-
-        // ----------------------------------------
-        // 示例 3: 类型安全的列表查询
-        // ----------------------------------------
-
-        const result = await befly.db.getList<UserTable>({
-            table: 'user',
-            where: where,
-            orderBy: ['createdAt#DESC'],
-            page: 1,
-            limit: 10
-        });
-
-        // result.lists 类型为 UserTable[]
-        for (const item of result.lists) {
-            // 完整的类型提示
-            console.log(item.email, item.createdAt);
-        }
-
-        // ----------------------------------------
-        // 示例 4: 复杂 WHERE 条件（$or, $and）
-        // ----------------------------------------
-
-        const complexWhere: TypedWhereConditions<UserTable> = {
-            state: 1,
-            $or: [{ email$like: '%@gmail.com' }, { email$like: '%@qq.com' }],
-            $and: [{ roleId$in: [1, 2] }, { lastLoginAt$notNull: true }]
-        };
-
-        const activeUsers = await befly.db.getAll<UserTable>({
-            table: 'user',
-            where: complexWhere,
-            orderBy: ['lastLoginAt#DESC']
-        });
-
-        // ----------------------------------------
-        // 示例 5: BETWEEN 范围查询
-        // ----------------------------------------
-
-        const rangeWhere: TypedWhereConditions<UserTable> = {
-            state: 1,
-            createdAt$between: [
-                Date.now() - 7 * 86400000, // 7天前
-                Date.now() // 现在
-            ],
-            roleId$between: [1, 10] // 角色 ID 1-10
-        };
-
-        return befly.tool.Yes('类型安全示例', {
-            user: user,
-            total: result.total,
-            activeCount: activeUsers.length
-        });
-    }
-};