@dlovely/mysql/dist/mysql.d.ts

对mysql的简易连接，能创建数据库、数据表管理，并使用sql编辑器

import type { Connection } from 'mysql2/promise';
import { ConnectionOptions } from 'mysql2/typings/mysql/lib/Connection';
import { mysql2TypingsMysqlLibProtocolPacketsOkPacket } from 'mysql2/typings/mysql/lib/protocol/packets/OkPacket';
import type { OkPacket } from 'mysql2';
import type { OkPacket as OkPacket_2 } from 'mysql2/promise';
import type { PoolConnection } from 'mysql2/promise';
import { PoolOptions } from 'mysql2/typings/mysql/lib/Pool';

declare type ColumnsName<
Columns extends TableColumns = never,
ColumnsRecord extends TableColumnsRecord = never
> =
| ([Columns] extends [never] ? never : TableColumnsName<Columns>)
| ([ColumnsRecord] extends [never]
? never
: TableColumnsRecordName<ColumnsRecord>)

declare namespace Create {
    interface Options extends DataBase {
        database: string
        name: string
        engine?: string
        columns: Column[]
        comment?: string
    }

    interface DataBase {
        name: string
        if_not_exists?: boolean
        charset?: string
        collate?: string
    }
}

declare namespace Create {
    type Column =
    | NumberColumn
    | StringColumn
    | CharColumn
    | DateColumn
    | JsonColumn
    | CollectColumn

    interface BaseColumn {
        name: string
        comment?: string

        default?: Default | string | number
        not_null?: boolean
        primary_key?: boolean
        unique?: boolean | string
        check?:
        | {
            rule: string
            name?: string
        }
        | string
        foreign_key?: {
            name: string
            table: string
            table_key: string
            on_update?: ForeignOperation
            on_delete?: ForeignOperation
        }

        charset?: string
        collate?: string
    }
    interface NumberColumn extends BaseColumn {
        type:
        | 'int'
        | 'tinyint'
        | 'smallint'
        | 'mediumint'
        | 'bigint'
        | 'bool'
        | 'float'
        | 'double'
        auto_increment?: boolean
        default?: number
    }
    interface StringColumn extends BaseColumn {
        type:
        | 'text'
        | 'tinytext'
        | 'mediumtext'
        | 'longtext'
        | 'blob'
        | 'tinyblob'
        | 'mediumblob'
        | 'longblob'
    }
    interface CharColumn extends BaseColumn {
        type: 'char' | 'varchar'
        length: number
    }
    interface DateColumn extends BaseColumn {
        type: 'date' | 'datetime' | 'timestamp'
        default?: Default
    }
    interface JsonColumn extends BaseColumn {
        type: 'json'
        not_null: true
        default?: undefined
    }
    interface CollectColumn extends BaseColumn {
        type: 'enum' | 'set'
        values: string[]
    }

    type ForeignOperation =
    | 'cascade'
    | 'set null'
    | 'set default'
    | 'restrict'
    | 'no action'
    interface Default {
        on_update?: boolean
    }
}

export declare class DataBase<DB extends keyof MySql.DataBase> {
    readonly name: DB;
    constructor(name: DB);
    setConfig({ charset, collate, }: {
        charset?: string | undefined;
        collate?: string | undefined;
    }): Promise<mysql2TypingsMysqlLibProtocolPacketsOkPacket>;
    /**
     * 创建数据库
     */
    create(options?: Omit<Create.DataBase, 'name'>): Promise<mysql2TypingsMysqlLibProtocolPacketsOkPacket>;
    /** 抛弃数据库 */
    drop(): Promise<mysql2TypingsMysqlLibProtocolPacketsOkPacket>;
}

export declare interface DBOptions {
    /** 存储引擎 */
    engine?: string;
    /** 字符类型 */
    charset?: string;
    /** 字符编码 */
    collate?: string;
}

export declare const defineMysqlConfig: (config: Partial<MysqlOptions>) => Partial<MysqlOptions>;

declare namespace Delete {
    interface Options {
        database?: string
        table: string
        where: Sql | Where.Options
    }
}

declare type DoPick<T, K> = T extends any
? {
    [Key in keyof T as Key extends K ? Key : never]: T[Key]
}
: never

declare type GenTableColumns<DB extends keyof MySql.DataBase, Name extends Split<keyof MySql.Table>[1], Columns = MySql.DataBase[DB][Name]> = UnionToTuple<MergeRecord<{
    [Key in keyof Columns]: Columns[Key] & {
        name: Key;
    };
}[keyof Columns]>>;

declare type InsertColumns<Columns extends TableColumns> = MergeRecord<
    {
    [Key in Columns[number] as IsReadOnly<
    Key,
    never,
    IsRequire<Key, Key['name'], never>
    >]: Key['type']
} & {
    [Key in Columns[number] as IsReadOnly<
    Key,
    never,
    IsRequire<Key, never, Key['name']>
    >]?: Key['type']
}
>

declare type IsExist<
Column extends TableColumn,
True = true,
False = false
> = Column['not_null'] extends true ? True : False

declare type IsReadOnly<
Column extends TableColumn,
True = true,
False = false
> = Column['readonly'] extends true ? True : False

declare type IsRequire<
Column extends TableColumn,
True = true,
False = false
> = Column['has_defa'] extends true
? False
: Column['not_null'] extends true
? True
: False

export declare class JoinTable<DB extends keyof MySql.DataBase, LCR extends TableColumnsRecord = never, RCR extends TableColumnsRecord = never, LN extends keyof MySql.DataBase[DB] & string = never, LC extends TableColumns = never, RN extends keyof MySql.DataBase[DB] & string = never, RC extends TableColumns = never, TCR extends TableColumnsRecord = MergeRecordWithoutNever<[
LCR,
RCR,
Record<LN, LC>,
Record<RN, RC>
]>> {
    readonly left_table: Table<DB, LN, LC> | JoinTable<any, any, any, any, any, any, any, LCR>;
    readonly left_key: ColumnsName<LC, LCR>;
    readonly right_table: Table<DB, RN, RC> | JoinTable<any, any, any, any, any, any, any, RCR>;
    readonly right_key: ColumnsName<RC, RCR>;
    readonly join_type: JoinType;
    constructor(left_table: Table<DB, LN, LC> | JoinTable<any, any, any, any, any, any, any, LCR>, left_key: ColumnsName<LC, LCR>, right_table: Table<DB, RN, RC> | JoinTable<any, any, any, any, any, any, any, RCR>, right_key: ColumnsName<RC, RCR>, join_type: JoinType);
    private _used;
    get used(): boolean;
    get name(): string;
    join<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<never, TCR>, type?: JoinType): JoinTable<DB, TCR, CR, never, never, N, C, [TCR] extends [never] ? [CR] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<never, never>> : MergeRecord<CR & Record<never, never> & Record<N, C>> : [CR] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<TCR & Record<never, never>> : MergeRecord<TCR & Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<TCR & CR & Record<never, never>> : MergeRecord<TCR & CR & Record<never, never> & Record<N, C>>>;
    leftJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<never, TCR>): JoinTable<DB, TCR, CR, never, never, N, C, [TCR] extends [never] ? [CR] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<never, never>> : MergeRecord<CR & Record<never, never> & Record<N, C>> : [CR] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<TCR & Record<never, never>> : MergeRecord<TCR & Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<TCR & CR & Record<never, never>> : MergeRecord<TCR & CR & Record<never, never> & Record<N, C>>>;
    rightJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<never, TCR>): JoinTable<DB, TCR, CR, never, never, N, C, [TCR] extends [never] ? [CR] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<never, never>> : MergeRecord<CR & Record<never, never> & Record<N, C>> : [CR] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<TCR & Record<never, never>> : MergeRecord<TCR & Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<TCR & CR & Record<never, never>> : MergeRecord<TCR & CR & Record<never, never> & Record<N, C>>>;
    fullJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<never, TCR>): JoinTable<DB, TCR, CR, never, never, N, C, [TCR] extends [never] ? [CR] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<never, never>> : MergeRecord<CR & Record<never, never> & Record<N, C>> : [CR] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<TCR & Record<never, never>> : MergeRecord<TCR & Record<never, never> & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<TCR & CR & Record<never, never>> : MergeRecord<TCR & CR & Record<never, never> & Record<N, C>>>;
    select<Column extends Partial<TableColumnsRecordMap<TCR>>>(columns?: Column, where?: Select.Options['where'], options?: Omit<Select.Options, 'table' | 'columns' | 'where'>): Promise<SelectColumnsRecord<TCR, Column>[]>;
    get __showTCR(): TCR;
}

export declare enum JoinType {
    INNER = "INNER",
    LEFT = "LEFT",
    RIGHT = "RIGHT",
    FULL = "FULL"
}

declare interface KeyType_2 {
    /** json是否为数组 */
    is_array?: boolean;
    /** 指定键值对 */
    records?: Record<string, string | KeyType_2>;
    /** string泛值 */
    string?: string | KeyType_2;
    /** number泛值 */
    number?: string | KeyType_2;
}
export { KeyType_2 as KeyType }

/**
 * LastInUnion<1 | 2> = 2.
 */
declare type LastInUnion<U> = UnionToIntersection2<
U extends unknown ? (x: U) => 0 : never
> extends (x: infer L) => 0
? L
: never

declare type MergeRecord<T extends Record<PropertyKey, unknown>> =
T extends Record<PropertyKey, unknown>
? {
    [K in keyof T]: T[K]
}
: never

declare type MergeRecordWithoutNever<
T extends Record<PropertyKey, unknown>[],
R extends Record<PropertyKey, unknown> = {}
> = T extends [infer F, ...infer L extends Array<Record<PropertyKey, unknown>>]
? [F] extends [never]
? MergeRecordWithoutNever<L, R>
: MergeRecordWithoutNever<L, R & F>
: MergeRecord<R>

export declare interface MysqlOptions {
    /** mysql连接类型 */
    type: 'pool' | 'connection';
    /** mysql连接参数 */
    config: ConnectionOptions | PoolOptions;
    /** 数据库默认选项 */
    database?: DBOptions;
    /** json键的具体类型配置 */
    json_key?: Record<string, Record<string, Record<string, KeyType_2>>>;
}

export declare class MysqlServer {
    readonly type: "pool" | "connection";
    readonly config: ConnectionOptions | PoolOptions;
    readonly options: DBOptions | undefined;
    readonly json_key: Record<string, Record<string, Record<string, KeyType_2>>> | undefined;
    constructor();
    private _active_database;
    /** 当前选中的database */
    get active_database(): string | undefined;
    /** 切换选中的database */
    use(database: string): void;
    private _pool?;
    /** 从配置处获取连接 */
    getConnection(): Promise<{
        active_database?: string;
        connection: Connection;
        release: () => void;
    }>;
    /**
     * 从配置处获取连接
     * @ 传入泛型以明确表示从连接池获取连接
     */
    getConnection<T extends true>(): Promise<{
        active_database?: string;
        connection: PoolConnection;
        release: () => void;
    }>;
    /**
     * 调用连接执行execute，并自动释放连接
     * @ 不传入泛型提示返回OkPacket
     */
    execute(options: string | Partial<SqlWithParams>, database?: string): Promise<OkPacket_2>;
    /**
     * 调用连接执行execute，并自动释放连接
     * @ 传入泛型提示返回类型数组
     */
    execute<T extends Record<string, unknown>>(options: string | Partial<SqlWithParams>, database?: string): Promise<T[]>;
    /** 调用连接并获取事务实例 */
    transaction(): Promise<Transaction>;
}

export { OkPacket }

declare namespace Select {
    interface Options {
        database?: string
        table: string
        distinct?: boolean
        columns?: string[]
        where?: Sql | Where.Options
        order_by?: Record<string, OrderByType>
        range?: Range
    }

    type OrderByType = boolean | 'desc' | 'asc'
    type Range =
    | number
    | [number, number]
    | { limit: number; offset: number }

    type JoinColumn = Record<string, string[]>
    interface JoinOptions extends Omit<Options, 'columns'> {
        columns?: JoinColumn
    }
}

declare type SelectColumns<Columns extends TableColumns> = MergeRecord<
    {
    readonly [Key in Columns[number] as IsReadOnly<
    Key,
    IsExist<Key, Key['name'], never>,
    never
    >]: Key['type']
} & {
    readonly [Key in Columns[number] as IsReadOnly<
    Key,
    IsExist<Key, never, Key['name']>,
    never
    >]?: Key['type']
} & {
    [Key in Columns[number] as IsReadOnly<
    Key,
    never,
    IsExist<Key, Key['name'], never>
    >]: Key['type']
} & {
    [Key in Columns[number] as IsReadOnly<
    Key,
    never,
    IsExist<Key, never, Key['name']>
    >]?: Key['type']
}
>

declare type SelectColumnsPick<
Columns extends TableColumns,
Column extends TableColumnsName<Columns>
> = [Column] extends [never]
? SelectColumns<Columns>
: DoPick<SelectColumns<Columns>, Column>

declare type SelectColumnsRecord<
ColumnsRecord extends TableColumnsRecord,
Column extends Partial<TableColumnsRecordMap<ColumnsRecord>>
> = [Column] extends [never]
? UnionToIntersection<
    {
    [Table in keyof ColumnsRecord]: SelectColumns<ColumnsRecord[Table]>
}[keyof ColumnsRecord]
>
: UnionToIntersection<
    {
    [Table in keyof Column]: Table extends keyof ColumnsRecord
    ? Column[Table] extends Array<infer Col extends string>
    ? SelectColumnsPick<ColumnsRecord[Table], Col>
    : never
    : never
}[keyof Column]
>

declare type Split<
T extends string,
D extends string = '.'
> = T extends `${infer F}${D}${infer L}` ? [F, ...Split<L, D>] : [T]

declare type Sql = SqlWithParams | SqlWithParams['sql']

declare interface SqlWithParams {
    sql: string
    params: any[]
}

export declare class Table<DB extends keyof MySql.DataBase, Name extends keyof MySql.DataBase[DB] & string, Columns extends TableColumns = GenTableColumns<DB, Name>> {
    readonly database: DB;
    readonly name: Name;
    constructor(database: DB, name: Name);
    private readonly _json_keys;
    insert(...datas: InsertColumns<Columns>[]): Promise<OkPacket>;
    delete(where: Delete.Options['where']): Promise<OkPacket>;
    update(data: UpdateColumns<Columns>, where?: Update.Options['where']): Promise<OkPacket>;
    select<Column extends Columns[number]['name']>(columns?: Column[], where?: Select.Options['where'], options?: Omit<Select.Options, 'table' | 'columns' | 'where'>): Promise<SelectColumnsPick<Columns, Column>[]>;
    join<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<Columns, never>, type?: JoinType): JoinTable<DB, never, CR, Name, Columns, N, C, [CR] extends [never] ? [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<Record<Name, Columns>> : MergeRecord<Record<Name, Columns> & Record<N, C>> : [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<{} & CR> : MergeRecord<CR & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<Name, Columns>> : MergeRecord<CR & Record<Name, Columns> & Record<N, C>>>;
    leftJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<Columns, never>): JoinTable<DB, never, CR, Name, Columns, N, C, [CR] extends [never] ? [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<Record<Name, Columns>> : MergeRecord<Record<Name, Columns> & Record<N, C>> : [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<{} & CR> : MergeRecord<CR & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<Name, Columns>> : MergeRecord<CR & Record<Name, Columns> & Record<N, C>>>;
    rightJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<Columns, never>): JoinTable<DB, never, CR, Name, Columns, N, C, [CR] extends [never] ? [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<Record<Name, Columns>> : MergeRecord<Record<Name, Columns> & Record<N, C>> : [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<{} & CR> : MergeRecord<CR & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<Name, Columns>> : MergeRecord<CR & Record<Name, Columns> & Record<N, C>>>;
    fullJoin<CR extends TableColumnsRecord = never, N extends keyof MySql.DataBase[DB] & string = never, C extends TableColumns = never>(table: Table<DB, N, C> | JoinTable<any, any, any, any, any, any, any, CR>, key: ColumnsName<C, CR>, self_key: ColumnsName<Columns, never>): JoinTable<DB, never, CR, Name, Columns, N, C, [CR] extends [never] ? [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? {} : MergeRecord<Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<Record<Name, Columns>> : MergeRecord<Record<Name, Columns> & Record<N, C>> : [Record<Name, Columns>] extends [never] ? [Record<N, C>] extends [never] ? MergeRecord<{} & CR> : MergeRecord<CR & Record<N, C>> : [Record<N, C>] extends [never] ? MergeRecord<CR & Record<Name, Columns>> : MergeRecord<CR & Record<Name, Columns> & Record<N, C>>>;
    create(columns: Create.Options['columns'], options?: Omit<Create.Options, 'database' | 'name' | 'columns'>): Promise<OkPacket>;
    truncate(): Promise<OkPacket>;
    drop(): Promise<OkPacket>;
}

declare interface TableColumn {
    readonly name: string
    readonly type: unknown
    readonly not_null: boolean
    readonly has_defa: boolean
    readonly readonly: boolean
}

declare type TableColumns = readonly TableColumn[]

declare type TableColumnsName<Columns extends TableColumns> =
Columns[number]['name']

declare type TableColumnsRecord = Record<string, TableColumns>

declare type TableColumnsRecordMap<ColumnsRecord extends TableColumnsRecord> =
ColumnsRecord extends TableColumnsRecord
? {
    [Table in keyof ColumnsRecord]: TableColumnsName<ColumnsRecord[Table]>[]
}
: never

declare type TableColumnsRecordName<ColumnsRecord extends TableColumnsRecord> = {
    [Table in keyof ColumnsRecord]: Table extends string
    ? `${Table}.${TableColumnsName<ColumnsRecord[Table]>}`
    : never
}[keyof ColumnsRecord]

declare class Transaction {
    private type;
    private readonly connection;
    constructor(type: 'connection' | 'pool', connection: Connection | PoolConnection);
    private _active;
    get active(): boolean;
    begin(): Promise<void>;
    /**
     * 调用连接执行execute，并自动释放连接
     * @ 不传入泛型提示返回OkPacket
     */
    execute(options: string | Partial<SqlWithParams>): Promise<OkPacket_2>;
    /**
     * 调用连接执行execute，并自动释放连接
     * @ 传入泛型提示返回类型数组
     */
    execute<T extends Record<string, unknown>>(options: string | Partial<SqlWithParams>): Promise<T[]>;
    commit(): Promise<void>;
    private _handleError;
    setHandleError(handleError: typeof Transaction._handleError): void;
    release(): Promise<void>;
    private _rollback;
    rollback(): Promise<void>;
}

declare type UnionToIntersection<U extends Record<PropertyKey, unknown>> = (
U extends unknown ? (k: U) => void : never
) extends (k: infer I extends Record<PropertyKey, unknown>) => void
? MergeRecord<I>
: never

/**
 * UnionToIntersection<{ foo: string } | { bar: string }> =
 *  { foo: string } & { bar: string }.
 */
declare type UnionToIntersection2<U> = (
U extends unknown ? (arg: U) => 0 : never
) extends (arg: infer I) => 0
? I
: never

/**
 * UnionToTuple<1 | 2> = [1, 2].
 */
declare type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
? []
: [...UnionToTuple<Exclude<U, Last>>, Last]

declare namespace Update {
    interface Options {
        database?: string
        table: string
        data: Record<string, unknown>
        where?: Sql | Where.Options
        json_key?: Map<string, string>
    }
}

declare type UpdateColumns<Columns extends TableColumns> = MergeRecord<{
    [Key in Columns[number] as IsReadOnly<Key, never, Key['name']>]?: Key['type']
}>

export declare const useServer: () => MysqlServer;

declare namespace Where {
    type Options = Single | Unions

    type CompareType = '=' | '<>' | '<' | '<=' | '>' | '>='
    interface Compare {
        key: string
        val: any
        type: CompareType
    }

    interface Like {
        key: string
        like: string
    }

    interface Between {
        key: string
        min: number
        max: number
    }

    interface In {
        key: string
        vals: any[]
    }

    type Single = Compare | Like | Between | In

    type UnionType = 'and' | 'or'
    type Unions = [UnionType, Options, Options]
}

export { }