@getstrata/core 0.5.98 → 0.5.100

package/dist/entries/database/model.js

@@ -97,7 +97,7 @@ function buildOperatorClauses(column, operator, params) {
     clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
   }
   if (operator.ilike !== undefined) {
-    clauses.push(`${column} ILIKE ${pushParam(params, `%${operator.ilike}%`)}`);
+    clauses.push(`${column} ILIKE ${pushParam(params, operator.ilike)}`);
   }
   if (operator.tsMatch !== undefined) {
     clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
@@ -458,6 +458,9 @@ function ownerId(owner, ownerKey) {
   }
   throw new Error("belongsTo.associate() requires a related model or { id }.");
 }
+function thenGet(get, onfulfilled, onrejected) {
+  return get().then(onfulfilled ?? undefined, onrejected ?? undefined);
+}
 
 class HasManyRelationQuery {
   parent;
@@ -521,13 +524,28 @@ class HasManyRelationQuery {
     return rows[0] ?? null;
   }
   async count() {
-    return (await this.get()).length;
+    return this.scopedQuery().count();
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
   }
   async create(attributes = {}) {
     return this.related.create(attributes, {
       [this.relation.foreignKey]: this.parent.get(this.relation.localKey)
     });
   }
+  async save(related) {
+    const forced = {
+      [this.relation.foreignKey]: this.parent.get(this.relation.localKey)
+    };
+    const savable = related;
+    if (typeof savable.save === "function") {
+      savable.mergeAttributes?.(forced);
+      await savable.save();
+      return related;
+    }
+    return this.create(related);
+  }
   async createMany(records) {
     const created = [];
     for (const attributes of records) {
@@ -575,11 +593,17 @@ class HasOneRelationQuery {
     return this.get();
   }
   async count() {
-    return await this.get() ? 1 : 0;
+    return this.inner.count();
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
   }
   async create(attributes = {}) {
     return this.inner.create(attributes);
   }
+  async save(related) {
+    return this.inner.save(related);
+  }
 }
 
 class BelongsToRelationQuery {
@@ -587,12 +611,17 @@ class BelongsToRelationQuery {
   related;
   relation;
   kind = "belongsTo";
+  extraWhere = {};
   extraOptions = {};
   constructor(parent, related, relation) {
     this.parent = parent;
     this.related = related;
     this.relation = relation;
   }
+  where(where) {
+    this.extraWhere = { ...this.extraWhere, ...where };
+    return this;
+  }
   orderBy(orderBy) {
     this.extraOptions = { ...this.extraOptions, orderBy };
     return this;
@@ -606,10 +635,10 @@ class BelongsToRelationQuery {
   }
   toExistsClause(parentTable) {
     const relatedTable = this.related.repository().getTable().name;
-    return {
-      sql: `SELECT 1 FROM ${quoteIdentifier(relatedTable)} WHERE ${qualifyColumn(relatedTable, this.relation.ownerKey)} = ${qualifyColumn(parentTable, this.relation.foreignKey)}`,
-      params: []
-    };
+    const extra = buildAdvancedWhereClause(relatedTable, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(relatedTable)} WHERE ${qualifyColumn(relatedTable, this.relation.ownerKey)} = ${qualifyColumn(parentTable, this.relation.foreignKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
   }
   async get() {
     const foreign = this.parent.get(this.relation.foreignKey);
@@ -617,7 +646,7 @@ class BelongsToRelationQuery {
       return null;
     }
     const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    let query = repository.query(asWhere({ [this.relation.ownerKey]: foreign }));
+    let query = repository.query(asWhere({ [this.relation.ownerKey]: foreign, ...this.extraWhere }));
     if (this.extraOptions.orderBy) {
       query = query.orderBy(this.extraOptions.orderBy);
     }
@@ -627,6 +656,9 @@ class BelongsToRelationQuery {
   async first() {
     return this.get();
   }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
   async associate(owner) {
     await this.parent.getRepository().updateById(this.parent.id, {
       [this.relation.foreignKey]: ownerId(owner, this.relation.ownerKey)
@@ -646,6 +678,7 @@ class BelongsToManyRelationQuery {
   kind = "belongsToMany";
   extraWhere = {};
   extraOptions = {};
+  pivotValues = {};
   constructor(parent, related, relation) {
     this.parent = parent;
     this.related = related;
@@ -659,7 +692,13 @@ class BelongsToManyRelationQuery {
     this.extraOptions = { ...this.extraOptions, orderBy };
     return this;
   }
-  applyEagerLoad(_query, _alias) {}
+  applyEagerLoad(query, alias) {
+    query.withBelongsToMany(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  withPivotValues(values) {
+    this.pivotValues = { ...this.pivotValues, ...values };
+    return this;
+  }
   hydrateEager(row, alias) {
     const value = row[alias] ?? [];
     const rows = Array.isArray(value) ? value : [];
@@ -699,13 +738,34 @@ class BelongsToManyRelationQuery {
     return rows[0] ?? null;
   }
   async count() {
-    return (await this.get()).length;
+    const parentId = this.parent.get(this.relation.parentKey);
+    const rows = await this.connection().unsafe(`SELECT COUNT(*) AS count FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
+    return Number(rows[0]?.count ?? 0);
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
   }
   async attach(ids) {
     const list = Array.isArray(ids) ? ids : [ids];
     const parentId = this.parent.get(this.relation.parentKey);
+    const extraKeys = Object.keys(this.pivotValues);
+    const extraColumns = extraKeys.length > 0 ? `, ${extraKeys.join(", ")}` : "";
+    const extraPlaceholders = extraKeys.map((_, index) => `$${index + 3}`).join(", ");
+    const extraValues = extraKeys.map((key) => this.pivotValues[key]);
     for (const id of list) {
-      await this.connection().unsafe(`INSERT INTO ${this.relation.pivotTable} (${String(this.relation.foreignPivotKey)}, ${String(this.relation.relatedPivotKey)}) VALUES ($1, $2)`, [parentId, id]);
+      await this.connection().unsafe(extraKeys.length > 0 ? `INSERT INTO ${this.relation.pivotTable} (${String(this.relation.foreignPivotKey)}, ${String(this.relation.relatedPivotKey)}${extraColumns}) VALUES ($1, $2, ${extraPlaceholders})` : `INSERT INTO ${this.relation.pivotTable} (${String(this.relation.foreignPivotKey)}, ${String(this.relation.relatedPivotKey)}) VALUES ($1, $2)`, [parentId, id, ...extraValues]);
+    }
+  }
+  async toggle(ids) {
+    const list = Array.isArray(ids) ? ids : [ids];
+    const parentId = this.parent.get(this.relation.parentKey);
+    for (const id of list) {
+      const existing = await this.connection().unsafe(`SELECT 1 FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} = $2 LIMIT 1`, [parentId, id]);
+      if (existing.length > 0) {
+        await this.detach(id);
+      } else {
+        await this.attach(id);
+      }
     }
   }
   async detach(ids) {
@@ -777,6 +837,17 @@ class MorphManyRelationQuery {
     const rows = await this.get();
     return rows[0] ?? null;
   }
+  async count() {
+    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
+    return repository.query(asWhere({
+      [this.relation.morphTypeKey]: this.relation.morphType,
+      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
+      ...this.extraWhere
+    })).count();
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
   async create(attributes = {}) {
     return this.related.create(attributes, {
       [this.relation.morphTypeKey]: this.relation.morphType,
@@ -817,6 +888,15 @@ class MorphOneRelationQuery {
   async get() {
     return this.inner.first();
   }
+  async first() {
+    return this.get();
+  }
+  async count() {
+    return this.inner.count();
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
   async create(attributes = {}) {
     return this.inner.create(attributes);
   }
@@ -827,11 +907,16 @@ class MorphToRelationQuery {
   relatedByType;
   relation;
   kind = "morphTo";
+  extraWhere = {};
   constructor(parent, relatedByType, relation) {
     this.parent = parent;
     this.relatedByType = relatedByType;
     this.relation = relation;
   }
+  where(where) {
+    this.extraWhere = { ...this.extraWhere, ...where };
+    return this;
+  }
   applyEagerLoad(query, alias) {
     const repositories = new Map(Object.entries(this.relatedByType).map(([type, model]) => [
       type,
@@ -849,9 +934,11 @@ class MorphToRelationQuery {
       return { sql: "SELECT 1 WHERE 1 = 0", params: [] };
     }
     const relatedTable = related.repository().getTable();
+    const extra = buildAdvancedWhereClause(relatedTable.name, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
     return {
-      sql: `SELECT 1 FROM ${quoteIdentifier(relatedTable.name)} WHERE ${qualifyColumn(relatedTable.name, relatedTable.primaryKey)} = ${qualifyColumn(parentTable, this.relation.morphIdKey)}`,
-      params: []
+      sql: `SELECT 1 FROM ${quoteIdentifier(relatedTable.name)} WHERE ${qualifyColumn(relatedTable.name, relatedTable.primaryKey)} = ${qualifyColumn(parentTable, this.relation.morphIdKey)}${extraSql ? ` AND ${extraSql}` : ""}`,
+      params: extra.params
     };
   }
   async get() {
@@ -862,9 +949,12 @@ class MorphToRelationQuery {
       return null;
     }
     const table = related.repository().getTable();
-    const row = await related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id })).first();
+    const row = await related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere })).first();
     return row ? related.newFromRecord(row) : null;
   }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
 }
 
 // ../../src/core/database/relationships.ts
@@ -892,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;
@@ -919,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);
     }
@@ -934,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 {
@@ -972,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;
@@ -1005,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);
     }
@@ -1015,6 +1167,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
 
 // ../../src/core/database/model.ts
 var modelRepositories = new WeakMap;
+var namedModels = new Map;
 var modelGlobalScopes = new WeakMap;
 var modelObservers = new WeakMap;
 var modelBooted = new WeakSet;
@@ -1032,38 +1185,59 @@ function accessorName(key) {
   const pascal = key.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
   return `get${pascal.charAt(0).toUpperCase()}${pascal.slice(1)}Attribute`;
 }
-function constrainRelationExists(model, name, constrain, not) {
-  const statics = modelStatics(model);
-  ensureBooted(model);
-  const repository = resolveModelRepository(model);
-  const dummy = statics.newFromRecord({});
-  const method = dummy[name];
-  if (typeof method !== "function") {
-    throw new Error(`${model.name} has no relation method ${name}().`);
-  }
-  const relationQuery = method.call(dummy);
-  constrain?.(relationQuery);
-  const exists = relationQuery.toExistsClause(repository.getTable().name);
-  const query = Model.query.call(model);
-  return not ? query.whereNotExists(exists.sql, exists.params) : query.whereExists(exists.sql, exists.params);
+function isLoadableModel(value) {
+  return Boolean(value && typeof value === "object" && typeof value.load === "function" && typeof value.loaded === "function" && typeof value.setLoaded === "function");
 }
-async function loadNested(model, path) {
-  const [head, ...rest] = path.split(".");
-  if (!head) {
+async function eagerLoadOnModels(models, paths) {
+  if (models.length === 0 || paths.length === 0) {
     return;
   }
-  await model.load(head);
-  if (rest.length === 0) {
-    return;
+  const grouped = new Map;
+  for (const path of paths) {
+    const [head, ...rest] = path.split(".");
+    if (!head) {
+      continue;
+    }
+    const nested = rest.join(".");
+    const existing = grouped.get(head) ?? [];
+    if (nested) {
+      existing.push(nested);
+    }
+    grouped.set(head, existing);
   }
-  const loaded = model.loaded(head);
-  const children = Array.isArray(loaded) ? loaded : loaded ? [loaded] : [];
-  for (const child of children) {
-    if (child && typeof child === "object" && typeof child.load === "function") {
-      await loadNested(child, rest.join("."));
+  for (const [head, nested] of grouped) {
+    const unloaded = models.filter((model) => model.loaded(head) === undefined);
+    if (unloaded.length > 0) {
+      const first = unloaded[0];
+      if (!first) {
+        continue;
+      }
+      const method = first[head];
+      if (typeof method !== "function") {
+        throw new Error(`${first.constructor.name} has no relation method ${head}().`);
+      }
+      const relationQuery = method.call(first);
+      const query = first.getRepository().query();
+      relationQuery.applyEagerLoad(query, head);
+      const attached = await query.attachToRows(unloaded.map((model) => model.toObject()));
+      for (const [index, model] of unloaded.entries()) {
+        const row = attached[index] ?? model.toObject();
+        model.setLoaded(head, relationQuery.hydrateEager(row, head));
+      }
+    }
+    if (nested.length === 0) {
+      continue;
     }
+    const children = models.flatMap((model) => {
+      const loaded = model.loaded(head);
+      return Array.isArray(loaded) ? loaded : loaded ? [loaded] : [];
+    });
+    await eagerLoadOnModels(children.filter(isLoadableModel), nested);
   }
 }
+async function loadNested(model, path) {
+  await eagerLoadOnModels([model], [path]);
+}
 function resolveModelRepository(model) {
   const repository = modelRepositories.get(model);
   if (!repository) {
@@ -1071,6 +1245,48 @@ function resolveModelRepository(model) {
   }
   return repository;
 }
+function registerModelClass(name, model) {
+  namedModels.set(name, model);
+}
+function resolveRelated(related) {
+  if (typeof related === "string") {
+    const found = namedModels.get(related);
+    if (!found) {
+      throw new Error(`Model [${related}] is not registered. Call registerModelClass() first.`);
+    }
+    return found;
+  }
+  if (typeof related === "function" && typeof related.repository !== "function") {
+    return related();
+  }
+  return related;
+}
+function inferRelationMethodName(callee) {
+  const stack = new Error().stack ?? "";
+  let seenCallee = false;
+  for (const line of stack.split(`
+`)) {
+    const match = /at (?:async )?(?:[^.\s]+\.)?(\w+)/.exec(line);
+    const name = match?.[1];
+    if (!name || name === "Error" || name === "inferRelationMethodName") {
+      continue;
+    }
+    if (!seenCallee) {
+      if (name === callee) {
+        seenCallee = true;
+      }
+      continue;
+    }
+    if (name !== callee) {
+      return name;
+    }
+  }
+  return;
+}
+function morphClassOf(model) {
+  const statics = modelStatics(model.constructor === Function ? model : model.constructor);
+  return statics.$morphClass ?? (model.constructor === Function ? model.name : model.constructor.name);
+}
 function modelStatics(model) {
   return model;
 }
@@ -1100,6 +1316,11 @@ function hydrateValue(value, cast) {
     case "bool":
     case "boolean":
       return value === true || value === 1 || value === "1" || value === "true";
+    case "integer":
+    case "int":
+      return value === "" ? null : Number(value);
+    case "hashed":
+      return value;
     default:
       return value;
   }
@@ -1117,6 +1338,11 @@ function dehydrateValue(value, cast) {
     case "bool":
     case "boolean":
       return Boolean(value);
+    case "integer":
+    case "int":
+      return value === "" ? null : Number(value);
+    case "hashed":
+      return value;
     default:
       return value;
   }
@@ -1171,6 +1397,153 @@ function applyTimestampsOnUpdate(columns, values, enabled) {
   return result;
 }
 
+class ModelQuery {
+  modelClass;
+  query;
+  eager = [];
+  constructor(modelClass, query) {
+    this.modelClass = modelClass;
+    this.query = query;
+  }
+  with(...relations) {
+    const statics = modelStatics(this.modelClass);
+    ensureBooted(this.modelClass);
+    const dummy = statics.newFromRecord({}, false);
+    for (const path of relations) {
+      const name = path.split(".")[0] ?? path;
+      const method = dummy[name];
+      if (typeof method !== "function") {
+        throw new Error(`${this.modelClass.name} has no relation method ${name}().`);
+      }
+      const relationQuery = method.call(dummy);
+      this.eager.push({ name, path, relationQuery });
+      relationQuery.applyEagerLoad(this.query, name);
+    }
+    return this;
+  }
+  where(input) {
+    this.query.where(input);
+    return this;
+  }
+  orWhere(input) {
+    this.query.orWhere(input);
+    return this;
+  }
+  orderBy(orderBy) {
+    this.query.orderBy(orderBy);
+    return this;
+  }
+  limit(limit) {
+    this.query.limit(limit);
+    return this;
+  }
+  offset(offset) {
+    this.query.offset(offset);
+    return this;
+  }
+  whereNull(column) {
+    this.query.whereNull(column);
+    return this;
+  }
+  whereIn(column, values) {
+    this.query.whereIn(column, values);
+    return this;
+  }
+  whereExists(sql, params = []) {
+    this.query.whereExists(sql, params);
+    return this;
+  }
+  whereNotExists(sql, params = []) {
+    this.query.whereNotExists(sql, params);
+    return this;
+  }
+  whereHas(name, constrain) {
+    return this.constrainExists(name, constrain, false);
+  }
+  has(name) {
+    return this.constrainExists(name, undefined, false);
+  }
+  doesntHave(name) {
+    return this.constrainExists(name, undefined, true);
+  }
+  whereDoesntHave(name, constrain) {
+    return this.constrainExists(name, constrain, true);
+  }
+  withHasMany(...args) {
+    this.query.withHasMany(...args);
+    return this;
+  }
+  withBelongsTo(...args) {
+    this.query.withBelongsTo(...args);
+    return this;
+  }
+  withBelongsToMany(...args) {
+    this.query.withBelongsToMany(...args);
+    return this;
+  }
+  withMorphMany(...args) {
+    this.query.withMorphMany(...args);
+    return this;
+  }
+  withMorphOne(...args) {
+    this.query.withMorphOne(...args);
+    return this;
+  }
+  withMorphTo(...args) {
+    this.query.withMorphTo(...args);
+    return this;
+  }
+  async get() {
+    const statics = modelStatics(this.modelClass);
+    const rows = await this.query.get();
+    const models = [];
+    for (const row of rows) {
+      const model = statics.newFromRecord(row, true);
+      await runObservers(model, "retrieved");
+      for (const { name, relationQuery } of this.eager) {
+        model.setLoaded(name, relationQuery.hydrateEager(row, name));
+      }
+      models.push(model);
+    }
+    const nested = this.eager.filter((item) => item.path.includes(".")).map((item) => item.path);
+    await eagerLoadOnModels(models.filter(isLoadableModel), nested);
+    return models;
+  }
+  async first() {
+    this.query.limit(1);
+    const models = await this.get();
+    return models[0] ?? null;
+  }
+  async find(id) {
+    const primaryKey = resolveModelRepository(this.modelClass).getTable().primaryKey;
+    return this.where({ [primaryKey]: id }).first();
+  }
+  async findOrFail(id, errorFactory) {
+    const model = await this.find(id);
+    if (model) {
+      return model;
+    }
+    throw errorFactory?.(id) ?? new NotFoundError(`${this.modelClass.name} ${String(id)} not found.`);
+  }
+  then(onfulfilled, onrejected) {
+    return this.get().then(onfulfilled ?? undefined, onrejected ?? undefined);
+  }
+  constrainExists(name, constrain, not) {
+    const statics = modelStatics(this.modelClass);
+    ensureBooted(this.modelClass);
+    const repository = resolveModelRepository(this.modelClass);
+    const dummy = statics.newFromRecord({});
+    const method = dummy[name];
+    if (typeof method !== "function") {
+      throw new Error(`${this.modelClass.name} has no relation method ${name}().`);
+    }
+    const relationQuery = method.call(dummy);
+    constrain?.(relationQuery);
+    const exists = relationQuery.toExistsClause(repository.getTable().name);
+    return not ? this.whereNotExists(exists.sql, exists.params) : this.whereExists(exists.sql, exists.params);
+  }
+}
+
 class Model {
   attributes;
   repository;
@@ -1181,6 +1554,7 @@ class Model {
   static $hidden;
   static $visible;
   static $appends;
+  static $morphClass;
   _exists;
   loadedRelations = {};
   hiddenOverrides = [];
@@ -1190,6 +1564,7 @@ class Model {
     this.attributes = attributes;
     this.repository = repository;
     this._exists = exists;
+    this.attributes = modelStatics(this.constructor).hydrateAttributes(attributes);
   }
   getRepository() {
     return this.repository;
@@ -1250,7 +1625,7 @@ class Model {
     return this;
   }
   primaryKey() {
-    throw new Error(`${this.constructor.name}.primaryKey() is not implemented.`);
+    return this.repository.getTable().primaryKey;
   }
   static primaryKeyField() {
     return resolveModelRepository(this).getTable().primaryKey;
@@ -1291,7 +1666,7 @@ class Model {
     for (const scope of getGlobalScopes(this)) {
       query = scope(query);
     }
-    return query;
+    return new ModelQuery(this, query);
   }
   static newFromRecord(record, exists = true) {
     const repository = resolveModelRepository(this);
@@ -1310,79 +1685,36 @@ class Model {
     const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
     const payload = statics.dehydrateAttributes(withTimestamps);
     const pending = statics.newFromRecord({ ...payload }, false);
+    if (await runObservers(pending, "saving") === false) {
+      throw new Error(`${this.name}.create() was cancelled by an observer.`);
+    }
     if (await runObservers(pending, "creating") === false) {
       throw new Error(`${this.name}.create() was cancelled by an observer.`);
     }
     const record = await repository.create(payload);
     const created = statics.fromRecord(record, repository, true);
     await runObservers(created, "created");
+    await runObservers(created, "saved");
     return created;
   }
   static with(...relations) {
-    const statics = modelStatics(this);
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
-    const dummy = statics.fromRecord({}, repository, false);
-    const resolved = relations.map((path) => {
-      const name = path.split(".")[0] ?? path;
-      const method = dummy[name];
-      if (typeof method !== "function") {
-        throw new Error(`${this.name} has no relation method ${name}().`);
-      }
-      const relationQuery = method.call(dummy);
-      return { name, path, relationQuery };
-    });
-    const query = Model.query.call(this);
-    for (const { name, relationQuery } of resolved) {
-      if (relationQuery.kind !== "belongsToMany") {
-        relationQuery.applyEagerLoad(query, name);
-      }
-    }
-    return {
-      async get() {
-        const rows = await query.get();
-        const models = [];
-        for (const row of rows) {
-          const model = statics.fromRecord(row, repository, true);
-          for (const { name, path, relationQuery } of resolved) {
-            if (relationQuery.kind === "belongsToMany") {
-              await model.load(path.includes(".") ? path : name);
-              continue;
-            }
-            model.setLoaded(name, relationQuery.hydrateEager(row, name));
-            const nested = path.split(".").slice(1).join(".");
-            if (nested) {
-              await loadNested(model, path);
-            }
-          }
-          models.push(model);
-        }
-        return models;
-      },
-      async first() {
-        const [model] = await this.get();
-        return model ?? null;
-      }
-    };
+    return Model.query.call(this).with(...relations);
   }
   static whereHas(name, constrain) {
-    return constrainRelationExists(this, name, constrain, false);
+    return Model.query.call(this).whereHas(name, constrain);
   }
   static has(name) {
-    return constrainRelationExists(this, name, undefined, false);
+    return Model.query.call(this).has(name);
   }
   static doesntHave(name) {
-    return constrainRelationExists(this, name, undefined, true);
+    return Model.query.call(this).doesntHave(name);
   }
   static whereDoesntHave(name, constrain) {
-    return constrainRelationExists(this, name, constrain, true);
+    return Model.query.call(this).whereDoesntHave(name, constrain);
   }
   static async find(id) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    const primaryKey = repository.getTable().primaryKey;
-    const record = await Model.query.call(this).where({ [primaryKey]: id }).first();
-    return record ? statics.fromRecord(record, repository, true) : null;
+    const primaryKey = resolveModelRepository(this).getTable().primaryKey;
+    return Model.query.call(this).where({ [primaryKey]: id }).first();
   }
   static async findOrFail(id, errorFactory) {
     const model = await Model.find.call(this, id);
@@ -1392,8 +1724,6 @@ class Model {
     throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
   }
   static async all(options = {}) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
     let query = Model.query.call(this);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
@@ -1401,21 +1731,17 @@ class Model {
     if (options.limit !== undefined) {
       query = query.limit(options.limit);
     }
-    const rows = await query.get();
-    return rows.map((row) => statics.fromRecord(row, repository, true));
+    return query.get();
   }
   static where(where) {
     return Model.query.call(this).where(where);
   }
   static async firstWhere(where, options = {}) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
     let query = Model.query.call(this).where(where);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
     }
-    const record = await query.first();
-    return record ? statics.fromRecord(record, repository, true) : null;
+    return query.first();
   }
   static async firstOrNew(where, values = {}) {
     const existing = await Model.firstWhere.call(this, where);
@@ -1444,6 +1770,9 @@ class Model {
     const casts = ModelClass.$casts ?? {};
     const table = this.repository.getTable();
     const updating = this.$exists;
+    if (await runObservers(this, "saving") === false) {
+      return this;
+    }
     if (await runObservers(this, updating ? "updating" : "creating") === false) {
       return this;
     }
@@ -1452,6 +1781,7 @@ class Model {
       const record2 = await this.repository.updateByIdOrThrow(this.id, changes);
       this.attributes = ModelClass.hydrateAttributes(record2);
       await runObservers(this, "updated");
+      await runObservers(this, "saved");
       return this;
     }
     const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
@@ -1461,6 +1791,7 @@ class Model {
     this.attributes = ModelClass.hydrateAttributes(record);
     this._exists = true;
     await runObservers(this, "created");
+    await runObservers(this, "saved");
     return this;
   }
   async update(changes) {
@@ -1493,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 = {}) {
@@ -1503,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 = {}) {
@@ -1523,28 +1854,31 @@ 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) {
     const table = this.repository.getTable();
-    return new HasManyRelationQuery(this, related, hasMany({
-      name: related.repository().getTable().name,
+    const relatedClass = resolveRelated(related);
+    return new HasManyRelationQuery(this, relatedClass, hasMany({
+      name: relatedClass.repository().getTable().name,
       localKey: localKey ?? table.primaryKey,
       foreignKey: foreignKey ?? foreignKeyFromTable(table.name)
     }));
   }
   hasOne(related, foreignKey, localKey) {
     const table = this.repository.getTable();
-    return new HasOneRelationQuery(this, related, hasOne({
-      name: related.repository().getTable().name,
+    const relatedClass = resolveRelated(related);
+    return new HasOneRelationQuery(this, relatedClass, hasOne({
+      name: relatedClass.repository().getTable().name,
       localKey: localKey ?? table.primaryKey,
       foreignKey: foreignKey ?? foreignKeyFromTable(table.name)
     }));
   }
   belongsTo(related, foreignKey, ownerKey) {
-    const relatedTable = related.repository().getTable();
-    return new BelongsToRelationQuery(this, related, belongsTo({
+    const relatedClass = resolveRelated(related);
+    const relatedTable = relatedClass.repository().getTable();
+    return new BelongsToRelationQuery(this, relatedClass, belongsTo({
       name: relatedTable.name,
       foreignKey: foreignKey ?? foreignKeyFromTable(relatedTable.name),
       ownerKey: ownerKey ?? relatedTable.primaryKey
@@ -1552,8 +1886,9 @@ class Model {
   }
   belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
     const table = this.repository.getTable();
-    const relatedTable = related.repository().getTable();
-    return new BelongsToManyRelationQuery(this, related, belongsToMany({
+    const relatedClass = resolveRelated(related);
+    const relatedTable = relatedClass.repository().getTable();
+    return new BelongsToManyRelationQuery(this, relatedClass, belongsToMany({
       name: relatedTable.name,
       pivotTable: pivotTable ?? pivotTableName(table.name, relatedTable.name),
       parentKey: table.primaryKey,
@@ -1562,31 +1897,38 @@ class Model {
       relatedPivotKey: relatedPivotKey ?? foreignKeyFromTable(relatedTable.name)
     }));
   }
-  morphMany(related, morphName, typeKey, idKey) {
+  morphMany(related, morphName, typeKey, idKey, morphType) {
     const table = this.repository.getTable();
-    return new MorphManyRelationQuery(this, related, morphMany({
+    const relatedClass = resolveRelated(related);
+    return new MorphManyRelationQuery(this, relatedClass, morphMany({
       name: morphName,
       localKey: table.primaryKey,
       morphTypeKey: typeKey ?? `${morphName}_type`,
       morphIdKey: idKey ?? `${morphName}_id`,
-      morphType: table.name
+      morphType: morphType ?? morphClassOf(this)
     }));
   }
-  morphOne(related, morphName, typeKey, idKey) {
+  morphOne(related, morphName, typeKey, idKey, morphType) {
     const table = this.repository.getTable();
-    return new MorphOneRelationQuery(this, related, morphOne({
+    const relatedClass = resolveRelated(related);
+    return new MorphOneRelationQuery(this, relatedClass, morphOne({
       name: morphName,
       localKey: table.primaryKey,
       morphTypeKey: typeKey ?? `${morphName}_type`,
       morphIdKey: idKey ?? `${morphName}_id`,
-      morphType: table.name
+      morphType: morphType ?? morphClassOf(this)
     }));
   }
-  morphTo(relatedByType, morphName = "imageable", typeKey, idKey) {
-    return new MorphToRelationQuery(this, relatedByType, morphTo({
-      name: morphName,
-      morphTypeKey: typeKey ?? `${morphName}_type`,
-      morphIdKey: idKey ?? `${morphName}_id`
+  morphTo(relatedByType, morphName, typeKey, idKey) {
+    const resolvedName = morphName ?? inferRelationMethodName("morphTo");
+    if (!resolvedName) {
+      throw new Error(`${this.constructor.name}.morphTo() needs an explicit morph name (Laravel infers it from the relation method).`);
+    }
+    const resolvedMap = Object.fromEntries(Object.entries(relatedByType).map(([type, related]) => [type, resolveRelated(related)]));
+    return new MorphToRelationQuery(this, resolvedMap, morphTo({
+      name: resolvedName,
+      morphTypeKey: typeKey ?? `${resolvedName}_type`,
+      morphIdKey: idKey ?? `${resolvedName}_id`
     }));
   }
   async load(...names) {
@@ -1618,6 +1960,14 @@ class Model {
 }
 function registerModelRepository(model, repository) {
   modelRepositories.set(model, repository);
+  const name = model.name;
+  if (name) {
+    namedModels.set(name, model);
+  }
+  const morphClass = model.$morphClass;
+  if (morphClass) {
+    namedModels.set(morphClass, model);
+  }
   ensureBooted(model);
   return model;
 }
@@ -1627,6 +1977,7 @@ export {
   HasManyRelationQuery,
   HasOneRelationQuery,
   Model,
+  ModelQuery,
   MorphManyRelationQuery,
   MorphOneRelationQuery,
   MorphToRelationQuery,
@@ -1634,5 +1985,6 @@ export {
   dehydrateValue,
   filterMassAssignable,
   hydrateValue,
+  registerModelClass,
   registerModelRepository
 };