bun-query-builder 0.1.23 → 0.1.25

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import type { BrowserConfig } from './types';
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
 // Export types for external use
 export type { BrowserModelInstance, BrowserModelQueryBuilder };
 /**

package/dist/client.d.ts

@@ -32,9 +32,9 @@ export declare interface WhereRaw {
 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>
+  selectRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   where: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => SelectQueryBuilder<DB, TTable, TSelected>
-  whereRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -100,13 +100,13 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   crossJoin: <T2 extends keyof DB & string>(table: T2) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
   crossJoinSub: (sub: { toSQL: () => any }, alias: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   groupBy: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  groupByRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  groupByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  havingRaw: (fragment: 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>
   selectAll?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orderByRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orderByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   union: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   unionAll: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   forPage: (page: number, perPage: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -356,6 +356,28 @@ export declare interface TransactionOptions {
 declare type Primitive = string | number | boolean | bigint | Date | null | undefined;
 declare type ValueOrRef = Primitive;
 export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not';
+/**
+ * Brand for SQL fragments produced by Bun's `sql\`...\`` tagged-template
+ * (or any equivalent helper). Typed as `object` so the *Raw methods
+ * (`whereRaw`, `selectRaw`, `groupByRaw`, `havingRaw`, `orderByRaw`)
+ * refuse to compile when passed a bare string — concatenated user
+ * input (`whereRaw(\`status = '${req.body.s}'\`)`) was the canonical
+ * SQL-injection vector flagged by the audit as Q-3.
+ *
+ * Callers who legitimately need raw SQL use `sql\`...\`` which
+ * separates the SQL fragment from parameter values:
+ *
+ * ```ts
+ * import { sql } from 'bun'
+ * db.selectFrom('users').whereRaw(sql\`lower(name) = lower(${input})\`)
+ * ```
+ *
+ * The runtime guard in each *Raw method also rejects bare strings as
+ * a defense-in-depth backstop for `as any` casts.
+ *
+ * See stacksjs/stacks#1858 Q-3.
+ */
+export type SqlFragment = object;
 export type WhereExpression<TableColumns> = | Partial<{ [K in keyof TableColumns & string]: ValueOrRef | ValueOrRef[] }>
   | [key: keyof TableColumns & string, op: WhereOperator, value: ValueOrRef | ValueOrRef[]]
   | WhereRaw;

package/dist/config.d.ts

@@ -11,11 +11,6 @@ export declare function getPlaceholder(index: number): string;
  */
 export declare function getPlaceholders(count: number, startIndex?: number): string;
 export declare function getConfig(): Promise<QueryBuilderConfig>;
-/**
- * Programmatically set/override the query builder configuration.
- * This is useful when you want to configure bun-query-builder from
- * your application code rather than using a config file.
- */
 export declare function setConfig(userConfig: Partial<QueryBuilderConfig>): void;
 export declare const defaultConfig: QueryBuilderConfig;
 // For backwards compatibility — synchronous access with default fallback.

package/dist/drivers/sqlite.d.ts

@@ -18,7 +18,7 @@ export declare class SQLiteDriver implements 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, onDelete?: string, onUpdate?: 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;

package/dist/orm.d.ts

@@ -1,5 +1,6 @@
 import { Database, type SQLQueryBindings } from 'bun:sqlite';
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
+import type { SupportedDialect } from './types';
 export type {
   ModelInstance,
   ModelQueryBuilder,
@@ -13,12 +14,21 @@ export type {
   HiddenKeys,
 };
 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 +129,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 +252,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 +305,11 @@ 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>;
+  refresh(): Promise<this | null>;
   replicate(): ModelInstance<TDef, TSelected>;
   toArray(): Record<string, unknown>;
   toJSON(): Omit<Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>, HiddenKeys<TDef>>;
@@ -288,15 +337,15 @@ 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
@@ -339,18 +388,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 +409,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/schema.d.ts

@@ -1,4 +1,4 @@
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
 /**
  * # `defineModel(model)`
  *