bun-query-builder 0.1.25 → 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

@@ -13,6 +13,18 @@ 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.
@@ -309,6 +321,8 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   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>;
@@ -352,6 +366,8 @@ export declare class BelongsToManyRelationBuilder<TRel extends ModelDefinition>
  */
 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>;

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
+}