DefinitelyTyped/anydb-sql/index.d.ts

// Type definitions for anydb-sql
// Project: https://github.com/doxout/anydb-sql
// Definitions by: Gorgi Kosev <https://github.com/spion>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped


interface AnyDBPool extends anydbSQL.DatabaseConnection {
    query: (text: string, values: any[], callback: (err: Error, result: any) => void) => void;
    begin: () => anydbSQL.Transaction;
    close: (err: Error) => void;
}

interface Dictionary<T> { [key: string]: T; }

declare namespace anydbSQL {
    export interface OrderByValueNode { }
    export interface ColumnDefinition {
        primaryKey?: boolean;
        dataType?: string;
        references?: { table: string; column: string };
        notNull?: boolean;
    }

    export interface TableDefinition {
        name: string;
        columns: Dictionary<ColumnDefinition>;
        has?: Dictionary<{ from: string; many?: boolean }>;
    }


    export interface QueryLike {
        query: string;
        values: any[];
        text: string;
    }
    export interface DatabaseConnection {
        queryAsync<T>(query: string, ...params: any[]): Promise<{ rowCount: number; rows: T[] }>;
        queryAsync<T>(query: QueryLike): Promise<{ rowCount: number; rows: T[] }>;
    }

    export interface Transaction extends DatabaseConnection {
        rollback(): void;
        commitAsync(): Promise<void>;
    }

    export interface SubQuery<T> {
        select(node: Column<T>): SubQuery<T>;
        where(...nodes: any[]): SubQuery<T>;
        from(table: TableNode): SubQuery<T>;
        group(...nodes: any[]): SubQuery<T>;
        order(criteria: OrderByValueNode): SubQuery<T>;
        notExists(subQuery: SubQuery<any>): SubQuery<T>;
    }

    interface Executable<T> {
        get(): Promise<T>;
        getWithin(tx: DatabaseConnection): Promise<T>;
        exec(): Promise<void>;
        all(): Promise<T[]>;
        execWithin(tx: DatabaseConnection): Promise<void>;
        allWithin(tx: DatabaseConnection): Promise<T[]>;
        toQuery(): QueryLike;
    }

    interface Queryable<T> {
        where(...nodes: any[]): Query<T>;
        delete(): ModifyingQuery;
        select<U>(...nodes: any[]): Query<U>;
        selectDeep<U>(table: Table<T>): Query<T>;
        selectDeep<U>(...nodesOrTables: any[]): Query<U>;
    }

    export interface Query<T> extends Executable<T>, Queryable<T> {
        from(table: TableNode): Query<T>;
        update(o: {}): ModifyingQuery;
        group(...nodes: any[]): Query<T>;
        order(...criteria: OrderByValueNode[]): Query<T>;
        limit(l: number): Query<T>;
        offset(o: number): Query<T>;
    }

    export interface ModifyingQuery extends Executable<void> {
        returning<U>(...nodes: any[]): Query<U>;
        where(...nodes: any[]): ModifyingQuery;
    }

    export interface TableNode {
        join(table: TableNode): JoinTableNode;
        leftJoin(table: TableNode): JoinTableNode;
    }

    export interface JoinTableNode extends TableNode {
        on(filter: BinaryNode | string): TableNode;
    }

    interface CreateQuery extends Executable<void> {
        ifNotExists(): Executable<void>;
    }
    interface DropQuery extends Executable<void> {
        ifExists(): Executable<void>;
    }
    export interface Table<T> extends TableNode, Queryable<T> {
        create(): CreateQuery;
        drop(): DropQuery;
        as(name: string): Table<T>;
        update(o: any): ModifyingQuery;
        insert(rows: T | T[]): ModifyingQuery;
        select(): Query<T>;
        select<U>(...nodes: any[]): Query<U>;
        from<U>(table: TableNode): Query<U>;
        star(): Column<any>;
        subQuery<U>(): SubQuery<U>;
        eventEmitter: {
            emit: (type: string, ...args: any[]) => void;
            on: (eventName: string, handler: Function) => void;
        };
        columns: Column<any>[];
        sql: SQL;
        alter(): AlterQuery<T>;
    }
    export interface AlterQuery<T> extends Executable<void> {
        addColumn(column: Column<any>): AlterQuery<T>;
        addColumn(name: string, options: string): AlterQuery<T>;
        dropColumn(column: Column<any>): AlterQuery<T>;
        renameColumn(column: Column<any>, newColumnOrName: Column<any> | string): AlterQuery<T>;
        renameColumn(name: string, newName: string): AlterQuery<T>;
        rename(newName: string): AlterQuery<T>;
    }

    export interface SQL {
        functions: {
            LOWER(c: Column<string>): Column<string>
        };
    }

    export interface BinaryNode {
        and(node: BinaryNode): BinaryNode;
        or(node: BinaryNode): BinaryNode;
    }

    export interface Column<T> {
        in(subQuery: T[] | SubQuery<T>): BinaryNode;
        notIn(arr: T[]): BinaryNode;
        equals(node: any): BinaryNode;
        notEquals(node: any): BinaryNode;
        gte(node: any): BinaryNode;
        lte(node: any): BinaryNode;
        gt(node: any): BinaryNode;
        lt(node: any): BinaryNode;
        like(str: string): BinaryNode;
        multiply: {
            (node: Column<T>): Column<T>
            (n: number): Column<number>
        };
        isNull(): BinaryNode;
        isNotNull(): BinaryNode;
        sum(): Column<number>;
        count(name?: string): Column<number>;
        distinct(): Column<T>;
        as(name: string): Column<T>;
        ascending: OrderByValueNode;
        descending: OrderByValueNode;
        asc: OrderByValueNode;
        desc: OrderByValueNode;
    }

    export interface AnydbSql extends DatabaseConnection {
        define<T>(map: TableDefinition): Table<T>;
        transaction<T>(fn: (tx: Transaction) => Promise<T>): Promise<T>;
        allOf(...tables: Table<any>[]): any;
        models: Dictionary<Table<any>>;
        functions: {
            LOWER: (name: Column<string>) => Column<string>
            RTRIM: (name: Column<string>) => Column<string>
        };
        makeFunction(name: string): Function;
        begin(): Transaction;
        open(): void;
        close(): void;
        getPool(): AnyDBPool;
        dialect(): string;
    }
}

declare function anydbSQL(config: Object): anydbSQL.AnydbSql;

export = anydbSQL;