driftsql 1.0.12 → 1.0.13

package/dist/index.d.ts

@@ -1,74 +1,133 @@
-type DriverOptions<T = object> = T & {
-    experimental?: Record<string, any>;
-};
+interface QueryResult<T = any> {
+    rows: T[];
+    rowCount: number;
+    command?: string;
+    fields?: QueryField[];
+}
+interface QueryField {
+    name: string;
+    dataTypeID: number;
+}
+interface DatabaseDriver {
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    close(): Promise<void>;
+}
+interface TransactionCapable {
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+}
+interface PreparedStatementCapable {
+    prepare(sql: string): Promise<PreparedStatement>;
+}
+interface PreparedStatement {
+    execute<T = any>(params?: any[]): Promise<QueryResult<T>>;
+    finalize(): Promise<void>;
+}
 
 interface PostgresConfig {
     connectionString?: string;
-    options?: DriverOptions<{
-        experimental?: {
-            /**
-             * Enable experimental postgres http support. Using github.com/lassejlv/postgres_http
-             */
-            http?: {
-                url: string;
-                apiKey?: string;
-            };
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
         };
-    }>;
+    };
+}
+declare class PostgresDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: PostgresConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
 }
 
 interface LibSQLConfig {
     url: string;
     authToken?: string;
-    options?: DriverOptions<{
-        experimental?: {
-            useTursoServerlessDriver?: boolean;
-        };
-    }>;
+    useTursoServerlessDriver?: boolean;
+}
+declare class LibSQLDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: LibSQLConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+    private convertLibsqlResult;
 }
 
 interface MySQLConfig {
     connectionString: string;
 }
+declare class MySQLDriver implements DatabaseDriver, TransactionCapable {
+    private client;
+    constructor(config: MySQLConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
 
-type Drivers = ClientOptions['drivers'];
-declare const inspectDB: (drivers: Drivers) => Promise<never>;
+interface SqliteConfig {
+    filename: string;
+    readonly?: boolean;
+}
+declare class SqliteDriver implements DatabaseDriver, TransactionCapable, PreparedStatementCapable {
+    private client;
+    constructor(config: SqliteConfig);
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (driver: DatabaseDriver) => Promise<T>): Promise<T>;
+    prepare(sql: string): Promise<PreparedStatement>;
+    close(): Promise<void>;
+    exec(sql: string): void;
+    backup(filename: string): Promise<void>;
+    pragma(pragma: string): any;
+}
 
-type UnifiedQueryResult<T extends Record<string, any>> = {
-    rows: T[];
-    rowCount: number;
-    command?: string;
-    fields?: Array<{
-        name: string;
-        dataTypeID: number;
-    }>;
-};
-interface ClientOptions {
-    drivers: {
-        libsql?: LibSQLConfig;
-        postgres?: PostgresConfig;
-        mysql?: MySQLConfig;
-    };
+interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
+    driver: T;
+    fallbackDrivers?: DatabaseDriver[];
 }
-declare class DriftSQLClient<DT> {
-    private postgres?;
-    private libsql?;
-    private mysql?;
-    private drivers;
+declare class SQLClient<DT = any> {
+    private primaryDriver;
+    private fallbackDrivers;
     constructor(options: ClientOptions);
-    readonly inspect: () => Promise<void>;
-    query<T extends Record<string, any>>(query: string, args?: (string | number | boolean | null)[]): Promise<UnifiedQueryResult<T>>;
+    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+    transaction<T>(callback: (client: SQLClient<DT>) => Promise<T>): Promise<T>;
+    prepare(sql: string): Promise<PreparedStatement>;
     findFirst<K extends keyof DT>(table: K, where?: Partial<DT[K]>): Promise<DT[K] | null>;
     findMany<K extends keyof DT>(table: K, options?: {
         where?: Partial<DT[K]>;
         limit?: number;
+        offset?: number;
     }): Promise<DT[K][]>;
     insert<K extends keyof DT>(table: K, data: Partial<DT[K]>): Promise<DT[K]>;
     update<K extends keyof DT>(table: K, data: Partial<DT[K]>, where: Partial<DT[K]>): Promise<DT[K] | null>;
-    delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
-    deleteFirst<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<boolean>;
+    delete<K extends keyof DT>(table: K, where: Partial<DT[K]>): Promise<number>;
+    getDriver(): DatabaseDriver;
+    supportsTransactions(): boolean;
+    supportsPreparedStatements(): boolean;
     close(): Promise<void>;
 }
+declare function createPostgresClient<DT = any>(config: {
+    connectionString?: string;
+    experimental?: {
+        http?: {
+            url: string;
+            apiKey?: string;
+        };
+    };
+}): SQLClient<DT>;
+declare function createLibSQLClient<DT = any>(config: {
+    url: string;
+    authToken?: string;
+    useTursoServerlessDriver?: boolean;
+}): SQLClient<DT>;
+declare function createMySQLClient<DT = any>(config: {
+    connectionString: string;
+}): SQLClient<DT>;
+declare function createSqliteClient<DT = any>(config: {
+    filename: string;
+    readonly?: boolean;
+}): SQLClient<DT>;
+declare const DriftSQLClient: typeof SQLClient;
 
-export { DriftSQLClient, inspectDB };
-export type { ClientOptions, UnifiedQueryResult };
+export { DriftSQLClient, LibSQLDriver, MySQLDriver, PostgresDriver, SQLClient, SqliteDriver, createLibSQLClient, createMySQLClient, createPostgresClient, createSqliteClient };
+export type { ClientOptions, DatabaseDriver, QueryResult };