bun-query-builder 0.1.41 → 0.1.45

package/dist/browser.d.ts

@@ -59,9 +59,9 @@ export declare function createBrowserModel<const TDef extends BrowserModelDefini
  * @defaultValue
  * ```ts
  * {
- *   login: (credentials?: { email: string, password: string }): Promise<BrowserAuthResponse> {
+ *   login: (credentials?: { email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
  *     const response) => Promise<unknown>,
- *   register: (data?: { name: string, email: string, password: string }): Promise<BrowserAuthResponse> {
+ *   register: (data?: { name: string, email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
  *     const response) => Promise<unknown>,
  *   logout: () => unknown,
  *   user: () => unknown,
@@ -73,11 +73,11 @@ export declare const browserAuth: {
   /**
    * Login and store token
    */
-  login: (credentials: { email: string, password: string }) => Promise<BrowserAuthResponse>;
+  login: (credentials: { email: string, password: string }) => Promise<;
   /**
    * Register a new user
    */
-  register: (data: { name: string, email: string, password: string }) => Promise<BrowserAuthResponse>;
+  register: (data: { name: string, email: string, password: string }) => Promise<;
   /**
    * Logout and clear token
    */
@@ -170,18 +170,6 @@ declare interface QueryState {
   selectColumns: string[]
   withRelations: string[]
 }
-/**
- * Response shape returned by `browserAuth.login` / `browserAuth.register`.
- * Lifted to a named type so the generated `.d.ts` doesn't carry a nested
- * inline object literal in the return position — bun-plugin-dtsx has a
- * bug where `Promise<{ ... }>` in that position emits as `Promise<;`,
- * breaking downstream typecheck for any consumer that imports from
- * `bun-query-builder/browser`.
- */
-export declare interface BrowserAuthResponse {
-  user: Record<string, unknown>
-  token: string
-}
 // Primitive type mappings
 declare type PrimitiveTypeMap = {
   string: string

package/dist/config.d.ts

@@ -1,4 +1,13 @@
-import type { QueryBuilderConfig } from './types';
+import type { QueryBuilderConfig, SupportedDialect } from './types';
+/**
+ * Whether a dialect belongs to the MySQL wire-protocol family (MySQL itself or
+ * SingleStore). These share `?` placeholders, backtick identifier quoting,
+ * `ON DUPLICATE KEY UPDATE` upserts, `LAST_INSERT_ID()` id recovery, and the
+ * `YYYY-MM-DD HH:MM:SS` datetime literal shape. Runtime DML branches should key
+ * off this helper rather than `dialect === 'mysql'` so SingleStore inherits the
+ * same behavior; only DDL (see `SingleStoreDriver`) diverges.
+ */
+export declare function isMysqlLike(dialect?: SupportedDialect): boolean;
 /**
  * Get the placeholder format for the current dialect.
  * PostgreSQL uses $1, $2, $3... while MySQL and SQLite use ?

package/dist/db.d.ts

@@ -1,6 +1,7 @@
 import { Database } from 'bun:sqlite';
 import { SQL } from 'bun';
 import type { PoolConfig } from './types';
+export declare function splitSqlStatements(sql: string): string[];
 /**
  * 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

package/dist/drivers/index.d.ts

@@ -1,5 +1,6 @@
 import { MySQLDriver } from './mysql';
 import { PostgresDriver } from './postgres';
+import { SingleStoreDriver } from './singlestore';
 import { SQLiteDriver } from './sqlite';
 import type { DialectDriver } from './postgres';
 import type { SupportedDialect } from '../types';
@@ -29,6 +30,7 @@ export type {
 export declare function getDialectDriver(dialect: SupportedDialect): DialectDriver;
 export { MySQLDriver } from './mysql';
 export { PostgresDriver } from './postgres';
+export { SingleStoreDriver } from './singlestore';
 export { SQLiteDriver } from './sqlite';
 // DynamoDB driver (NoSQL)
 export {

package/dist/drivers/mysql.d.ts

@@ -18,6 +18,11 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class MySQLDriver implements DialectDriver {
+  protected quoteIdentifier(id: string): string;
+  protected getColumnType(column: ColumnPlan): string;
+  protected getPrimaryKeyType(column: ColumnPlan): string;
+  protected getAutoIncrementClause(column: ColumnPlan): string;
+  protected getDefaultValue(column: ColumnPlan): string;
   createEnumType(_enumTypeName: string, _values: string[]): string;
   createTable(table: TablePlan): string;
   createIndex(tableName: string, index: IndexPlan): string;
@@ -34,4 +39,5 @@ export declare class MySQLDriver implements DialectDriver {
   createMigrationsTable(): string;
   getExecutedMigrationsQuery(): string;
   recordMigrationQuery(): string;
+  protected renderColumn(column: ColumnPlan): string;
 }

package/dist/drivers/singlestore.d.ts

@@ -0,0 +1,28 @@
+import { MySQLDriver } from './mysql';
+import type { IndexPlan, TablePlan } from '../migrations';
+/**
+ * SingleStore DDL driver.
+ *
+ * SingleStore (formerly MemSQL) speaks the MySQL wire protocol, so runtime DML
+ * (placeholders, backtick quoting, `ON DUPLICATE KEY UPDATE`, `LAST_INSERT_ID`)
+ * is identical — see `isMysqlLike` in `config.ts`. Only the DDL diverges, which
+ * is what this driver customizes:
+ *
+ *  - **Distributed tables.** Rows are hash-partitioned across leaf nodes by a
+ *    `SHARD KEY`. When a model declares `shardKey`, we emit it; otherwise
+ *    SingleStore shards on the primary key (or a random key for columnstore),
+ *    so a plain MySQL-shaped `CREATE TABLE` still works.
+ *  - **Storage engine.** `tableKind: 'columnstore'` (default for analytics
+ *    workloads) emits `SORT KEY (...)`; `'rowstore'` emits `ROWSTORE`;
+ *    `'reference'` emits a `REFERENCE` table (fully replicated, no shard key —
+ *    ideal for small dimension tables that get JOINed everywhere).
+ *  - **No foreign keys.** SingleStore does not support `FOREIGN KEY`
+ *    constraints, so `addForeignKey` is a no-op (referential integrity is an
+ *    application concern). This mirrors how the MySQL driver already treats
+ *    enums (`createEnumType` → '').
+ */
+export declare class SingleStoreDriver extends MySQLDriver {
+  createTable(table: TablePlan): string;
+  addForeignKey(): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+}

package/dist/drivers/sqlite.d.ts

@@ -1,4 +1,10 @@
 import type { ColumnPlan, IndexPlan, RebuildTableSpec, TablePlan } from '../migrations';
+/**
+ * Whether a plan type belongs to the numeric family. Used by the `_id`
+ * safety net (numeric ids must store as INTEGER on SQLite) — non-numeric
+ * declared types must never be coerced by the name heuristic.
+ */
+export declare function isNumericPlanType(type: string | undefined): boolean;
 export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string

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

@@ -9,6 +9,7 @@ export declare function createSingleTableManager(config: SingleTableConfig): Sin
  */
 export declare function createRepository<T extends Record<string, any>>(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions): SingleTableRepository<T>;
 /**
+ * Common single table design patterns
  * @defaultValue
  * ```ts
  * {
@@ -16,11 +17,11 @@ export declare function createRepository<T extends Record<string, any>>(manager:
  *   oneToMany: (parentEntity: string,
  *     childEntity: string,
  *     parentIdField?: string,
- *     childIdField?: string,) => OneToManyPattern,
+ *     childIdField?: string,) => { parent: SingleTableEntity, child: SingleTableEntity },
  *   manyToMany: (entityName: string,
  *     relationName: string,
  *     idField?: string,
- *     relatedIdField?: string,) => ManyToManyPattern,
+ *     relatedIdField?: string,) => { entity: SingleTableEntity, relation: SingleTableEntity },
  *   hierarchical: (entityName: string, rootIdField?: string, pathField?: string) => SingleTableEntity
  * }
  * ```
@@ -37,14 +38,20 @@ export declare const SingleTablePatterns: {
    * Parent: PK=PARENT#<parentId>, SK=METADATA
    * Child: PK=PARENT#<parentId>, SK=CHILD#<childId>
    */
-  oneToMany: (parentEntity: string, childEntity: string, parentIdField?: string, childIdField?: string,) => OneToManyPattern;
+  oneToMany: (parentEntity: string,
+    childEntity: string,
+    parentIdField?: string,
+    childIdField?: string,) => ;
   /**
    * Many-to-many relationship pattern using adjacency list
    * Entity: PK=ENTITY#<entityId>, SK=METADATA
    * Relationship: PK=ENTITY#<entityId>, SK=RELATED#<relatedId>
    * Inverse: PK=ENTITY#<relatedId>, SK=RELATED#<entityId> (via GSI)
    */
-  manyToMany: (entityName: string, relationName: string, idField?: string, relatedIdField?: string,) => ManyToManyPattern;
+  manyToMany: (entityName: string,
+    relationName: string,
+    idField?: string,
+    relatedIdField?: string,) => ;
   /**
    * Hierarchical data pattern (e.g., org chart, file system)
    * PK: ROOT#<rootId>
@@ -93,25 +100,6 @@ export declare interface ManyToManyPattern {
   entity: SingleTableEntity
   relation: SingleTableEntity
 }
-/**
- * Common single table design patterns
- */
-/**
- * Result shapes for relationship pattern helpers. Lifted to named
- * interfaces so the generated `.d.ts` doesn't carry an inline object
- * literal in the return position — bun-plugin-dtsx has a bug where
- * `(...) => { ... }` in that position emits as `=> ;`, breaking
- * downstream typecheck for any consumer importing from
- * `bun-query-builder/dynamodb-single-table`.
- */
-export declare interface OneToManyPattern {
-  parent: SingleTableEntity
-  child: SingleTableEntity
-}
-export declare interface ManyToManyPattern {
-  entity: SingleTableEntity
-  relation: SingleTableEntity
-}
 /**
  * Single Table Design Manager
  *

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 // Resolve ambiguous re-exports by explicitly choosing which module's version to use
 export type { WhereOperator } from './browser';
 export type { ModelQueryBuilder } from './dynamodb/index';
-export type { ColumnName } from './client';
+export type { ColumnName, QueryBuilder } from './client';
+export type { ModelRecord } from './schema';
+export type { ModelDefinition as OrmModelDefinition, ModelStatic as OrmModelStatic } from './orm';
 // Re-export the type-inference version of InferRelationNames (supports wrapped models)
 // to resolve the ambiguity with orm.ts's InferRelationNames (which takes raw definitions)
 export type { InferRelationNames } from './type-inference';
@@ -40,6 +42,7 @@ export * from './pivot';
 export * from './orm';
 export * from './schema';
 export * from './seeder';
+export * from './sqlite-pragmas';
 export * from './type-inference';
 export * from './types';
 export { type ModelDefinition, defineModel } from './model';

package/dist/migrations.d.ts

@@ -61,6 +61,8 @@ export declare interface ColumnPlan {
   defaultValue?: PrimitiveDefault
   references?: { table: string, column: string, onDelete?: OnForeignKeyAction, onUpdate?: OnForeignKeyAction }
   enumValues?: string[]
+  maxLength?: number
+  enumTypeName?: string
 }
 export declare interface IndexPlan {
   name: string
@@ -72,6 +74,9 @@ export declare interface TablePlan {
   table: string
   columns: ColumnPlan[]
   indexes: IndexPlan[]
+  shardKey?: string[]
+  sortKey?: string[]
+  tableKind?: 'rowstore' | 'columnstore' | 'reference'
 }
 export declare interface MigrationPlan {
   dialect: SupportedDialect

package/dist/orm.d.ts

@@ -37,10 +37,8 @@ export declare function configureOrm(options: { database?: string | Database; ve
  * 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;
+/** Create a model class from a definition with full type inference. */
+export declare function createModel<const TDef extends ModelDefinition>(definition: TDef): ModelStatic<TDef>;
 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
@@ -111,6 +109,7 @@ export declare interface ModelDefinition {
     readonly taggable?: boolean
     readonly categorizable?: boolean
     readonly commentables?: boolean
+    readonly commentable?: boolean
     readonly useActivityLog?: boolean | object
     readonly useSocials?: readonly string[]
   }
@@ -128,11 +127,11 @@ export declare interface ModelDefinition {
   readonly attributes: {
     readonly [key: string]: TypedAttribute<unknown>
   }
-  readonly get?: Record<string, (attributes: Record<string, unknown>) => unknown>
-  readonly set?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly get?: Record<string, (attributes: any) => unknown>
+  readonly set?: Record<string, (attributes: any) => unknown>
   readonly scopes?: Record<string, (value: unknown) => unknown>
   readonly indexes?: readonly object[]
-  readonly dashboard?: { readonly highlight?: boolean | number }
+  readonly dashboard?: { readonly enabled?: boolean; readonly highlight?: boolean | number }
   readonly hooks?: {
     readonly beforeCreate?: (data: Record<string, unknown>) => void | Promise<void>
     readonly afterCreate?: (model: ModelHookInstance) => void | Promise<void>
@@ -179,6 +178,31 @@ declare interface ResolvedRelation {
   pivotModelName?: string
   pivotTimestamps?: boolean
 }
+/**
+ * Overloaded where/orWhere signatures for static model methods.
+ * Object literals cannot have overloaded methods, so we express them as an interface
+ * and intersect with the concrete model object via a type assertion.
+ */
+declare interface StaticWhereOverloads<TDef extends ModelDefinition> {
+  where<K extends ColumnName<TDef>>(
+    column: K,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  where<K extends ColumnName<TDef>>(
+    column: K,
+    operator: WhereOperator,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  orWhere<K extends ColumnName<TDef>>(
+    column: K,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  orWhere<K extends ColumnName<TDef>>(
+    column: K,
+    operator: WhereOperator,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+}
 // Binding helper type for SQL queries
 declare type Bindings = SQLQueryBindings[];
 // Primitive type mappings
@@ -193,12 +217,17 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
+  T extends { validate: (value: infer U) => any } ? U :
   unknown;
 // Extract attribute keys from definition
 declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attributes'] & string;
 // Infer single attribute type
 declare type InferAttributeType<TAttr> = TAttr extends { type: infer T } ? InferType<T> :
-  TAttr extends { factory: (faker: Faker) => infer R } ? R :
+  TAttr extends { factory: (faker: Faker) => infer R }
+    ? [Exclude<R, null | undefined>] extends [never]
+      ? TAttr extends { validation: { rule: infer V } } ? InferType<V> | Extract<R, null | undefined> : R
+      : R
+    : TAttr extends { validation: { rule: infer R } } ? InferType<R> :
   unknown;
 // Build the full attributes type from definition. Columns declared
 // `nullable: true` admit null — mirrors InferAttributes in type-inference.ts.
@@ -207,6 +236,14 @@ declare type InferModelAttributes<TDef extends ModelDefinition> = {
     ? InferAttributeType<TDef['attributes'][K]> | null
     : InferAttributeType<TDef['attributes'][K]>
 }
+declare type SnakeCase<S extends string> = S extends `${infer C}${infer Rest}`
+  ? C extends Lowercase<C>
+    ? `${C}${SnakeCase<Rest>}`
+    : `_${Lowercase<C>}${SnakeCase<Rest>}`
+  : S;
+declare type SnakeCaseAttributes<TDef extends ModelDefinition> = {
+  [K in keyof InferModelAttributes<TDef> & string as SnakeCase<K>]: InferModelAttributes<TDef>[K]
+}
 // System fields added by traits. The primary-key column honors the model's
 // declared `primaryKey` (default 'id') — a custom-pk model exposes THAT
 // column, not a phantom 'id'. Mirrors InferAttributes in type-inference.ts.
@@ -219,9 +256,10 @@ declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends {
   (TDef['traits'] extends { useAuth: true | object } ? { two_factor_secret: string | null; public_key: string | null } : {}) &
   (TDef['traits'] extends { billable: true | object } ? { stripe_id: string | null } : {});
 // Complete model type
-declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SystemFields<TDef>;
+declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SnakeCaseAttributes<TDef> & SystemFields<TDef>;
 // All valid column names
 declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
+  | SnakeCase<AttributeKeys<TDef>>
   | (TDef extends { primaryKey: infer PK extends string } ? PK : 'id')
   | (TDef['traits'] extends { useUuid: true } ? 'uuid' : never)
   | (TDef['traits'] extends { useTimestamps: true } ? 'created_at' | 'updated_at' : never)
@@ -238,6 +276,10 @@ declare type HiddenKeys<TDef extends ModelDefinition> = {
 declare type FillableKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { fillable: true } ? K : never
 }[AttributeKeys<TDef>];
+declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
+  ModelAttributes<TDef>,
+  FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>>
+>>;
 // Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
 declare type NumericColumns<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
@@ -280,6 +322,10 @@ declare type LoadedRelationValue<TDef, R extends string> = 'one' extends Relatio
     : 'many' extends RelationCardinality<TDef, R>
       ? ModelInstance<any, any>[] | undefined
       : ModelInstance<any, any>[] | ModelInstance<any, any> | null | undefined;
+/** A hydrated model instance with its selected columns exposed as proxy properties. */
+export type ModelRecord<TDef extends ModelDefinition, TSelected extends ColumnName<TDef> = ColumnName<TDef>,> = ModelInstance<TDef, TSelected>
+  & Pick<ModelAttributes<TDef>, Extract<TSelected, keyof ModelAttributes<TDef>>>
+  & { [R in InferRelationNames<TDef>]?: LoadedRelationValue<TDef, R> }
 declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'not like' | 'in' | 'not in';
 // --- Dialect-aware execution layer -------------------------------------------
 //
@@ -295,6 +341,66 @@ declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'no
 // `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 }
+/** The fully inferred static model API produced from a model definition. */
+export type ModelStatic<TDef extends ModelDefinition> = StaticWhereOverloads<TDef> & {
+  query: () => ModelQueryBuilder<TDef>
+  whereIn: <K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]) => ModelQueryBuilder<TDef>
+  whereNotIn: <K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]) => ModelQueryBuilder<TDef>
+  whereNull: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  whereNotNull: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  whereLike: <K extends ColumnName<TDef>>(column: K, pattern: string) => ModelQueryBuilder<TDef>
+  orderBy: <K extends ColumnName<TDef>>(column: K, direction?: 'asc' | 'desc') => ModelQueryBuilder<TDef>
+  orderByDesc: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  select: <K extends ColumnName<TDef>>(...columns: K[]) => ModelQueryBuilder<TDef, K>
+  with: <R extends InferRelationNames<TDef>>(...relations: R[]) => ModelQueryBuilder<TDef>
+  limit: (count: number) => ModelQueryBuilder<TDef>
+  take: (count: number) => ModelQueryBuilder<TDef>
+  skip: (count: number) => ModelQueryBuilder<TDef>
+  withTrashed: () => ModelQueryBuilder<TDef>
+  onlyTrashed: () => ModelQueryBuilder<TDef>
+  find: (id: number | string) => Promise<ModelRecord<TDef> | undefined>
+  findOrFail: (id: number | string) => Promise<ModelRecord<TDef>>
+  findMany: (ids: (number | string)[]) => Promise<ModelRecord<TDef>[]>
+  all: () => Promise<ModelRecord<TDef>[]>
+  first: () => Promise<ModelRecord<TDef> | undefined>
+  firstOrFail: () => Promise<ModelRecord<TDef>>
+  last: () => Promise<ModelRecord<TDef> | undefined>
+  count: () => Promise<number>
+  exists: () => Promise<boolean>
+  doesntExist: () => Promise<boolean>
+  paginate: (page?: number, perPage?: number) => Promise<{
+    data: ModelRecord<TDef>[]
+    total: number
+    page: number
+    perPage: number
+    lastPage: number
+    hasMorePages: boolean
+    isEmpty: boolean
+    from: number | null
+    to: number | null
+  }>
+  whereBetween: <K extends ColumnName<TDef>>(column: K, range: [min: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown, max: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown]) => ModelQueryBuilder<TDef>
+  whereNotBetween: <K extends ColumnName<TDef>>(column: K, range: [min: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown, max: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown]) => ModelQueryBuilder<TDef>
+  create: (data: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  createMany: (items: FillableAttributes<TDef>[]) => Promise<ModelRecord<TDef>[]>
+  updateOrCreate: (search: Partial<ModelAttributes<TDef>>, data: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  firstOrCreate: (search: Partial<ModelAttributes<TDef>>, data?: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  destroy: (id: number | string) => Promise<boolean>
+  remove: (id: number | string) => Promise<boolean>
+  truncate: () => Promise<void>
+  getDefinition: () => TDef
+  getTable: () => string
+  make: (data?: Partial<ModelAttributes<TDef>>) => ModelInstance<TDef>
+  latest: (column?: ColumnName<TDef>) => ModelQueryBuilder<TDef>
+  oldest: (column?: ColumnName<TDef>) => ModelQueryBuilder<TDef>
+  max: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) | null>
+  min: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) | null>
+  avg: <K extends NumericColumns<TDef>>(column: K) => Promise<number>
+  sum: <K extends NumericColumns<TDef>>(column: K) => Promise<number>
+  pluck: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]>
+} & {
+  [K in AttributeKeys<TDef> as `where${Capitalize<K>}`]: (value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) => ModelQueryBuilder<TDef>
+}
 declare class SqliteExecutor implements OrmExecutor {
   readonly dialect: unknown;
   public readonly sqliteDb: Database;
@@ -332,10 +438,10 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   isClean(column?: ColumnName<TDef>): boolean;
   getOriginal<K extends ColumnName<TDef>>(column: K): K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown;
   getChanges(): Partial<InferModelAttributes<TDef>>;
-  fill(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
+  fill(data: FillableAttributes<TDef>): this;
   forceFill(data: Partial<InferModelAttributes<TDef>>): this;
   save(): Promise<this>;
-  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): Promise<this>;
+  update(data: FillableAttributes<TDef>): Promise<this>;
   fresh(): Promise<ModelInstance<TDef, TSelected> | null>;
   delete(): Promise<boolean>;
   restore(): Promise<this>;
@@ -421,14 +527,14 @@ 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(): Promise<ModelInstance<TDef, TSelected>[]>;
-  first(): Promise<ModelInstance<TDef, TSelected> | undefined>;
-  firstOrFail(): Promise<ModelInstance<TDef, TSelected>>;
-  last(): Promise<ModelInstance<TDef, TSelected> | undefined>;
+  get(): Promise<ModelRecord<TDef, TSelected>[]>;
+  first(): Promise<ModelRecord<TDef, TSelected> | undefined>;
+  firstOrFail(): Promise<ModelRecord<TDef, TSelected>>;
+  last(): Promise<ModelRecord<TDef, TSelected> | undefined>;
   count(): Promise<number>;
   exists(): Promise<boolean>;
   doesntExist(): Promise<boolean>;
-  sole(): Promise<ModelInstance<TDef, TSelected>>;
+  sole(): Promise<ModelRecord<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>;

package/dist/sqlite-pragmas.d.ts

@@ -0,0 +1,30 @@
+import type { Database } from 'bun:sqlite';
+/** The pragma list currently in effect: the config override, or the defaults. */
+export declare function resolveSqlitePragmas(): readonly string[];
+/**
+ * Apply the bootstrap pragmas to a freshly-opened `bun:sqlite` Database.
+ *
+ * Fail-open per pragma: a single rejected pragma (e.g. a dialect-specific
+ * one in a custom list) must not take down connection creation — matching
+ * the long-standing behavior of the WAL pragma this generalizes.
+ */
+export declare function applySqliteBootstrapPragmas(db: Database): void;
+/**
+ * Bootstrap pragmas applied to every sqlite connection the library opens.
+ *
+ * SQLite scopes these settings to the CONNECTION, not the database file, and
+ * ships with unsafe defaults on every fresh connection: `foreign_keys` is OFF
+ * (so `REFERENCES ... ON DELETE CASCADE` in the schema is silently inert and
+ * orphan rows insert without error) and there is no busy timeout (concurrent
+ * writers surface as immediate `SQLITE_BUSY` failures). They therefore have
+ * to be re-applied on every connection the library creates — historically
+ * only the query-builder connection got `journal_mode = WAL` while the
+ * model-layer executor (the connection `Model.create()/save()/delete()`
+ * writes through) got nothing at all, leaving FK enforcement off on the
+ * exact connection performing the writes.
+ *
+ * Override via `setConfig({ sqlite: { pragmas: [...] } })` — the custom list
+ * REPLACES this one. Caller-supplied `Database` instances
+ * (`configureOrm({ database: db })`) are never touched.
+ */
+export declare const DEFAULT_SQLITE_PRAGMAS: readonly string[];