bun-query-builder 0.1.57 → 0.1.59

package/dist/bin/cli.js

@@ -20018,6 +20018,23 @@ var init_actions = __esm(() => {
   init_wait_ready();
 });
 
+// src/relation-utils.ts
+function normalizeRelationEntry(entry) {
+  if (typeof entry === "string")
+    return { model: entry };
+  if (entry && typeof entry === "object" && typeof entry.model === "string") {
+    const e = entry;
+    return { model: e.model, foreignKey: e.foreignKey, onDelete: e.onDelete };
+  }
+  return null;
+}
+function normalizeRelationList(rel) {
+  if (!rel)
+    return [];
+  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
+  return entries.map(normalizeRelationEntry).filter((x) => x !== null);
+}
+
 // ../../node_modules/@stacksjs/ts-faker/dist/chunk-aggdkeg4.js
 import { existsSync as zS } from "fs";
 import { join as YS } from "path";
@@ -24753,12 +24770,12 @@ class ModelInstance {
   only(keys) {
     const out = {};
     for (const k2 of keys) {
-      out[k2] = this._attributes[k2];
+      out[k2] = this._attributes[toSnakeCase(k2)];
     }
     return out;
   }
   except(keys) {
-    const drop = new Set(keys.map((k2) => k2));
+    const drop = new Set(keys.map((k2) => toSnakeCase(k2)));
     const out = {};
     for (const k2 of Object.keys(this._attributes)) {
       if (!drop.has(k2))
@@ -24786,7 +24803,8 @@ class ModelInstance {
     if (this._original === null)
       return false;
     if (column) {
-      return this._attributes[column] !== this._original[column];
+      const key = toSnakeCase(column);
+      return this._attributes[key] !== this._original[key];
     }
     return Object.keys(this._attributes).some((k2) => this._attributes[k2] !== this._original[k2]);
   }
@@ -24795,7 +24813,7 @@ class ModelInstance {
   }
   getOriginal(column) {
     const orig = this.getOriginalAttributes();
-    return orig[column];
+    return orig[toSnakeCase(column)];
   }
   getChanges() {
     if (this._original === null)
@@ -24834,7 +24852,7 @@ class ModelInstance {
     const setters = this._definition.set || {};
     for (const [key, setter] of Object.entries(setters)) {
       if (this.isDirty(key)) {
-        this._attributes[key] = setter(this._attributes);
+        this._attributes[toSnakeCase(key)] = setter(this._attributes);
       }
     }
     if (this._attributes[pk]) {
@@ -25045,6 +25063,34 @@ function resolveRelation(definition, relationName) {
     }
     return null;
   }
+  function findBelongsToEntry() {
+    const rel = definition.belongsTo;
+    if (!rel)
+      return null;
+    const lower = relationName.toLowerCase();
+    const unwrap = (entry) => {
+      if (typeof entry === "string")
+        return { model: entry };
+      if (entry && typeof entry === "object" && typeof entry.model === "string")
+        return { model: entry.model, foreignKey: entry.foreignKey };
+      return null;
+    };
+    if (Array.isArray(rel)) {
+      for (const item of rel) {
+        const e2 = unwrap(item);
+        if (e2 && e2.model.toLowerCase() === lower)
+          return e2;
+      }
+      return null;
+    }
+    if (typeof rel === "object") {
+      for (const [key, value] of Object.entries(rel)) {
+        if (key === relationName || key.toLowerCase() === lower)
+          return unwrap(value);
+      }
+    }
+    return null;
+  }
   function findBelongsToManyEntry() {
     const rel = definition.belongsToMany;
     if (!rel)
@@ -25084,12 +25130,13 @@ function resolveRelation(definition, relationName) {
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasOne", relatedModelName: hasOneModel, relatedTable, foreignKey, localKey: parentPk };
   }
-  const belongsToModel = findModelName(definition.belongsTo);
-  if (belongsToModel) {
+  const belongsToEntry = findBelongsToEntry();
+  if (belongsToEntry) {
+    const belongsToModel = belongsToEntry.model;
     const relatedModel = getModelFromRegistry(belongsToModel);
     const relatedTable = relatedModel?.getTable?.() || toTableName(belongsToModel);
     const relatedPk = relatedModel?.getDefinition?.()?.primaryKey || "id";
-    const foreignKey = toSnakeCase(belongsToModel) + "_id";
+    const foreignKey = belongsToEntry.foreignKey || `${toSnakeCase(belongsToModel)}_id`;
     return { type: "belongsTo", relatedModelName: belongsToModel, relatedTable, foreignKey, localKey: relatedPk };
   }
   const found = findBelongsToManyEntry();
@@ -25634,7 +25681,10 @@ class ModelQueryBuilder {
     return this;
   }
   with(...relations) {
-    this._withRelations = relations;
+    for (const r2 of relations) {
+      if (!this._withRelations.includes(r2))
+        this._withRelations.push(r2);
+    }
     return this;
   }
   getWithRelations() {
@@ -26193,12 +26243,19 @@ function createModel(definition) {
 }
 async function createTableFromModel(definition) {
   const exec = getExecutor();
-  const pk = definition.primaryKey || "id";
+  const pk = toSnakeCase(definition.primaryKey || "id");
   const columns = [];
+  const emitted = new Set([pk]);
   columns.push(definition.autoIncrement !== false ? `${pk} INTEGER PRIMARY KEY AUTOINCREMENT` : `${pk} INTEGER PRIMARY KEY`);
-  if (definition.traits?.useUuid)
+  if (definition.traits?.useUuid) {
     columns.push("uuid TEXT UNIQUE");
-  for (const [name, attr] of Object.entries(definition.attributes)) {
+    emitted.add("uuid");
+  }
+  for (const [attrName, attr] of Object.entries(definition.attributes)) {
+    const name = toSnakeCase(attrName);
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
     let colType = "TEXT";
     if (attr.type === "number")
       colType = "INTEGER";
@@ -26219,10 +26276,23 @@ async function createTableFromModel(definition) {
     }
     columns.push(colDef);
   }
+  for (const rel of normalizeRelationList(definition.belongsTo)) {
+    const name = rel.foreignKey ?? `${toSnakeCase(rel.model)}_id`;
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
+    columns.push(`${name} INTEGER`);
+  }
   if (timestampsEnabled(definition)) {
-    columns.push("created_at TEXT", "updated_at TEXT");
+    for (const c2 of ["created_at", "updated_at"]) {
+      if (emitted.has(c2))
+        continue;
+      emitted.add(c2);
+      columns.push(`${c2} TEXT`);
+    }
   }
-  if (softDeletesEnabled(definition)) {
+  if (softDeletesEnabled(definition) && !emitted.has("deleted_at")) {
+    emitted.add("deleted_at");
     columns.push("deleted_at TEXT");
   }
   await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
@@ -26265,7 +26335,7 @@ async function seedModel(definition, count, faker) {
     const data = {};
     for (const [name, attr] of Object.entries(definition.attributes)) {
       if (attr.factory)
-        data[name] = attr.factory(faker);
+        data[toSnakeCase(name)] = attr.factory(faker);
     }
     if (timestampsEnabled(definition)) {
       const now = formatNow();
@@ -27766,23 +27836,6 @@ async function loadModels(options) {
 }
 var init_loader = () => {};
 
-// src/relation-utils.ts
-function normalizeRelationEntry(entry) {
-  if (typeof entry === "string")
-    return { model: entry };
-  if (entry && typeof entry === "object" && typeof entry.model === "string") {
-    const e2 = entry;
-    return { model: e2.model, foreignKey: e2.foreignKey, onDelete: e2.onDelete };
-  }
-  return null;
-}
-function normalizeRelationList(rel) {
-  if (!rel)
-    return [];
-  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
-  return entries.map(normalizeRelationEntry).filter((x2) => x2 !== null);
-}
-
 // src/meta.ts
 function buildSchemaMeta(models) {
   const modelToTable = {};
@@ -31022,7 +31075,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.57";
+var version2 = "0.1.59";
 
 // bin/cli.ts
 init_actions();

package/dist/orm.d.ts

@@ -68,6 +68,17 @@ export declare interface ModelHookInstance extends Record<string, unknown> {
   except?(keys: ReadonlyArray<string>): Record<string, unknown>
   toArray?(): Record<string, unknown>
 }
+/**
+ * Object form of a `belongsTo` entry. The migration generator has always
+ * honored `foreignKey`/`onDelete` here (see `normalizeRelationEntry`), but the
+ * declaration type only admitted plain model-name strings — so the supported
+ * form was a type error at the call site.
+ */
+export declare interface BelongsToEntry {
+  readonly model: string
+  readonly foreignKey?: string
+  readonly onDelete?: import('./schema').OnForeignKeyAction
+}
 // Base model definition
 export declare interface ModelDefinition {
   readonly name: string
@@ -113,7 +124,7 @@ export declare interface ModelDefinition {
     readonly useActivityLog?: boolean | object
     readonly useSocials?: readonly string[]
   }
-  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsTo?: readonly (string | BelongsToEntry)[] | Readonly<Record<string, string | BelongsToEntry>>
   readonly hasMany?: readonly string[] | Readonly<Record<string, string>>
   readonly hasOne?: readonly string[] | Readonly<Record<string, string>>
   readonly belongsToMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
@@ -247,7 +258,7 @@ declare type SnakeCaseAttributes<TDef extends ModelDefinition> = {
 // 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 } &
+declare type TraitSystemFields<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 } : {}) &
@@ -255,8 +266,65 @@ declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends {
   (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {}) &
   (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 } : {});
+/**
+ * Every column name the model declares itself, in both the casing it was
+ * written in and its snake_case column form.
+ */
+declare type DeclaredColumns<TDef extends ModelDefinition> = AttributeKeys<TDef> | SnakeCase<AttributeKeys<TDef>>;
+/**
+ * Trait-added system fields, minus anything the model declares explicitly.
+ *
+ * Without the `Omit`, a model that declares a column a trait also contributes
+ * (`created_at: { type: 'date' }` alongside `useTimestamps`, or a `user_id`
+ * string alongside `belongsTo: ['User']`) intersected the two shapes into
+ * `Date & string` — or outright `never`. Every read of that column then had an
+ * uninhabited type and every write was rejected. A column the model spells out
+ * is the authority on its own type; the trait default only fills the gap.
+ */
+declare type SystemFields<TDef extends ModelDefinition> = Omit<TraitSystemFields<TDef>, DeclaredColumns<TDef>>;
+/**
+ * A single `belongsTo` entry reduced to the FK column it puts on this table.
+ * Mirrors `normalizeRelationEntry` in relation-utils.ts: an explicit
+ * `foreignKey` wins, otherwise the name is derived from the model name.
+ */
+declare type BelongsToFkOf<E> = E extends string
+    ? `${SnakeCase<Uncapitalize<E>>}_id`
+    : E extends { foreignKey: infer F extends string }
+      ? F
+      : E extends { model: infer M extends string }
+        ? `${SnakeCase<Uncapitalize<M>>}_id`
+        : never;
+/**
+ * The foreign-key columns a `belongsTo` puts on THIS model's table.
+ *
+ * `belongsTo: ['Farm', 'Field']` means the migration carries `farm_id` and
+ * `field_id`, so they are as real as any declared attribute and code queries
+ * them constantly (`Mission.where('field_id', field.id)`). They were missing
+ * from both `ModelAttributes` and `ColumnName`, which made every such query a
+ * type error against a column that demonstrably exists.
+ *
+ * All four declaration shapes the migration generator accepts are covered:
+ * `['Farm']`, `[{ model: 'Farm', foreignKey: 'owner_id' }]`, `{ farm: 'Farm' }`
+ * and `{ owner: { model: 'User', foreignKey: 'owner_id' } }`. The array case
+ * MUST be checked first — a tuple also structurally matches `Record`, and the
+ * record branch would otherwise read its numeric indices as entries.
+ *
+ * The default name follows the same snake_case convention the relation resolver
+ * uses at runtime: `Farm` -> `farm_id`, `TreatmentMap` -> `treatment_map_id`.
+ */
+declare type BelongsToKeys<TDef extends ModelDefinition> = TDef extends { belongsTo: infer R }
+    ? R extends readonly (infer E)[]
+      ? BelongsToFkOf<E>
+      : R extends Readonly<Record<string, infer W>>
+        ? BelongsToFkOf<W>
+        : never
+    : never;
+// A declared attribute of the same name wins — see SystemFields above.
+declare type BelongsToColumns<TDef extends ModelDefinition> = {
+  [K in Exclude<BelongsToKeys<TDef>, DeclaredColumns<TDef>>]: number
+}
 // Complete model type
-declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SnakeCaseAttributes<TDef> & SystemFields<TDef>;
+declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SnakeCaseAttributes<TDef> & SystemFields<TDef> & BelongsToColumns<TDef>;
 // All valid column names
 declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
   | SnakeCase<AttributeKeys<TDef>>
@@ -267,7 +335,8 @@ declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
   | (TDef['traits'] extends { useSoftDeletes: true } ? 'deleted_at' : never)
   | (TDef['traits'] extends { softDeletable: true | object } ? 'deleted_at' : never)
   | (TDef['traits'] extends { useAuth: true | object } ? 'two_factor_secret' | 'public_key' : never)
-  | (TDef['traits'] extends { billable: true | object } ? 'stripe_id' : never);
+  | (TDef['traits'] extends { billable: true | object } ? 'stripe_id' : never)
+  | BelongsToKeys<TDef>;
 // Hidden fields
 declare type HiddenKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { hidden: true } ? K : never
@@ -276,9 +345,18 @@ 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>];
+/**
+ * `belongsTo` foreign keys are always writable.
+ *
+ * Attaching a record to its parent IS the create: `Mission.create({ …,
+ * field_id: field.id })`. There is no attribute declaration to put
+ * `fillable: true` on, because the column comes from the relation rather than
+ * from `attributes`, so without this every such create was a type error
+ * against the one column the relation exists to set.
+ */
 declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
   ModelAttributes<TDef>,
-  FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>>
+  FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>> | BelongsToKeys<TDef>
 >>;
 // Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
 declare type NumericColumns<TDef extends ModelDefinition> = {

package/dist/src/index.js

@@ -20017,6 +20017,23 @@ var init_actions = __esm(() => {
   init_wait_ready();
 });
 
+// src/relation-utils.ts
+function normalizeRelationEntry(entry) {
+  if (typeof entry === "string")
+    return { model: entry };
+  if (entry && typeof entry === "object" && typeof entry.model === "string") {
+    const e = entry;
+    return { model: e.model, foreignKey: e.foreignKey, onDelete: e.onDelete };
+  }
+  return null;
+}
+function normalizeRelationList(rel) {
+  if (!rel)
+    return [];
+  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
+  return entries.map(normalizeRelationEntry).filter((x) => x !== null);
+}
+
 // ../../node_modules/@stacksjs/ts-faker/dist/chunk-aggdkeg4.js
 import { existsSync as zS } from "fs";
 import { join as YS } from "path";
@@ -24752,12 +24769,12 @@ class ModelInstance {
   only(keys) {
     const out = {};
     for (const k2 of keys) {
-      out[k2] = this._attributes[k2];
+      out[k2] = this._attributes[toSnakeCase(k2)];
     }
     return out;
   }
   except(keys) {
-    const drop = new Set(keys.map((k2) => k2));
+    const drop = new Set(keys.map((k2) => toSnakeCase(k2)));
     const out = {};
     for (const k2 of Object.keys(this._attributes)) {
       if (!drop.has(k2))
@@ -24785,7 +24802,8 @@ class ModelInstance {
     if (this._original === null)
       return false;
     if (column) {
-      return this._attributes[column] !== this._original[column];
+      const key = toSnakeCase(column);
+      return this._attributes[key] !== this._original[key];
     }
     return Object.keys(this._attributes).some((k2) => this._attributes[k2] !== this._original[k2]);
   }
@@ -24794,7 +24812,7 @@ class ModelInstance {
   }
   getOriginal(column) {
     const orig = this.getOriginalAttributes();
-    return orig[column];
+    return orig[toSnakeCase(column)];
   }
   getChanges() {
     if (this._original === null)
@@ -24833,7 +24851,7 @@ class ModelInstance {
     const setters = this._definition.set || {};
     for (const [key, setter] of Object.entries(setters)) {
       if (this.isDirty(key)) {
-        this._attributes[key] = setter(this._attributes);
+        this._attributes[toSnakeCase(key)] = setter(this._attributes);
       }
     }
     if (this._attributes[pk]) {
@@ -25044,6 +25062,34 @@ function resolveRelation(definition, relationName) {
     }
     return null;
   }
+  function findBelongsToEntry() {
+    const rel = definition.belongsTo;
+    if (!rel)
+      return null;
+    const lower = relationName.toLowerCase();
+    const unwrap = (entry) => {
+      if (typeof entry === "string")
+        return { model: entry };
+      if (entry && typeof entry === "object" && typeof entry.model === "string")
+        return { model: entry.model, foreignKey: entry.foreignKey };
+      return null;
+    };
+    if (Array.isArray(rel)) {
+      for (const item of rel) {
+        const e2 = unwrap(item);
+        if (e2 && e2.model.toLowerCase() === lower)
+          return e2;
+      }
+      return null;
+    }
+    if (typeof rel === "object") {
+      for (const [key, value] of Object.entries(rel)) {
+        if (key === relationName || key.toLowerCase() === lower)
+          return unwrap(value);
+      }
+    }
+    return null;
+  }
   function findBelongsToManyEntry() {
     const rel = definition.belongsToMany;
     if (!rel)
@@ -25083,12 +25129,13 @@ function resolveRelation(definition, relationName) {
     const foreignKey = toSnakeCase(parentName) + "_id";
     return { type: "hasOne", relatedModelName: hasOneModel, relatedTable, foreignKey, localKey: parentPk };
   }
-  const belongsToModel = findModelName(definition.belongsTo);
-  if (belongsToModel) {
+  const belongsToEntry = findBelongsToEntry();
+  if (belongsToEntry) {
+    const belongsToModel = belongsToEntry.model;
     const relatedModel = getModelFromRegistry(belongsToModel);
     const relatedTable = relatedModel?.getTable?.() || toTableName(belongsToModel);
     const relatedPk = relatedModel?.getDefinition?.()?.primaryKey || "id";
-    const foreignKey = toSnakeCase(belongsToModel) + "_id";
+    const foreignKey = belongsToEntry.foreignKey || `${toSnakeCase(belongsToModel)}_id`;
     return { type: "belongsTo", relatedModelName: belongsToModel, relatedTable, foreignKey, localKey: relatedPk };
   }
   const found = findBelongsToManyEntry();
@@ -25633,7 +25680,10 @@ class ModelQueryBuilder {
     return this;
   }
   with(...relations) {
-    this._withRelations = relations;
+    for (const r2 of relations) {
+      if (!this._withRelations.includes(r2))
+        this._withRelations.push(r2);
+    }
     return this;
   }
   getWithRelations() {
@@ -26192,12 +26242,19 @@ function createModel(definition) {
 }
 async function createTableFromModel(definition) {
   const exec = getExecutor();
-  const pk = definition.primaryKey || "id";
+  const pk = toSnakeCase(definition.primaryKey || "id");
   const columns = [];
+  const emitted = new Set([pk]);
   columns.push(definition.autoIncrement !== false ? `${pk} INTEGER PRIMARY KEY AUTOINCREMENT` : `${pk} INTEGER PRIMARY KEY`);
-  if (definition.traits?.useUuid)
+  if (definition.traits?.useUuid) {
     columns.push("uuid TEXT UNIQUE");
-  for (const [name, attr] of Object.entries(definition.attributes)) {
+    emitted.add("uuid");
+  }
+  for (const [attrName, attr] of Object.entries(definition.attributes)) {
+    const name = toSnakeCase(attrName);
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
     let colType = "TEXT";
     if (attr.type === "number")
       colType = "INTEGER";
@@ -26218,10 +26275,23 @@ async function createTableFromModel(definition) {
     }
     columns.push(colDef);
   }
+  for (const rel of normalizeRelationList(definition.belongsTo)) {
+    const name = rel.foreignKey ?? `${toSnakeCase(rel.model)}_id`;
+    if (emitted.has(name))
+      continue;
+    emitted.add(name);
+    columns.push(`${name} INTEGER`);
+  }
   if (timestampsEnabled(definition)) {
-    columns.push("created_at TEXT", "updated_at TEXT");
+    for (const c2 of ["created_at", "updated_at"]) {
+      if (emitted.has(c2))
+        continue;
+      emitted.add(c2);
+      columns.push(`${c2} TEXT`);
+    }
   }
-  if (softDeletesEnabled(definition)) {
+  if (softDeletesEnabled(definition) && !emitted.has("deleted_at")) {
+    emitted.add("deleted_at");
     columns.push("deleted_at TEXT");
   }
   await exec.run(`CREATE TABLE IF NOT EXISTS ${definition.table} (${columns.join(", ")})`, []);
@@ -26264,7 +26334,7 @@ async function seedModel(definition, count, faker) {
     const data = {};
     for (const [name, attr] of Object.entries(definition.attributes)) {
       if (attr.factory)
-        data[name] = attr.factory(faker);
+        data[toSnakeCase(name)] = attr.factory(faker);
     }
     if (timestampsEnabled(definition)) {
       const now = formatNow();
@@ -27765,23 +27835,6 @@ async function loadModels(options) {
 }
 var init_loader = () => {};
 
-// src/relation-utils.ts
-function normalizeRelationEntry(entry) {
-  if (typeof entry === "string")
-    return { model: entry };
-  if (entry && typeof entry === "object" && typeof entry.model === "string") {
-    const e2 = entry;
-    return { model: e2.model, foreignKey: e2.foreignKey, onDelete: e2.onDelete };
-  }
-  return null;
-}
-function normalizeRelationList(rel) {
-  if (!rel)
-    return [];
-  const entries = Array.isArray(rel) ? rel : typeof rel === "object" ? Object.values(rel) : [];
-  return entries.map(normalizeRelationEntry).filter((x2) => x2 !== null);
-}
-
 // src/meta.ts
 function buildSchemaMeta(models) {
   const modelToTable = {};

package/dist/type-inference.d.ts

@@ -32,7 +32,7 @@ declare interface InferableModelDefinition {
     readonly useAuth?: boolean | object
     readonly billable?: boolean | object
   }
-  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsTo?: readonly (string | object)[] | Readonly<Record<string, string | object>>
   readonly hasMany?: readonly string[] | Readonly<Record<string, string>>
   readonly hasOne?: readonly string[] | Readonly<Record<string, string>>
   readonly belongsToMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
@@ -72,6 +72,41 @@ declare type ResolveDefinition<TModel> = TModel extends { getDefinition: () => i
         never;
 /** Extract user-defined attribute keys from a model definition */
 declare type DefinitionAttributeKeys<TDef extends InferableModelDefinition> = keyof TDef['attributes'] & string;
+/** The model's primary-key column name, defaulting to `id`. */
+declare type PrimaryKeyOf<TDef> = TDef extends { primaryKey: infer PK extends string } ? PK : 'id';
+/**
+ * A single `belongsTo` entry reduced to the FK column it puts on this table.
+ * Mirrors `normalizeRelationEntry` in relation-utils.ts and `BelongsToFkOf` in
+ * orm.ts: an explicit `foreignKey` wins, otherwise the name is derived from
+ * the model name.
+ */
+declare type BelongsToFkOf<E> = E extends string
+    ? `${SnakeCase<Uncapitalize<E>>}_id`
+    : E extends { foreignKey: infer F extends string }
+      ? F
+      : E extends { model: infer M extends string }
+        ? `${SnakeCase<Uncapitalize<M>>}_id`
+        : never;
+/**
+ * The foreign-key columns a `belongsTo` puts on THIS model's table — they are
+ * emitted by the migration generator, so they are as real as any declared
+ * attribute. The array case MUST be checked first: a tuple also structurally
+ * matches `Record`, and the record branch would otherwise read its numeric
+ * indices as entries.
+ */
+declare type BelongsToKeys<TDef> = TDef extends { belongsTo: infer R }
+    ? R extends readonly (infer E)[]
+      ? BelongsToFkOf<E>
+      : R extends Readonly<Record<string, infer W>>
+        ? BelongsToFkOf<W>
+        : never
+    : never;
+/** camelCase -> snake_case, matching the column names migrations emit. */
+declare type SnakeCase<S extends string> = S extends `${infer C}${infer Rest}`
+  ? C extends Lowercase<C>
+    ? `${C}${SnakeCase<Rest>}`
+    : `_${Lowercase<C>}${SnakeCase<Rest>}`
+  : S;
 // ============================================================================
 // Single attribute type inference
 // ============================================================================
@@ -93,14 +128,23 @@ export type InferAttributes<TModel> = ResolveDefinition<TModel> extends infer TD
         [K in DefinitionAttributeKeys<TDef>]: TDef['attributes'][K] extends { nullable: true }
           ? InferSingleAttributeType<TDef['attributes'][K]> | null
           : InferSingleAttributeType<TDef['attributes'][K]>
-      } & { [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 } : {})
-      & (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
-      & (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {})
-      & (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 } : {})
+      }
+      // A column the model spells out is the authority on its own type; the
+      // trait / FK default only fills the gap. Without the Omit, a model that
+      // declares `created_at: { type: 'date' }` alongside `useTimestamps`
+      // intersected the two into `Date & string` — an uninhabited type.
+      & Omit<
+        { [K in PrimaryKeyOf<TDef>]: 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 } : {})
+        & (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
+        & (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {})
+        & (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 } : {})
+        & { [K in BelongsToKeys<TDef>]: number },
+        DefinitionAttributeKeys<TDef>
+      >
     : never;
 /**
  * The full row type for a model, including an index signature for trait-added
@@ -144,6 +188,11 @@ export type ModelCreateDataLoose<TModel> = InferFillableAttributes<TModel> & { [
  * Infer only the fillable fields from a model definition or wrapped model.
  * This is the type accepted by `create()`, `update()`, and `fill()`.
  *
+ * Mirrors `InferAttributes`: a column declared `nullable: true` admits `null`.
+ * Columns that are `nullable` or carry a `default` are also OPTIONAL — the
+ * database supplies a value when the caller omits one, so requiring them at
+ * the call site rejected perfectly valid inserts.
+ *
  * @example
  * ```ts
  * type UserFillable = InferFillableAttributes<typeof UserModel>
@@ -151,11 +200,25 @@ export type ModelCreateDataLoose<TModel> = InferFillableAttributes<TModel> & { [
  * ```
  */
 export type InferFillableAttributes<TModel> = ResolveDefinition<TModel> extends infer TDef extends InferableModelDefinition
-    ? {
-        [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true } ? K : never]:
-        InferSingleAttributeType<TDef['attributes'][K]>
-      }
+    ? FillableRequired<TDef> & FillableOptional<TDef>
     : never;
+/** Fillable keys the caller MUST supply — no `nullable`, no `default`. */
+declare type FillableRequired<TDef extends InferableModelDefinition> = {
+  [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true }
+    ? TDef['attributes'][K] extends { nullable: true } | { default: unknown } ? never : K
+    : never]:
+  InferFillableType<TDef['attributes'][K]>
+}
+/** Fillable keys the database can fill in — `nullable` or `default`. */
+declare type FillableOptional<TDef extends InferableModelDefinition> = {
+  [K in DefinitionAttributeKeys<TDef> as TDef['attributes'][K] extends { fillable: true }
+    ? TDef['attributes'][K] extends { nullable: true } | { default: unknown } ? K : never
+    : never]?:
+  InferFillableType<TDef['attributes'][K]>
+}
+declare type InferFillableType<TAttr> = TAttr extends { nullable: true }
+  ? InferSingleAttributeType<TAttr> | null
+  : InferSingleAttributeType<TAttr>;
 /**
  * Infer the primary key type from a model definition or wrapped model.
  * Returns the literal string type of the primary key column name.
@@ -183,7 +246,9 @@ export type InferTableName<TModel> = ResolveDefinition<TModel> extends infer TDe
     : never;
 /**
  * Infer all valid relation names from a model definition or wrapped model.
- * Combines belongsTo, hasMany, hasOne, belongsToMany, hasOneThrough, and hasManyThrough.
+ * Covers every relation kind `RelationCardinality` knows about: belongsTo,
+ * hasMany, hasOne, belongsToMany, hasOneThrough, hasManyThrough, and the
+ * polymorphic morphOne / morphMany / morphToMany / morphedByMany.
  *
  * @example
  * ```ts
@@ -198,6 +263,10 @@ export type InferRelationNames<TModel> = ResolveDefinition<TModel> extends infer
     | InferBelongsToManyNames<TDef>
     | InferHasOneThroughNames<TDef>
     | InferHasManyThroughNames<TDef>
+    | InferMorphOneNames<TDef>
+    | InferMorphManyNames<TDef>
+    | InferMorphToManyNames<TDef>
+    | InferMorphedByManyNames<TDef>
     : never;
 /**
  * Infer column names that have numeric types from a model definition or wrapped model.
@@ -223,10 +292,18 @@ export type InferNumericColumns<TModel> = ResolveDefinition<TModel> extends infe
  * type UserCols = InferColumnNames<typeof UserModel>
  * // 'name' | 'email' | 'age' | 'role' | 'id' | 'uuid' | 'created_at' | 'updated_at'
  * ```
+ *
+ * Kept in parity with the ORM layer's `ColumnName`: the primary key honors a
+ * custom `primaryKey` (a custom-pk model exposes THAT column, not a phantom
+ * `id`), belongsTo-implied foreign keys are included because the migration
+ * generator emits them, and every declared attribute is also valid in its
+ * snake_case column form.
  */
 export type InferColumnNames<TModel> = ResolveDefinition<TModel> extends infer TDef extends InferableModelDefinition
     ? DefinitionAttributeKeys<TDef>
-    | 'id'
+    | SnakeCase<DefinitionAttributeKeys<TDef>>
+    | PrimaryKeyOf<TDef>
+    | BelongsToKeys<TDef>
     | (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)
@@ -303,25 +380,35 @@ export type InferPivotColumns<TModel, R extends string> = ResolveDefinition<TMod
       : Record<string, unknown>
     : Record<string, unknown>;
 /**
- * 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<...>>`
+ * Relation names of one relation declaration. A bare string (`morphOne:
+ * 'Image'`) lowercases the model name; array form lowercases the (unwrapped)
+ * model name; record form uses the keys.
+ *
+ * Order matters. The bare-string case must precede the record case (a string
+ * would otherwise fall through to `never`), and the array case MUST precede
+ * the record case: 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 RelationKeyOf<V> = V extends string
+    ? Lowercase<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;
+declare type InferMorphOneNames<TDef> = TDef extends { morphOne: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphManyNames<TDef> = TDef extends { morphMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphToManyNames<TDef> = TDef extends { morphToMany: infer V } ? RelationKeyOf<V> : never;
+declare type InferMorphedByManyNames<TDef> = TDef extends { morphedByMany: infer V } ? RelationKeyOf<V> : never;
 /**
  * Determine the cardinality of a relation on a model.
  * hasMany / belongsToMany / hasManyThrough / morphMany / morphToMany /

package/package.json

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