driftsql 1.0.31 → 2.0.0-beta.1

package/dist/index.d.ts

@@ -1,35 +1,360 @@
-import type { DatabaseDriver, QueryResult } from './types';
-export type { DatabaseDriver, QueryResult, QueryError, QueryField, ConnectionError } from './types';
-export { PostgresDriver } from './drivers/postgres';
-export { LibSQLDriver } from './drivers/libsql';
-export { MySQLDriver } from './drivers/mysql';
-export { NeonDriver } from './drivers/neon';
-export { SqliteCloudDriver } from './drivers/sqlitecloud';
-export { inspectDB } from './inspect';
-export { SurrealDriver } from './drivers/surreal';
-export interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
-    driver: T;
-    fallbackDrivers?: DatabaseDriver[];
-}
-export declare class SQLClient<DT = any> {
-    private primaryDriver;
-    private fallbackDrivers;
-    constructor(options: ClientOptions);
-    query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
-    transaction<T>(callback: (client: SQLClient<DT>) => Promise<T>): Promise<T>;
-    prepare(sql: string): Promise<import("./types").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<number>;
-    getDriver(): DatabaseDriver;
-    supportsTransactions(): boolean;
-    supportsPreparedStatements(): boolean;
-    close(): Promise<void>;
-}
-export declare const DriftSQLClient: typeof SQLClient;
+//#region src/types.d.ts
+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>>;
+  findFirst?(table: string, where?: Record<string, any>): Promise<QueryResult<any> | null>;
+  findMany?(table: string, options?: {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+  }): Promise<QueryResult<any>>;
+  insert?(table: string, data: Record<string, any>): Promise<QueryResult<any>>;
+  update?(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<any>>;
+  delete?(table: string, where: Record<string, any>): Promise<number>;
+  close(): Promise<void>;
+}
+interface PreparedStatement {
+  execute<T = any>(params?: any[]): Promise<QueryResult<T>>;
+  finalize(): Promise<void>;
+}
+declare class DatabaseError extends Error {
+  readonly driverType: string;
+  readonly originalError?: Error | undefined;
+  constructor(message: string, driverType: string, originalError?: Error | undefined);
+}
+declare class QueryError extends DatabaseError {
+  constructor(driverType: string, sql: string, originalError?: Error);
+}
+declare class ConnectionError extends DatabaseError {
+  constructor(driverType: string, originalError?: Error);
+}
+//#endregion
+//#region src/utils/inspect.d.ts
+interface InspectOptions {
+  driver: DatabaseDriver;
+  outputFile?: string;
+}
+//#endregion
+//#region src/drivers/postgres.d.ts
+interface PostgresDriverConfig {
+  connectionString: string;
+  max?: number;
+  idle_timeout?: number;
+  connect_timeout?: number;
+}
+declare class PostgresDriver implements DatabaseDriver {
+  private client;
+  findFirst?: (table: string, where?: Record<string, any>) => Promise<QueryResult<any> | null>;
+  findMany?: (table: string, options?: {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+  }) => Promise<QueryResult<any>>;
+  insert?: (table: string, data: Record<string, any>) => Promise<QueryResult<any>>;
+  update?: (table: string, data: Record<string, any>, where: Record<string, any>) => Promise<QueryResult<any>>;
+  delete?: (table: string, where: Record<string, any>) => Promise<number>;
+  constructor(config: PostgresDriverConfig);
+  query<T = any>(sql: string, params?: any[]): Promise<QueryResult<T>>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/drivers/helpers/postgres.d.ts
+interface PostgresHelpers {
+  findFirst?(table: string, where?: Record<string, any>): Promise<QueryResult<any> | null>;
+  findMany?(table: string, options?: {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+  }): Promise<QueryResult<any>>;
+  insert?(table: string, data: Record<string, any>): Promise<QueryResult<any>>;
+  update?(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<any>>;
+  delete?(table: string, where: Record<string, any>): Promise<number>;
+}
+declare function createPostgresHelpers(driver: DatabaseDriver): PostgresHelpers;
+//#endregion
+//#region src/drivers/helpers/mysql.d.ts
+interface MySQLHelpers {
+  findFirst?(table: string, where?: Record<string, any>): Promise<QueryResult<any> | null>;
+  findMany?(table: string, options?: {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+  }): Promise<QueryResult<any>>;
+  insert?(table: string, data: Record<string, any>): Promise<QueryResult<any>>;
+  update?(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<any>>;
+  delete?(table: string, where: Record<string, any>): Promise<number>;
+}
+declare function createMySQLHelpers(driver: DatabaseDriver): MySQLHelpers;
+//#endregion
+//#region src/drivers/helpers/sqlite.d.ts
+interface SQLiteHelpers {
+  findFirst?(table: string, where?: Record<string, any>): Promise<QueryResult<any> | null>;
+  findMany?(table: string, options?: {
+    where?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+  }): Promise<QueryResult<any>>;
+  insert?(table: string, data: Record<string, any>): Promise<QueryResult<any>>;
+  update?(table: string, data: Record<string, any>, where: Record<string, any>): Promise<QueryResult<any>>;
+  delete?(table: string, where: Record<string, any>): Promise<number>;
+}
+declare function createSQLiteHelpers(driver: DatabaseDriver): SQLiteHelpers;
+//#endregion
+//#region src/schema/types.d.ts
+type ColumnType = 'serial' | 'bigserial' | 'integer' | 'bigint' | 'smallint' | 'text' | 'varchar' | 'char' | 'boolean' | 'timestamp' | 'timestamptz' | 'date' | 'time' | 'json' | 'jsonb' | 'uuid' | 'decimal' | 'numeric' | 'real' | 'double precision' | 'bytea';
+interface ColumnDefinition {
+  name: string;
+  type: ColumnType;
+  length?: number;
+  precision?: number;
+  scale?: number;
+  primaryKey?: boolean;
+  notNull?: boolean;
+  unique?: boolean;
+  default?: string | number | boolean;
+  references?: {
+    table: string;
+    column: string;
+    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+  };
+  check?: string;
+}
+interface IndexDefinition {
+  name: string;
+  columns: string[];
+  unique?: boolean;
+  type?: 'btree' | 'hash' | 'gist' | 'gin';
+}
+interface TableDefinition {
+  name: string;
+  columns: ColumnDefinition[];
+  indexes?: IndexDefinition[];
+  primaryKey?: string[];
+  checks?: Array<{
+    name: string;
+    expression: string;
+  }>;
+}
+interface Migration {
+  version: string;
+  name: string;
+  up: string[];
+  down: string[];
+}
+type SQLDialect = 'postgres' | 'mysql' | 'sqlite';
+//#endregion
+//#region src/schema/column.d.ts
+declare class Column {
+  private definition;
+  constructor(name: string, type: ColumnType);
+  length(len: number): this;
+  precision(p: number, s?: number): this;
+  primaryKey(): this;
+  notNull(): this;
+  unique(): this;
+  default(value: string | number | boolean): this;
+  references(table: string, column?: string): this;
+  onDelete(action: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'): this;
+  onUpdate(action: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION'): this;
+  check(expression: string): this;
+  getDefinition(): ColumnDefinition;
+}
+declare function serial(name: string): Column;
+declare function bigserial(name: string): Column;
+declare function integer(name: string): Column;
+declare function bigint(name: string): Column;
+declare function smallint(name: string): Column;
+declare function text(name: string): Column;
+declare function varchar(name: string, length?: number): Column;
+declare function char(name: string, length?: number): Column;
+declare function boolean(name: string): Column;
+declare function timestamp(name: string): Column;
+declare function timestamptz(name: string): Column;
+declare function date(name: string): Column;
+declare function time(name: string): Column;
+declare function json(name: string): Column;
+declare function jsonb(name: string): Column;
+declare function uuid(name: string): Column;
+declare function decimal(name: string, precision?: number, scale?: number): Column;
+declare function numeric(name: string, precision?: number, scale?: number): Column;
+declare function real(name: string): Column;
+declare function doublePrecision(name: string): Column;
+declare function bytea(name: string): Column;
+//#endregion
+//#region src/schema/table.d.ts
+declare class Table {
+  private definition;
+  constructor(name: string);
+  column(column: Column): this;
+  primaryKey(...columns: string[]): this;
+  index(name: string, columns: string[], options?: {
+    unique?: boolean;
+    type?: 'btree' | 'hash' | 'gist' | 'gin';
+  }): this;
+  unique(name: string, ...columns: string[]): this;
+  check(name: string, expression: string): this;
+  getDefinition(): TableDefinition;
+}
+declare function createTable(name: string, callback: (table: Table) => void): Table;
+//#endregion
+//#region src/schema/migration.d.ts
+declare class MigrationBuilder {
+  private upStatements;
+  private downStatements;
+  private dialect;
+  constructor(dialect?: SQLDialect);
+  createTable(table: Table): this;
+  dropTable(tableName: string): this;
+  addColumn(tableName: string, columnSql: string): this;
+  dropColumn(tableName: string, columnName: string): this;
+  renameTable(oldName: string, newName: string): this;
+  raw(sql: string, downSql?: string): this;
+  build(version: string, name: string): Migration;
+  private getGenerator;
+}
+declare function createMigration(dialect?: SQLDialect): MigrationBuilder;
+//#endregion
+//#region src/schema/runner.d.ts
+declare class MigrationRunner {
+  private client;
+  constructor(client: SQLClient);
+  ensureMigrationsTable(): Promise<void>;
+  getAppliedMigrations(): Promise<string[]>;
+  up(migration: Migration): Promise<void>;
+  down(migration: Migration): Promise<void>;
+  upAll(migrations: Migration[]): Promise<void>;
+  downAll(migrations: Migration[]): Promise<void>;
+  reset(migrations: Migration[]): Promise<void>;
+}
+//#endregion
+//#region src/schema/differ.d.ts
+interface SchemaChange {
+  type: 'create_table' | 'drop_table' | 'add_column' | 'drop_column' | 'modify_column' | 'create_index' | 'drop_index';
+  table: string;
+  details?: any;
+}
+declare class SchemaDiffer {
+  private dialect;
+  constructor(dialect?: SQLDialect);
+  detectChanges(oldSchema: TableDefinition[], newSchema: TableDefinition[]): SchemaChange[];
+  private detectColumnChanges;
+  private detectIndexChanges;
+  private hasColumnChanged;
+  generateMigration(changes: SchemaChange[], version: string, name: string): MigrationBuilder;
+  private generateColumnSQL;
+  private generateIndexSQL;
+  private formatDefault;
+  private getGenerator;
+}
+declare function detectChanges(oldSchema: TableDefinition[], newSchema: TableDefinition[], dialect?: SQLDialect): SchemaChange[];
+declare function generateMigrationFromChanges(changes: SchemaChange[], version: string, name: string, dialect?: SQLDialect): MigrationBuilder;
+//#endregion
+//#region src/schema/snapshot.d.ts
+interface SchemaSnapshot {
+  version: string;
+  timestamp: number;
+  tables: TableDefinition[];
+}
+declare class SnapshotManager {
+  private snapshotPath;
+  constructor(snapshotPath?: string);
+  save(tables: TableDefinition[]): Promise<void>;
+  load(): Promise<SchemaSnapshot | null>;
+  exists(): Promise<boolean>;
+}
+//#endregion
+//#region src/schema/type-generator.d.ts
+declare class TypeGenerator {
+  generateTypes(tables: TableDefinition[]): string;
+  private generateTableInterface;
+  private generateDatabaseInterface;
+  private columnToTypeScript;
+  private pascalCase;
+  writeToFile(tables: TableDefinition[], filePath: string): Promise<void>;
+}
+declare function generateTypesFromSchema(tables: TableDefinition[], outputPath: string): Promise<void>;
+//#endregion
+//#region src/schema/generators/postgres.d.ts
+declare class PostgresGenerator {
+  generateCreateTable(table: TableDefinition): string;
+  generateDropTable(tableName: string): string;
+  private generateColumnDefinition;
+  private getColumnType;
+  private formatDefault;
+  private generateIndex;
+}
+//#endregion
+//#region src/schema/generators/mysql.d.ts
+declare class MySQLGenerator {
+  generateCreateTable(table: TableDefinition): string;
+  generateDropTable(tableName: string): string;
+  private generateColumnDefinition;
+  private getColumnType;
+  private formatDefault;
+  private generateIndex;
+}
+//#endregion
+//#region src/schema/generators/sqlite.d.ts
+declare class SQLiteGenerator {
+  generateCreateTable(table: TableDefinition): string;
+  generateDropTable(tableName: string): string;
+  private generateColumnDefinition;
+  private getColumnType;
+  private formatDefault;
+  private generateIndex;
+}
+//#endregion
+//#region src/index.d.ts
+interface ClientOptions<T extends DatabaseDriver = DatabaseDriver> {
+  driver: T;
+  fallbackDrivers?: DatabaseDriver[];
+  cacheTTL?: number;
+}
+declare class SQLClient<DT = any> {
+  private readonly primaryDriver;
+  private readonly fallbackDrivers;
+  private readonly queryCache;
+  private readonly cacheTTL;
+  private readonly maxCacheSize;
+  constructor(options: ClientOptions);
+  private isCacheValid;
+  private getCacheKey;
+  private maintainCacheSize;
+  private cacheResult;
+  private tryFallbackDrivers;
+  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<number>;
+  getDriver(): DatabaseDriver;
+  inspectDB(options?: InspectOptions): Promise<void>;
+  supportsTransactions(): boolean;
+  supportsPreparedStatements(): boolean;
+  clearCache(): void;
+  getCacheStats(): {
+    size: number;
+    ttl: number;
+  };
+  close(): Promise<void>;
+}
+declare const DriftSQLClient: typeof SQLClient;
+//#endregion
+export { ClientOptions, Column, ColumnDefinition, ColumnType, type ConnectionError, type DatabaseDriver, DriftSQLClient, IndexDefinition, Migration, MigrationBuilder, MigrationRunner, MySQLGenerator, MySQLHelpers, PostgresDriver, PostgresGenerator, PostgresHelpers, type QueryError, type QueryField, type QueryResult, SQLClient, SQLDialect, SQLiteGenerator, SQLiteHelpers, SchemaChange, SchemaDiffer, SchemaSnapshot, SnapshotManager, Table, TableDefinition, TypeGenerator, bigint, bigserial, boolean, bytea, char, createMigration, createMySQLHelpers, createPostgresHelpers, createSQLiteHelpers, createTable, date, decimal, detectChanges, doublePrecision, generateMigrationFromChanges, generateTypesFromSchema, integer, json, jsonb, numeric, real, serial, smallint, text, time, timestamp, timestamptz, uuid, varchar };

package/dist/index.js

@@ -1,48 +1 @@
-import consola4 from"consola";function hasTransactionSupport(driver){return"transaction"in driver&&typeof driver.transaction==="function"}function hasPreparedStatementSupport(driver){return"prepare"in driver&&typeof driver.prepare==="function"}class DatabaseError extends Error{driverType;originalError;constructor(message,driverType,originalError){super(message);this.driverType=driverType;this.originalError=originalError;this.name="DatabaseError"}}class QueryError extends DatabaseError{constructor(driverType,sql,originalError){super(`Query failed: ${sql}`,driverType,originalError);this.name="QueryError"}}class ConnectionError extends DatabaseError{constructor(driverType,originalError){super(`Failed to connect to ${driverType}`,driverType,originalError);this.name="ConnectionError"}}import postgres from"postgres";import ky from"ky";class PostgresDriver{client;constructor(config){try{if(config.experimental?.http){this.client=new PostgresHTTPDriver(config.experimental.http)}else{this.client=postgres(config.connectionString||"")}}catch(error){throw new ConnectionError("postgres",error)}}async query(sql,params){try{if(this.client instanceof PostgresHTTPDriver){return await this.client.query(sql,params)}const result=await this.client.unsafe(sql,params||[]);return{rows:result,rowCount:Array.isArray(result)?result.length:0,command:undefined}}catch(error){throw new QueryError("postgres",sql,error)}}async transaction(callback){if(this.client instanceof PostgresHTTPDriver){throw new Error("Transactions not supported with HTTP driver")}const result=await this.client.begin(async(sql)=>{const transactionDriver=new PostgresDriver({connectionString:""});transactionDriver.client=sql;return await callback(transactionDriver)});return result}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){if(this.client instanceof PostgresHTTPDriver){return await this.client.findMany(table,options)}const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT $${params.length+1}`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET $${params.length+1}`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map((_,index)=>`$${index+1}`).join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;const result=await this.query(sql,values);if(!result.rows[0]){throw new Error("Insert failed: No data returned")}return result}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map((_,index)=>`${setEntries[index]?.[0]} = $${index+1}`).join(", ");const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${setEntries.length+index+1}`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];const result=await this.query(sql,params);return result.rows.length>0?result:result}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);const result=await this.query(sql,params);return result.rowCount}async close(){try{if(this.client instanceof PostgresHTTPDriver){return await this.client.close()}await this.client.end()}catch(error){console.error("Error closing Postgres client:",error)}}}class PostgresHTTPDriver{httpClient;constructor(config){this.httpClient=ky.create({prefixUrl:config.url,headers:{Authorization:`Bearer ${config.apiKey||""}`}})}async query(sql,params){try{const response=await this.httpClient.post("query",{json:{query:sql,args:params}}).json();return{rows:response.rows,rowCount:response.rowCount,command:undefined}}catch(error){throw new QueryError("postgres-http",sql,error)}}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT $${params.length+1}`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET $${params.length+1}`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map((_,index)=>`$${index+1}`).join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;const result=await this.query(sql,values);if(!result.rows[0]){throw new Error("Insert failed: No data returned")}return result}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map((_,index)=>`${setEntries[index]?.[0]} = $${index+1}`).join(", ");const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${setEntries.length+index+1}`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];const result=await this.query(sql,params);return result.rows.length>0?result:result}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);const result=await this.query(sql,params);return result.rowCount}async close(){return Promise.resolve()}}import{createClient}from"@libsql/client";import{createClient as tursoServerLessClient}from"@tursodatabase/serverless/compat";class LibSQLDriver{client;constructor(config){try{this.client=config.useTursoServerlessDriver?tursoServerLessClient({url:config.url,...config.authToken?{authToken:config.authToken}:{}}):createClient({url:config.url,...config.authToken?{authToken:config.authToken}:{}})}catch(error){throw new ConnectionError("libsql",error)}}async query(sql,params){try{const result=await this.client.execute(sql,params);return this.convertLibsqlResult(result)}catch(error){throw new QueryError("libsql",sql,error)}}async transaction(callback){const transactionDriver=new LibSQLDriver({url:"",authToken:""});transactionDriver.client=this.client;return await callback(transactionDriver)}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const result=await this.client.execute(sql,values);if(result.lastInsertRowid){try{const selectSql=`SELECT * FROM ${tableName} WHERE rowid = ?`;const insertedRow=await this.query(selectSql,[result.lastInsertRowid]);return{rows:insertedRow.rows,rowCount:result.rowsAffected||0,command:undefined,fields:insertedRow.fields}}catch{return{rows:[],rowCount:result.rowsAffected||0,command:undefined,fields:[]}}}return{rows:[],rowCount:result.rowsAffected||0,command:undefined,fields:[]}}catch(error){throw new QueryError("libsql",sql,error)}}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const result=await this.client.execute(sql,params);const selectSql=`SELECT * FROM ${tableName} WHERE ${whereClause}`;const selectParams=whereEntries.map(([,value])=>value);const updatedRows=await this.query(selectSql,selectParams);return{rows:updatedRows.rows,rowCount:result.rowsAffected||0,command:undefined,fields:updatedRows.fields}}catch(error){throw new QueryError("libsql",sql,error)}}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const result=await this.client.execute(sql,params);return result.rowsAffected||0}catch(error){throw new QueryError("libsql",sql,error)}}async close(){try{this.client.close()}catch(error){console.error("Error closing LibSQL client:",error)}}convertLibsqlResult(result){const rows=result.rows.map((row)=>{const obj={};result.columns.forEach((col,index)=>{obj[col]=row[index]});return obj});return{rows,rowCount:result.rowsAffected||rows.length,command:undefined,fields:result.columns.map((col)=>({name:col,dataTypeID:0}))}}}import consola from"consola";import*as mysql from"mysql2/promise";class MySQLDriver{client;constructor(config){try{this.client=mysql.createConnection(config.connectionString)}catch(error){throw new ConnectionError("mysql",error)}}async query(sql,params){try{const[rows,fields]=await(await this.client).execute(sql,params||[]);const rowCount=Array.isArray(rows)?rows.length:0;const normalizedFields=fields.map((field)=>({name:field.name,dataTypeID:field.columnType}));return{rows,rowCount,command:undefined,fields:normalizedFields}}catch(error){throw new QueryError("mysql",sql,error)}}async transaction(callback){const connection=await this.client;try{await connection.beginTransaction();const transactionDriver=new MySQLDriver({connectionString:""});transactionDriver.client=Promise.resolve(connection);const result=await callback(transactionDriver);await connection.commit();return result}catch(error){await connection.rollback();throw error}}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const connection=await this.client;const[result]=await connection.execute(sql,values);const insertResult=result;if(insertResult.insertId){try{const selectSql=`SELECT * FROM ${tableName} WHERE id = ?`;const insertedRow=await this.query(selectSql,[insertResult.insertId]);return{rows:insertedRow.rows,rowCount:insertResult.affectedRows||0,command:undefined,fields:insertedRow.fields}}catch{return{rows:[],rowCount:insertResult.affectedRows||0,command:undefined,fields:[]}}}return{rows:[],rowCount:insertResult.affectedRows||0,command:undefined,fields:[]}}catch(error){throw new QueryError("mysql",sql,error)}}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const connection=await this.client;const[result]=await connection.execute(sql,params);const selectSql=`SELECT * FROM ${tableName} WHERE ${whereClause}`;const selectParams=whereEntries.map(([,value])=>value);const updatedRows=await this.query(selectSql,selectParams);const updateResult=result;return{rows:updatedRows.rows,rowCount:updateResult.affectedRows||0,command:undefined,fields:updatedRows.fields}}catch(error){throw new QueryError("mysql",sql,error)}}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const connection=await this.client;const[result]=await connection.execute(sql,params);const deleteResult=result;return deleteResult.affectedRows||0}catch(error){throw new QueryError("mysql",sql,error)}}async close(){try{await(await this.client).end()}catch(error){consola.error("Error closing MySQL client:",error)}}}import{neon}from"@neondatabase/serverless";class NeonDriver{client;constructor(options){this.client=neon(options.connectionString)}async query(sql,params){try{const resp=await this.client.query(sql,params);return{rows:resp,rowCount:resp.length||0}}catch(error){throw new QueryError("neon",`Failed to query database: ${error}`)}}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT $${params.length+1}`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET $${params.length+1}`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map((_,index)=>`$${index+1}`).join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;const result=await this.query(sql,values);if(!result.rows[0]){throw new Error("Insert failed: No data returned")}return result}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map((_,index)=>`${setEntries[index]?.[0]} = $${index+1}`).join(", ");const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${setEntries.length+index+1}`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];const result=await this.query(sql,params);return result.rows.length>0?result:result}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = $${index+1}`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);const result=await this.query(sql,params);return result.rowCount}close(){return Promise.resolve()}}import{Database}from"@sqlitecloud/drivers";class SqliteCloudDriver{options;client;constructor(options){this.options=options;this.client=new Database(this.options.connectionString)}async query(sql,params){try{const result=await this.client.sql(sql,params);const rows=Array.isArray(result)?result.map((row)=>{const data={};for(const key in row){if(typeof row[key]!=="function"){data[key]=row[key]}}return data}):[];return{rows,rowCount:rows.length,command:undefined}}catch(error){throw new QueryError("sqlitecloud",sql,error)}}async prepare(sql){return this.client.prepare(sql)}async findFirst(table,where){const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}sql+=" LIMIT 1";const result=await this.query(sql,params);return result.rows.length>0?result:null}async findMany(table,options){const{where,limit,offset}=options||{};const whereEntries=Object.entries(where||{});let sql=`SELECT * FROM ${table}`;let params=[];if(whereEntries.length>0){const whereClause=whereEntries.map((_,index)=>`${whereEntries[index]?.[0]} = ?`).join(" AND ");sql+=` WHERE ${whereClause}`;params=whereEntries.map(([,value])=>value)}if(typeof limit==="number"&&limit>0){sql+=` LIMIT ?`;params.push(limit)}if(typeof offset==="number"&&offset>0){sql+=` OFFSET ?`;params.push(offset)}return this.query(sql,params)}async insert(table,data){const tableName=String(table);const keys=Object.keys(data);const values=Object.values(data);if(keys.length===0){throw new Error("No data provided for insert")}const placeholders=keys.map(()=>"?").join(", ");const sql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders})`;try{const result=await this.query(sql,values);if(result.rows.length===0){const returningSql=`INSERT INTO ${tableName} (${keys.join(", ")}) VALUES (${placeholders}) RETURNING *`;return await this.query(returningSql,values)}return result}catch(error){throw new QueryError("sqlitecloud",sql,error)}}async update(table,data,where){const tableName=String(table);const setEntries=Object.entries(data);const whereEntries=Object.entries(where);if(setEntries.length===0){throw new Error("No data provided for update")}if(whereEntries.length===0){throw new Error("No conditions provided for update")}const setClause=setEntries.map(([key])=>`${key} = ?`).join(", ");const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`UPDATE ${tableName} SET ${setClause} WHERE ${whereClause} RETURNING *`;const params=[...setEntries.map(([,value])=>value),...whereEntries.map(([,value])=>value)];try{const result=await this.query(sql,params);return result}catch(error){throw new QueryError("sqlitecloud",sql,error)}}async delete(table,where){const tableName=String(table);const whereEntries=Object.entries(where);if(whereEntries.length===0){throw new Error("No conditions provided for delete")}const whereClause=whereEntries.map(([key])=>`${key} = ?`).join(" AND ");const sql=`DELETE FROM ${tableName} WHERE ${whereClause}`;const params=whereEntries.map(([,value])=>value);try{const result=await this.query(sql,params);return result.rowCount}catch(error){throw new QueryError("sqlitecloud",sql,error)}}async close(){this.client.close()}}import consola2 from"consola";import chalk from"chalk";import fs from"node:fs/promises";var withTimeout=(promise,timeoutMs=30000)=>{return Promise.race([promise,new Promise((_,reject)=>setTimeout(()=>reject(new Error(`Query timeout after ${timeoutMs}ms`)),timeoutMs))])};var retryQuery=async(queryFn,maxRetries=3,baseDelay=1000)=>{for(let attempt=1;attempt<=maxRetries;attempt++){try{return await queryFn()}catch(error){if(attempt===maxRetries){throw error}const delay=baseDelay*Math.pow(2,attempt-1);consola2.warn(`Query attempt ${attempt} failed, retrying in ${delay}ms...`,error);await new Promise((resolve)=>setTimeout(resolve,delay))}}throw new Error("Max retries exceeded")};var mapDatabaseTypeToTypeScript=(dataType,isNullable=false,driverType="postgres")=>{const nullable=isNullable?" | null":"";const lowerType=dataType.toLowerCase();switch(lowerType){case"uuid":{return`string${nullable}`}case"character varying":case"varchar":case"text":case"char":case"character":case"longtext":case"mediumtext":case"tinytext":{return`string${nullable}`}case"integer":case"int":case"int4":case"smallint":case"int2":case"bigint":case"int8":case"serial":case"bigserial":case"numeric":case"decimal":case"real":case"float4":case"double precision":case"float8":case"tinyint":case"mediumint":case"float":case"double":{return`number${nullable}`}case"boolean":case"bool":case"bit":{return`boolean${nullable}`}case"timestamp":case"timestamp with time zone":case"timestamp without time zone":case"timestamptz":case"date":case"time":case"time with time zone":case"time without time zone":case"timetz":case"interval":case"datetime":case"year":{return`Date${nullable}`}case"json":case"jsonb":{return`any${nullable}`}case"array":{return`any[]${nullable}`}case"bytea":case"binary":case"varbinary":case"blob":case"longblob":case"mediumblob":case"tinyblob":{return`Buffer${nullable}`}case"enum":case"set":{return`string${nullable}`}default:{consola2.warn(`Unknown ${driverType} type: ${dataType}, defaulting to 'any'`);return`any${nullable}`}}};var getDriverType=(driver)=>{if(driver instanceof PostgresDriver)return"postgres";if(driver instanceof LibSQLDriver)return"libsql";if(driver instanceof MySQLDriver)return"mysql";if(driver instanceof NeonDriver)return"neon";if(driver instanceof SqliteCloudDriver)return"sqlitecloud";return`${driver.constructor.name||"unknown driver"}`};var inspectDB=async(options)=>{consola2.warn("inspectDB is experimental and may make mistakes when inspecting your database. However it will not destroy your database.");const{driver,outputFile="db-types.ts"}=options;const driverType=getDriverType(driver);consola2.start(`Inspecting database using ${driverType} driver`);const client=new SQLClient({driver});let generatedTypes="";try{let tablesQuery;let tableSchemaFilter;if(driverType==="mysql"){const dbResult=await withTimeout(retryQuery(()=>client.query("SELECT DATABASE() as `database`",[])),1e4);const currentDatabase=dbResult.rows[0]?.database;if(!currentDatabase){throw new Error("Could not determine current MySQL database name")}consola2.success(`Using MySQL database: ${currentDatabase}`);tablesQuery=`SELECT TABLE_NAME as table_name
-                   FROM information_schema.tables
-                   WHERE TABLE_SCHEMA = ?
-                   AND TABLE_TYPE = 'BASE TABLE'
-                   ORDER BY TABLE_NAME`;tableSchemaFilter=currentDatabase}else if(driverType==="postgres"||driverType==="neon"){tablesQuery=`SELECT table_name
-                   FROM information_schema.tables
-                   WHERE table_schema = $1
-                   AND table_type = 'BASE TABLE'
-                   ORDER BY table_name`;tableSchemaFilter="public"}else if(driverType==="libsql"||driverType==="sqlite"||driverType==="sqlitecloud"){tablesQuery=`SELECT name as table_name
-                   FROM sqlite_master
-                   WHERE type = 'table'
-                   ORDER BY name`;tableSchemaFilter=undefined}else{throw new Error(`Unsupported driver type: ${driverType}`)}const tables=await withTimeout(retryQuery(()=>client.query(tablesQuery,tableSchemaFilter?[tableSchemaFilter]:[])),30000);consola2.info("Tables in the database:",tables.rows.map((t)=>t.table_name).join(", "));let processedTables=0;const totalTables=tables.rows.length;for(const table of tables.rows){const tableName=table.table_name;if(tableName.startsWith("sqlite_sequence")||tableName.startsWith("_prisma_migrations")){continue}processedTables++;consola2.info(`[${processedTables}/${totalTables}] Inspecting table: ${tableName}`);try{let columnsQuery;let queryParams;if(driverType==="mysql"){columnsQuery=`
-          SELECT
-            COLUMN_NAME as column_name,
-            DATA_TYPE as data_type,
-            IS_NULLABLE as is_nullable,
-            COLUMN_DEFAULT as column_default
-          FROM information_schema.columns
-          WHERE TABLE_NAME = ?
-          AND TABLE_SCHEMA = ?
-          ORDER BY ORDINAL_POSITION
-        `;queryParams=[tableName,tableSchemaFilter]}else if(driverType==="postgres"||driverType==="neon"){columnsQuery=`
-          SELECT
-            column_name,
-            data_type,
-            is_nullable,
-            column_default
-          FROM information_schema.columns
-          WHERE table_name = $1
-          AND table_schema = $2
-          ORDER BY ordinal_position
-        `;queryParams=[tableName,tableSchemaFilter]}else{columnsQuery=`
-          SELECT
-            name as column_name,
-            type as data_type,
-            CASE WHEN "notnull" = 0 THEN 'YES' ELSE 'NO' END as is_nullable,
-            dflt_value as column_default
-          FROM pragma_table_info(?)
-          ORDER BY cid
-        `;queryParams=[tableName]}const columns=await withTimeout(retryQuery(()=>client.query(columnsQuery,queryParams)),15000);if(columns.rows.length===0){consola2.info(`No columns found for table: ${tableName}`);continue}consola2.info(`Columns in '${tableName}'`);columns.rows.forEach((c)=>{const typeDisplay=c.data_type+(c.is_nullable==="YES"?" (nullable)":"");consola2.info(`  > ${chalk.bold.yellow(typeDisplay)} > ${c.column_name}`)});const uniqueColumns=new Map;columns.rows.forEach((col)=>{if(!uniqueColumns.has(col.column_name)){uniqueColumns.set(col.column_name,col)}});generatedTypes+=`export interface ${tableName.charAt(0).toUpperCase()+tableName.slice(1)} {
-`;for(const col of uniqueColumns.values()){const tsType=mapDatabaseTypeToTypeScript(col.data_type,col.is_nullable==="YES",driverType);generatedTypes+=`  ${col.column_name}: ${tsType};
-`}generatedTypes+=`}
-
-`}catch(error){consola2.error(`Failed to process table ${tableName}:`,error);consola2.info(`Skipping table ${tableName} and continuing...`);continue}}generatedTypes+=`export interface Database {
-`;for(const table of tables.rows){if(table.table_name.startsWith("sqlite_sequence")||table.table_name.startsWith("_prisma_migrations")){continue}const interfaceName=table.table_name.charAt(0).toUpperCase()+table.table_name.slice(1);generatedTypes+=`  ${table.table_name}: ${interfaceName};
-`}generatedTypes+=`}
-
-`;await fs.writeFile(outputFile,generatedTypes,"utf8");consola2.success(`TypeScript types written to ${outputFile}`);consola2.success(`Successfully processed ${processedTables} tables`)}catch(error){consola2.error("Fatal error during database inspection:",error);throw error}finally{await client.close().catch((error)=>consola2.error("Error closing client:",error))}};import Surreal from"surrealdb";import consola3 from"consola";class SurrealDriver{client;constructor(config){consola3.warn("SurrealDriver is very experimental and not all functions from the sdk are supported. It is only used for testing purposes.");this.client=new Surreal;this.client.connect(config.url,{namespace:config.namespace,database:config.database,auth:config.auth})}async query(sql,params){try{if(params)throw new QueryError("surreal",sql,new Error("SurrealDB does need params"));const dbResult=await this.client.query(sql);return{rows:dbResult,rowCount:dbResult.length}}catch(error){throw new QueryError("surreal",sql,error)}}async close(){await this.client.close()}}class SQLClient{primaryDriver;fallbackDrivers;constructor(options){this.primaryDriver=options.driver;this.fallbackDrivers=options.fallbackDrivers||[]}async query(sql,params){const drivers=[this.primaryDriver,...this.fallbackDrivers];let lastError;for(const driver of drivers){try{return await driver.query(sql,params)}catch(error){lastError=error;consola4.warn(`Query failed with ${driver.constructor.name}:`,error);continue}}throw lastError||new DatabaseError("All drivers failed to execute query","unknown")}async transaction(callback){if(!hasTransactionSupport(this.primaryDriver)){throw new DatabaseError("Primary driver does not support transactions",this.primaryDriver.constructor.name)}return await this.primaryDriver.transaction(async(transactionDriver)=>{const transactionClient=new SQLClient({driver:transactionDriver,fallbackDrivers:[]});return await callback(transactionClient)})}async prepare(sql){if(!hasPreparedStatementSupport(this.primaryDriver)){throw new DatabaseError("Primary driver does not support prepared statements",this.primaryDriver.constructor.name)}return await this.primaryDriver.prepare(sql)}async findFirst(table,where){if(!this.primaryDriver.findFirst)throw new DatabaseError("Primary driver does not support findFirst",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.findFirst(table,where);return response.rows[0]||null}catch(error){throw new QueryError("findFirst",`Error finding first in ${String(table)}`,error)}}async findMany(table,options){if(!this.primaryDriver.findMany)throw new DatabaseError("Primary driver does not support findMany",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.findMany(table,options);return response.rows}catch(error){throw new QueryError("findMany",`Error finding many in ${String(table)}`,error)}}async insert(table,data){if(!this.primaryDriver.insert)throw new DatabaseError("Primary driver does not support insert",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.insert(table,data);return response.rows[0]}catch(error){throw new QueryError("insert",`Error inserting into ${String(table)}`,error)}}async update(table,data,where){if(!this.primaryDriver.update)throw new DatabaseError("Primary driver does not support update",this.primaryDriver.constructor.name);try{const response=await this.primaryDriver.update(table,data,where);return response.rows[0]||null}catch(error){throw new QueryError("update",`Error updating ${String(table)}`,error)}}async delete(table,where){if(!this.primaryDriver.delete)throw new DatabaseError("Primary driver does not support delete",this.primaryDriver.constructor.name);try{const affectedRows=await this.primaryDriver.delete(table,where);return affectedRows}catch(error){throw new QueryError("delete",`Error deleting from ${String(table)}`,error)}}getDriver(){return this.primaryDriver}supportsTransactions(){return hasTransactionSupport(this.primaryDriver)}supportsPreparedStatements(){return hasPreparedStatementSupport(this.primaryDriver)}async close(){const drivers=[this.primaryDriver,...this.fallbackDrivers];await Promise.all(drivers.map((driver)=>driver.close().catch((err)=>consola4.warn(`Error closing ${driver.constructor.name}:`,err))))}}var DriftSQLClient=SQLClient;export{inspectDB,SurrealDriver,SqliteCloudDriver,SQLClient,PostgresDriver,NeonDriver,MySQLDriver,LibSQLDriver,DriftSQLClient};
+import{t as e}from"./postgres-9C7eE0wB.js";import{A as t,C as n,D as r,E as i,F as a,I as o,L as s,M as c,N as l,O as u,P as d,R as f,S as p,T as m,_ as h,a as g,b as _,c as v,d as y,f as b,g as x,h as S,i as C,j as w,k as T,l as E,m as D,n as O,o as k,p as A,r as j,s as M,t as N,u as P,v as F,w as I,x as L,y as R,z}from"./src-B1L6LdRV.js";import{n as B,t as V}from"./type-generator-CpqI7vBb.js";export{D as Column,N as DriftSQLClient,v as MigrationBuilder,M as MigrationRunner,y as MySQLGenerator,f as PostgresDriver,e as PostgresGenerator,O as SQLClient,P as SQLiteGenerator,C as SchemaDiffer,j as SnapshotManager,b as Table,V as TypeGenerator,S as bigint,x as bigserial,h as boolean,F as bytea,R as char,E as createMigration,s as createMySQLHelpers,z as createPostgresHelpers,o as createSQLiteHelpers,A as createTable,_ as date,L as decimal,g as detectChanges,p as doublePrecision,k as generateMigrationFromChanges,B as generateTypesFromSchema,n as integer,I as json,m as jsonb,i as numeric,r as real,u as serial,T as smallint,t as text,w as time,c as timestamp,l as timestamptz,d as uuid,a as varchar};

package/dist/postgres-9C7eE0wB.js

@@ -0,0 +1,5 @@
+var e=Object.defineProperty,t=Object.getOwnPropertyDescriptor,n=Object.getOwnPropertyNames,r=Object.prototype.hasOwnProperty,i=(e,t)=>()=>(e&&(t=e(e=0)),t),a=t=>{let n={};for(var r in t)e(n,r,{get:t[r],enumerable:!0});return n},o=(i,a,o,s)=>{if(a&&typeof a==`object`||typeof a==`function`)for(var c=n(a),l=0,u=c.length,d;l<u;l++)d=c[l],!r.call(i,d)&&d!==o&&e(i,d,{get:(e=>a[e]).bind(null,d),enumerable:!(s=t(a,d))||s.enumerable});return i},s=t=>o(e({},`__esModule`,{value:!0}),t),c=a({PostgresGenerator:()=>l}),l,u=i((()=>{l=class{generateCreateTable(e){let t=[];t.push(`CREATE TABLE "${e.name}" (`);let n=[];for(let t of e.columns)n.push(`  `+this.generateColumnDefinition(t));if(e.primaryKey&&e.primaryKey.length>0){let t=e.primaryKey.map(e=>`"${e}"`).join(`, `);n.push(`  PRIMARY KEY (${t})`)}if(e.checks&&e.checks.length>0)for(let t of e.checks)n.push(`  CONSTRAINT "${t.name}" CHECK (${t.expression})`);t.push(n.join(`,
+`)),t.push(`);`);let r=[t.join(`
+`)];if(e.indexes&&e.indexes.length>0)for(let t of e.indexes)r.push(this.generateIndex(e.name,t));return r.join(`
+
+`)}generateDropTable(e){return`DROP TABLE IF EXISTS "${e}" CASCADE;`}generateColumnDefinition(e){let t=[`"${e.name}"`];if(t.push(this.getColumnType(e)),e.primaryKey&&!e.type.includes(`serial`)&&t.push(`PRIMARY KEY`),e.notNull&&!e.primaryKey&&!e.type.includes(`serial`)&&t.push(`NOT NULL`),e.unique&&t.push(`UNIQUE`),e.default!==void 0&&t.push(`DEFAULT ${this.formatDefault(e.default)}`),e.references){let n=e.references;t.push(`REFERENCES "${n.table}"("${n.column}")`),n.onDelete&&t.push(`ON DELETE ${n.onDelete}`),n.onUpdate&&t.push(`ON UPDATE ${n.onUpdate}`)}return e.check&&t.push(`CHECK (${e.check})`),t.join(` `)}getColumnType(e){let t=e.type.toUpperCase();return e.length?t+=`(${e.length})`:e.precision&&(e.scale===void 0?t+=`(${e.precision})`:t+=`(${e.precision}, ${e.scale})`),t}formatDefault(e){return typeof e==`string`?e.toUpperCase()===`NOW()`||e.toUpperCase()===`CURRENT_TIMESTAMP`?e.toUpperCase():`'${e}'`:typeof e==`boolean`?e?`TRUE`:`FALSE`:String(e)}generateIndex(e,t){let n=t.unique?`UNIQUE `:``,r=t.type?` USING ${t.type.toUpperCase()}`:``,i=t.columns.map(e=>`"${e}"`).join(`, `);return`CREATE ${n}INDEX "${t.name}" ON "${e}"${r} (${i});`}}}));export{a,i,u as n,s as o,c as r,l as t};

package/dist/postgres-DfhzvfQU.js

@@ -0,0 +1 @@
+import{n as e,t}from"./postgres-9C7eE0wB.js";e();export{t as PostgresGenerator};