bun-query-builder 0.1.27 → 0.1.29

package/dist/bin/cli.js

@@ -14728,17 +14728,15 @@ function createQueryBuilder(state) {
             addWhereText("WHERE", `${String(col)} IS ${onlyTrashed ? "NOT " : ""}NULL`);
           }
         }
+        const cacheKey = useCache ? `${String(finalQuery)}\x00${JSON.stringify(whereParams)}` : "";
         if (useCache) {
-          const cacheKey = String(finalQuery);
           const cached = queryCache.get(cacheKey);
           if (cached)
             return cached;
         }
         const result = await runWithHooks(finalQuery, "select", { signal: abortSignal, timeoutMs });
-        if (useCache) {
-          const cacheKey = String(finalQuery);
+        if (useCache)
           queryCache.set(cacheKey, result, cacheTtl);
-        }
         return hydratePivotRows(result);
       },
       async executeTakeFirst() {
@@ -23803,6 +23801,13 @@ function assertValidIdentifier(name, context) {
   if (!SAFE_SQL_IDENTIFIER.test(name))
     throw new TypeError(`[bun-query-builder] ${context}: identifier '${name}' contains characters outside [A-Za-z0-9_] \u2014 refusing to interpolate into SQL`);
 }
+function assertValidOrderByColumn(name, context) {
+  if (typeof name !== "string" || name.length === 0)
+    throw new TypeError(`[bun-query-builder] ${context}: identifier must be a non-empty string, got ${typeof name}`);
+  const parts = name.split(".");
+  if (parts.length > 2 || parts.some((p2) => p2.length === 0 || p2.length > 64 || !SAFE_SQL_IDENTIFIER.test(p2)))
+    throw new TypeError(`[bun-query-builder] ${context}: invalid ORDER BY column '${name}' \u2014 expected 'column' or 'table.column' of [A-Za-z0-9_] \u2014 refusing to interpolate into SQL`);
+}
 function getModelFromRegistry(name) {
   if (!_getModel) {
     try {
@@ -24091,12 +24096,16 @@ class ModelInstance {
     for (const [key, value] of Object.entries(data)) {
       const attr = attrs[key];
       if (attr?.fillable && !attr?.guarded) {
+        if (this._original === null)
+          this._original = { ...this._attributes };
         this._attributes[key] = value;
       }
     }
     return this;
   }
   forceFill(data) {
+    if (this._original === null)
+      this._original = { ...this._attributes };
     Object.assign(this._attributes, data);
     return this;
   }
@@ -24492,7 +24501,7 @@ class BelongsToManyRelationBuilder {
     return this;
   }
   orderBy(column, direction = "asc") {
-    assertValidIdentifier(column, "orderBy(column)");
+    assertValidOrderByColumn(column, "orderBy(column)");
     if (direction !== "asc" && direction !== "desc")
       throw new TypeError(`[bun-query-builder] orderBy(direction): expected 'asc' or 'desc', got '${direction}'`);
     this._orderBy.push(`${column} ${direction.toUpperCase()}`);
@@ -24833,7 +24842,7 @@ class ModelQueryBuilder {
     return this;
   }
   orderBy(column, direction = "asc") {
-    assertValidIdentifier(column, "orderBy(column)");
+    assertValidOrderByColumn(column, "orderBy(column)");
     if (direction !== "asc" && direction !== "desc")
       throw new TypeError(`[bun-query-builder] orderBy(direction): expected 'asc' or 'desc', got '${direction}'`);
     this._orderBy.push({ column, direction });
@@ -25194,7 +25203,14 @@ class ModelQueryBuilder {
       sql2 += ` WHERE ${whereBody}`;
     }
     const row = await exec.get(sql2, params);
-    return row?.v == null ? null : Number(row.v);
+    const v2 = row?.v;
+    if (v2 == null)
+      return null;
+    if (typeof v2 === "string") {
+      const n2 = Number(v2);
+      return v2.trim() !== "" && !Number.isNaN(n2) ? n2 : v2;
+    }
+    return v2;
   }
   max(column) {
     return this.aggregate("MAX", column);
@@ -25203,10 +25219,10 @@ class ModelQueryBuilder {
     return this.aggregate("MIN", column);
   }
   async avg(column) {
-    return await this.aggregate("AVG", column) || 0;
+    return Number(await this.aggregate("AVG", column) ?? 0) || 0;
   }
   async sum(column) {
-    return await this.aggregate("SUM", column) || 0;
+    return Number(await this.aggregate("SUM", column) ?? 0) || 0;
   }
   async delete() {
     const exec = getExecutor();
@@ -29920,7 +29936,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.27";
+var version2 = "0.1.29";
 
 // bin/cli.ts
 init_actions();

package/dist/browser.d.ts

@@ -201,9 +201,12 @@ declare type BrowserAttributeKeys<TDef extends BrowserModelDefinition> = keyof T
 declare type InferBrowserAttributeType<TAttr> = TAttr extends { type: infer T } ? InferType<T> :
   TAttr extends { factory: (faker: unknown) => infer R } ? R :
   unknown;
-// Build the full attributes type from definition
+// Build the full attributes type from definition. Columns declared
+// `nullable: true` admit null — mirrors InferAttributes in type-inference.ts.
 declare type InferBrowserModelAttributes<TDef extends BrowserModelDefinition> = {
-  [K in BrowserAttributeKeys<TDef>]: InferBrowserAttributeType<TDef['attributes'][K]>
+  [K in BrowserAttributeKeys<TDef>]: TDef['attributes'][K] extends { nullable: true }
+    ? InferBrowserAttributeType<TDef['attributes'][K]> | null
+    : InferBrowserAttributeType<TDef['attributes'][K]>
 }
 // System fields added by traits
 declare type BrowserSystemFields<TDef extends BrowserModelDefinition> = { id: number } &

package/dist/client.d.ts

@@ -104,8 +104,11 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   havingRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   addSelect: (...columns: ((keyof DB[TTable]['columns'] & string) | string | SqlFragment)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  select?: (columns: string | SqlFragment | ((keyof DB[TTable]['columns'] & string) | string | SqlFragment)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  selectAll?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  select?: {
+    <K extends keyof DB[TTable]['columns'] & string>(columns: K[]): SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>, TJoined>
+    (columns: string | SqlFragment | (string | SqlFragment)[]): SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  }
+  selectAll?: () => SelectQueryBuilder<DB, TTable, DB[TTable]['columns'], 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>
@@ -146,7 +149,7 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   }
   exists: () => Promise<boolean>
   doesntExist: () => Promise<boolean>
-  cursorPaginate: (perPage: number, cursor?: string | number, column?: string, direction?: 'asc' | 'desc') => Promise<{ data: any[], meta: { perPage: number, nextCursor: string | number | null } }>
+  cursorPaginate: (perPage: number, cursor?: string | number, column?: string, direction?: 'asc' | 'desc') => Promise<{ data: SelectedRow<DB, TTable, TSelected>[], meta: { perPage: number, nextCursor: string | number | null } }>
   chunk: (size: number, handler: (rows: any[]) => Promise<void> | void) => Promise<void>
   chunkById: (size: number, column?: string, handler?: (rows: any[]) => Promise<void> | void) => Promise<void>
   eachById: (size: number, column?: string, handler?: (row: any) => Promise<void> | void) => Promise<void>
@@ -175,8 +178,8 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   count: () => Promise<number>
   avg: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
   sum: (column: keyof DB[TTable]['columns'] & string) => Promise<number>
-  max: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
-  min: (column: keyof DB[TTable]['columns'] & string) => Promise<any>
+  max: <K extends keyof DB[TTable]['columns'] & string>(column: K) => Promise<DB[TTable]['columns'][K] | null>
+  min: <K extends keyof DB[TTable]['columns'] & string>(column: K) => Promise<DB[TTable]['columns'][K] | null>
   readonly rows: TSelected[]
   readonly row: TSelected
   values: () => Promise<any[][]>
@@ -224,13 +227,19 @@ export declare interface TableQueryBuilder<DB extends DatabaseSchema<any>, TTabl
   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: (...columns: (keyof DB[TTable]['columns'] & string)[]) => SelectQueryBuilder<DB, TTable, any>
+  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>> {
-  select: <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
-    table: TTable,
-    ...columns: (K | `${string} as ${string}`)[]
-  ) => SelectQueryBuilder<DB, TTable, any>
+  select: {
+    <TTable extends keyof DB & string, K extends keyof DB[TTable]['columns'] & string>(
+      table: TTable,
+      ...columns: K[]
+    ): SelectQueryBuilder<DB, TTable, Pick<DB[TTable]['columns'], K>>
+    <TTable extends keyof DB & string>(
+      table: TTable,
+      ...columns: ((keyof DB[TTable]['columns'] & string) | `${string} as ${string}`)[]
+    ): SelectQueryBuilder<DB, TTable, any>
+  }
   selectFrom: <TTable extends keyof DB & string>(table: TTable) => TypedSelectQueryBuilder<DB, TTable, DB[TTable]['columns'], TTable, `SELECT * FROM ${TTable}`>
   insertInto: <TTable extends keyof DB & string>(table: TTable) => TypedInsertQueryBuilder<DB, TTable>
   updateTable: <TTable extends keyof DB & string>(table: TTable) => UpdateQueryBuilder<DB, TTable>
@@ -413,22 +422,29 @@ declare type JoinColumn<DB extends DatabaseSchema<any>, TTables extends string>
  *
  * The relation names declared for a table, read from the type-level
  * `relations` map that `DatabaseSchema` carries. Falls back to `string`
- * for hand-written schema types that don't declare relation metadata, so
- * existing untyped schemas keep compiling.
+ * for hand-written schema types that don't declare relation metadata
+ * (inferred `R` is `unknown` when the property is absent), so existing
+ * 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 }
-    ? [keyof NonNullable<R>] extends [never] ? string : keyof NonNullable<R> & string
+    ? unknown extends R ? string : keyof NonNullable<R> & string
     : string;
 /**
  * # `WithRelationArg<DB, TTable>`
  *
  * Argument accepted by `.with()`: a declared relation name, a dotted nested
  * path rooted at a declared relation (`'posts.comments'`), or a record
- * mapping relation names to constraint callbacks.
+ * mapping relation names to constraint callbacks. A table with zero declared
+ * 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>
-  | `${TableRelationName<DB, TTable>}.${string}`
-  | Partial<Record<TableRelationName<DB, TTable>, (qb: any) => any>>;
+export type WithRelationArg<DB extends DatabaseSchema<any>, TTable extends keyof DB & string> = [TableRelationName<DB, TTable>] extends [never]
+    ? never
+    :
+      | TableRelationName<DB, TTable>
+      | `${TableRelationName<DB, TTable>}.${string}`
+      | Partial<Record<TableRelationName<DB, TTable>, (qb: any) => any>>;
 // Convert snake_case to PascalCase at the type level (e.g. created_at -> CreatedAt)
 declare type SnakeToPascal<S extends string> = S extends `${infer H}_${infer T}`
   ? `${Capitalize<H>}${SnakeToPascal<T>}`
@@ -449,11 +465,15 @@ declare type _TypedDynamicWhereMethods<DB extends DatabaseSchema<any>, TTable ex
     value: DB[TTable]['columns'][K],
   ) => TypedSelectQueryBuilder<DB, TTable, TSelected, TJoined, `${TSql} AND ${K} = ?`>
 }
+// NOTE: TypedSelectQueryBuilder must NOT also intersect DynamicWhereMethods —
+// _TypedDynamicWhereMethods declares the same `where<Column>` keys, and the
+// 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<
   BaseSelectQueryBuilder<DB, TTable, TSelected, TJoined>,
   'toSQL' | 'where' | 'andWhere' | 'orWhere' | 'orderBy' | 'limit'
-> & DynamicWhereMethods<DB, TTable, TSelected, TJoined>
-& _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
+> & _TypedDynamicWhereMethods<DB, TTable, TSelected, TJoined, TSql>
 & {
   toSQL: () => TSql
   where: (<K extends keyof DB[TTable]['columns'] & string>(

package/dist/orm.d.ts

@@ -196,12 +196,17 @@ declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attribute
 declare type InferAttributeType<TAttr> = TAttr extends { type: infer T } ? InferType<T> :
   TAttr extends { factory: (faker: Faker) => infer R } ? R :
   unknown;
-// Build the full attributes type from definition
+// Build the full attributes type from definition. Columns declared
+// `nullable: true` admit null — mirrors InferAttributes in type-inference.ts.
 declare type InferModelAttributes<TDef extends ModelDefinition> = {
-  [K in AttributeKeys<TDef>]: InferAttributeType<TDef['attributes'][K]>
+  [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { nullable: true }
+    ? InferAttributeType<TDef['attributes'][K]> | null
+    : InferAttributeType<TDef['attributes'][K]>
 }
-// System fields added by traits
-declare type SystemFields<TDef extends ModelDefinition> = { id: number } &
+// 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.
+declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends { primaryKey: infer PK extends string } ? PK : 'id']: number } &
   (TDef['traits'] extends { useUuid: true } ? { uuid: string } : {}) &
   (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string | null } : {}) &
   (TDef['traits'] extends { timestampable: true | object } ? { created_at: string; updated_at: string | null } : {}) &
@@ -213,7 +218,7 @@ declare type SystemFields<TDef extends ModelDefinition> = { id: number } &
 declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SystemFields<TDef>;
 // All valid column names
 declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
-  | 'id'
+  | (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)
   | (TDef['traits'] extends { timestampable: true | object } ? 'created_at' | 'updated_at' : never)
@@ -233,31 +238,26 @@ declare type FillableKeys<TDef extends ModelDefinition> = {
 declare type NumericColumns<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
 }[AttributeKeys<TDef>];
-// Infer relation names from model definition (supports both array and object syntax)
-declare type InferBelongsToNames<TDef> = (TDef extends { belongsTo: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { belongsTo: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasManyNames<TDef> = (TDef extends { hasMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { hasMany: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasOneNames<TDef> = (TDef extends { hasOne: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { hasOne: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferBelongsToManyNames<TDef> = (TDef extends { belongsToMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { belongsToMany: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasOneThroughNames<TDef> = (TDef extends { hasOneThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { hasOneThrough: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasManyThroughNames<TDef> = (TDef extends { hasManyThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { hasManyThrough: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
+/**
+ * Relation names of one relation declaration. Array form lowercases the
+ * (unwrapped) model name; record form uses the keys. The array case MUST be
+ * checked first: a tuple also structurally matches `Readonly<Record<...>>`
+ * and would otherwise leak its own keys ('length', indices, ...) into the
+ * relation-name union.
+ */
+declare type RelationKeyOf<V> = V extends readonly (infer E)[]
+    ? E extends string ? Lowercase<E>
+      : E extends { model: infer M extends string } ? Lowercase<M>
+        : never
+    : V extends Readonly<Record<infer K, unknown>>
+      ? K & string
+      : never;
+declare type InferBelongsToNames<TDef> = TDef extends { belongsTo: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasManyNames<TDef> = TDef extends { hasMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasOneNames<TDef> = TDef extends { hasOne: infer V } ? RelationKeyOf<V> : never;
+declare type InferBelongsToManyNames<TDef> = TDef extends { belongsToMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasOneThroughNames<TDef> = TDef extends { hasOneThrough: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasManyThroughNames<TDef> = TDef extends { hasManyThrough: infer V } ? RelationKeyOf<V> : never;
 export type InferRelationNames<TDef> = | InferBelongsToNames<TDef>
   | InferHasManyNames<TDef>
   | InferHasOneNames<TDef>
@@ -317,8 +317,8 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   getAttribute<K extends TSelected>(key: K): K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown;
   getAttributes(): Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>;
   set<K extends ColumnName<TDef>>(key: K, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): void;
-  only<K extends TSelected>(keys: ReadonlyArray<K>): Partial<ModelAttributes<TDef>>;
-  except<K extends TSelected>(keys: ReadonlyArray<K>): Partial<ModelAttributes<TDef>>;
+  only<K extends TSelected>(keys: ReadonlyArray<K>): Pick<ModelAttributes<TDef>, K & keyof ModelAttributes<TDef>>;
+  except<K extends TSelected>(keys: ReadonlyArray<K>): Omit<Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>, K>;
   getRelation<R extends InferRelationNames<TDef> & string>(name: R): LoadedRelationValue<TDef, R>;
   setRelation(name: string, data: ModelInstance<any, any>[] | ModelInstance<any, any> | null): void;
   getLoadedRelations(): Record<string, ModelInstance<any, any>[] | ModelInstance<any, any> | null>;
@@ -440,8 +440,8 @@ declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends
     to: number | null
   }>;
   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>;
+  max<K extends ColumnName<TDef>>(column: K): Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : number) | null>;
+  min<K extends ColumnName<TDef>>(column: K): Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : number) | null>;
   avg<K extends NumericColumns<TDef>>(column: K): Promise<number>;
   sum<K extends NumericColumns<TDef>>(column: K): Promise<number>;
   delete(): Promise<number>;

package/dist/src/index.js

@@ -14728,17 +14728,15 @@ function createQueryBuilder(state) {
             addWhereText("WHERE", `${String(col)} IS ${onlyTrashed ? "NOT " : ""}NULL`);
           }
         }
+        const cacheKey = useCache ? `${String(finalQuery)}\x00${JSON.stringify(whereParams)}` : "";
         if (useCache) {
-          const cacheKey = String(finalQuery);
           const cached = queryCache.get(cacheKey);
           if (cached)
             return cached;
         }
         const result = await runWithHooks(finalQuery, "select", { signal: abortSignal, timeoutMs });
-        if (useCache) {
-          const cacheKey = String(finalQuery);
+        if (useCache)
           queryCache.set(cacheKey, result, cacheTtl);
-        }
         return hydratePivotRows(result);
       },
       async executeTakeFirst() {
@@ -23803,6 +23801,13 @@ function assertValidIdentifier(name, context) {
   if (!SAFE_SQL_IDENTIFIER.test(name))
     throw new TypeError(`[bun-query-builder] ${context}: identifier '${name}' contains characters outside [A-Za-z0-9_] \u2014 refusing to interpolate into SQL`);
 }
+function assertValidOrderByColumn(name, context) {
+  if (typeof name !== "string" || name.length === 0)
+    throw new TypeError(`[bun-query-builder] ${context}: identifier must be a non-empty string, got ${typeof name}`);
+  const parts = name.split(".");
+  if (parts.length > 2 || parts.some((p2) => p2.length === 0 || p2.length > 64 || !SAFE_SQL_IDENTIFIER.test(p2)))
+    throw new TypeError(`[bun-query-builder] ${context}: invalid ORDER BY column '${name}' \u2014 expected 'column' or 'table.column' of [A-Za-z0-9_] \u2014 refusing to interpolate into SQL`);
+}
 function getModelFromRegistry(name) {
   if (!_getModel) {
     try {
@@ -24091,12 +24096,16 @@ class ModelInstance {
     for (const [key, value] of Object.entries(data)) {
       const attr = attrs[key];
       if (attr?.fillable && !attr?.guarded) {
+        if (this._original === null)
+          this._original = { ...this._attributes };
         this._attributes[key] = value;
       }
     }
     return this;
   }
   forceFill(data) {
+    if (this._original === null)
+      this._original = { ...this._attributes };
     Object.assign(this._attributes, data);
     return this;
   }
@@ -24492,7 +24501,7 @@ class BelongsToManyRelationBuilder {
     return this;
   }
   orderBy(column, direction = "asc") {
-    assertValidIdentifier(column, "orderBy(column)");
+    assertValidOrderByColumn(column, "orderBy(column)");
     if (direction !== "asc" && direction !== "desc")
       throw new TypeError(`[bun-query-builder] orderBy(direction): expected 'asc' or 'desc', got '${direction}'`);
     this._orderBy.push(`${column} ${direction.toUpperCase()}`);
@@ -24833,7 +24842,7 @@ class ModelQueryBuilder {
     return this;
   }
   orderBy(column, direction = "asc") {
-    assertValidIdentifier(column, "orderBy(column)");
+    assertValidOrderByColumn(column, "orderBy(column)");
     if (direction !== "asc" && direction !== "desc")
       throw new TypeError(`[bun-query-builder] orderBy(direction): expected 'asc' or 'desc', got '${direction}'`);
     this._orderBy.push({ column, direction });
@@ -25194,7 +25203,14 @@ class ModelQueryBuilder {
       sql2 += ` WHERE ${whereBody}`;
     }
     const row = await exec.get(sql2, params);
-    return row?.v == null ? null : Number(row.v);
+    const v2 = row?.v;
+    if (v2 == null)
+      return null;
+    if (typeof v2 === "string") {
+      const n2 = Number(v2);
+      return v2.trim() !== "" && !Number.isNaN(n2) ? n2 : v2;
+    }
+    return v2;
   }
   max(column) {
     return this.aggregate("MAX", column);
@@ -25203,10 +25219,10 @@ class ModelQueryBuilder {
     return this.aggregate("MIN", column);
   }
   async avg(column) {
-    return await this.aggregate("AVG", column) || 0;
+    return Number(await this.aggregate("AVG", column) ?? 0) || 0;
   }
   async sum(column) {
-    return await this.aggregate("SUM", column) || 0;
+    return Number(await this.aggregate("SUM", column) ?? 0) || 0;
   }
   async delete() {
     const exec = getExecutor();

package/dist/type-inference.d.ts

@@ -302,112 +302,42 @@ export type InferPivotColumns<TModel, R extends string> = ResolveDefinition<TMod
         : Record<string, unknown>
       : Record<string, unknown>
     : Record<string, unknown>;
-// ============================================================================
-// Internal relation name inference helpers
-// ============================================================================
-declare type InferBelongsToNames<TDef> = (TDef extends { belongsTo: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { belongsTo: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasManyNames<TDef> = (TDef extends { hasMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { hasMany: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasOneNames<TDef> = (TDef extends { hasOne: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never)
-  | (TDef extends { hasOne: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferBelongsToManyNames<TDef> = (TDef extends { belongsToMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { belongsToMany: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasOneThroughNames<TDef> = (TDef extends { hasOneThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { hasOneThrough: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
-declare type InferHasManyThroughNames<TDef> = (TDef extends { hasManyThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
-  | (TDef extends { hasManyThrough: Readonly<Record<infer K, unknown>> }
-    ? K extends string ? K : never : never);
+/**
+ * Relation names of one relation declaration. Array form lowercases the
+ * (unwrapped) model name; record form uses the keys. The array case MUST be
+ * checked first: a tuple also structurally matches `Readonly<Record<...>>`
+ * and would otherwise leak its own keys ('length', indices, ...) into the
+ * relation-name union.
+ */
+declare type RelationKeyOf<V> = V extends readonly (infer E)[]
+    ? E extends string ? Lowercase<E>
+      : E extends { model: infer M extends string } ? Lowercase<M>
+        : never
+    : V extends Readonly<Record<infer K, unknown>>
+      ? K & string
+      : never;
+declare type InferBelongsToNames<TDef> = TDef extends { belongsTo: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasManyNames<TDef> = TDef extends { hasMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasOneNames<TDef> = TDef extends { hasOne: infer V } ? RelationKeyOf<V> : never;
+declare type InferBelongsToManyNames<TDef> = TDef extends { belongsToMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasOneThroughNames<TDef> = TDef extends { hasOneThrough: infer V } ? RelationKeyOf<V> : never;
+declare type InferHasManyThroughNames<TDef> = TDef extends { hasManyThrough: infer V } ? RelationKeyOf<V> : never;
 /**
  * Determine the cardinality of a relation on a model.
- * hasMany → 'many', hasOne/belongsTo → 'one'
+ * hasMany / belongsToMany / hasManyThrough / morphMany / morphToMany /
+ * morphedByMany → 'many'; hasOne / belongsTo / hasOneThrough / morphOne →
+ * 'one'. Both array and record declaration forms are supported via
+ * `RelationKeyOf` (array-first, so tuple keys never leak in).
  */
 export type RelationCardinality<TModel, R extends string> = ResolveDefinition<TModel> extends infer TDef
-    ? // hasMany array syntax
-    (TDef extends { hasMany: readonly (infer M)[] }
-        ? Lowercase<M & string> extends R ? 'many' : never
-        : never)
-    // hasMany object syntax
-    | (TDef extends { hasMany: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
-    // hasOne array syntax
-    | (TDef extends { hasOne: readonly (infer M)[] }
-        ? Lowercase<M & string> extends R ? 'one' : never
-        : never)
-    // hasOne object syntax
-    | (TDef extends { hasOne: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'one' : never : never
-        : never)
-    // belongsTo array syntax
-    | (TDef extends { belongsTo: readonly (infer M)[] }
-        ? Lowercase<M & string> extends R ? 'one' : never
-        : never)
-    // belongsTo object syntax
-    | (TDef extends { belongsTo: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'one' : never : never
-        : never)
-    // belongsToMany array syntax
-    | (TDef extends { belongsToMany: readonly (infer M)[] }
-        ? M extends string
-          ? Lowercase<M> extends R ? 'many' : never
-          : M extends { model: infer N extends string }
-            ? Lowercase<N> extends R ? 'many' : never
-            : never
-        : never)
-    // belongsToMany object syntax
-    | (TDef extends { belongsToMany: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
-    // hasOneThrough array syntax ({ model } entries)
-    | (TDef extends { hasOneThrough: readonly (infer M)[] }
-        ? M extends string
-          ? Lowercase<M> extends R ? 'one' : never
-          : M extends { model: infer N extends string }
-            ? Lowercase<N> extends R ? 'one' : never
-            : never
-        : never)
-    // hasOneThrough object syntax
-    | (TDef extends { hasOneThrough: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'one' : never : never
-        : never)
-    // hasManyThrough array syntax ({ model } entries)
-    | (TDef extends { hasManyThrough: readonly (infer M)[] }
-        ? M extends string
-          ? Lowercase<M> extends R ? 'many' : never
-          : M extends { model: infer N extends string }
-            ? Lowercase<N> extends R ? 'many' : never
-            : never
-        : never)
-    // hasManyThrough object syntax
-    | (TDef extends { hasManyThrough: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
-    // morphOne object syntax
-    | (TDef extends { morphOne: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'one' : never : never
-        : never)
-    // morphMany object syntax
-    | (TDef extends { morphMany: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
-    // morphToMany object syntax
-    | (TDef extends { morphToMany: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
-    // morphedByMany object syntax
-    | (TDef extends { morphedByMany: Readonly<Record<infer K, unknown>> }
-        ? K extends string ? K extends R ? 'many' : never : never
-        : never)
+    ? (TDef extends { hasMany: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
+    | (TDef extends { hasOne: infer V } ? (R extends RelationKeyOf<V> ? 'one' : never) : never)
+    | (TDef extends { belongsTo: infer V } ? (R extends RelationKeyOf<V> ? 'one' : never) : never)
+    | (TDef extends { belongsToMany: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
+    | (TDef extends { hasOneThrough: infer V } ? (R extends RelationKeyOf<V> ? 'one' : never) : never)
+    | (TDef extends { hasManyThrough: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
+    | (TDef extends { morphOne: infer V } ? (R extends RelationKeyOf<V> ? 'one' : never) : never)
+    | (TDef extends { morphMany: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
+    | (TDef extends { morphToMany: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
+    | (TDef extends { morphedByMany: infer V } ? (R extends RelationKeyOf<V> ? 'many' : never) : never)
     : never;

package/package.json

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