bun-query-builder 0.1.12 → 0.1.15

package/dist/browser.d.ts

@@ -1,5 +1,6 @@
 import type { BrowserConfig } from './types';
 import type { Faker } from 'ts-mocker';
+// Export types for external use
 export type { BrowserModelInstance, BrowserModelQueryBuilder };
 /**
  * Configure the browser query client
@@ -55,28 +56,38 @@ export declare function createBrowserDb<Tables extends Record<string, any>>(): {
 export declare function createBrowserModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
 /**
  * Auth helpers for browser
+ * @defaultValue
+ * ```ts
+ * {
+ *   async login: (credentials: { email: string, password: string }) => unknown,
+ *   async register: (data: { name: string, email: string, password: string }) => unknown,
+ *   async logout: () => unknown,
+ *   async user: () => unknown,
+ *   async check: () => unknown
+ * }
+ * ```
  */
 export declare const browserAuth: {
   /**
    * Login and store token
    */
-  async login(credentials: { email: string, password: string }): () => unknown;
+  async login: (credentials: { email: string, password: string }) => unknown;
   /**
    * Register a new user
    */
-  async register(data: { name: string, email: string, password: string }): () => unknown;
+  async register: (data: { name: string, email: string, password: string }) => unknown;
   /**
    * Logout and clear token
    */
-  async logout(): unknown;
+  async logout: () => unknown;
   /**
    * Get current authenticated user
    */
-  async user(): unknown;
+  async user: () => unknown;
   /**
    * Check if user is authenticated
    */
-  async check(): unknown;
+  async check: () => unknown;
   /**
    * Get the current token
    */
@@ -100,22 +111,54 @@ export declare interface BrowserTypedAttribute<T = unknown> {
 }
 // Base model definition for browser
 export declare interface BrowserModelDefinition {
-  name: string
-  table: string
-  primaryKey?: string
-  traits?: {
+  readonly name: string
+  readonly table: string
+  readonly primaryKey?: string
+  readonly traits?: {
     readonly useUuid?: boolean
-    readonly useTimestamps?: boolean
-    readonly useSoftDeletes?: boolean
-    readonly useApi?: {
-      readonly uri: string
+    readonly useTimestamps?: boolean | object
+    readonly timestampable?: boolean | object
+    readonly useSoftDeletes?: boolean | object
+    readonly softDeletable?: boolean | object
+    readonly useApi?: boolean | {
+      readonly uri?: string
       readonly routes?: readonly string[]
+      readonly middleware?: readonly string[]
     }
+    readonly useAuth?: boolean | object
+    readonly billable?: boolean | object
+    readonly useSearch?: boolean | object
+    readonly useSeeder?: boolean | object
+    readonly seedable?: boolean | object
+    readonly authenticatable?: boolean | object
+    readonly observe?: boolean | readonly string[]
+    readonly likeable?: boolean | object
+    readonly taggable?: boolean
+    readonly categorizable?: boolean
+    readonly commentables?: boolean
+    readonly useActivityLog?: boolean | object
+    readonly useSocials?: readonly string[]
   }
-  attributes: {
+  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly hasMany?: readonly string[] | Readonly<Record<string, string>>
+  readonly hasOne?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsToMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly hasOneThrough?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly hasManyThrough?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly attributes: {
     readonly [key: string]: BrowserTypedAttribute<unknown>
   }
 }
+declare interface WhereClause {
+  column: string
+  operator: WhereOperator
+  value: unknown
+  boolean: 'and' | 'or'
+}
+declare interface OrderByClause {
+  column: string
+  direction: 'asc' | 'desc'
+}
 declare interface QueryState {
   table: string
   wheres: WhereClause[]
@@ -137,13 +180,13 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
-  unknown
+  unknown;
 // Extract attribute keys from definition
-declare type BrowserAttributeKeys<TDef extends BrowserModelDefinition> = keyof TDef['attributes'] & string
+declare type BrowserAttributeKeys<TDef extends BrowserModelDefinition> = keyof TDef['attributes'] & string;
 // Infer single attribute type
 declare type InferBrowserAttributeType<TAttr> = TAttr extends { type: infer T } ? InferType<T> :
   TAttr extends { factory: (faker: unknown) => infer R } ? R :
-  unknown
+  unknown;
 // Build the full attributes type from definition
 declare type InferBrowserModelAttributes<TDef extends BrowserModelDefinition> = {
   [K in BrowserAttributeKeys<TDef>]: InferBrowserAttributeType<TDef['attributes'][K]>
@@ -151,26 +194,69 @@ declare type InferBrowserModelAttributes<TDef extends BrowserModelDefinition> =
 // System fields added by traits
 declare type BrowserSystemFields<TDef extends BrowserModelDefinition> = { id: number } &
   (TDef['traits'] extends { useUuid: true } ? { uuid: string } : {}) &
-  (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string } : {}) &
-  (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
+  (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string | null } : {}) &
+  (TDef['traits'] extends { timestampable: true | object } ? { created_at: string; updated_at: string | null } : {}) &
+  (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {}) &
+  (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {}) &
+  (TDef['traits'] extends { useAuth: true | object } ? { two_factor_secret: string | null; public_key: string | null } : {}) &
+  (TDef['traits'] extends { billable: true | object } ? { stripe_id: string | null } : {});
 // Complete model type
-declare type BrowserModelAttributes<TDef extends BrowserModelDefinition> = InferBrowserModelAttributes<TDef> & BrowserSystemFields<TDef>
+declare type BrowserModelAttributes<TDef extends BrowserModelDefinition> = InferBrowserModelAttributes<TDef> & BrowserSystemFields<TDef>;
 // All valid column names
 declare type BrowserColumnName<TDef extends BrowserModelDefinition> = | BrowserAttributeKeys<TDef>
   | 'id'
   | (TDef['traits'] extends { useUuid: true } ? 'uuid' : never)
   | (TDef['traits'] extends { useTimestamps: true } ? 'created_at' | 'updated_at' : never)
+  | (TDef['traits'] extends { timestampable: true | object } ? 'created_at' | 'updated_at' : never)
   | (TDef['traits'] extends { useSoftDeletes: true } ? 'deleted_at' : never)
+  | (TDef['traits'] extends { softDeletable: true | object } ? 'deleted_at' : never)
+  | (TDef['traits'] extends { useAuth: true | object } ? 'two_factor_secret' | 'public_key' : never)
+  | (TDef['traits'] extends { billable: true | object } ? 'stripe_id' : never);
 // Hidden fields
 declare type BrowserHiddenKeys<TDef extends BrowserModelDefinition> = {
   [K in BrowserAttributeKeys<TDef>]: TDef['attributes'][K] extends { hidden: true } ? K : never
-}[BrowserAttributeKeys<TDef>]
+}[BrowserAttributeKeys<TDef>];
 // Fillable fields
 declare type BrowserFillableKeys<TDef extends BrowserModelDefinition> = {
   [K in BrowserAttributeKeys<TDef>]: TDef['attributes'][K] extends { fillable: true } ? K : never
-}[BrowserAttributeKeys<TDef>]
+}[BrowserAttributeKeys<TDef>];
+// Numeric columns — constrains aggregate-like column parameters
+declare type BrowserNumericColumns<TDef extends BrowserModelDefinition> = {
+  [K in BrowserAttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
+}[BrowserAttributeKeys<TDef>];
+// Relation name inference for browser models (supports both array and object syntax)
+declare type BrowserBelongsToNames<TDef> = (TDef extends { belongsTo: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { belongsTo: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserHasManyNames<TDef> = (TDef extends { hasMany: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { hasMany: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserHasOneNames<TDef> = (TDef extends { hasOne: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { hasOne: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserBelongsToManyNames<TDef> = (TDef extends { belongsToMany: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { belongsToMany: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserHasOneThroughNames<TDef> = (TDef extends { hasOneThrough: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { hasOneThrough: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserHasManyThroughNames<TDef> = (TDef extends { hasManyThrough: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { hasManyThrough: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type BrowserRelationNames<TDef> = | BrowserBelongsToNames<TDef>
+  | BrowserHasManyNames<TDef>
+  | BrowserHasOneNames<TDef>
+  | BrowserBelongsToManyNames<TDef>
+  | BrowserHasOneThroughNames<TDef>
+  | BrowserHasManyThroughNames<TDef>;
 // Types for query building
-export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not'
+export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not';
 /**
  * Custom error class for browser query errors
  */
@@ -183,9 +269,8 @@ export declare class BrowserQueryError extends Error {
  * Fluent API that builds queries and executes them via fetch
  */
 export declare class BrowserQueryBuilder<T = any> {
-  private state: QueryState;
   constructor(table: string);
-  select(columns: string[]): this;
+  select(...columns: string[]): this;
   where(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
   orWhere(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
   andWhere(column: string, operatorOrValue: WhereOperator | any, value?: any): this;
@@ -201,9 +286,7 @@ export declare class BrowserQueryBuilder<T = any> {
   offset(count: number): this;
   skip(count: number): this;
   take(count: number): this;
-  with(relations: string[]): this;
-  private buildQueryParams(): URLSearchParams;
-  private buildUrl(path?: string | number): string;
+  with(...relations: string[]): this;
   get(): Promise<T[]>;
   first(): Promise<T | null>;
   firstOrFail(): Promise<T>;
@@ -229,26 +312,18 @@ export declare class BrowserQueryBuilder<T = any> {
  * Browser Model Instance - represents a single record with type-safe access
  */
 declare class BrowserModelInstance<TDef extends BrowserModelDefinition, TSelected extends BrowserColumnName<TDef> = BrowserColumnName<TDef>> {
-  private _attributes: Record<string, unknown>;
-  private _definition: TDef;
   constructor(definition: TDef, attributes?: Partial<BrowserModelAttributes<TDef>>);
   get<K extends TSelected>(key: K): K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : never;
   set<K extends BrowserAttributeKeys<TDef>>(key: K, value: BrowserModelAttributes<TDef>[K]): void;
+  get attributes(): Pick<BrowserModelAttributes<TDef>, TSelected & keyof BrowserModelAttributes<TDef>>;
+  get id(): number;
   toJSON(): Omit<Pick<BrowserModelAttributes<TDef>, TSelected & keyof BrowserModelAttributes<TDef>>, BrowserHiddenKeys<TDef>>;
 }
 /**
  * Typed Browser Query Builder with precise type narrowing
  */
 declare class BrowserModelQueryBuilder<TDef extends BrowserModelDefinition, TSelected extends BrowserColumnName<TDef> = BrowserColumnName<TDef>> {
-  private _definition: TDef;
-  private _wheres: { column: string; operator: WhereOperator; value: unknown; boolean: 'and' | 'or' }[];
-  private _orderBy: { column: string; direction: 'asc' | 'desc' }[];
-  private _limit?: number;
-  private _offset?: number;
-  private _select: string[];
-  private _withRelations: string[];
   constructor(definition: TDef);
-  private getTablePath(): string;
   where<K extends BrowserColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | (K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown), value?: K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown): BrowserModelQueryBuilder<TDef, TSelected>;
   orWhere<K extends BrowserColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | (K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown), value?: K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown): BrowserModelQueryBuilder<TDef, TSelected>;
   whereIn<K extends BrowserColumnName<TDef>>(column: K, values: (K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown)[]): BrowserModelQueryBuilder<TDef, TSelected>;
@@ -263,12 +338,10 @@ declare class BrowserModelQueryBuilder<TDef extends BrowserModelDefinition, TSel
   take(count: number): BrowserModelQueryBuilder<TDef, TSelected>;
   offset(count: number): BrowserModelQueryBuilder<TDef, TSelected>;
   skip(count: number): BrowserModelQueryBuilder<TDef, TSelected>;
-  select<K extends BrowserColumnName<TDef>>(columns: K[]): BrowserModelQueryBuilder<TDef, K>;
-  with(relations: string[]): BrowserModelQueryBuilder<TDef, TSelected>;
+  select<K extends BrowserColumnName<TDef>>(...columns: K[]): BrowserModelQueryBuilder<TDef, K>;
+  with<R extends BrowserRelationNames<TDef> extends never ? string : BrowserRelationNames<TDef>>(...relations: R[]): BrowserModelQueryBuilder<TDef, TSelected>;
   latest(column?: BrowserColumnName<TDef>): BrowserModelQueryBuilder<TDef, TSelected>;
   oldest(column?: BrowserColumnName<TDef>): BrowserModelQueryBuilder<TDef, TSelected>;
-  private buildQueryParams(): URLSearchParams;
-  private buildUrl(path?: string | number): string;
   get(): Promise<BrowserModelInstance<TDef, TSelected>[]>;
   first(): Promise<BrowserModelInstance<TDef, TSelected> | null>;
   firstOrFail(): Promise<BrowserModelInstance<TDef, TSelected>>;
@@ -277,7 +350,7 @@ declare class BrowserModelQueryBuilder<TDef extends BrowserModelDefinition, TSel
   count(): Promise<number>;
   exists(): Promise<boolean>;
   pluck<K extends BrowserColumnName<TDef>>(column: K): Promise<(K extends keyof BrowserModelAttributes<TDef> ? BrowserModelAttributes<TDef>[K] : unknown)[]>;
-  paginate(page?: any, perPage?: any): Promise<{
+  paginate(page?: number, perPage?: number): Promise<{
     data: BrowserModelInstance<TDef, TSelected>[]
     total: number
     page: number
@@ -285,4 +358,5 @@ declare class BrowserModelQueryBuilder<TDef extends BrowserModelDefinition, TSel
     lastPage: number
   }>;
 }
-export default browserQuery;
+// Export for convenience
+export default browserQuery;

package/dist/client.d.ts

@@ -28,7 +28,7 @@ export declare function setQueryCacheMaxSize(size: number): void;
 export declare interface WhereRaw {
   raw: any
 }
-export declare 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>
@@ -126,29 +126,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>
@@ -184,8 +162,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[][]>
@@ -354,6 +332,8 @@ declare interface InternalState {
   schema?: any
   txDefaults?: TransactionOptions
 }
+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 }
 export declare interface TransactionOptions {
   retries?: number
   isolation?: TransactionIsolation
@@ -366,51 +346,39 @@ export declare interface TransactionOptions {
   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'
+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
+  | WhereRaw;
+export type QueryResult = any;
 /**
  * # `SortDirection`
  *
  * The direction used when ordering query results.
  */
-export type SortDirection = 'asc' | 'desc'
+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
+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>
+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
+  : 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>
+  : 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> = {
+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} = ?`>
@@ -423,7 +391,7 @@ declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable ex
     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<
+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>
@@ -463,16 +431,16 @@ export type TypedSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
   ) => 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> = {
+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>
+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']>[],
@@ -487,13 +455,11 @@ export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
     `${TSql} RETURNING ${string}`
   >
 }
-declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable'
+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;
 }
-export { resetConnection };
+export { resetConnection };

package/dist/config.d.ts

@@ -9,7 +9,7 @@ export declare function getPlaceholder(index: number): string;
  * PostgreSQL: $1, $2, $3
  * MySQL/SQLite: ?, ?, ?
  */
-export declare function getPlaceholders(count: number, startIndex?: any): string;
+export declare function getPlaceholders(count: number, startIndex?: number): string;
 export declare function getConfig(): Promise<QueryBuilderConfig>;
 /**
  * Programmatically set/override the query builder configuration.
@@ -18,5 +18,18 @@ export declare function getConfig(): Promise<QueryBuilderConfig>;
  */
 export declare function setConfig(userConfig: Partial<QueryBuilderConfig>): void;
 export declare const defaultConfig: QueryBuilderConfig;
-// For backwards compatibility - synchronous access with default fallback
-export declare const config: QueryBuilderConfig;
+// For backwards compatibility — synchronous access with default fallback.
+//
+// Why `let` + an explicit `Object.assign(config, defaultConfig)` instead of
+// the obvious `export const config = defaultConfig`: when downstream code
+// (e.g. `bunfig`, our config loader) introduces a top-level `await`, Bun's
+// bundler may wrap this module's initializer in `__esm(async () => {...})`.
+// Static `const x = y` exports inside such a wrapper are reassigned only
+// once the async init runs, so callers that reach `setConfig(...)` before
+// that init (e.g. another module's top-level `setConfig` call mid-graph)
+// see `config` as `undefined` and `Object.assign(undefined, ...)` throws.
+// Initializing as `let config = {...defaultConfig}` outside the wrapper, and
+// having `setConfig` re-hydrate from defaults if it's somehow still empty,
+// keeps the surface synchronous for every consumer regardless of how the
+// module ends up bundled.
+export declare let config: QueryBuilderConfig;

package/dist/db.d.ts

@@ -1,12 +1,12 @@
-import { SQL } from 'bun';
 import { Database } from 'bun:sqlite';
+import { SQL } from 'bun';
 /**
  * Returns a Bun SQL instance configured for the current dialect and database settings.
  * For SQLite, uses bun:sqlite directly for better compiled binary support.
  * Handles connection errors gracefully by falling back to in-memory SQLite.
  */
 export declare function getBunSql(): SQL;
-export declare function getOrCreateBunSql(forceNew?: any): SQL;
+export declare function getOrCreateBunSql(forceNew?: boolean): SQL;
 /**
  * Resets the cached database connection.
  * Call this after changing config via setConfig() to ensure the new config is used.
@@ -21,10 +21,11 @@ export declare const bunSql: SQL;
  * using bun:sqlite's Database class for better compiled binary support.
  */
 declare class SQLiteWrapper {
-  private db: Database;
   constructor(filename: string);
   query(sql: string, params?: any[]): any[];
   run(sql: string, params?: any[]): any;
   close(): void;
+  get database(): Database;
 }
-export { SQL } from 'bun';
+// Also export the SQL class for advanced usage
+export { SQL } from 'bun';

package/dist/drivers/dynamodb.d.ts

@@ -273,7 +273,7 @@ export declare interface DynamoDBConfig {
 /**
  * DynamoDB attribute type mapping
  */
-export type DynamoDBAttributeType = 'S' | 'N' | 'B' | 'SS' | 'NS' | 'BS' | 'M' | 'L' | 'BOOL' | 'NULL'
+export type DynamoDBAttributeType = 'S' | 'N' | 'B' | 'SS' | 'NS' | 'BS' | 'M' | 'L' | 'BOOL' | 'NULL';
 /**
  * DynamoDB query condition operators
  */
@@ -283,13 +283,11 @@ export type DynamoDBComparisonOperator = | '='
   | '>'
   | '>='
   | 'BETWEEN'
-  | 'begins_with'
+  | 'begins_with';
 /**
  * DynamoDB Driver Implementation
  */
 export declare class DynamoDBDriverImpl implements DynamoDBDriver {
-  private config: DynamoDBConfig;
-  private entityMappings: Map<string, SingleTableEntityMapping>;
   constructor(config: DynamoDBConfig);
   createTable(definition: DynamoDBTableDefinition): DynamoDBTableDefinition;
   deleteTable(tableName: string): { tableName: string };
@@ -327,12 +325,4 @@ export declare class DynamoDBDriverImpl implements DynamoDBDriver {
   };
   marshall(item: Record<string, any>): Record<string, any>;
   unmarshall(item: Record<string, any>): Record<string, any>;
-  private interpolatePattern(pattern: string, values: Record<string, any>): string;
-  private buildExpression(conditions: DynamoDBCondition[], joiner: 'AND' | 'OR'): {
-    expression: string
-    expressionAttributeNames: Record<string, string>
-    expressionAttributeValues: Record<string, any>
-  };
-  private marshallValue(value: any): any;
-  private unmarshallValue(value: any): any;
-}
+}

package/dist/drivers/index.d.ts

@@ -30,7 +30,8 @@ export declare function getDialectDriver(dialect: SupportedDialect): DialectDriv
 export { MySQLDriver } from './mysql';
 export { PostgresDriver } from './postgres';
 export { SQLiteDriver } from './sqlite';
+// DynamoDB driver (NoSQL)
 export {
   createDynamoDBDriver,
   DynamoDBDriverImpl,
-} from './dynamodb';
+} from './dynamodb';

package/dist/drivers/mysql.d.ts

@@ -3,7 +3,7 @@ export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string
   createIndex: (tableName: string, index: IndexPlan) => string
-  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string) => string
   addColumn: (tableName: string, column: ColumnPlan) => string
   modifyColumn: (tableName: string, column: ColumnPlan) => string
   dropTable: (tableName: string) => string
@@ -15,15 +15,10 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class MySQLDriver implements DialectDriver {
-  private quoteIdentifier(id: string): string;
-  private getColumnType(column: ColumnPlan): string;
-  private getPrimaryKeyType(column: ColumnPlan): string;
-  private getAutoIncrementClause(column: ColumnPlan): string;
-  private getDefaultValue(column: ColumnPlan): string;
   createEnumType(_enumTypeName: string, _values: string[]): string;
   createTable(table: TablePlan): string;
   createIndex(tableName: string, index: IndexPlan): string;
-  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string): string;
   addColumn(tableName: string, column: ColumnPlan): string;
   modifyColumn(tableName: string, column: ColumnPlan): string;
   dropTable(tableName: string): string;
@@ -33,5 +28,4 @@ export declare class MySQLDriver implements DialectDriver {
   createMigrationsTable(): string;
   getExecutedMigrationsQuery(): string;
   recordMigrationQuery(): string;
-  private renderColumn(column: ColumnPlan): string;
-}
+}

package/dist/drivers/postgres.d.ts

@@ -3,7 +3,7 @@ export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string
   createIndex: (tableName: string, index: IndexPlan) => string
-  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string) => string
+  addForeignKey: (tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string) => string
   addColumn: (tableName: string, column: ColumnPlan) => string
   modifyColumn: (tableName: string, column: ColumnPlan) => string
   dropTable: (tableName: string) => string
@@ -15,15 +15,10 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class PostgresDriver implements DialectDriver {
-  private quoteIdentifier(id: string): string;
-  private getColumnType(column: ColumnPlan): string;
-  private getPrimaryKeyType(column: ColumnPlan): string;
-  private getAutoIncrementClause(_column: ColumnPlan): string;
-  private getDefaultValue(column: ColumnPlan): string;
   createEnumType(enumTypeName: string, values: string[]): string;
   createTable(table: TablePlan): string;
   createIndex(tableName: string, index: IndexPlan): string;
-  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string): string;
   addColumn(tableName: string, column: ColumnPlan): string;
   modifyColumn(tableName: string, column: ColumnPlan): string;
   dropTable(tableName: string): string;
@@ -33,5 +28,4 @@ export declare class PostgresDriver implements DialectDriver {
   createMigrationsTable(): string;
   getExecutedMigrationsQuery(): string;
   recordMigrationQuery(): string;
-  private renderColumn(column: ColumnPlan): string;
-}
+}