bun-query-builder 0.1.27 → 0.1.28

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 });
@@ -29920,7 +29929,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.27";
+var version2 = "0.1.28";
 
 // 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

@@ -413,22 +413,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>}`

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>

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 });

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.28",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",