@getstrata/core 0.5.99 → 0.5.100

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @getstrata/core changelog
 
+## 0.5.100
+
+HiroApp dogfood of 0.5.99: eager `with()` / nested `load("a.b")` missed related rows when a Postgres int4 PK arrived as a JS `number` and an int8 FK as a `bigint`. Map matching used `===`.
+
+- Relation indexers and eager attach compare keys with `relationMatchKey` (`1`, `1n`, `"1"` match).
+- Sequential `load("position")` / `application.position()` already used SQL `get()` and were unaffected.
+- `registerModelRepository(User, users)` already names `User` and `$morphClass`. Do not also call `registerModelClass("User", User)`. `registerModelClass` is only for an alias that is neither `constructor.name` nor `$morphClass`.
+
+Still non-conforming (honest): Bun cannot infer `morphTo()` method names. `hashed` cast is a no-op. `Factory.has()` without a bound model still needs an explicit FK.
+
 ## 0.5.99
 
 HiroApp dogfood of 0.5.98 found lookalike APIs. This release matches Laravel call shape and SQL, not just export names.

package/dist/core/database/model.d.ts

@@ -25,6 +25,7 @@ type ModelObserver = {
     deleting?: (model: AnyModel) => unknown;
     deleted?: (model: AnyModel) => unknown;
 };
+/** Alias for `hasMany("Name")` when `Name` is not `constructor.name` or `$morphClass`. */
 declare function registerModelClass(name: string, model: object): void;
 declare function hydrateValue(value: unknown, cast: CastType): unknown;
 declare function dehydrateValue(value: unknown, cast: CastType): unknown;
@@ -135,6 +136,7 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     setLoaded(name: string, value: unknown): this;
     mergeAttributes(patch: Partial<TEntity>): this;
 }
+/** Binds a Model class to its table/connection and names it for `hasMany("User")`. */
 declare function registerModelRepository<TModelClass>(model: TModelClass, repository: object): TModelClass;
 export { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuery, HasOneRelationQuery, MorphManyRelationQuery, MorphOneRelationQuery, MorphToRelationQuery, } from "./relationQuery.ts";
 export type { CastType, GlobalScopeFn, ModelClassType, ModelConstructor };

package/dist/core/database/relationships.d.ts

@@ -48,6 +48,8 @@ declare function belongsToMany<TParent, TRelated, Pivot extends object, ParentKe
     foreignPivotKey: ForeignPivotKey;
     relatedPivotKey: RelatedPivotKey;
 }): BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>;
+declare function relationMatchKey(value: unknown): string;
+declare function getByRelationKey<K, V>(map: ReadonlyMap<K, V>, key: unknown): V | undefined;
 declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasManyRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild[]>;
 declare function indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
@@ -95,6 +97,6 @@ declare function morphTo<TChild, MorphTypeKey extends keyof TChild & string = ke
 }): MorphToRelation<TChild, MorphTypeKey, MorphIdKey>;
 declare function indexMorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild[]>;
 declare function indexMorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild | undefined>;
-declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<TParent[OwnerKey], TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
+declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, _OwnerKey extends keyof TParent & string = keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<unknown, TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
 export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };
+export { belongsTo, belongsToMany, getByRelationKey, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, relationMatchKey, };

package/dist/entries/database/model.js

@@ -982,26 +982,67 @@ function belongsToMany(definition) {
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -1009,12 +1050,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -1024,23 +1065,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -1062,27 +1113,38 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -1095,7 +1157,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -1762,7 +1824,7 @@ class Model {
   }
   async loadHasMany(as, relation, childRepository, options = {}) {
     const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
+    const loaded = getByRelationKey(grouped, this.attributes[relation.localKey]) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   async loadHasOne(as, relation, childRepository, options = {}) {
@@ -1772,7 +1834,7 @@ class Model {
   }
   async loadBelongsTo(as, relation, parentRepository, options = {}) {
     const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = grouped.get(this.attributes[relation.foreignKey]);
+    const loaded = getByRelationKey(grouped, this.attributes[relation.foreignKey]);
     return Object.assign(this, { [as]: loaded });
   }
   async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
@@ -1792,7 +1854,7 @@ class Model {
       }
     });
     const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = grouped.get(parentId) ?? [];
+    const loaded = getByRelationKey(grouped, parentId) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   hasMany(related, foreignKey, localKey) {

package/dist/entries/database/relationships.js

@@ -24,26 +24,67 @@ function belongsToMany(definition) {
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -51,12 +92,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -66,23 +107,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -104,27 +155,38 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -137,7 +199,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -147,6 +209,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
 export {
   belongsTo,
   belongsToMany,
+  getByRelationKey,
   hasMany,
   hasOne,
   indexBelongsToManyRelation,
@@ -158,5 +221,6 @@ export {
   indexMorphToRelation,
   morphMany,
   morphOne,
-  morphTo
+  morphTo,
+  relationMatchKey
 };

package/dist/entries/database/repositoryQuery.js

@@ -422,6 +422,214 @@ function buildDeleteByIdQuery(table, id) {
   };
 }
 
+// ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function hasOne(definition) {
+  return {
+    type: "hasOne",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
+function belongsToMany(definition) {
+  return {
+    type: "belongsToMany",
+    ...definition
+  };
+}
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
+function indexHasManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexHasOneRelation(parents, children, relation) {
+  const grouped = indexHasManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexBelongsToRelation(children, parents, relation) {
+  const parentsById = new Map;
+  for (const parent of parents) {
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
+  }
+  const result = new Map;
+  for (const child of children) {
+    const foreignKey = child[relation.foreignKey];
+    const parent = parentsById.get(relationMatchKey(foreignKey));
+    if (parent) {
+      result.set(foreignKey, parent);
+    }
+  }
+  return result;
+}
+function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
+  const relatedById = new Map;
+  for (const related of relatedRows) {
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
+  }
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
+  }
+  for (const pivot of pivotRows) {
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
+    if (!group || !related) {
+      continue;
+    }
+    group.push(related);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function morphMany(definition) {
+  return {
+    type: "morphMany",
+    ...definition
+  };
+}
+function morphOne(definition) {
+  return {
+    type: "morphOne",
+    ...definition
+  };
+}
+function morphTo(definition) {
+  return {
+    type: "morphTo",
+    ...definition
+  };
+}
+function indexMorphManyRelation(parents, children, relation) {
+  const groups = new Map;
+  const originalKeys = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
+  }
+  for (const child of children) {
+    if (child[relation.morphTypeKey] !== relation.morphType) {
+      continue;
+    }
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
+}
+function indexMorphOneRelation(parents, children, relation) {
+  const grouped = indexMorphManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
+function indexMorphToRelation(children, parentsByType, relation) {
+  const result = new Map;
+  for (const child of children) {
+    const morphType = String(child[relation.morphTypeKey]);
+    const parents = parentsByType.get(morphType);
+    if (!parents) {
+      continue;
+    }
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
+    if (parent) {
+      result.set(child[relation.morphIdKey], parent);
+    }
+  }
+  return result;
+}
+
 // ../../src/core/database/whereBuilder.ts
 class WhereBuilder {
   nodes = [];
@@ -652,7 +860,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -661,7 +869,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -670,7 +878,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey])
         }));
         continue;
       }
@@ -679,7 +887,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.parentKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.parentKey]) ?? []
         }));
         continue;
       }
@@ -688,7 +896,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.morphIdKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.morphIdKey])
         }));
         continue;
       }
@@ -696,7 +904,7 @@ class RepositoryQuery {
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
         ...row,
-        [load.as]: grouped.get(row[relation.foreignKey])
+        [load.as]: getByRelationKey(grouped, row[relation.foreignKey])
       }));
     }
     return result;

package/dist/index.js

@@ -2084,26 +2084,67 @@ function belongsToMany(definition) {
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -2111,12 +2152,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -2126,23 +2167,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -2164,27 +2215,38 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -2197,7 +2259,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -2435,7 +2497,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -2444,7 +2506,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -2453,7 +2515,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey])
         }));
         continue;
       }
@@ -2462,7 +2524,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.parentKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.parentKey]) ?? []
         }));
         continue;
       }
@@ -2471,7 +2533,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.morphIdKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.morphIdKey])
         }));
         continue;
       }
@@ -2479,7 +2541,7 @@ class RepositoryQuery {
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
         ...row,
-        [load.as]: grouped.get(row[relation.foreignKey])
+        [load.as]: getByRelationKey(grouped, row[relation.foreignKey])
       }));
     }
     return result;
@@ -2770,7 +2832,7 @@ class BaseRepository {
     const grouped = await this.loadMorphManyForParents(parents, relation, options);
     const result = new Map;
     for (const parent of parents) {
-      const matches = grouped.get(parent[relation.localKey]) ?? [];
+      const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
       result.set(parent[relation.localKey], matches[0]);
     }
     return result;
@@ -2799,7 +2861,7 @@ class BaseRepository {
       }, options);
       const indexed = new Map;
       for (const parent of parents) {
-        indexed.set(parent[ownerKey], parent);
+        indexed.set(relationMatchKey(parent[ownerKey]), parent);
       }
       parentsByType.set(morphType, indexed);
     }
@@ -4313,7 +4375,7 @@ class Model {
   }
   async loadHasMany(as, relation, childRepository, options = {}) {
     const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
+    const loaded = getByRelationKey(grouped, this.attributes[relation.localKey]) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   async loadHasOne(as, relation, childRepository, options = {}) {
@@ -4323,7 +4385,7 @@ class Model {
   }
   async loadBelongsTo(as, relation, parentRepository, options = {}) {
     const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = grouped.get(this.attributes[relation.foreignKey]);
+    const loaded = getByRelationKey(grouped, this.attributes[relation.foreignKey]);
     return Object.assign(this, { [as]: loaded });
   }
   async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
@@ -4343,7 +4405,7 @@ class Model {
       }
     });
     const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = grouped.get(parentId) ?? [];
+    const loaded = getByRelationKey(grouped, parentId) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   hasMany(related, foreignKey, localKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.5.99",
+  "version": "0.5.100",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",