baja-lite 1.8.8 → 1.8.9

package/const/symbols.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 全局 Symbol 注册表，跨文件共享。
+ *
+ * 这些 Symbol 大多用作 `globalThis[symbol]` 的键（保存 dao 实例、配置、缓存等运行时状态），
+ * 或者用作类的私有字段键（如 `_inTransaction` / `_daoConnection`）。
+ *
+ * 标 `@internal` 的项是包内部约定，外部不应当读写——但因为跨文件共享必须 export，
+ * 在 TS 里没法严格强制访问范围；保留 `_` 前缀作为风格提示。
+ */
+/** @internal 实体的表名 */
+export declare const _tableName: unique symbol;
+/** @internal 实体绑定的 dbName（多数据源时用） */
+export declare const _daoDBName: unique symbol;
+/** @internal 实体类名（小驼峰） */
+export declare const _className: unique symbol;
+/** @internal 实体类名（大驼峰） */
+export declare const _ClassName: unique symbol;
+/** @internal 实体类名（短横线） */
+export declare const _vueName: unique symbol;
+/** @internal 实体->数据转换器，由 @DB 注入 */
+export declare const _transformer: unique symbol;
+/** @internal 表注释 */
+export declare const _comment: unique symbol;
+/** @internal SqlCache 实例，挂在 globalThis */
+export declare const _sqlCache: unique symbol;
+/** @internal DAO 注册表 {dbType: {dbName: Dao}}，挂在 globalThis */
+export declare const _dao: unique symbol;
+/** 主数据源（无名）的占位 key —— 注意：这是字符串，不是 Symbol。 */
+export declare const _primaryDB = "______primaryDB_______";
+/** @internal 实体绑定的 dbType */
+export declare const _dbType: unique symbol;
+/** @internal sqlite 表版本号（用于自动迁移） */
+export declare const _sqlite_version: unique symbol;
+/** @internal Connection 内部持有的真实驱动连接对象 */
+export declare const _daoConnection: unique symbol;
+/** @internal Connection 是否在事务中 */
+export declare const _inTransaction: unique symbol;
+/** @internal Dao 内部持有的真实驱动 pool/db 对象 */
+export declare const _daoDB: unique symbol;
+/** @internal SqliteRemote 的远端 db 名 */
+export declare const _sqliteRemoteName: unique symbol;
+/** @internal @DB 注解写入的 ServiceOption */
+export declare const _SqlOption: unique symbol;
+/** 数据转换函数注册表（boot 时传入），挂在 globalThis */
+export declare const _DataConvert: unique symbol;
+/** 模板渲染上下文（boot 时传入），挂在 globalThis */
+export declare const _Context: unique symbol;
+/** MySQL keepalive 间隔（毫秒），挂在 globalThis */
+export declare const _MysqlKeepAliveTime: unique symbol;
+/** @internal XML resultMap 注册表 */
+export declare const _resultMap: unique symbol;
+/** @internal sqlId -> resultMap 映射 */
+export declare const _resultMap_SQLID: unique symbol;
+/** 枚举映射（boot 时传入），挂在 globalThis */
+export declare const _enum: unique symbol;
+/** 全局配置（boot 时聚合），挂在 globalThis */
+export declare const _GlobalSqlOption: unique symbol;
+/** EventBus，挂在 globalThis */
+export declare const _EventBus: unique symbol;
+/** LoggerService 实例，挂在 globalThis */
+export declare const _LoggerService: unique symbol;
+/** 内存缓存 LRU 存储（key → entry），挂在 globalThis */
+export declare const _memCache: unique symbol;
+/** 内存缓存 single-flight 表（key → in-flight Promise），挂在 globalThis */
+export declare const _memInflight: unique symbol;
+/** 延迟加载的 node:path 模块，挂在 globalThis */
+export declare const _path: unique symbol;
+/** 延迟加载的 node:fs 模块，挂在 globalThis */
+export declare const _fs: unique symbol;
+/** MySQL/Postgres keepalive 默认间隔（30 秒） */
+export declare const DEFAULT_KEEPALIVE_INTERVAL = 30000;
+/** 默认批量处理数量 */
+export declare const DEFAULT_MAX_DEAL = 500;

package/const/symbols.js

@@ -0,0 +1,78 @@
+/**
+ * 全局 Symbol 注册表，跨文件共享。
+ *
+ * 这些 Symbol 大多用作 `globalThis[symbol]` 的键（保存 dao 实例、配置、缓存等运行时状态），
+ * 或者用作类的私有字段键（如 `_inTransaction` / `_daoConnection`）。
+ *
+ * 标 `@internal` 的项是包内部约定，外部不应当读写——但因为跨文件共享必须 export，
+ * 在 TS 里没法严格强制访问范围；保留 `_` 前缀作为风格提示。
+ */
+/** @internal 实体的表名 */
+export const _tableName = Symbol('tableName');
+/** @internal 实体绑定的 dbName（多数据源时用） */
+export const _daoDBName = Symbol('dbName');
+/** @internal 实体类名（小驼峰） */
+export const _className = Symbol('className');
+/** @internal 实体类名（大驼峰） */
+export const _ClassName = Symbol('ClassName');
+/** @internal 实体类名（短横线） */
+export const _vueName = Symbol('vueName');
+/** @internal 实体->数据转换器，由 @DB 注入 */
+export const _transformer = Symbol('transformer');
+/** @internal 表注释 */
+export const _comment = Symbol('comment');
+/** @internal SqlCache 实例，挂在 globalThis */
+export const _sqlCache = Symbol('sqlMap');
+/** @internal DAO 注册表 {dbType: {dbName: Dao}}，挂在 globalThis */
+export const _dao = Symbol('dao');
+/** 主数据源（无名）的占位 key —— 注意：这是字符串，不是 Symbol。 */
+export const _primaryDB = '______primaryDB_______';
+/** @internal 实体绑定的 dbType */
+export const _dbType = Symbol('dbType');
+/** @internal sqlite 表版本号（用于自动迁移） */
+export const _sqlite_version = Symbol('sqlite_version');
+/** @internal Connection 内部持有的真实驱动连接对象 */
+export const _daoConnection = Symbol('daoConnection');
+/** @internal Connection 是否在事务中 */
+export const _inTransaction = Symbol('inTransaction');
+/** @internal Dao 内部持有的真实驱动 pool/db 对象 */
+export const _daoDB = Symbol('daoDB');
+/** @internal SqliteRemote 的远端 db 名 */
+export const _sqliteRemoteName = Symbol('sqliteRemoteName');
+/** @internal @DB 注解写入的 ServiceOption */
+export const _SqlOption = Symbol('SqlOption');
+/** 数据转换函数注册表（boot 时传入），挂在 globalThis */
+export const _DataConvert = Symbol('DataConvert');
+/** 模板渲染上下文（boot 时传入），挂在 globalThis */
+export const _Context = Symbol('Context');
+/** MySQL keepalive 间隔（毫秒），挂在 globalThis */
+export const _MysqlKeepAliveTime = Symbol('MysqlKeepAliveTime');
+/** @internal XML resultMap 注册表 */
+export const _resultMap = Symbol('resultMap');
+/** @internal sqlId -> resultMap 映射 */
+export const _resultMap_SQLID = Symbol('resultMap_SQLID');
+/** 枚举映射（boot 时传入），挂在 globalThis */
+export const _enum = Symbol('_enum');
+/** 全局配置（boot 时聚合），挂在 globalThis */
+export const _GlobalSqlOption = Symbol('GlobalSqlOption');
+/** EventBus，挂在 globalThis */
+export const _EventBus = Symbol('EventBus');
+/** LoggerService 实例，挂在 globalThis */
+export const _LoggerService = Symbol('LoggerService');
+/** 内存缓存 LRU 存储（key → entry），挂在 globalThis */
+export const _memCache = Symbol('memCache');
+/** 内存缓存 single-flight 表（key → in-flight Promise），挂在 globalThis */
+export const _memInflight = Symbol('memInflight');
+/** 延迟加载的 node:path 模块，挂在 globalThis */
+export const _path = Symbol('path');
+/** 延迟加载的 node:fs 模块，挂在 globalThis */
+export const _fs = Symbol('fs');
+// ===== 常量 =====
+/** MySQL/Postgres keepalive 默认间隔（30 秒） */
+export const DEFAULT_KEEPALIVE_INTERVAL = 30000;
+/** 默认批量处理数量 */
+export const DEFAULT_MAX_DEAL = 500;
+// 初始化 globalThis 上的 _resultMap_SQLID（原 sql.ts 文件顶层的副作用语句）
+if (globalThis[_resultMap_SQLID] === undefined) {
+    globalThis[_resultMap_SQLID] = {};
+}

package/const/types.d.ts

@@ -0,0 +1,504 @@
+import { DBType, EnumMap } from 'baja-lite-field';
+import { XML } from '../convert-xml.js';
+import { LogLevel, LoggerService } from '../logger.js';
+import { _daoConnection, _daoDB, _inTransaction } from '../const/symbols.js';
+export declare enum MapperIfUndefined {
+    Null = 0,
+    Skip = 1,
+    Zero = 2,
+    EmptyString = 3
+}
+export declare enum SyncMode {
+    /** 同步执行 */
+    Sync = 0,
+    /** 异步执行 */
+    Async = 1
+}
+export declare enum InsertMode {
+    /**
+    # 默认使用
+    ** 支持单个、批量,语法 `INSERT INTO XX VALUES (第一条数据), (第二条数据);`
+    ** 批量执行有性能优势，但无法利用数据库的sql预编译功能
+    */
+    Insert = 0,
+    /**
+    # 利用临时表
+    ## 执行步骤
+    1. 建立临时表(从正式表复制)
+    2. 数据全部进入临时表
+    3. 临时表数据转移到正式表: `INSERT INTO 正式表 SELECT * FROM 临时表`
+    4. 删除临时表
+    ## 注意
+    1. 适用于：主键不会冲突、非自增
+    2. 临时表的结构复制正式表
+     */
+    InsertWithTempTable = 1,
+    /**
+     * 如果不存在则插入
+     * 来源是数据库，根据ID或者指定字段查询
+     */
+    InsertIfNotExists = 2,
+    /**
+    # 插入或者更新
+    1. 判断依据是主键,来源是从数据库查询
+     */
+    Replace = 3
+}
+export declare enum DeleteMode {
+    /**
+     ##常规删除 默认
+     ### 例一
+     `DELETE FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `DELETE FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common = 0,
+    TempTable = 1
+}
+export declare enum SelectMode {
+    /**
+     ##常规 默认
+     ### 例一
+     `SELECT * FROM WHERE (id = 1) OR (id = 2)`
+     ### 例二
+     `SELECT * FROM WHERE (id = 1 AND idx = 11) OR (id = 2 AND idx = 22)`
+    */
+    Common = 0,
+    TempTable = 1
+}
+export declare enum TemplateResult {
+    /** 确定返回一条记录，如果不是一个，将报错，返回类型是T */
+    AssertOne = 0,
+    /** 可能返回一条记录，返回类型是T|null */
+    NotSureOne = 1,
+    /** 返回多条记录 */
+    Many = 2,
+    /** 仅查询记录数量 */
+    Count = 3
+}
+export declare enum SelectResult {
+    /** 一行一列 确定非空 */
+    R_C_Assert = 0,
+    /** 一行一列 可能空 */
+    R_C_NotSure = 1,
+    /** 一行多列 确定非空 */
+    R_CS_Assert = 2,
+    /** 一行多列 可能空 */
+    R_CS_NotSure = 3,
+    /** 多行一列 */
+    RS_C = 4,
+    /** 多行多列 */
+    RS_CS = 5
+}
+export declare enum ColumnMode {
+    NONE = 0,
+    HUMP = 1
+}
+export declare const SqliteMemory = ":memory:";
+export declare const _defOption: {
+    maxDeal: number;
+    skipUndefined: boolean;
+    skipNull: boolean;
+    skipEmptyString: boolean;
+};
+/** @internal SqlService 方法的通用选项（每个方法都有的几个字段） */
+export interface MethodOption {
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    dbType?: DBType;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+}
+/**
+ 数据服务注解
+ @internal 由 @DB 装饰器消费
+ */
+export interface ServiceOption {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    tableName?: string;
+    /** 数据库、连接名称，对于MYSQL、mongo，适用于多数据源，对于sqlite，适用于不同的数据库文件  */
+    dbName?: string;
+    /** 调用时，永远不需要传
+     * @deprecated
+     * */
+    dao?: Dao;
+    /** 调用时，仅在开启事务时需要主动传入,传入方式： */
+    conn?: Connection | null;
+    /** 对应的实体类,必须是Class */
+    clz?: any;
+    /** 默认mysql */
+    dbType?: DBType;
+    /** SQLite版本以及升级为该版本时需要执行的SQL,初始版本为0.0.1,切记每个位置不要变为两位数*/
+    sqliteVersion?: string;
+    /** 备注 */
+    comment?: string;
+}
+export type SqlMapper = {
+    columnName: string;
+    mapNames: string[];
+    def?: any;
+    convert?: (data: any) => any;
+}[];
+export type SqlMappers = Record<string, SqlMapper>;
+export type SqlModel = Record<string, string | ((options: {
+    ctx?: any;
+    isCount?: boolean;
+    isSum?: boolean;
+    limitStart?: number;
+    limitEnd?: number;
+    sortName?: string;
+    sortType?: string;
+    params?: any;
+}) => string)>;
+/** @internal 历史遗留：和 SqlModel 几乎相同，但额外允许 XML[]（XML 解析后的中间格式）。新代码请用 SqlModel。 */
+export type _SqlModel = Record<string, string | ((options: {
+    ctx?: any;
+    isCount?: boolean;
+    isSum?: boolean;
+    limitStart?: number;
+    limitEnd?: number;
+    sortName?: string;
+    sortType?: string;
+    params?: any;
+}) => string) | XML[]>;
+/**
+ # 全局行为配置文件
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOptionForWeb {
+    /** 增改忽略Undefined */
+    skipUndefined?: boolean;
+    /** 增改忽略NULL */
+    skipNull?: boolean;
+    /** 增改忽略空字符串 */
+    skipEmptyString?: boolean;
+    /** 批量增改时，每次执行最多处理的记录数量 */
+    maxDeal?: number;
+    /** 内存缓存的 LRU 上限（@MethodCache + storage: 'memory'）。默认 10000。 */
+    memCacheMaxSize?: number;
+    SqliteRemote?: {
+        /**
+         ## 单一数据源
+        ```
+        db: 'd:/1.db'
+        ```
+        ## 多数据源：传入多个连接配置
+        ```
+        db: {
+                db1: 'd:/1.db',
+                db2: 'd:/2.db'
+        }
+        ```
+        不支持 `SqliteMemory`
+        */
+        db?: Record<string, string> | string;
+        /** 远程SQLITE接口实现，适用于Electron, 采用Ipc 的handel机制实现 */
+        service: SqliteRemoteInterface;
+    };
+    /** 日志等级 */
+    log?: LogLevel[] | LogLevel;
+    /**
+     作用与sqlDir类似，不同在于sqlMap`不需要`目录，而是直接指定一个sqlModel对象，对象的格式和sqlDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlMap?: SqlModel;
+    /**
+     作用与sqlFnDir类似，不同在于sqlFNMap`不需要`目录，而是直接指定一个 Record<string, string>，对象的格式和sqlFnDir的文件内容一样。
+     ** 适用于简单使用
+     */
+    sqlFNMap?: Record<string, string>;
+    /**
+    // 第一个元素=列名，第二个元素是属性路径，
+    [
+        ['dit_id', ['id']], // 列名ditid,对应属性id
+        ['event_id', ['eventMainInfo', 'id']] // 列名event_id对应属性eventMainInfo.id
+    ]
+     */
+    sqlMapperMap?: SqlMappers;
+    /** 提供的枚举MAP */
+    enums?: EnumMap;
+    /**
+     * `列名与属性映射` 是否自动将下划线转为驼峰，默认NONE，即不转.
+     * 当设置为columnMode.HUMP时，切记将代码生成器中属性名称改对
+     * # 自定义sql查询时，无法自动转换哦,可使用标签转换：
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2, seller_sku {{/hump}}
+     * ```
+     * 转换为
+     *```
+        SELECT
+     *  {{#hump}} seller_sku2 sellerSku2, seller_sku sellerSku {{/hump}}
+     * ```
+     */
+    columnMode?: ColumnMode;
+    /** 对于WEB模式，默认为SqliteRemote */
+    dbType?: DBType;
+    /**
+     * * 数据转换器，用于service的select、page方法，以及stream查询
+     * * 例如
+     * ```
+     * dataConvert: {
+     *      // 使用时，传入qiniu和列名，将根据列名对应的值生成URL
+     *      qiniu: data => qiniuConvertUrl(data)
+     * }
+     * ```
+     */
+    dataConvert?: Record<string, (data: any) => any>;
+    /** 公开上下文 */
+    ctx?: any;
+    /** 日志服务 */
+    logger?: LoggerService;
+}
+/**
+ # 全局行为配置文件
+   MYSQL编码： 'utf8mb4', utf8mb4_general_ci'
+ ### `sqlDir?: string;` 数据库查询语句存放目录.存放格式为 export.default 的js、ts， 存放内容满足格式：
+
+    ```
+    interface SqlModel {
+        [key: string]: string | ((params: { [k: string]: any }, context: any, isCount?: boolean) => string)
+    }
+    ```
+    可以继承该接口来约束格式
+ */
+export interface GlobalSqlOption extends GlobalSqlOptionForWeb {
+    /**
+       初始化MYSQL链接 支持多数据源
+       ## 单一数据源: 直接传入Mysql2的连接配置
+       [MYSQL初始化文档](https://github.com/mysqljs/mysql#connection-options)
+       ```
+       Mysql: {
+          host: '127.0.0.1',
+          ...
+       }
+       ```
+       ## 多数据源：传入多个Mysql2的连接配置
+       ```
+       Mysql: {
+          db1: {
+              host: '127.0.0.1',
+              ...
+          },
+          db2: {
+              host: '127.0.0.1',
+              ...
+          },
+          ...
+       }
+       ```
+      */
+    Mysql?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+     * MYSQL保持心跳的间隔，默认30秒
+     */
+    MysqlKeepAlive?: number;
+    /**
+         初始化postgresql链接 支持多数据源
+         ## 单一数据源: 直接传入postgresql的连接配置
+         [Postgresql初始化文档](https://github.com/brianc/node-postgres/tree/master/packages/pg-pool)
+         ```
+         Postgresql: {
+            database: 'postgres',
+            ...
+         }
+         ```
+         ## 多数据源：传入多个Postgresql的连接配置
+         ```
+         Postgresql: {
+            db1: { ... },
+            db2: { ... },
+            ...
+         }
+         ```
+        */
+    Postgresql?: Record<string, Record<string, any>> | Record<string, any>;
+    /**
+     ## 单一数据源
+     ```
+     Sqlite: 'd:/1.db'
+     ```
+     ## 多数据源：传入多个连接配置
+     ```
+       Sqlite: {
+            db1: 'd:/1.db',
+            db2: 'd:/2.db'
+       }
+     ```
+       路径 = `SqliteMemory` 将创建内存库
+     */
+    Sqlite?: Record<string, string> | string;
+    /**
+     ## 日志文件存放路径,该目录下文件名是模块名，例如有一个文件名为 `user.js`,内容为:
+     ```
+       export default {
+            'sql_1': 'SELECT * FROM user WHERE username = :username',
+            'sql_2': (options: {
+                ctx?: any;
+                isCount?: boolean;
+                isSum?: boolean;
+                limitStart?: number;
+                limitEnd?: number;
+                sortName?: string; sortType?: string;
+                params?: Record<string, any>;
+            }) => {
+                return   `
+                    SELECT * FROM user u LEFT JOIN organ o ON u.orgid = o.orgid
+                    WHERE o.orgid = :orgid;
+                `;
+            }
+        } as SqlModel;
+     ```
+     ** 可以看到，sql语句支持直接映射一个sql语句，也可以通过函数返回,返回字符串支持[mustache](https://github.com/janl/mustache.js)
+     ** 上面的文件中，将注册两个SQL：`user.sql_1` 和 `user.sql_2`.
+     ** `[k: string]: any;` 是用查询时传入的参数，可以指定为任意类型，可以用来生成sql，例如进行循环语句
+     ** ctx 是框架的上下文，可以自行指定类型
+     ** 其他 是保留参数
+     ** 函数类型中，可以调用自己定义的通用sql
+     ### 注意
+     1. 不要直接拼接参数：不安全且效率低
+     2. sqlite不支持多语句拼接
+    ## 也支持.mu文件,格式略
+    */
+    sqlDir?: string;
+    /**
+    ## [mustache](https://mustache.github.io/) 编译时的[模板](https://github.com/janl/mustache.js#:~:text=requires%20only%20this%3A-,%7B%7B%3E%20next_more%7D%7D,-Why%3F%20Because%20the)
+      ## 文件名就是模板名
+     */
+    sqlFNDir?: string;
+    /**
+     *  #TODO 未完成读取 sqlMapDir
+     *  # sqlMapDir 目录定义如下，
+     *      `test.ts`
+     *      ```
+     *         export const dict:SqlMappers = [
+     *             {columnName: 'dit_id', mapNames: ['DTID'], def: 0, convert: 转换函数},
+     *             {columnName: 'event_id', mapNames: ['eventMainInfo', 'id'], def: 0,  convert: 转换函数},
+     *         ]
+     *      ```
+     *      将得到 test.dict 这个map
+     */
+    sqlMapDir?: string;
+    /**
+      ## 映射数据为对象，文件名就是模板名
+    ```
+    // 第一个元素=列名，第二个元素是属性路径，
+    // 该目录下可存放json文件，内容如下
+    //
+    // 可以在查询时使用，优先级高于hump
+    // 例如:
+    [
+        ['dit_id', ['id'], 可选的默认值],
+        ['event_id', ['eventMainInfo', 'id']]
+    ]
+    ```
+     */
+    sqlMapperDir?: string;
+    /**
+     [REDIS初始化文档](https://github.com/redis/ioredis?tab=readme-ov-file#:~:text=connect%20to%20by%3A-,new%20Redis()%3B,-//%20Connect%20to%20127.0.0.1)
+    ```
+    Redis: {
+        host: '127.0.0.1',
+        ...
+    }
+    ```
+    ## 多数据源：传入多个Redis的连接配置
+    ```
+    Redis: {
+        db1: { host: '127.0.0.1', ... },
+        db2: { host: '127.0.0.1', ... },
+    }
+    ```
+     */
+    Redis?: Record<string, Record<string, any>> | Record<string, any>;
+    /** sqlite数据库驱动初始化函数 */
+    BetterSqlite3?: any;
+    /**
+     * 读取查询语句时，是否扫描JS文件？
+     * JS文件需要默认导出一个 SqlModel对象
+     */
+    jsMode?: boolean;
+}
+export interface PageQuery<L> {
+    sum?: Record<string, string | number>;
+    total?: number;
+    size?: number;
+    records?: L[];
+}
+/** sqlite electron服务端需要支持的接口 */
+export interface SqliteRemoteInterface {
+    execute(inData: Uint8Array): Promise<Uint8Array>;
+    pluck(inData: Uint8Array): Promise<Uint8Array>;
+    get(inData: Uint8Array): Promise<Uint8Array>;
+    raw(inData: Uint8Array): Promise<Uint8Array>;
+    query(inData: Uint8Array): Promise<Uint8Array>;
+    initDB(dbName: string): void;
+    export(dbName: string, exportPath: string): Promise<void>;
+    restore(dbName: string, importPath: string): void;
+    close(dbName?: string): void;
+}
+export interface Connection {
+    [_daoConnection]: any;
+    [_inTransaction]: boolean;
+    execute(sync: SyncMode.Sync, sql?: string, params?: any): {
+        affectedRows: number;
+        insertId: bigint;
+    };
+    execute(sync: SyncMode.Async, sql?: string, params?: any): Promise<{
+        affectedRows: number;
+        insertId: bigint;
+    }>;
+    /** 一行一列 */
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_One_Column | null;
+    pluck<One_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_One_Column | null>;
+    /** 一行多列 */
+    get<One_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): One_Row_Many_Column | null;
+    get<One_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<One_Row_Many_Column | null>;
+    /** 多行一列 */
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_One_Column[];
+    raw<Many_Row_One_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_One_Column[]>;
+    /** 多行多列 */
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Sync, sql?: string, params?: any): Many_Row_Many_Column[];
+    query<Many_Row_Many_Column = any>(sync: SyncMode.Async, sql?: string, params?: any): Promise<Many_Row_Many_Column[]>;
+    release(sync: SyncMode.Sync): void;
+    release(sync: SyncMode.Async): Promise<void>;
+}
+export interface Dao {
+    [_daoDB]: any;
+    transaction<T = any>(sync: SyncMode.Sync, fn: (conn: Connection) => T, conn?: Connection | null): T | null;
+    transaction<T = any>(sync: SyncMode.Async, fn: (conn: Connection) => Promise<T>, conn?: Connection | null): Promise<T | null>;
+    createConnection(sync: SyncMode.Sync): Connection | null;
+    createConnection(sync: SyncMode.Async): Promise<Connection | null>;
+    close(sync: SyncMode.Sync): void;
+    close(sync: SyncMode.Async): Promise<void>;
+    backup(sync: SyncMode.Sync, name: string): void;
+    backup(sync: SyncMode.Async, name: string): Promise<void>;
+    remove(sync: SyncMode.Sync): void;
+    remove(sync: SyncMode.Async): Promise<void>;
+    restore(sync: SyncMode.Sync, name: string): void;
+    restore(sync: SyncMode.Async, name: string): Promise<void>;
+}
+/** 缓存存储后端。`redis` 走 ioredis 全局共享；`memory` 走进程内 LRU + Promise-based single-flight。 */
+export declare enum StorageType {
+    Redis = 0,
+    Memory = 1
+}