sqlitebruv/dist/index.d.ts

A Simple and Efficient Query Builder for D1/Turso and Bun's SQLite

interface BruvSchema<Model> {
    name: string;
    columns: {
        [x in keyof Omit<Model, "id">]: SchemaColumnOptions;
    };
}
interface SchemaColumnOptions {
    type: "INTEGER" | "REAL" | "TEXT" | "DATETIME";
    required?: boolean;
    unique?: boolean;
    default?: () => string;
    target?: string;
    check?: string[];
}
type Params = string | number | null | boolean;
interface Query {
    from: string;
    select?: string[];
    where?: {
        condition: string;
        params: any[];
    }[];
    andWhere?: {
        condition: string;
        params: any[];
    }[];
    orWhere?: {
        condition: string;
        params: any[];
    }[];
    orderBy?: {
        column: string;
        direction: "ASC" | "DESC";
    };
    limit?: number;
    offset?: number;
    cacheAs?: string;
    invalidateCache?: string;
    action?: "get" | "getOne" | "insert" | "update" | "delete" | "count";
    data?: any;
}
interface TursoConfig {
    url: string;
    authToken: string;
}
interface D1Config {
    accountId: string;
    databaseId: string;
    apiKey: string;
}
export declare class SqliteBruv<T extends Record<string, Params> = Record<string, Params>> {
    static migrationFolder: string;
    private _columns;
    private _conditions;
    private _tableName?;
    private _params;
    private _limit?;
    private _offset?;
    private _orderBy?;
    private _logging;
    private _hotCache;
    private _turso?;
    private _D1?;
    private _QueryMode?;
    private readonly MAX_PARAMS;
    private readonly ALLOWED_OPERATORS;
    private readonly DANGEROUS_PATTERNS;
    loading?: Promise<unknown>;
    constructor({ logging, schema, D1Config, TursoConfig, localFile, QueryMode, createMigrations, }: {
        D1Config?: D1Config;
        TursoConfig?: TursoConfig;
        QueryMode?: boolean;
        localFile?: string;
        schema: Schema[];
        logging?: boolean;
        createMigrations?: boolean;
    });
    from<Model extends Record<string, any> = Record<string, any>>(tableName: string): SqliteBruv<Model>;
    select(...columns: string[]): this;
    private validateCondition;
    private validateParams;
    where(condition: string, ...params: Params[]): this;
    andWhere(condition: string, ...params: Params[]): this;
    orWhere(condition: string, ...params: Params[]): this;
    limit(count: number): this;
    offset(count: number): this;
    orderBy(column: string, direction: "ASC" | "DESC"): this;
    invalidateCache(cacheName: string): undefined;
    get({ cacheAs }?: {
        cacheAs?: string;
    }): Promise<T[]>;
    getOne({ cacheAs }?: {
        cacheAs?: string;
    }): Promise<T>;
    insert(data: T): Promise<T>;
    update(data: Partial<T>): Promise<T>;
    delete(): Promise<T>;
    count({ cacheAs }?: {
        cacheAs?: string;
    }): Promise<{
        [x: string]: any;
        count: number;
    }>;
    executeJsonQuery(query: Query): Promise<any>;
    private build;
    clear(): void;
    private executeTursoQuery;
    raw(raw: string, params?: (string | number | boolean)[]): Promise<any>;
    rawAll(raw: string): any;
    cacheResponse(response: any, cacheName?: string): Promise<any>;
}
export declare class Schema<Model extends Record<string, any> = {}> {
    private string;
    name: string;
    db?: SqliteBruv;
    columns: {
        [x in keyof Omit<Model, "id">]: SchemaColumnOptions;
    };
    constructor(def: BruvSchema<Model>);
    get query(): SqliteBruv<Model>;
    queryRaw(raw: string): Promise<any>;
    getSql(): Promise<string>;
}
export {};