yoorm/lib/index.d.ts

一个链式连接mysql,sqlite 和 postgresql 数据库的扩展包

import mysql from 'mysql2/promise';
type DatabaseType = 'mysql' | 'sqlite' | 'postgres';
type Operator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'LIKE' | 'IN' | 'NOT IN' | 'IS NULL' | 'IS NOT NULL' | 'BETWEEN' | 'NOT BETWEEN' | 'REGEXP' | 'NOT REGEXP' | 'NOT LIKE';
type Order = 'ASC' | 'DESC';
interface DatabaseConfig {
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    database?: string;
    [key: string]: any;
}
interface MultiDatabaseConfig {
    default?: string;
    databases: {
        [name: string]: {
            type: DatabaseType;
            config: DatabaseConfig;
        };
    };
}
interface TransactionConn {
    table: (table: string) => YoyoMysqlClass;
    query: (sql: string, values?: any) => Promise<[Array<{
        [key: string]: any;
    }>, mysql.FieldPacket[]]>;
    execute: (sql: string, values?: any) => Promise<mysql.ResultSetHeader | [Array<{
        [key: string]: any;
    }>, mysql.FieldPacket[]]>;
}
interface ResultSet {
    data: any[];
    count: number;
    maxCount: number;
    fields: mysql.FieldPacket[];
}
interface ResultSetPages extends ResultSet {
    maxPage?: number;
}
type WhereArr = Array<[string, Operator, any]>;
export default class YoyoMysql {
    private static _POOLS;
    private static _DEFAULT_DB;
    static isShowSql: boolean;
    static printMethod: (sql: string, highlightSQL: (sql: string) => void) => void;
    /**
     * 初始化多数据库连接池
     * @param config 多数据库配置
     */
    static createPools(config: MultiDatabaseConfig): typeof YoyoMysql;
    /**
     * 设置默认数据库
     * @param name 数据库名称
     */
    static setDefaultDB(name: string): typeof YoyoMysql;
    /**
     * 获取数据库连接池
     * @param name 数据库名称(可选)
     */
    static getPool(name?: string): any;
    /**
     * 获取数据库类型
     * @param name 数据库名称(可选)
     */
    static getDBType(name?: string): DatabaseType;
    /**
     * 设置表名(可指定数据库)
     * @param table 表名
     * @param dbName 数据库名称(可选)
     */
    static table(table: string, dbName?: string): YoyoMysqlClass;
    /**
     * 执行SQL查询(可指定数据库)
     * @param sql SQL语句
     * @param values 参数
     * @param dbName 数据库名称(可选)
     */
    static query(sql: string, values?: any[], dbName?: string): Promise<[Array<{
        [key: string]: any;
    }>, mysql.FieldPacket[]]>;
    /**
     * 执行SQL语句(可指定数据库)
     * @param sql SQL语句
     * @param values 参数
     * @param dbName 数据库名称(可选)
     */
    static execute(sql: string, values?: any[], dbName?: string): Promise<[Array<{
        [key: string]: any;
    }>, mysql.FieldPacket[]]>;
    /**
     * 开启事务(可指定数据库)
     * @param callback 回调函数
     * @param isError 是否抛出错误
     * @param dbName 数据库名称(可选)
     */
    static beginTransaction(callback: (conn: TransactionConn) => Promise<any>, isError?: boolean, dbName?: string): Promise<any>;
    /**
     * 获取一条连接(可指定数据库)
     * @param callback 回调函数
     * @param dbName 数据库名称(可选)
     */
    static getOneConnection(callback: (conn: TransactionConn) => Promise<any>, dbName?: string): Promise<any>;
    /**
     * 使用临时配置创建数据库连接并执行操作
     * @param config 数据库连接配置
     * @param callback 要执行的回调函数
     */
    static withTempConnection(config: DatabaseConfig, callback: (conn: TransactionConn) => Promise<any>): Promise<any>;
    /**
     * 设置连接池
     * @param pool 连接池
     * @param name 数据库名称(可选)
     * @param type 数据库类型(可选)
     */
    static setPool(pool: any, name?: string, type?: DatabaseType): void;
}
declare class YoyoMysqlClass {
    private _link;
    private _dbType;
    private _table?;
    private _fields;
    private _clogic;
    private _where;
    private _group;
    private _having;
    private _order;
    private _join;
    private _limit;
    constructor(link: any, dbType?: DatabaseType);
    /**
     * 切换当前查询使用的数据库
     * @param dbName 数据库名称
     */
    useDB(dbName: string): this;
    /**
     * 设置表名
     * @param table 表名
     */
    table(table: string): this;
    /**
     * 添加查询字段
     * @param field 字段名
     */
    field(field: string): this;
    /**
     * 添加多个查询字段
     * @param fields 字段名数组
     */
    field(fields: Array<string>): this;
    /**
     * 添加排序条件
     * @param field 字段名
     * @param order 排序方式
     */
    order(field: string, order?: Order): this;
    /**
     * 添加多个排序条件
     * @param fields 排序字段对象
     */
    order(fields: Record<string, Order> | string): this;
    /**
     * 添加分组字段
     * @param fieldArr 字段数组
     */
    group(fieldArr: Array<string>): this;
    /**
     * 添加一个分组字段
     * @param field 字段名
     */
    group(field: string): this;
    /**
     * 添加HAVING条件
     * @param where 条件语句
     */
    having(where: string): this;
    /**
     * 添加结果集限制
     * @param limit 限制数量
     * @param offset 偏移量
     */
    limit(limit: number, offset?: number): this;
    /**
     * 添加LEFT JOIN
     * @param table 表名
     * @param where 连接条件
     */
    leftJoin(table: string, where: string): this;
    /**
     * 添加RIGHT JOIN
     * @param table 表名
     * @param where 连接条件
     */
    rightJoin(table: string, where: string): this;
    /**
     * 添加INNER JOIN
     * @param table 表名
     * @param where 连接条件
     */
    join(table: string, where: string): this;
    /**
     * 添加FULL JOIN
     * @param table 表名
     * @param where 连接条件
     */
    fullJoin(table: string, where: string): this;
    /**
     * 构建WHERE条件
     * @param field 字段名或条件数组
     * @param args 参数
     */
    private _whereComposite;
    /**
     * 添加IN条件(子查询)
     * @param field 字段名
     * @param callback 回调函数
     */
    whereIn(field: string, callback: () => this): this;
    /**
     * 添加WHERE条件
     * @param field 字段名
     * @param operator 操作符
     * @param value 值
     */
    where(field: string, operator: Operator, value: any): this;
    /**
     * 添加WHERE条件(默认操作符为=)
     * @param field 字段名
     * @param value 值
     */
    where(field: string, value: (string | number) | Record<string, (string | number)>): this;
    /**
     * 添加WHERE条件(子查询)
     * @param field 字段名
     * @param callback 回调函数
     */
    where(field: string, callback: () => this): this;
    /**
     * 添加WHERE条件数组
     * @param whereArr 条件数组
     */
    where(whereArr: WhereArr): this;
    /**
     * 添加OR条件
     * @param field 字段名
     * @param operator 操作符
     * @param value 值
     */
    whereOr(field: string, operator: Operator, value: any): this;
    /**
     * 添加OR条件(默认操作符为=)
     * @param field 字段名
     * @param value 值
     */
    whereOr(field: string, value: (string | number) | Record<string, (string | number)>): this;
    /**
     * 添加OR条件(子查询)
     * @param field 字段名
     * @param callback 回调函数
     */
    whereOr(field: string, callback: () => this): this;
    /**
     * 添加OR条件数组
     * @param whereArr 条件数组
     */
    whereOr(whereArr: WhereArr): this;
    /**
     * 查询单条记录
     */
    find(): Promise<Record<string, any> | null>;
    /**
     * 查询多条记录
     */
    select(): Promise<ResultSet>;
    /**
     * 分页查询
     * @param page 页码
     * @param count 每页数量
     */
    pages(page?: number, count?: number): Promise<ResultSetPages>;
    /**
     * 删除记录
     */
    delete(): Promise<mysql.ResultSetHeader>;
    /**
     * 插入记录
     * @param data 插入数据
     */
    insert(data: any[][] | Record<string, any> | Record<string, any>[] | any[]): Promise<mysql.ResultSetHeader>;
    /**
     * 更新记录
     * @param data 更新数据
     */
    update(data: Record<string, (number | string)> | [string, string][] | [string, string]): Promise<mysql.ResultSetHeader>;
    /**
     * 构建WHERE条件
     */
    private buildWhere;
    /**
     * 构建SELECT语句
     */
    private buildSelect;
    /**
     * 构建DELETE语句
     */
    private buildDelete;
    /**
     * 构建INSERT语句
     * @param data 插入数据
     */
    private buildInsert;
    /**
     * 构建UPDATE语句
     * @param data 更新数据
     */
    private buildUpdate;
    /**
     * 构建SQL语句
     * @param type SQL类型
     * @param data 数据(可选)
     */
    buildSql(type?: 'select' | 'insert' | 'update' | 'delete', data?: any): {
        sql: string;
        params: any[];
    };
}
export {};