bun-query-builder 0.2.44 → 0.2.46

package/dist/bin/cli.js

@@ -140,7 +140,7 @@ class BrowserQueryBuilder {
     return this;
   }
   andWhere(column, operatorOrValue, value) {
-    return this.where(column, operatorOrValue, value);
+    return value === undefined ? this.where(column, operatorOrValue) : this.where(column, operatorOrValue, value);
   }
   whereNull(column) {
     return this.where(column, "is", null);
@@ -11862,6 +11862,12 @@ import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 import process21 from "process";
+function toBindings(params) {
+  return params;
+}
+function asEmbeddedValue(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
 function bindNumberedPlaceholders(sql, params) {
   if (params.length === 0 || !/\$\d/.test(sql))
     return { sql, params };
@@ -12050,11 +12056,13 @@ function createSQLiteSQL(filename) {
     const params = [];
     for (let i = 0;i < values.length; i++) {
       const value = values[i];
-      if (value && typeof value === "object" && typeof value.sql === "string" && Array.isArray(value.values)) {
-        sql += value.sql + (strings[i + 1] || "");
-        params.push(...value.values);
-      } else if (value && typeof value === "object" && (value.__raw || value.raw)) {
-        const rawValue = value.__raw ? value.value : typeof value.raw === "string" ? value.raw : value.raw();
+      const embedded = asEmbeddedValue(value);
+      if (embedded && typeof embedded.sql === "string" && Array.isArray(embedded.values)) {
+        sql += embedded.sql + (strings[i + 1] || "");
+        params.push(...embedded.values);
+      } else if (embedded && (embedded.__raw || embedded.raw)) {
+        const raw = embedded.raw;
+        const rawValue = embedded.__raw ? embedded.value : typeof raw === "string" ? raw : raw();
         sql += rawValue + (strings[i + 1] || "");
       } else if (Array.isArray(value)) {
         const placeholders = value.map(() => "?").join(", ");
@@ -12072,10 +12080,10 @@ function createSQLiteSQL(filename) {
         try {
           const trimmed = sql.trim().toUpperCase();
           if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-            const result = wrapper.query(sql, params);
+            const result = wrapper.query(sql, toBindings(params));
             return Promise.resolve(result);
           } else {
-            const result = wrapper.run(sql, params);
+            const result = wrapper.run(sql, toBindings(params));
             return Promise.resolve(result);
           }
         } catch (error) {
@@ -12102,10 +12110,10 @@ function createSQLiteSQL(filename) {
       try {
         const trimmed = sql.trim().toUpperCase();
         if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-          const result = wrapper.query(sql, params);
+          const result = wrapper.query(sql, toBindings(params));
           return Promise.resolve(result);
         } else {
-          const result = wrapper.run(sql, params);
+          const result = wrapper.run(sql, toBindings(params));
           return Promise.resolve(result);
         }
       } catch (error) {
@@ -12128,7 +12136,7 @@ function createSQLiteSQL(filename) {
   };
   sqlFunction.query = (sql, params) => {
     try {
-      const result = wrapper.query(sql, params || []);
+      const result = wrapper.query(sql, toBindings(params || []));
       return Promise.resolve(result);
     } catch (error) {
       return Promise.reject(error);
@@ -14936,6 +14944,10 @@ function createQueryBuilder(state) {
         built = null;
         return this;
       },
+      $call(callback) {
+        callback(this);
+        return this;
+      },
       union(other) {
         appendSetOp("UNION", other);
         return this;
@@ -26784,6 +26796,18 @@ class ModelQueryBuilder {
       return "";
     return this._trashed === "only" ? `${SOFT_DELETE_COLUMN} IS NOT NULL` : `${SOFT_DELETE_COLUMN} IS NULL`;
   }
+  assertNoUnappliedClauses(method) {
+    const ignored = [];
+    if (this._limit !== undefined)
+      ignored.push("limit()");
+    if (this._offset !== undefined)
+      ignored.push("offset()");
+    if (this._orderBy.length > 0)
+      ignored.push("orderBy()");
+    if (ignored.length > 0) {
+      throw new TypeError(`[orm] ${method}() cannot apply ${ignored.join(", ")} \u2014 an UPDATE/DELETE takes no ORDER BY or LIMIT on every supported dialect. ` + `Previously these were ignored, so the statement affected every matching row. Narrow it with where() instead.`);
+    }
+  }
   composeWhere(params) {
     const userClause = this._wheres.length > 0 ? this.buildWhereClauses(params) : "";
     const sd = this.softDeleteClause();
@@ -27033,6 +27057,7 @@ class ModelQueryBuilder {
   }
   async increment(column, amount = 1) {
     assertValidIdentifier(column, "increment(column)");
+    this.assertNoUnappliedClauses("increment");
     const exec = getExecutor();
     const params = [amount];
     const incCol = sqlColumn(column);
@@ -27041,9 +27066,9 @@ class ModelQueryBuilder {
       sql2 += `, updated_at = ?`;
       params.push(formatNow());
     }
-    if (this._wheres.length > 0) {
-      const clauses = this.buildWhereClauses(params);
-      sql2 += ` WHERE ${clauses}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }
@@ -27142,15 +27167,18 @@ class ModelQueryBuilder {
     return Number(await this.aggregate("SUM", column) ?? 0) || 0;
   }
   async delete() {
+    this.assertNoUnappliedClauses("delete");
     const exec = getExecutor();
     const params = [];
     let sql2 = `DELETE FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }
   async update(data) {
+    this.assertNoUnappliedClauses("update");
     const exec = getExecutor();
     const entries = Object.entries(data);
     const sets = entries.map(([k2]) => `${sqlColumn(k2)} = ?`).join(", ");
@@ -27159,8 +27187,9 @@ class ModelQueryBuilder {
       params.push(formatNow());
     }
     let sql2 = `UPDATE ${this._definition.table} SET ${sets}${timestampsEnabled(this._definition) ? ", updated_at = ?" : ""}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }
@@ -32515,7 +32544,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.2.44";
+var version2 = "0.2.46";
 
 // bin/cli.ts
 init_actions();

package/dist/browser.d.ts

@@ -282,13 +282,19 @@ export declare class BrowserQueryError extends Error {
 export declare class BrowserQueryBuilder<T = any> {
   constructor(table: string);
   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;
+  where(column: string, value: unknown): this;
+  where(column: string, operator: WhereOperator, value: unknown): this;
+  where(column: string, operatorOrValue: unknown, value?: unknown): this;
+  orWhere(column: string, value: unknown): this;
+  orWhere(column: string, operator: WhereOperator, value: unknown): this;
+  orWhere(column: string, operatorOrValue: unknown, value?: unknown): this;
+  andWhere(column: string, value: unknown): this;
+  andWhere(column: string, operator: WhereOperator, value: unknown): this;
+  andWhere(column: string, operatorOrValue: unknown, value?: unknown): this;
   whereNull(column: string): this;
   whereNotNull(column: string): this;
-  whereIn(column: string, values: any[]): this;
-  whereNotIn(column: string, values: any[]): this;
+  whereIn(column: string, values: readonly unknown[]): this;
+  whereNotIn(column: string, values: readonly unknown[]): this;
   orderBy(column: string, direction?: 'asc' | 'desc'): this;
   orderByDesc(column: string): this;
   latest(column?: string): this;

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { config } from './config';
 import { resetConnection } from './db';
-import type { DatabaseSchema } from './schema';
+import type { AnyDatabaseSchema } from './schema';
 import type { DriverConnection } from './db';
 import type { QueryHooks, SupportedDialect } from './types';
 import type { SchemaMeta } from './meta';
@@ -50,7 +50,7 @@ export declare function raw(strings: TemplateStringsArray | string, ...values: u
  */
 export declare function escapeStringLiteral(value: string, dialect?: SupportedDialect): string;
 // eslint-disable-next-line pickier/no-unused-vars
-export declare function createQueryBuilder<DB extends DatabaseSchema<any>>(state?: Partial<InternalState>): QueryBuilder<DB>;
+export declare function createQueryBuilder<DB extends AnyDatabaseSchema>(state?: Partial<InternalState>): QueryBuilder<DB>;
 /**
  * # `clearQueryCache()`
  *
@@ -80,7 +80,7 @@ declare interface RawExpression {
 export declare interface WhereRaw {
   raw: SqlFragment
 }
-export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> {
+export declare interface BaseSelectQueryBuilder<DB extends AnyDatabaseSchema, 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: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -108,7 +108,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   orWhereGroup: (callback: (builder: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNull: (column: keyof DB[TTable]['columns'] & string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereNotNull: (column: keyof DB[TTable]['columns'] & string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orWhereBetween: (column: keyof DB[TTable]['columns'] & string, start: any, end: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orWhereBetween: <K extends keyof DB[TTable]['columns'] & string>(column: K, start: DB[TTable]['columns'][K], end: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereExists: (subquery: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereAny: <K extends keyof DB[TTable]['columns'] & string>(columns: K[], op: WhereOperator, value: DB[TTable]['columns'][K]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -180,6 +180,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   }
   selectAll?: () => SelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TJoined>
   orderByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  $call: (callback: (query: SelectQueryBuilder<DB, TTable, TSelected, TJoined>) => unknown) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   union: (other: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   unionAll: (other: { toSQL: () => string }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   forPage: (page: number, perPage: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -265,7 +266,7 @@ 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 declare interface InsertQueryBuilder<DB extends AnyDatabaseSchema, 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
@@ -274,7 +275,7 @@ export declare interface InsertQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<DB[TTable]['columns'] | undefined>
   executeTakeFirstOrThrow: () => Promise<DB[TTable]['columns']>
 }
-export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface UpdateQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   set: (values: Partial<{ [K in keyof DB[TTable]['columns']]: DB[TTable]['columns'][K] | SqlFragment }>) => UpdateQueryBuilder<DB, TTable>
   where: <K extends keyof DB[TTable]['columns'] & string>(
     expr: WhereExpression<DB[TTable]['columns']> | K | SqlFragment,
@@ -290,7 +291,7 @@ export declare interface UpdateQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<{ numUpdatedRows?: number }>
   executeTakeFirstOrThrow: () => Promise<{ numUpdatedRows: number }>
 }
-export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface DeleteQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> {
   where: <K extends keyof DB[TTable]['columns'] & string>(
     expr: WhereExpression<DB[TTable]['columns']> | K,
     op?: WhereOperator,
@@ -305,13 +306,13 @@ export declare interface DeleteQueryBuilder<DB extends DatabaseSchema<any>, TTab
   executeTakeFirst: () => Promise<{ numDeletedRows?: number }>
   executeTakeFirstOrThrow: () => Promise<{ numDeletedRows: number }>
 }
-export declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> {
+export declare interface TableQueryBuilder<DB extends AnyDatabaseSchema, 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: <K extends keyof DB[TTable]['columns'] & string>(...columns: K[]) => SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
 }
-export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
+export declare interface QueryBuilder<DB extends AnyDatabaseSchema> {
   select: {
     <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
       table: TTable,
@@ -434,25 +435,25 @@ export declare interface QueryBuilder<DB extends DatabaseSchema<any>> {
   getRelationshipTarget?: (table: string, relationName: string) => string | null
 }
 declare interface InternalState {
-  sql: any
+  sql: DriverConnection
   meta?: SchemaMeta
-  schema?: any
+  schema?: AnyDatabaseSchema
   txDefaults?: TransactionOptions
   hooks?: QueryHooks
   inTransaction?: boolean
 }
 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 }
+declare interface TxLoggerEvent { type: 'start' | 'retry' | 'commit' | 'rollback' | 'error', attempt: number, error?: unknown, durationMs?: number }
 export declare interface TransactionOptions {
   retries?: number
   isolation?: TransactionIsolation
-  onRetry?: (attempt: number, error: any) => void
+  onRetry?: (attempt: number, error: unknown) => void
   afterCommit?: () => void
   sqlStates?: string[]
   backoff?: TxBackoff
   logger?: (event: TxLoggerEvent) => void
   readOnly?: boolean
-  onRollback?: (error: any) => void
+  onRollback?: (error: unknown) => void
   afterRollback?: () => void
 }
 // Where condition helpers
@@ -497,10 +498,10 @@ export type SortDirection = 'asc' | 'desc';
  *
  * 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 AnyDatabaseSchema, 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 PrimaryKeyValue<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = DB[TTable]['primaryKey'] extends keyof DB[TTable]['columns']
+export type SelectedRow<DB extends AnyDatabaseSchema, _TTable extends keyof DB & string, TSelected,> = Readonly<TSelected>;
+declare type PrimaryKeyValue<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = DB[TTable]['primaryKey'] extends keyof DB[TTable]['columns']
     ? DB[TTable]['columns'][DB[TTable]['primaryKey']]
     : unknown;
 declare type NumericColumnName<Columns> = {
@@ -508,7 +509,7 @@ declare type NumericColumnName<Columns> = {
     ? K
     : Exclude<Columns[K], null | undefined> extends number ? K : never
 }[keyof Columns & string];
-declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string> = TTables extends any
+declare type JoinColumn<DB extends AnyDatabaseSchema, TTables extends string> = TTables extends any
   ? `${TTables}.${keyof DB[TTables]['columns'] & string}`
   : never;
 /**
@@ -521,20 +522,20 @@ declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string>
  * untyped schemas keep compiling. A table that declares ZERO relations
  * yields `never` — every relation name is rejected.
  */
-export type TableRelationName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = DB[TTable] extends { relations?: infer R }
+export type TableRelationName<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = DB[TTable] extends { relations?: infer R }
     ? unknown extends R ? string : keyof NonNullable<R> & string
     : string;
-declare type RelatedTableName<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = DB[TTable] extends { relations?: infer Relations }
+declare type RelatedTableName<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = DB[TTable] extends { relations?: infer Relations }
   ? TRelation extends keyof NonNullable<Relations>
     ? Extract<NonNullable<Relations>[TRelation], keyof DB & string>
     : keyof DB & string
   : keyof DB & string;
-declare type RelationQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = SelectQueryBuilder<
+declare type RelationQueryBuilder<DB extends AnyDatabaseSchema, TTable extends keyof DB & string, TRelation extends TableRelationName<DB, TTable>,> = SelectQueryBuilder<
   DB,
   RelatedTableName<DB, TTable, TRelation>,
   DB[RelatedTableName<DB, TTable, TRelation>]['columns']
 >;
-declare type RelationConstraintRecord<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = {
+declare type RelationConstraintRecord<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = {
   [R in TableRelationName<DB, TTable>]: Partial<Record<R, (qb: RelationQueryBuilder<DB, TTable, R>) => unknown>>
 }[TableRelationName<DB, TTable>];
 /**
@@ -546,7 +547,7 @@ declare type RelationConstraintRecord<DB extends DatabaseSchema<any>, TTable ext
  * relations accepts nothing (the bare `Partial<Record<never, ...>>` would be
  * `{}`, which strings are assignable to — hence the explicit never guard).
  */
-export type WithRelationArg<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = [TableRelationName<DB, TTable>] extends [never]
+export type WithRelationArg<DB extends AnyDatabaseSchema, TTable extends keyof DB & string> = [TableRelationName<DB, TTable>] extends [never]
     ? never
     :
       | TableRelationName<DB, TTable>
@@ -559,7 +560,7 @@ declare type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
 // 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 AnyDatabaseSchema, 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} = ?`>
@@ -577,7 +578,7 @@ declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable ex
 // untyped variant (returning a plain SelectQueryBuilder) would win overload
 // resolution, silently downgrading `toSQL()` from the composed literal SQL
 // type back to `string` after any dynamic-where call.
-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 AnyDatabaseSchema, 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'
 > & _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
@@ -616,16 +617,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 AnyDatabaseSchema, 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 AnyDatabaseSchema, 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 AnyDatabaseSchema, 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']>[],
@@ -642,8 +643,8 @@ export type TypedInsertQueryBuilder<DB extends DatabaseSchema<any>, TTable exten
 }
 declare type TransactionIsolation = 'read committed' | 'repeatable read' | 'serializable';
 declare class QueryCache {
-  get(key: string): any | null;
-  set(key: string, data: any, ttlMs: number): void;
+  get<T = unknown>(key: string): T | null;
+  set(key: string, data: unknown, ttlMs: number): void;
   clear(): void;
   setMaxSize(size: number): void;
 }

package/dist/db.d.ts

@@ -1,6 +1,20 @@
 import { Database } from 'bun:sqlite';
 import { SQL } from 'bun';
+import type { SQLQueryBindings } from 'bun:sqlite';
 import type { DatabaseConfig, PoolConfig, SupportedDialect } from './types';
+/**
+ * The one place user values become driver bindings.
+ *
+ * Everything a caller interpolates arrives as `unknown` - that is honest, we
+ * do not know what it is. bun:sqlite accepts a narrower set. The conversion is
+ * unchecked because the driver itself is the validator: it throws a clear
+ * "can't bind" for anything it cannot take, and a check here would only
+ * duplicate that rule and drift from it. Kept as one named function so the
+ * boundary is visible, rather than an `any` at each of the six call sites.
+ */
+export declare function toBindings(params: readonly unknown[]): SQLQueryBindings[];
+/** A template value seen as a possible fragment; null when it is a plain bind param. */
+export declare function asEmbeddedValue(value: unknown): EmbeddedValue | null;
 /**
  * SQLite wrapper that provides a SQL-like tagged template literal interface
  * using bun:sqlite's Database class for better compiled binary support.
@@ -29,7 +43,7 @@ import type { DatabaseConfig, PoolConfig, SupportedDialect } from './types';
  * numbered placeholders is returned untouched, so `?` queries and Bun's own
  * tagged-template output are unaffected.
  */
-export declare function bindNumberedPlaceholders(sql: string, params: any[]): { sql: string, params: any[] };
+export declare function bindNumberedPlaceholders<T>(sql: string, params: T[]): { sql: string, params: T[] };
 export declare function splitSqlStatements(sql: string): string[];
 /**
  * Creates a database connection string based on the configured dialect and database settings.
@@ -108,6 +122,22 @@ export declare const bunSql: SQL;
  * Both Bun's native `SQL` query and our `createSQLiteSQL` wrapper satisfy this.
  * See stacksjs/bun-query-builder#1044.
  */
+/**
+ * What a value interpolated into a tagged template can turn out to be.
+ *
+ * Three things arrive here: a plain bind param, a nested query (carries `sql`
+ * plus a `values` ARRAY), and a raw-SQL marker (carries `__raw`/`raw` and no
+ * `values`). Naming the shape is what lets the branches below read properties
+ * without an `any` - and the order of those branches is load-bearing, see
+ * stacksjs/bun-query-builder#1084.
+ */
+export declare interface EmbeddedValue {
+  sql?: unknown
+  values?: unknown
+  __raw?: unknown
+  raw?: unknown
+  value?: unknown
+}
 export declare interface DriverQuery {
   execute: () => Promise<any>
   values?: () => any
@@ -124,10 +154,10 @@ export declare interface DriverQuery {
  * casts be dropped. See stacksjs/bun-query-builder#1044.
  */
 export declare interface DriverConnection {
-  (strings: TemplateStringsArray, ...values: any[]): DriverQuery
+  (strings: TemplateStringsArray, ...values: unknown[]): DriverQuery
   (value: any): any
-  unsafe: (sql: string, values?: any[]) => AwaitableDriverQuery
-  query?: (sql: string, params?: any[]) => any
+  unsafe: (sql: string, values?: unknown[]) => AwaitableDriverQuery
+  query?: (sql: string, params?: unknown[]) => any
   close?: () => Promise<void> | void
   _prepareStatement?: (sql: string) => any
   [key: string]: any
@@ -136,8 +166,8 @@ export declare interface DriverConnection {
 export type AwaitableDriverQuery = DriverQuery & PromiseLike<any>;
 declare class SQLiteWrapper {
   constructor(filename: string);
-  query(sql: string, params?: any[]): any[];
-  run(sql: string, params?: any[]): any;
+  query(sql: string, params?: SQLQueryBindings[]): any[];
+  run(sql: string, params?: SQLQueryBindings[]): any;
   close(): void;
   get database(): Database;
 }

package/dist/dynamodb-client.d.ts

@@ -11,12 +11,31 @@ export declare function createDynamoDBItemBuilder<T = any>(options: DynamoDBQuer
  * Create a DynamoDB client with fluent query builder methods
  */
 export declare function createDynamoDBClient(options: DynamoDBQueryBuilderOptions): DynamoDBClientMethods;
+/**
+ * The AWS SDK client, described by the one method this package uses.
+ *
+ * `@aws-sdk/client-dynamodb` is not a dependency (callers bring their own),
+ * so the shape is structural: anything with a `send` satisfies it, including
+ * the real `DynamoDBClient` and a test double.
+ */
+export declare interface DynamoDBClientLike {
+  send: (command: unknown) => Promise<unknown>
+  [key: string]: unknown
+}
+/** What DynamoDB reports about the capacity a call consumed. */
+export declare interface DynamoDBConsumedCapacity {
+  TableName?: string
+  CapacityUnits?: number
+  ReadCapacityUnits?: number
+  WriteCapacityUnits?: number
+  [key: string]: unknown
+}
 /**
  * DynamoDB Query Builder Options
  */
 export declare interface DynamoDBQueryBuilderOptions {
   config: DynamoDBConfig
-  client?: any
+  client?: DynamoDBClientLike
 }
 /**
  * Result type for DynamoDB operations
@@ -27,7 +46,7 @@ export declare interface DynamoDBResult<T = any> {
   count?: number
   scannedCount?: number
   lastEvaluatedKey?: Record<string, any>
-  consumedCapacity?: any
+  consumedCapacity?: DynamoDBConsumedCapacity
 }
 /**
  * DynamoDB Client Factory
@@ -41,6 +60,26 @@ export declare interface DynamoDBClientMethods {
   registerEntity: (mapping: SingleTableEntityMapping) => void
   buildKey: (entityType: string, values: Record<string, any>) => { pk: string, sk: string }
 }
+/**
+ * A value DynamoDB can store or compare against.
+ *
+ * DynamoDB's type system is small and closed - scalars, binary, lists and
+ * maps - so the attribute surface below says that rather than `any`. A value
+ * outside this set could never have round-tripped through the wire format.
+ */
+export type DynamoDBValue = | string
+  | number
+  | boolean
+  | null
+  | Uint8Array
+  | DynamoDBValue[]
+  | { [key: string]: DynamoDBValue }
+/** Every operator a DynamoDB filter expression accepts. */
+export type DynamoDBFilterOperator = | DynamoDBComparisonOperator
+  | 'contains'
+  | 'attribute_exists'
+  | 'attribute_not_exists'
+  | 'IN';
 /**
  * DynamoDB Query Builder
  *
@@ -51,23 +90,23 @@ export declare class DynamoDBQueryBuilder<T = any> {
   table(tableName: string): this;
   index(indexName: string): this;
   entity(entityType: string): this;
-  whereKey(attribute: string, operator: DynamoDBComparisonOperator, value: any): this;
-  wherePartitionKey(attribute: string, value: any): this;
-  whereSortKey(attribute: string, value: any): this;
+  whereKey(attribute: string, operator: DynamoDBComparisonOperator, value: DynamoDBValue): this;
+  wherePartitionKey(attribute: string, value: DynamoDBValue): this;
+  whereSortKey(attribute: string, value: DynamoDBValue): this;
   whereSortKeyBeginsWith(attribute: string, prefix: string): this;
-  whereSortKeyBetween(attribute: string, start: any, end: any): this;
-  where(attribute: string, operator: DynamoDBComparisonOperator | 'contains' | 'attribute_exists' | 'attribute_not_exists' | 'IN', value?: any): this;
-  whereEquals(attribute: string, value: any): this;
-  whereLessThan(attribute: string, value: any): this;
-  whereLessThanOrEqual(attribute: string, value: any): this;
-  whereGreaterThan(attribute: string, value: any): this;
-  whereGreaterThanOrEqual(attribute: string, value: any): this;
-  whereBetween(attribute: string, start: any, end: any): this;
+  whereSortKeyBetween(attribute: string, start: DynamoDBValue, end: DynamoDBValue): this;
+  where(attribute: string, operator: DynamoDBFilterOperator, value?: DynamoDBValue): this;
+  whereEquals(attribute: string, value: DynamoDBValue): this;
+  whereLessThan(attribute: string, value: DynamoDBValue): this;
+  whereLessThanOrEqual(attribute: string, value: DynamoDBValue): this;
+  whereGreaterThan(attribute: string, value: DynamoDBValue): this;
+  whereGreaterThanOrEqual(attribute: string, value: DynamoDBValue): this;
+  whereBetween(attribute: string, start: DynamoDBValue, end: DynamoDBValue): this;
   whereBeginsWith(attribute: string, prefix: string): this;
-  whereContains(attribute: string, value: any): this;
+  whereContains(attribute: string, value: DynamoDBValue): this;
   whereExists(attribute: string): this;
   whereNotExists(attribute: string): this;
-  whereIn(attribute: string, values: any[]): this;
+  whereIn(attribute: string, values: DynamoDBValue[]): this;
   select(...attributes: string[]): this;
   limit(count: number): this;
   ascending(): this;
@@ -93,11 +132,11 @@ export declare class DynamoDBItemBuilder<T = any> {
   table(tableName: string): this;
   key(key: Record<string, any>): this;
   item(data: Record<string, any>): this;
-  set(attribute: string, value: any): this;
+  set(attribute: string, value: DynamoDBValue): this;
   setMany(values: Record<string, any>): this;
   remove(attribute: string): this;
-  add(attribute: string, value: any): this;
-  deleteFromSet(attribute: string, values: any): this;
+  add(attribute: string, value: DynamoDBValue): this;
+  deleteFromSet(attribute: string, values: DynamoDBValue): this;
   condition(expression: string): this;
   ifNotExists(attribute?: string): this;
   ifExists(attribute?: string): this;

package/dist/dynamodb-single-table.d.ts

@@ -1,4 +1,4 @@
-import type { DynamoDBQueryBuilderOptions } from './dynamodb-client';
+import type { DynamoDBFilterOperator, DynamoDBQueryBuilderOptions, DynamoDBValue } from './dynamodb-client';
 import type { DynamoDBTableDefinition } from './drivers/dynamodb';
 /**
  * Create a single table manager
@@ -135,7 +135,7 @@ export declare class SingleTableQueryBuilder<T> {
   whereSortKey(skData: Record<string, any>): this;
   whereSortKeyBeginsWith(prefix: string): this;
   useIndex(indexName: string, pkData: Record<string, any>): this;
-  where(attribute: string, operator: any, value?: any): this;
+  where(attribute: string, operator: DynamoDBFilterOperator, value?: DynamoDBValue): this;
   select(...attributes: string[]): this;
   limit(count: number): this;
   descending(): this;

package/dist/dynamodb-tooling-adapter.d.ts

@@ -1,6 +1,7 @@
 import { DynamoDBItemBuilder, DynamoDBQueryBuilder } from './dynamodb-client';
 import { SingleTableManager, SingleTableRepository } from './dynamodb-single-table';
-import type { DynamoDBDriver } from './drivers/dynamodb';
+import type { DynamoDBClientLike } from './dynamodb-client';
+import type { DynamoDBDriver, DynamoDBTableDefinition } from './drivers/dynamodb';
 /**
  * Resolve key pattern placeholders with actual values
  */
@@ -8,7 +9,7 @@ export declare function resolveKeyPattern(keyPatterns: KeyPatterns, data: Record
 /**
  * Parse models from configuration (stub implementation)
  */
-export declare function parseStacksModels(_config: any): Promise<{ models: Map<string, ParsedModel> }>;
+export declare function parseStacksModels(_config: unknown): Promise<{ models: Map<string, ParsedModel> }>;
 /**
  * Convert model instance to DynamoDB item format (stub)
  */
@@ -63,7 +64,7 @@ export declare interface ParsedAttribute {
   nullable: boolean
   unique: boolean
   hidden: boolean
-  defaultValue?: any
+  defaultValue?: unknown
   cast?: string
   dynamoDbType: 'S' | 'N' | 'B' | 'BOOL' | 'NULL' | 'M' | 'L' | 'SS' | 'NS' | 'BS'
 }
@@ -127,7 +128,7 @@ export declare interface StacksModel {
     nullable?: boolean
     unique?: boolean
     hidden?: boolean
-    default?: any
+    default?: unknown
     cast?: string
     validation?: { rule?: string }
   }>
@@ -177,7 +178,7 @@ export declare interface DynamoDBToolingConfig {
  */
 export declare class DynamoDBToolingAdapter {
   constructor(config: DynamoDBToolingConfig);
-  setClient(client: any): this;
+  setClient(client: DynamoDBClientLike): this;
   discoverModels(): Promise<ParsedModel[]>;
   registerModel(model: StacksModel): ParsedModel;
   registerParsedModel(parsed: ParsedModel): ParsedModel;
@@ -192,6 +193,6 @@ export declare class DynamoDBToolingAdapter {
   parseItem<T = any>(item: Record<string, any>): { type: string, data: T } | undefined;
   getDriver(): DynamoDBDriver;
   getSingleTableManager(): SingleTableManager;
-  generateTableDefinition(): any;
+  generateTableDefinition(): DynamoDBTableDefinition;
   generateAccessPatterns(modelName: string): AccessPattern[];
 }

package/dist/meta.d.ts

@@ -17,6 +17,6 @@ export declare interface SchemaMeta {
     morphToMany?: Record<string, string>
     morphedByMany?: Record<string, string>
   }>
-  scopes?: Record<string, Record<string, (qb: any, value?: any) => any>>
+  scopes?: Record<string, Record<string, (qb: any, value?: unknown) => unknown>>
   models?: ModelRecord
 }

package/dist/orm.d.ts

@@ -16,18 +16,9 @@ export type {
 };
 /** Drops the `createModel` models. Paired with `clearModelRegistry()`. */
 export declare function clearLocalModels(): void;
-/**
- * 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;
+export declare function extractChanges(res: WriteResultLike | null | undefined): number;
 /** Extract a generated primary key from a Bun SQL driver result. */
-export declare function extractInsertId(res: any): number | bigint | null;
+export declare function extractInsertId(res: WriteResultLike | null | undefined): number | bigint | null;
 export declare function configureOrm(options: { database?: string | Database; verbose?: boolean }): void;
 /**
  * Return the underlying `bun:sqlite` Database backing the model layer.
@@ -140,8 +131,8 @@ export declare interface ModelDefinition {
   readonly attributes: {
     readonly [key: string]: TypedAttribute<unknown>
   }
-  readonly get?: Record<string, (attributes: any) => unknown>
-  readonly set?: Record<string, (attributes: any) => unknown>
+  readonly get?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly set?: Record<string, (attributes: Record<string, unknown>) => unknown>
   readonly scopes?: Record<string, (value: unknown) => unknown>
   readonly indexes?: readonly object[]
   readonly dashboard?: { readonly enabled?: boolean; readonly highlight?: boolean | number }
@@ -162,6 +153,33 @@ declare interface OrmExecutor {
   insert: (sql: string, params: unknown[], primaryKey: string) => Promise<RunResult>
   readonly sqliteDb?: Database
 }
+/**
+ * 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.
+ */
+/**
+ * What a driver hands back after a write.
+ *
+ * Each one reports the affected count under its own name - and Postgres
+ * returns an empty array carrying `count`, so the shape is genuinely a union
+ * rather than one thing. Naming the fields beats `any`: a caller reading this
+ * type learns which drivers report what.
+ */
+export declare interface WriteResultLike {
+  affectedRows?: number
+  count?: number
+  changes?: number
+  lastInsertRowid?: number | bigint
+  insertId?: number | bigint
+  command?: string
+  rows?: unknown[]
+  [key: string]: unknown
+}
 /**
  * Resolve a relation from its name and the parent model's definition.
  * Uses the model registry to find the related model's definition.

package/dist/schema.d.ts

@@ -171,15 +171,46 @@ export declare interface ModelOptions extends Base {
   morphToMany?: MorphToMany<ModelNames>
   morphedByMany?: MorphedByMany<ModelNames>
   scopes?: {
-    [key: string]: (value: any) => any
+    [key: string]: (value: any) => unknown
   }
   get?: {
-    [key: string]: (value: any) => any
+    [key: string]: (value: any) => unknown
   }
   set?: {
-    [key: string]: (value: any) => any
+    [key: string]: (value: any) => unknown
   }
 }
+/**
+ * # `DatabaseSchema<Models>`
+ *
+ * Maps model definitions to a concrete database schema shape containing the
+ * table columns and primary key. This is the primary input for the query
+ * builder's type-safety.
+ *
+ * The `relations` field is type-level only (phantom): `buildDatabaseSchema`
+ * never materializes it at runtime. It maps relation names to related table
+ * names so builder methods like `.with()` can narrow their accepted relation
+ * names per table.
+ *
+ * @example
+ * ```ts
+ * const models = defineModels({ User, Post })
+ * type Schema = DatabaseSchema<typeof models>
+ * ```
+ */
+/**
+ * Any database schema, described by its shape rather than by `any`.
+ *
+ * Generic constraints throughout the client read `DB extends DatabaseSchema<any>`,
+ * which says "a schema of anything" and drags `any` into every published
+ * signature that mentions one. This says the same thing accurately: a schema
+ * is tables, each with columns, a primary key, and optionally relations.
+ */
+export declare interface AnySchemaTable {
+  columns: Record<string, unknown>
+  primaryKey?: unknown
+  relations?: Record<string, string> | undefined
+}
 /**
  * # `ValidatorMessage`
  *
@@ -316,24 +347,7 @@ declare type RelatedTableName<MRecord extends ModelRecord, ModelName> = ModelNam
 export type InferTableRelations<M, MRecord extends ModelRecord> = {
   [K in keyof ModelRelationsRecord<UnwrapModelDefinition<M>> & string]: RelatedTableName<MRecord, ModelRelationsRecord<UnwrapModelDefinition<M>>[K]>
 }
-/**
- * # `DatabaseSchema<Models>`
- *
- * Maps model definitions to a concrete database schema shape containing the
- * table columns and primary key. This is the primary input for the query
- * builder's type-safety.
- *
- * The `relations` field is type-level only (phantom): `buildDatabaseSchema`
- * never materializes it at runtime. It maps relation names to related table
- * names so builder methods like `.with()` can narrow their accepted relation
- * names per table.
- *
- * @example
- * ```ts
- * const models = defineModels({ User, Post })
- * type Schema = DatabaseSchema<typeof models>
- * ```
- */
+export type AnyDatabaseSchema = Record<string, AnySchemaTable>;
 export type DatabaseSchema<MRecord extends ModelRecord> = {
   [MName in keyof MRecord & string as InferTableName<UnwrapModelDefinition<MRecord[MName]>>]: {
     columns: InferAttributes<UnwrapModelDefinition<MRecord[MName]>>

package/dist/seeder.d.ts

@@ -17,12 +17,22 @@ export declare interface RunSeederOptions {
   class?: string
   verbose?: boolean
 }
+/**
+ * The query builder handed to a seeder.
+ *
+ * A seeder is written against the app's own schema, which this base class
+ * cannot know, so the handle stays `any` deliberately - narrowing it here
+ * would reject every real seeder's typed table access. Named rather than
+ * inline so the reason travels with it.
+ */
+// eslint-disable-next-line ts/no-explicit-any
+export type SeederQueryBuilder = any;
 /**
  * Base seeder class that all seeders should extend.
  * Provides access to query builder and faker for generating test data.
  */
 export declare abstract class Seeder {
-  abstract run(qb: any): Promise<void>;
+  abstract run(qb: SeederQueryBuilder): Promise<void>;
   get order(): number;
   get description(): string | undefined;
 }

package/dist/sql-fragments.d.ts

@@ -32,7 +32,7 @@ export declare function renderWhereTerms(terms: readonly WhereTerm[]): string;
  * happened to come back empty — the same shape of silent, widening-or-narrowing
  * failure as the `IN ()` bug itself.
  */
-export declare function renderInPredicate(column: string, values: any[], negated: boolean, placeholders: string): string;
+export declare function renderInPredicate(column: string, values: readonly unknown[], negated: boolean, placeholders: string): string;
 /**
  * Rewrite `?` placeholders into the numbered form Postgres requires.
  *

package/dist/src/browser.js

@@ -139,7 +139,7 @@ class BrowserQueryBuilder {
     return this;
   }
   andWhere(column, operatorOrValue, value) {
-    return this.where(column, operatorOrValue, value);
+    return value === undefined ? this.where(column, operatorOrValue) : this.where(column, operatorOrValue, value);
   }
   whereNull(column) {
     return this.where(column, "is", null);

package/dist/src/index.js

@@ -139,7 +139,7 @@ class BrowserQueryBuilder {
     return this;
   }
   andWhere(column, operatorOrValue, value) {
-    return this.where(column, operatorOrValue, value);
+    return value === undefined ? this.where(column, operatorOrValue) : this.where(column, operatorOrValue, value);
   }
   whereNull(column) {
     return this.where(column, "is", null);
@@ -11861,6 +11861,12 @@ import { Database } from "bun:sqlite";
 import { mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname5 } from "path";
 import process21 from "process";
+function toBindings(params) {
+  return params;
+}
+function asEmbeddedValue(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
 function bindNumberedPlaceholders(sql, params) {
   if (params.length === 0 || !/\$\d/.test(sql))
     return { sql, params };
@@ -12049,11 +12055,13 @@ function createSQLiteSQL(filename) {
     const params = [];
     for (let i = 0;i < values.length; i++) {
       const value = values[i];
-      if (value && typeof value === "object" && typeof value.sql === "string" && Array.isArray(value.values)) {
-        sql += value.sql + (strings[i + 1] || "");
-        params.push(...value.values);
-      } else if (value && typeof value === "object" && (value.__raw || value.raw)) {
-        const rawValue = value.__raw ? value.value : typeof value.raw === "string" ? value.raw : value.raw();
+      const embedded = asEmbeddedValue(value);
+      if (embedded && typeof embedded.sql === "string" && Array.isArray(embedded.values)) {
+        sql += embedded.sql + (strings[i + 1] || "");
+        params.push(...embedded.values);
+      } else if (embedded && (embedded.__raw || embedded.raw)) {
+        const raw = embedded.raw;
+        const rawValue = embedded.__raw ? embedded.value : typeof raw === "string" ? raw : raw();
         sql += rawValue + (strings[i + 1] || "");
       } else if (Array.isArray(value)) {
         const placeholders = value.map(() => "?").join(", ");
@@ -12071,10 +12079,10 @@ function createSQLiteSQL(filename) {
         try {
           const trimmed = sql.trim().toUpperCase();
           if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-            const result = wrapper.query(sql, params);
+            const result = wrapper.query(sql, toBindings(params));
             return Promise.resolve(result);
           } else {
-            const result = wrapper.run(sql, params);
+            const result = wrapper.run(sql, toBindings(params));
             return Promise.resolve(result);
           }
         } catch (error) {
@@ -12101,10 +12109,10 @@ function createSQLiteSQL(filename) {
       try {
         const trimmed = sql.trim().toUpperCase();
         if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || /\bRETURNING\b/.test(trimmed)) {
-          const result = wrapper.query(sql, params);
+          const result = wrapper.query(sql, toBindings(params));
           return Promise.resolve(result);
         } else {
-          const result = wrapper.run(sql, params);
+          const result = wrapper.run(sql, toBindings(params));
           return Promise.resolve(result);
         }
       } catch (error) {
@@ -12127,7 +12135,7 @@ function createSQLiteSQL(filename) {
   };
   sqlFunction.query = (sql, params) => {
     try {
-      const result = wrapper.query(sql, params || []);
+      const result = wrapper.query(sql, toBindings(params || []));
       return Promise.resolve(result);
     } catch (error) {
       return Promise.reject(error);
@@ -14935,6 +14943,10 @@ function createQueryBuilder(state) {
         built = null;
         return this;
       },
+      $call(callback) {
+        callback(this);
+        return this;
+      },
       union(other) {
         appendSetOp("UNION", other);
         return this;
@@ -26783,6 +26795,18 @@ class ModelQueryBuilder {
       return "";
     return this._trashed === "only" ? `${SOFT_DELETE_COLUMN} IS NOT NULL` : `${SOFT_DELETE_COLUMN} IS NULL`;
   }
+  assertNoUnappliedClauses(method) {
+    const ignored = [];
+    if (this._limit !== undefined)
+      ignored.push("limit()");
+    if (this._offset !== undefined)
+      ignored.push("offset()");
+    if (this._orderBy.length > 0)
+      ignored.push("orderBy()");
+    if (ignored.length > 0) {
+      throw new TypeError(`[orm] ${method}() cannot apply ${ignored.join(", ")} \u2014 an UPDATE/DELETE takes no ORDER BY or LIMIT on every supported dialect. ` + `Previously these were ignored, so the statement affected every matching row. Narrow it with where() instead.`);
+    }
+  }
   composeWhere(params) {
     const userClause = this._wheres.length > 0 ? this.buildWhereClauses(params) : "";
     const sd = this.softDeleteClause();
@@ -27032,6 +27056,7 @@ class ModelQueryBuilder {
   }
   async increment(column, amount = 1) {
     assertValidIdentifier(column, "increment(column)");
+    this.assertNoUnappliedClauses("increment");
     const exec = getExecutor();
     const params = [amount];
     const incCol = sqlColumn(column);
@@ -27040,9 +27065,9 @@ class ModelQueryBuilder {
       sql2 += `, updated_at = ?`;
       params.push(formatNow());
     }
-    if (this._wheres.length > 0) {
-      const clauses = this.buildWhereClauses(params);
-      sql2 += ` WHERE ${clauses}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }
@@ -27141,15 +27166,18 @@ class ModelQueryBuilder {
     return Number(await this.aggregate("SUM", column) ?? 0) || 0;
   }
   async delete() {
+    this.assertNoUnappliedClauses("delete");
     const exec = getExecutor();
     const params = [];
     let sql2 = `DELETE FROM ${this._definition.table}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }
   async update(data) {
+    this.assertNoUnappliedClauses("update");
     const exec = getExecutor();
     const entries = Object.entries(data);
     const sets = entries.map(([k2]) => `${sqlColumn(k2)} = ?`).join(", ");
@@ -27158,8 +27186,9 @@ class ModelQueryBuilder {
       params.push(formatNow());
     }
     let sql2 = `UPDATE ${this._definition.table} SET ${sets}${timestampsEnabled(this._definition) ? ", updated_at = ?" : ""}`;
-    if (this._wheres.length > 0) {
-      sql2 += ` WHERE ${this.buildWhereClauses(params)}`;
+    const whereBody = this.composeWhere(params);
+    if (whereBody) {
+      sql2 += ` WHERE ${whereBody}`;
     }
     return (await exec.run(sql2, params)).changes;
   }

package/dist/types.d.ts

@@ -134,25 +134,25 @@ export declare interface SqlConfig {
   sharedLockSyntax?: 'FOR SHARE' | 'LOCK IN SHARE MODE'
   jsonContainsMode?: 'operator' | 'function'
 }
-/**
- * # `QueryHooks`
- *
- * Optional lifecycle hooks around query execution. These are invoked for any
- * statement executed through the builder (select/insert/update/delete/raw).
- */
+/** Common fields on every query lifecycle event. */
+export declare interface QueryEvent {
+  sql: string
+  params?: QueryParam[]
+  kind?: QueryKind
+}
 export declare interface QueryHooks {
-  onQueryStart?: (event: { sql: string, params?: any[], kind?: 'select' | 'insert' | 'update' | 'delete' | 'raw' }) => void
-  onQueryEnd?: (event: { sql: string, params?: any[], durationMs: number, rowCount?: number, kind?: 'select' | 'insert' | 'update' | 'delete' | 'raw' }) => void
-  onQueryError?: (event: { sql: string, params?: any[], error: any, durationMs: number, kind?: 'select' | 'insert' | 'update' | 'delete' | 'raw' }) => void
-  startSpan?: (event: { sql: string, params?: any[], kind?: 'select' | 'insert' | 'update' | 'delete' | 'raw' }) => { end: (error?: any) => void }
+  onQueryStart?: (event: QueryEvent) => void
+  onQueryEnd?: (event: QueryEvent & { durationMs: number, rowCount?: number }) => void
+  onQueryError?: (event: QueryEvent & { error: unknown, durationMs: number }) => void
+  startSpan?: (event: QueryEvent) => { end: (error?: unknown) => void }
   slowQueryThresholdMs?: number
-  onSlowQuery?: (event: { sql: string, params?: any[], durationMs: number, kind?: 'select' | 'insert' | 'update' | 'delete' | 'raw' }) => void
-  beforeCreate?: (event: { table: string, data: any }) => void | Promise<void>
-  afterCreate?: (event: { table: string, data: any, result: any }) => void | Promise<void>
-  beforeUpdate?: (event: { table: string, data: any, where?: any }) => void | Promise<void>
-  afterUpdate?: (event: { table: string, data: any, where?: any, result: any }) => void | Promise<void>
-  beforeDelete?: (event: { table: string, where?: any }) => void | Promise<void>
-  afterDelete?: (event: { table: string, where?: any, result: any }) => void | Promise<void>
+  onSlowQuery?: (event: QueryEvent & { durationMs: number }) => void
+  beforeCreate?: (event: { table: string, data: QueryRecord }) => void | Promise<void>
+  afterCreate?: (event: { table: string, data: QueryRecord, result: unknown }) => void | Promise<void>
+  beforeUpdate?: (event: { table: string, data: QueryRecord, where?: QueryWhere }) => void | Promise<void>
+  afterUpdate?: (event: { table: string, data: QueryRecord, where?: QueryWhere, result: unknown }) => void | Promise<void>
+  beforeDelete?: (event: { table: string, where?: QueryWhere }) => void | Promise<void>
+  afterDelete?: (event: { table: string, where?: QueryWhere, result: unknown }) => void | Promise<void>
 }
 /**
  * # `FeatureToggles`
@@ -208,7 +208,7 @@ export declare interface BrowserConfig {
   onUnauthorized?: () => void
   headers?: Record<string, string>
   timeout?: number
-  transformResponse?: <T>(response: any) => T
+  transformResponse?: <T>(response: unknown) => T
   transformRequest?: <T>(data: T) => any
 }
 /**
@@ -284,7 +284,7 @@ export declare interface GenerateMigrationResult {
   sql: string
   sqlStatements: string[]
   hasChanges: boolean
-  plan: any
+  plan: import('./migrations').MigrationPlan
   operations?: import('./migrations').MigrationOperation[]
 }
 export declare interface UnsafeOptions {
@@ -309,6 +309,20 @@ export declare interface UnsafeOptions {
  * - 'browser': Browser-compatible mode that uses fetch() API calls instead of direct database connections
  */
 export type SupportedDialect = 'postgres' | 'mysql' | 'singlestore' | 'vitess' | 'sqlite' | 'browser';
+/**
+ * # `QueryHooks`
+ *
+ * Optional lifecycle hooks around query execution. These are invoked for any
+ * statement executed through the builder (select/insert/update/delete/raw).
+ */
+/** A bound statement parameter: whatever a driver will accept as a value. */
+export type QueryParam = string | number | bigint | boolean | Date | Uint8Array | null;
+/** The kind of statement a hook is reporting on. */
+export type QueryKind = 'select' | 'insert' | 'update' | 'delete' | 'raw';
+/** The row shape a hook sees. Columns are unknown until the caller narrows. */
+export type QueryRecord = Record<string, unknown>;
+/** A `where` description as the mutation hooks receive it. */
+export type QueryWhere = Record<string, unknown>;
 /**
  * # `DeepPartial`
  *
@@ -340,7 +354,7 @@ export type SupportedDialect = 'postgres' | 'mysql' | 'singlestore' | 'vitess' |
  *     signature is not a property. `keyof (() => void)` is `never`, so the
  *     hook collapses to an empty object type: no longer callable, and loose
  *     enough to accept `42`. It also erases type parameters, which would turn
- *     `BrowserConfig.transformResponse` (`<T>(response: any) => T`) into a
+ *     `BrowserConfig.transformResponse` (`<T>(response: unknown) => T`) into a
  *     shape with no signature at all. A hook or a token getter is a leaf.
  *
  *  2. ARRAYS SECOND, because the merge replaces them rather than merging them.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.2.44",
+  "version": "0.2.46",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",