bun-query-builder 0.1.8 → 0.1.9

package/dist/client.d.ts

@@ -1,141 +1,33 @@
+import { config } from './config';
 import type { DatabaseSchema } from './schema';
 import type { SchemaMeta } from './meta';
-
-declare interface RawExpression {
-  raw: string
-}
-declare function isRawExpression(expr: unknown): expr is RawExpression;
-declare const SQL_PATTERNS: {
-  SELECT_STAR: unknown;
-  SELECT: unknown;
-  SELECT_FROM: unknown;
-  WHERE: unknown;
-  IDENTIFIER: unknown;
-  DELETED_AT: unknown
-};
-declare interface CacheEntry {
-  data: any
-  expiresAt: number
-}
-declare const entry: unknown;
-declare const firstKey: unknown;
-declare const queryCache: unknown;
-export declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not'
-
-export interface WhereRaw {
+export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
+/**
+ * # `clearQueryCache()`
+ *
+ * Clears all cached query results.
+ *
+ * @example
+ * ```ts
+ * clearQueryCache()
+ * ```
+ */
+export declare function clearQueryCache(): void;
+/**
+ * # `setQueryCacheMaxSize(size)`
+ *
+ * Sets the maximum number of cached queries (default 100).
+ *
+ * @example
+ * ```ts
+ * setQueryCacheMaxSize(500)
+ * ```
+ */
+export declare function setQueryCacheMaxSize(size: number): void;
+export declare interface WhereRaw {
   raw: any
 }
-
-export type WhereExpression<TableColumns> =
-  | Partial<{ [K in keyof TableColumns & string]: ValueOrRef | ValueOrRef[] }>
-  | [key: keyof TableColumns & string, op: WhereOperator, value: ValueOrRef | ValueOrRef[]]
-  | WhereRaw
-
-export type QueryResult = any
-
-export type SortDirection = 'asc' | 'desc'
-
-export type ColumnName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = keyof DB[TTable]['columns'] & string
-export type SelectedRow<
-  DB extends DatabaseSchema<any>,
-  _TTable extends keyof DB & string,
-  TSelected,
-> = Readonly<TSelected>
-
-type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string> = TTables extends any
-  ? `${TTables}.${keyof DB[TTables]['columns'] & string}`
-  : never
-
-type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
-  ? `${Capitalize<H>}${SnakeToPascal<T>}`
-  : Capitalize<S>
-
-type _TypedDynamicWhereMethods<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSelected,
-  TJoined extends string,
-  TSql extends string,
-> = {
-  [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (
-    value: DB[TTable]['columns'][K],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>
-} & {
-  [K in keyof DB[TTable]['columns'] & string as `orWhere${SnakeToPascal<K>}`]: (
-    value: DB[TTable]['columns'][K],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} = ?`>
-} & {
-  [K in keyof DB[TTable]['columns'] & string as `andWhere${SnakeToPascal<K>}`]: (
-    value: DB[TTable]['columns'][K],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>
-}
-
-export type TypedSelectQueryBuilder<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSelected,
-  TJoined extends string = TTable,
-  TSql extends string = `SELECT * FROM ${TTable}`,
-> = Omit<
-  BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined>,
-  'toSQL' | 'where' | 'andWhere' | 'orWhere' | 'orderBy' | 'limit'
-> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>
-& _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
-& {
-  toSQL: () => TSql
-  where: (<K extends keyof DB[TTable]['columns'] & string>(
-    expr: Record<K, DB[TTable]['columns'][K]>,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
-    expr: WhereExpression<DB[TTable]['columns']> | string,
-    op?: WhereOperator,
-    value?: any,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${string}`>)
-  andWhere: (<K extends keyof DB[TTable]['columns'] & string>(
-    expr: Record<K, DB[TTable]['columns'][K]>,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
-    expr: WhereExpression<DB[TTable]['columns']> | string,
-    op?: WhereOperator,
-    value?: any,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${string}`>)
-  orWhere: (<K extends keyof DB[TTable]['columns'] & string>(
-    expr: Record<K, DB[TTable]['columns'][K]>,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
-    expr: [K, OP, any],
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
-    expr: WhereExpression<DB[TTable]['columns']> | string,
-    op?: WhereOperator,
-    value?: any,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${string}`>)
-  orderBy: <C extends keyof DB[TTable]['columns'] & string, D extends 'asc' | 'desc' = 'asc'>(
-    column: C,
-    direction?: D,
-  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} ORDER BY ${C} ${D}`>
-  limit: <N extends number>(n: N) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} LIMIT ${N}`>
-}
-
-type DynamicWhereMethods<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSelected,
-  TJoined extends string = TTable,
-> = {
-  [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-} & {
-  [K in keyof DB[TTable]['columns'] & string as `orWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-} & {
-  [K in keyof DB[TTable]['columns'] & string as `andWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-}
-
-export interface BaseSelectQueryBuilder<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSelected,
-  TJoined extends string = TTable,
-> {
+export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable> {
   distinct: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   distinctOn: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   selectRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -233,7 +125,29 @@ export interface BaseSelectQueryBuilder<
   withRecursive: (name: string, sub: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   value: <K extends keyof TSelected & string>(column: K) => Promise<SelectedRow<DB, TTable, TSelected>[K]>
   pluck: {
+    /**
+     * # `pluck(column)`
+     *
+     * Returns an array of values for a single column.
+     *
+     * @example
+     * ```ts
+     * const names = await db.selectFrom('users').pluck('name')
+     * const ids = await db.selectFrom('users').orderBy('id').pluck('id')
+     * ```
+     */
     <K extends keyof TSelected & string>(column: K): Promise<SelectedRow<DB, TTable, TSelected>[K][]>
+    /**
+     * # `pluck(column, key)`
+     *
+     * Returns an object keyed by the given key column.
+     *
+     * @example
+     * ```ts
+     * const byId = await db.selectFrom('users').pluck('email', 'id')
+     * const map = await db.selectFrom('users').pluck('name', 'email')
+     * ```
+     */
     <K extends keyof TSelected & string, K2 extends keyof TSelected & string>(column: K, key: K2): Promise<Record<string, SelectedRow<DB, TTable, TSelected>[K]>>
   }
   exists: () => Promise<boolean>
@@ -268,8 +182,8 @@ export interface BaseSelectQueryBuilder<
   sum: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
   max: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
   min: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
-  readonly rows: TSelected[]
-  readonly row: TSelected
+  rows: TSelected[]
+  row: TSelected
   values: () => Promise<any[][]>
   toParams?: () => any[]
   raw: () => Promise<any[][]>
@@ -283,22 +197,13 @@ export interface BaseSelectQueryBuilder<
   denseRank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   rank?: (alias?: string, partitionBy?: string | string[], orderBy?: [string, 'asc' | 'desc'][]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
 }
-
-export type SelectQueryBuilder<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSelected,
-  TJoined extends string = TTable,
-> = BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>
-
-export interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
   values: (data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => InsertQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
   toSQL: () => string
   execute: () => Promise<number | DB[TTable]['columns'] | DB[TTable]['columns'][]>
 }
-
-export interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
   set: (values: Partial<DB[TTable]['columns']>) => UpdateQueryBuilder<DB, TTable>
   where: (expr: WhereExpression<DB[TTable]['columns']>) => UpdateQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
@@ -306,23 +211,20 @@ export interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
   execute: () => Promise<number>
   executeTakeFirst?: () => Promise<{ numUpdatedRows?: number }>
 }
-
-export interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
   where: (expr: WhereExpression<DB[TTable]['columns']>) => DeleteQueryBuilder<DB, TTable>
   returning: <K extends keyof DB[TTable]['columns'] & string>(...cols: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
   toSQL: () => string
   execute: () => Promise<number>
   executeTakeFirst?: () => Promise<{ numDeletedRows?: number }>
 }
-
-export interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
   insert: (data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[]) => InsertQueryBuilder<DB, TTable>
   update: (values: Partial<DB[TTable]['columns']>) => UpdateQueryBuilder<DB, TTable>
   delete: () => DeleteQueryBuilder<DB, TTable>
   select: (...columns: (keyof DB[TTable]['columns'] & string)[]) => SelectQueryBuilder<DB, TTable, any>
 }
-
-export interface QueryBuilder<DB extends DatabaseSchema<any>> {
+export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   select: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
     table: TTable,
     ...columns: (K | `${string} as ${string}`)[]
@@ -364,85 +266,69 @@ export interface QueryBuilder<DB extends DatabaseSchema<any>> {
   insertGetId: <TTable extends keyof DB & string>(table: TTable, values: Partial<DB[TTable]['columns']>, idColumn?: keyof DB[TTable]['columns'] & string) => Promise<any>
   updateOrInsert: <TTable extends keyof DB & string>(table: TTable, match: Partial<DB[TTable]['columns']>, values: Partial<DB[TTable]['columns']>) => Promise<boolean>
   upsert: <TTable extends keyof DB & string>(table: TTable, rows: Partial<DB[TTable]['columns']>[], conflictColumns: (keyof DB[TTable]['columns'] & string)[], mergeColumns?: (keyof DB[TTable]['columns'] & string)[]) => Promise<any>
-
   create: <TTable extends keyof DB & string>(
     table: TTable,
     values: Partial<DB[TTable]['columns']>,
   ) => Promise<DB[TTable]['columns']>
-
   createMany: <TTable extends keyof DB & string>(
     table: TTable,
     rows: Partial<DB[TTable]['columns']>[],
   ) => Promise<void>
-
   insertMany: <TTable extends keyof DB & string>(
     table: TTable,
     rows: Partial<DB[TTable]['columns']>[],
   ) => Promise<void>
-
   updateMany: <TTable extends keyof DB & string>(
     table: TTable,
     conditions: WhereExpression<DB[TTable]['columns']>,
     data: Partial<DB[TTable]['columns']>,
   ) => Promise<number>
-
   deleteMany: <TTable extends keyof DB & string>(
     table: TTable,
     ids: any[],
   ) => Promise<number>
-
   firstOrCreate: <TTable extends keyof DB & string>(
     table: TTable,
     match: Partial<DB[TTable]['columns']>,
     defaults?: Partial<DB[TTable]['columns']>,
   ) => Promise<DB[TTable]['columns']>
-
   updateOrCreate: <TTable extends keyof DB & string>(
     table: TTable,
     match: Partial<DB[TTable]['columns']>,
     values: Partial<DB[TTable]['columns']>,
   ) => Promise<DB[TTable]['columns']>
-
   save: <TTable extends keyof DB & string>(
     table: TTable,
     values: Partial<DB[TTable]['columns']>,
   ) => Promise<DB[TTable]['columns']>
-
   remove: <TTable extends keyof DB & string>(
     table: TTable,
     id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
   ) => Promise<any>
-
   find: <TTable extends keyof DB & string>(
     table: TTable,
     id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
   ) => Promise<DB[TTable]['columns'] | undefined>
-
   findOrFail: <TTable extends keyof DB & string>(
     table: TTable,
     id: DB[TTable]['columns'][DB[TTable]['primaryKey'] & keyof DB[TTable]['columns']] | any,
   ) => Promise<DB[TTable]['columns']>
-
   findMany: <TTable extends keyof DB & string>(
     table: TTable,
     ids: any[],
   ) => Promise<DB[TTable]['columns'][]>
-
   latest: <TTable extends keyof DB & string>(
     table: TTable,
     column?: keyof DB[TTable]['columns'] & string,
   ) => Promise<DB[TTable]['columns'] | undefined>
-
   oldest: <TTable extends keyof DB & string>(
     table: TTable,
     column?: keyof DB[TTable]['columns'] & string,
   ) => Promise<DB[TTable]['columns'] | undefined>
-
   skip: <TTable extends keyof DB & string>(
     table: TTable,
     count: number,
   ) => SelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TTable>
-
   rawQuery: (query: string) => Promise<any>
   id?: (name: string) => any
   ids?: (...names: string[]) => any
@@ -453,12 +339,131 @@ export interface QueryBuilder<DB extends DatabaseSchema<any>> {
   getRelationshipType?: (table: string, relationName: string) => string | null
   getRelationshipTarget?: (table: string, relationName: string) => string | null
 }
-
-export type TypedInsertQueryBuilder<
-  DB extends DatabaseSchema<any>,
-  TTable extends keyof DB & string,
-  TSql extends string = `INSERT INTO ${TTable}`,
-> = Omit<InsertQueryBuilder<DB, TTable>, 'toSQL' | 'values' | 'returning'> & {
+declare interface InternalState {
+  sql: any
+  meta?: SchemaMeta
+  schema?: any
+  txDefaults?: TransactionOptions
+}
+export declare interface TransactionOptions {
+  retries?: number
+  isolation?: TransactionIsolation
+  onRetry?: (attempt: number, error: any) => void
+  afterCommit?: () => void
+  sqlStates?: string[]
+  backoff?: TxBackoff
+  logger?: (event: TxLoggerEvent) => void
+  readOnly?: boolean
+  onRollback?: (error: any) => void
+  afterRollback?: () => void
+}
+declare interface TxBackoff {
+  baseMs?: number
+  maxMs?: number
+  factor?: number
+  jitter?: boolean
+}
+declare interface TxLoggerEvent {
+  type: 'start' | 'retry' | 'commit' | 'rollback' | 'error'
+  attempt: number
+  error?: any
+  durationMs?: number
+}
+// Where condition helpers
+declare type Primitive = string | number | boolean | bigint | Date | null | undefined
+declare type ValueOrRef = Primitive
+export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not'
+export type WhereExpression<TableColumns> = | Partial<{ [K in keyof TableColumns & string]: ValueOrRef | ValueOrRef[] }>
+  | [key: keyof TableColumns & string, op: WhereOperator, value: ValueOrRef | ValueOrRef[]]
+  | WhereRaw
+export type QueryResult = any
+/**
+ * # `SortDirection`
+ *
+ * The direction used when ordering query results.
+ */
+export type SortDirection = 'asc' | 'desc'
+/**
+ * # `ColumnName<DB, TTable>`
+ *
+ * Helper type extracting a string union of column names for a given table.
+ */
+export type ColumnName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = keyof DB[TTable]['columns'] & string
+// Named row alias to improve IDE hover readability
+export type SelectedRow<DB extends DatabaseSchema<any>, _TTable extends keyof DB & string, TSelected> = Readonly<TSelected>
+declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string> = TTables extends any
+  ? `${TTables}.${keyof DB[TTables]['columns'] & string}`
+  : never
+// Convert snake_case to PascalCase at the type level (e.g. created_at -> CreatedAt)
+declare type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
+  ? `${Capitalize<H>}${SnakeToPascal<T>}`
+  : Capitalize<S>
+// Typed SQL builder (type-level only). We piggy-back on the runtime builder but
+// thread a phantom TSql string through method signatures so hovers can show the
+// composed SQL at compile-time for common operations.
+declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string, TSql extends string> = {
+  [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (
+    value: DB[TTable]['columns'][K],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>
+} & {
+  [K in keyof DB[TTable]['columns'] & string as `orWhere${SnakeToPascal<K>}`]: (
+    value: DB[TTable]['columns'][K],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} = ?`>
+} & {
+  [K in keyof DB[TTable]['columns'] & string as `andWhere${SnakeToPascal<K>}`]: (
+    value: DB[TTable]['columns'][K],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>
+}
+export type TypedSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable, TSql extends string = `SELECT * FROM ${TTable}`> = Omit<
+  BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined>,
+  'toSQL' | 'where' | 'andWhere' | 'orWhere' | 'orderBy' | 'limit'
+> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>
+& _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
+& {
+  toSQL: () => TSql
+  where: (<K extends keyof DB[TTable]['columns'] & string>(
+    expr: Record<K, DB[TTable]['columns'][K]>,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
+    expr: [K, OP, any],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
+    expr: WhereExpression<DB[TTable]['columns']> | string,
+    op?: WhereOperator,
+    value?: any,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} WHERE ${string}`>)
+  andWhere: (<K extends keyof DB[TTable]['columns'] & string>(
+    expr: Record<K, DB[TTable]['columns'][K]>,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
+    expr: [K, OP, any],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
+    expr: WhereExpression<DB[TTable]['columns']> | string,
+    op?: WhereOperator,
+    value?: any,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${string}`>)
+  orWhere: (<K extends keyof DB[TTable]['columns'] & string>(
+    expr: Record<K, DB[TTable]['columns'][K]>,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} = ?`>) & (<K extends keyof DB[TTable]['columns'] & string, OP extends WhereOperator>(
+    expr: [K, OP, any],
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${K} ${Uppercase<OP>} ${OP extends 'in' | 'not in' ? '(?)' : '?'}`>) & ((
+    expr: WhereExpression<DB[TTable]['columns']> | string,
+    op?: WhereOperator,
+    value?: any,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} OR ${string}`>)
+  orderBy: <C extends keyof DB[TTable]['columns'] & string, D extends 'asc' | 'desc' = 'asc'>(
+    column: C,
+    direction?: D,
+  ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} ORDER BY ${C} ${D}`>
+  limit: <N extends number>(n: N) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} LIMIT ${N}`>
+}
+declare type DynamicWhereMethods<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable> = {
+  [K in keyof DB[TTable]['columns'] & string as `where${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+} & {
+  [K in keyof DB[TTable]['columns'] & string as `orWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+} & {
+  [K in keyof DB[TTable]['columns'] & string as `andWhere${SnakeToPascal<K>}`]: (value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+}
+export type SelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable> = BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>
+// Typed INSERT builder to expose a structured SQL literal in hovers
+export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSql extends string = `INSERT INTO ${TTable}`> = Omit<InsertQueryBuilder<DB, TTable>, 'toSQL' | 'values' | 'returning'> & {
   toSQL: () => TSql
   values: (
     data: Partial<DB[TTable]['columns']> | Partial<DB[TTable]['columns']>[],
@@ -473,27 +478,12 @@ export type TypedInsertQueryBuilder<
     `${TSql} RETURNING ${string}`
   >
 }
-
-interface InternalState {
-  sql: any
-  meta?: SchemaMeta
-  schema?: any
-  txDefaults?: TransactionOptions
-}
-declare function isRetriableTxError(err: any): boolean;
-declare function matchesSqlState(err: any, states?: string[]): boolean;
-declare function sleep(ms: number): Promise<void>;
-declare function computeBackoffMs(attempt: number, cfg?: TxBackoff): number;
-export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
-declare function applyCondition(expr: WhereExpression<any>): any;
-declare function applyWhere(columns: Record<string, unknown>, q: any, expr?: WhereExpression<any>): void;
-declare function computeSqlText(q: any): string;
-declare function runWithHooks<T = any>(q: any, kind: 'select' | 'insert' | 'update' | 'delete' | 'raw', opts?: { signal?: AbortSignal, timeoutMs?: number }): Promise<T>;
-declare function makeExecutableQuery(q: any, text?: string): void;
-declare function makeSelect<TTable extends keyof DB & string>(table: TTable): TypedSelectQueryBuilder<DB, TTable, any, TTable, `SELECT * FROM $;
-declare function makeSelect<TTable extends keyof DB & string>(table: TTable, columns: string[]): TypedSelectQueryBuilder<DB, TTable, any, TTable, `SELECT $;
-declare function makeSelect<TTable extends keyof DB & string>(table: TTable, columns?: string[]): any;
-declare function createSubQueryBuilder(newQ: any): void;
-declare function applyWhereCondition(query: any, expr: any, op?: WhereOperator, value?: any, prefix?: 'WHERE' | 'AND' | 'OR'): void;
-export declare function clearQueryCache(): void;
-export declare function setQueryCacheMaxSize(size: number): void;
+declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable'
+declare class QueryCache {
+  private cache: any;
+  private maxSize: any;
+  get(key: string): any | null;
+  set(key: string, data: any, ttlMs: number): void;
+  clear(): void;
+  setMaxSize(size: number): void;
+}

package/dist/config.d.ts

@@ -1,4 +1,3 @@
-import type { QueryBuilderConfig } from './types';
-
 export declare const defaultConfig: QueryBuilderConfig;
+// eslint-disable-next-line antfu/no-top-level-await
 export declare const config: QueryBuilderConfig;

package/dist/db.d.ts

@@ -1,10 +1,11 @@
-import type { DatabaseConfig, SupportedDialect } from './types';
 import { SQL } from 'bun';
-
-declare function createConnectionString(dialect: SupportedDialect, dbConfig: DatabaseConfig): string;
+/**
+ * Returns a Bun SQL instance configured for the current dialect and database settings.
+ * Handles connection errors gracefully by falling back to in-memory SQLite.
+ */
 export declare function getBunSql(): SQL;
-export declare function getOrCreateBunSql(forceNew?: boolean): SQL;
-export declare function withFreshConnection<T>(fn?: (sql): Promise<T>;
-export declare const bunSql: (...args: any[]) => unknown;
-
-export { SQL } from 'bun'
+export declare function getOrCreateBunSql(forceNew?: any): SQL;
+// Wrapper that catches "Connection closed" errors and retries with a fresh connection
+export declare function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T>;
+export declare const bunSql: unknown;
+export { SQL } from 'bun';

package/dist/drivers/index.d.ts

@@ -1,12 +1,10 @@
-import type { DialectDriver } from './postgres';
-import type { SupportedDialect } from '../types';
 import { MySQLDriver } from './mysql';
 import { PostgresDriver } from './postgres';
 import { SQLiteDriver } from './sqlite';
-
-export type { DialectDriver } from './postgres'
+import type { DialectDriver } from './postgres';
+import type { SupportedDialect } from '../types';
+export type { DialectDriver } from './postgres';
 export declare function getDialectDriver(dialect: SupportedDialect): DialectDriver;
-
-export { MySQLDriver } from './mysql'
-export { PostgresDriver } from './postgres'
-export { SQLiteDriver } from './sqlite'
+export { MySQLDriver } from './mysql';
+export { PostgresDriver } from './postgres';
+export { SQLiteDriver } from './sqlite';