driftsql 1.0.32 → 2.0.0-beta.2

package/dist/index.d.ts

@@ -1,37 +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 { BunDriver } from './drivers/bun';
-export { PoubelleDriver } from './drivers/poubelle/poubelle';
-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 };