bun-query-builder 0.1.5 → 0.1.7

package/dist/client.d.ts

@@ -1,33 +1,141 @@
-import { config } from './config';
 import type { DatabaseSchema } from './schema';
 import type { SchemaMeta } from './meta';
-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 {
+
+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 {
   raw: any
 }
-export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable> {
+
+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,
+> {
   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>
@@ -125,29 +233,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   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>
@@ -182,8 +268,8 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   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>
-  rows: TSelected[]
-  row: TSelected
+  readonly rows: TSelected[]
+  readonly row: TSelected
   values: () => Promise<any[][]>
   toParams?: () => any[]
   raw: () => Promise<any[][]>
@@ -197,13 +283,22 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   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 declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+
+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> {
   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 declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+
+export 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>>
@@ -211,20 +306,23 @@ export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTab
   execute: () => Promise<number>
   executeTakeFirst?: () => Promise<{ numUpdatedRows?: number }>
 }
-export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+
+export 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 declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+
+export 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 declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
+
+export 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}`)[]
@@ -266,69 +364,85 @@ export declare 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
@@ -339,131 +453,12 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   getRelationshipType?: (table: string, relationName: string) => string | null
   getRelationshipTarget?: (table: string, relationName: string) => string | null
 }
-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'> & {
+
+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']>[],
@@ -478,12 +473,27 @@ export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
     `${TSql} RETURNING ${string}`
   >
 }
-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;
-}
+
+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;

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+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,11 +1,10 @@
+import type { DatabaseConfig, SupportedDialect } from './types';
 import { SQL } from 'bun';
-/**
- * Returns a Bun SQL instance configured for the current dialect and database settings.
- * Handles connection errors gracefully by falling back to in-memory SQLite.
- */
+
+declare function createConnectionString(dialect: SupportedDialect, dbConfig: DatabaseConfig): string;
 export declare function getBunSql(): SQL;
-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';
+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'

package/dist/drivers/index.d.ts

@@ -1,10 +1,12 @@
+import type { DialectDriver } from './postgres';
+import type { SupportedDialect } from '../types';
 import { MySQLDriver } from './mysql';
 import { PostgresDriver } from './postgres';
 import { SQLiteDriver } from './sqlite';
-import type { DialectDriver } from './postgres';
-import type { SupportedDialect } from '../types';
-export type { DialectDriver } from './postgres';
+
+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'