bun-query-builder 0.1.24 → 0.1.26

package/dist/client.d.ts

@@ -103,8 +103,8 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   groupByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   havingRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  addSelect: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  select?: (columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  addSelect: (...columns: ((keyof DB[TTable]['columns'] & string) | string | SqlFragment)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  select?: (columns: string | SqlFragment | ((keyof DB[TTable]['columns'] & string) | string | SqlFragment)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   selectAll?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orderByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   union: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -148,7 +148,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   explain: () => Promise<any[]>
   simple: () => any
   toText?: () => string
-  paginate: (perPage: number, page?: number) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, total: number, lastPage: number } }>
+  paginate: (perPage: number, page?: number, opts?: { tx?: { unsafe: (sql: string, params?: any[]) => any } }) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, total: number, lastPage: number } }>
   simplePaginate: (perPage: number, page?: number) => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, page: number, hasMore: boolean } }>
   toSQL: () => string
   execute: () => Promise<SelectedRow<DB, TTable, TSelected>[]>

package/dist/config.d.ts

@@ -13,18 +13,4 @@ export declare function getPlaceholders(count: number, startIndex?: number): str
 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.
-//
-// 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;
+export declare const config: QueryBuilderConfig;

package/dist/db.d.ts

@@ -1,5 +1,20 @@
 import { Database } from 'bun:sqlite';
 import { SQL } from 'bun';
+import type { PoolConfig } from './types';
+/**
+ * Map the qb-level `pool` config (ms-based, ergonomic) onto the Bun SQL
+ * driver's native option names (second resolution). Only the knobs Bun's
+ * `SQL` actually honors are emitted — `min`/`autoReconnect` are accepted on
+ * `PoolConfig` for forward-compatibility but the driver manages them itself,
+ * so they are intentionally not passed through. See
+ * stacksjs/bun-query-builder#1014.
+ */
+export declare function resolvePoolOptions(pool?: PoolConfig): {
+  max?: number
+  idleTimeout?: number
+  connectionTimeout?: number
+  maxLifetime?: number
+};
 /**
  * Returns a Bun SQL instance configured for the current dialect and database settings.
  * For SQLite, uses bun:sqlite directly for better compiled binary support.
@@ -16,6 +31,37 @@ export declare function resetConnection(): void;
 export declare function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T>;
 // Export a lazy proxy - no connection is made until first use
 export declare const bunSql: SQL;
+/**
+ * The query object returned by `connection.unsafe(...)` / a tagged template.
+ * Both Bun's native `SQL` query and our `createSQLiteSQL` wrapper satisfy this.
+ * See stacksjs/bun-query-builder#1044.
+ */
+export declare interface DriverQuery {
+  execute: () => Promise<any>
+  values?: () => any
+  raw?: () => any
+  toString: () => string
+  cancel?: () => void
+  readonly sql?: string
+  [key: string]: any
+}
+/**
+ * The shared connection surface used across the dispatch path — both the
+ * `bun:sqlite` wrapper and Bun's native `SQL` satisfy it. Typing `_sql` against
+ * this (instead of `any`) is what lets the ~hundreds of `(_sql as any).unsafe`
+ * casts be dropped. See stacksjs/bun-query-builder#1044.
+ */
+export declare interface DriverConnection {
+  (strings: TemplateStringsArray, ...values: any[]): DriverQuery
+  (value: any): any
+  unsafe: (sql: string, values?: any[]) => AwaitableDriverQuery
+  query?: (sql: string, params?: any[]) => any
+  close?: () => Promise<void> | void
+  _prepareStatement?: (sql: string) => any
+  [key: string]: any
+}
+/** An `unsafe(...)` result: a query object that is ALSO directly awaitable. */
+export type AwaitableDriverQuery = DriverQuery & PromiseLike<any>;
 /**
  * SQLite wrapper that provides a SQL-like tagged template literal interface
  * using bun:sqlite's Database class for better compiled binary support.
@@ -27,5 +73,13 @@ declare class SQLiteWrapper {
   close(): void;
   get database(): Database;
 }
+// NOTE: this module no longer installs a process-wide `unhandledRejection`
+// handler. A library has no business doing so: ANY such listener suppresses the
+// runtime's default crash for EVERY unhandled rejection in the consumer's
+// process (the old handler's body matched only DB errors but silently swallowed
+// the rest), masking genuine production bugs. Expected "database does not exist"
+// errors during tests are surfaced/awaited at query time now (#1022); a test
+// harness that needs to tolerate a missing DB should install its own handler.
+// See stacksjs/bun-query-builder#1040.
 // Also export the SQL class for advanced usage
 export { SQL } from 'bun';

package/dist/orm.d.ts

@@ -1,5 +1,6 @@
 import { Database, type SQLQueryBindings } from 'bun:sqlite';
 import type { Faker } from '@stacksjs/ts-faker';
+import type { SupportedDialect } from './types';
 export type {
   ModelInstance,
   ModelQueryBuilder,
@@ -12,13 +13,34 @@ export type {
   FillableKeys,
   HiddenKeys,
 };
+/**
+ * Extract an affected-row count from a Bun SQL driver result.
+ *
+ * Verified against live Postgres (Bun 1.3): a non-RETURNING `UPDATE`/`DELETE`
+ * returns an empty array carrying `{ count: <affected>, affectedRows: null,
+ * command: 'UPDATE' }`. So `count` must be checked BEFORE the `Array.length`
+ * fallback (which would be 0) — see stacksjs/bun-query-builder#1032. MySQL
+ * surfaces `affectedRows` instead.
+ */
+export declare function extractChanges(res: any): number;
+/** Extract a generated primary key from a Bun SQL driver result. */
+export declare function extractInsertId(res: any): number | bigint | null;
 export declare function configureOrm(options: { database?: string | Database; verbose?: boolean }): void;
+/**
+ * Return the underlying `bun:sqlite` Database backing the model layer.
+ *
+ * Only meaningful when the active dialect is sqlite (or a sqlite Database was
+ * supplied via `configureOrm`). For mysql/postgres there is no `Database`
+ * object — use the async model API instead. Retained for backwards
+ * compatibility with callers that reach for the raw sqlite handle (tests,
+ * low-level table setup).
+ */
 export declare function getDatabase(): Database;
 /**
  * Create a model class from a definition with full type inference
  */
 export declare function createModel<const TDef extends ModelDefinition>(definition: TDef): void;
-export declare function createTableFromModel(definition: ModelDefinition): void;
+export declare function createTableFromModel(definition: ModelDefinition): Promise<void>;
 export declare function seedModel(definition: ModelDefinition, count?: number, faker?: Record<string, unknown>): Promise<void>;
 // Attribute definition with explicit type
 export declare interface TypedAttribute<T = unknown> {
@@ -119,6 +141,14 @@ export declare interface ModelDefinition {
     readonly afterDelete?: (model: ModelHookInstance) => void | Promise<void>
   }
 }
+declare interface OrmExecutor {
+  readonly dialect: SupportedDialect
+  all: (sql: string, params: unknown[]) => Promise<Record<string, unknown>[]>
+  get: (sql: string, params: unknown[]) => Promise<Record<string, unknown> | undefined>
+  run: (sql: string, params: unknown[]) => Promise<RunResult>
+  insert: (sql: string, params: unknown[], primaryKey: string) => Promise<RunResult>
+  readonly sqliteDb?: Database
+}
 /**
  * Resolve a relation from its name and the parent model's definition.
  * Uses the model registry to find the related model's definition.
@@ -234,6 +264,37 @@ export type InferRelationNames<TDef> = | InferBelongsToNames<TDef>
   | InferHasOneThroughNames<TDef>
   | InferHasManyThroughNames<TDef>;
 declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'not like' | 'in' | 'not in';
+// --- Dialect-aware execution layer -------------------------------------------
+//
+// The model API historically ran every query through a hardcoded in-memory
+// `bun:sqlite` Database, so projects configured for MySQL/Postgres had their
+// model calls silently routed to a fresh, empty SQLite database — every query
+// returned "no such table" (stacksjs/bun-query-builder#1021).
+//
+// All model queries now go through an `OrmExecutor` chosen from the configured
+// dialect. SQLite keeps its synchronous `bun:sqlite` engine (wrapped in
+// resolved Promises); MySQL/Postgres route through Bun's async `SQL` driver via
+// the shared `getOrCreateBunSql()` connection — the same path the direct
+// `selectFrom(...)` builder already uses. Because the network drivers are
+// async-only, every model read/write method now returns a Promise.
+declare type RunResult = { changes: number, lastInsertId: number | bigint | null }
+declare class SqliteExecutor implements OrmExecutor {
+  readonly dialect: unknown;
+  public readonly sqliteDb: Database;
+  constructor(sqliteDb: Database);
+  all(sql: string, params: unknown[]): Promise<Record<string, unknown>[]>;
+  get(sql: string, params: unknown[]): Promise<Record<string, unknown> | undefined>;
+  run(sql: string, params: unknown[]): Promise<RunResult>;
+  insert(sql: string, params: unknown[]): Promise<RunResult>;
+}
+declare class DriverExecutor implements OrmExecutor {
+  public readonly dialect: SupportedDialect;
+  constructor(dialect: SupportedDialect);
+  all(sql: string, params: unknown[]): Promise<Record<string, unknown>[]>;
+  get(sql: string, params: unknown[]): Promise<Record<string, unknown> | undefined>;
+  run(sql: string, params: unknown[]): Promise<RunResult>;
+  insert(sql: string, params: unknown[], primaryKey: string): Promise<RunResult>;
+}
 /**
  * Model instance - represents a single database record
  */
@@ -256,11 +317,13 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   getChanges(): Partial<InferModelAttributes<TDef>>;
   fill(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
   forceFill(data: Partial<InferModelAttributes<TDef>>): this;
-  save(): this;
-  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
-  fresh(): ModelInstance<TDef, TSelected> | null;
-  delete(): boolean;
-  refresh(): this | null;
+  save(): Promise<this>;
+  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): Promise<this>;
+  fresh(): Promise<ModelInstance<TDef, TSelected> | null>;
+  delete(): Promise<boolean>;
+  restore(): Promise<this>;
+  trashed(): boolean;
+  refresh(): Promise<this | null>;
   replicate(): ModelInstance<TDef, TSelected>;
   toArray(): Record<string, unknown>;
   toJSON(): Omit<Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>, HiddenKeys<TDef>>;
@@ -288,21 +351,23 @@ export declare class BelongsToManyRelationBuilder<TRel extends ModelDefinition>
   orderBy(column: string, direction?: 'asc' | 'desc'): this;
   limit(n: number): this;
   offset(n: number): this;
-  get(): ModelInstance<TRel, any>[];
-  first(): ModelInstance<TRel, any> | undefined;
-  count(): number;
-  exists(): boolean;
-  attach(idOrIds: unknown | unknown[], extras?: Record<string, unknown>): number;
-  detach(idOrIds?: unknown | unknown[]): number;
-  updateExistingPivot(relatedId: unknown, extras: Record<string, unknown>): number;
-  sync(items: Array<unknown | { id: unknown, [key: string]: unknown }>): { attached: unknown[], detached: unknown[], updated: unknown[] };
-  toggle(idOrIds: unknown | unknown[]): { attached: unknown[], detached: unknown[] };
+  get(): Promise<ModelInstance<TRel, any>[]>;
+  first(): Promise<ModelInstance<TRel, any> | undefined>;
+  count(): Promise<number>;
+  exists(): Promise<boolean>;
+  attach(idOrIds: unknown | unknown[], extras?: Record<string, unknown>): Promise<number>;
+  detach(idOrIds?: unknown | unknown[]): Promise<number>;
+  updateExistingPivot(relatedId: unknown, extras: Record<string, unknown>): Promise<number>;
+  sync(items: Array<unknown | { id: unknown, [key: string]: unknown }>): Promise<{ attached: unknown[], detached: unknown[], updated: unknown[] }>;
+  toggle(idOrIds: unknown | unknown[]): Promise<{ attached: unknown[], detached: unknown[] }>;
 }
 /**
  * Query builder with precise type narrowing
  */
 declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends ColumnName<TDef> = ColumnName<TDef>> {
   constructor(definition: TDef);
+  withTrashed(): ModelQueryBuilder<TDef, TSelected>;
+  onlyTrashed(): ModelQueryBuilder<TDef, TSelected>;
   where<K extends ColumnName<TDef>>(column: K, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
   where<K extends ColumnName<TDef>>(column: K, operator: WhereOperator, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
   where<K extends ColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | unknown, value?: unknown): ModelQueryBuilder<TDef, TSelected>;
@@ -339,18 +404,18 @@ declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends
   with<R extends InferRelationNames<TDef>>(...relations: R[]): ModelQueryBuilder<TDef, TSelected>;
   getWithRelations(): string[];
   toSql(): { sql: string; params: unknown[] };
-  get(): ModelInstance<TDef, TSelected>[];
-  first(): ModelInstance<TDef, TSelected> | undefined;
-  firstOrFail(): ModelInstance<TDef, TSelected>;
-  last(): ModelInstance<TDef, TSelected> | undefined;
-  count(): number;
-  exists(): boolean;
-  doesntExist(): boolean;
-  sole(): ModelInstance<TDef, TSelected>;
-  increment<K extends NumericColumns<TDef>>(column: K, amount?: number): number;
-  decrement<K extends NumericColumns<TDef>>(column: K, amount?: number): number;
-  chunk(size: number, callback: (items: ModelInstance<TDef, TSelected>[]) => void | false): void;
-  paginate(page?: number, perPage?: number): {
+  get(): Promise<ModelInstance<TDef, TSelected>[]>;
+  first(): Promise<ModelInstance<TDef, TSelected> | undefined>;
+  firstOrFail(): Promise<ModelInstance<TDef, TSelected>>;
+  last(): Promise<ModelInstance<TDef, TSelected> | undefined>;
+  count(): Promise<number>;
+  exists(): Promise<boolean>;
+  doesntExist(): Promise<boolean>;
+  sole(): Promise<ModelInstance<TDef, TSelected>>;
+  increment<K extends NumericColumns<TDef>>(column: K, amount?: number): Promise<number>;
+  decrement<K extends NumericColumns<TDef>>(column: K, amount?: number): Promise<number>;
+  chunk(size: number, callback: (items: ModelInstance<TDef, TSelected>[]) => void | false | Promise<void | false>): Promise<void>;
+  paginate(page?: number, perPage?: number): Promise<{
     data: ModelInstance<TDef, TSelected>[]
     total: number
     page: number
@@ -360,12 +425,12 @@ declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends
     isEmpty: boolean
     from: number | null
     to: number | null
-  };
-  pluck<K extends ColumnName<TDef>>(column: K): (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[];
-  max<K extends ColumnName<TDef>>(column: K): number | null;
-  min<K extends ColumnName<TDef>>(column: K): number | null;
-  avg<K extends NumericColumns<TDef>>(column: K): number;
-  sum<K extends NumericColumns<TDef>>(column: K): number;
-  delete(): number;
-  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): number;
+  }>;
+  pluck<K extends ColumnName<TDef>>(column: K): Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]>;
+  max<K extends ColumnName<TDef>>(column: K): Promise<number | null>;
+  min<K extends ColumnName<TDef>>(column: K): Promise<number | null>;
+  avg<K extends NumericColumns<TDef>>(column: K): Promise<number>;
+  sum<K extends NumericColumns<TDef>>(column: K): Promise<number>;
+  delete(): Promise<number>;
+  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): Promise<number>;
 }

package/dist/relation-utils.d.ts

@@ -0,0 +1,27 @@
+import type { OnForeignKeyAction } from './schema';
+/**
+ * Unwrap a single relation entry to a descriptor, or null if it isn't a valid
+ * relation entry. Accepts:
+ *   - `'Model'`
+ *   - `{ model: 'Model', foreignKey?, onDelete? }`
+ */
+export declare function normalizeRelationEntry(entry: unknown): NormalizedRelation | null;
+/**
+ * Flatten a relation declaration into descriptors. Accepts every supported
+ * shape: string array, object-in-array, record (name->Model) and record
+ * (name->config). Invalid entries are dropped.
+ */
+export declare function normalizeRelationList(rel: unknown): NormalizedRelation[];
+/**
+ * A relation entry reduced to the fields the schema/migration layers need.
+ *
+ * Single source of truth for unwrapping the supported relation-declaration
+ * shapes. Previously `meta.ts` (toRecord) and `migrations.ts`
+ * (normalizeBelongsTo) each re-implemented this — the exact shape that caused
+ * stacksjs/bun-query-builder#1023, and the fix had to be applied twice. See #1042.
+ */
+export declare interface NormalizedRelation {
+  model: string
+  foreignKey?: string
+  onDelete?: OnForeignKeyAction
+}