@getstrata/core 0.5.97 → 0.5.99

package/dist/index.js

@@ -1497,6 +1497,12 @@ class ServiceContainer {
   resolve(key) {
     return this.get(key);
   }
+  make(key) {
+    return this.resolve(key);
+  }
+  instance(key, value) {
+    return this.set(key, value);
+  }
   has(key) {
     return this.services.has(key) || this.singletonFactories.has(key) || this.bindings.has(key);
   }
@@ -1525,6 +1531,9 @@ class ConfigStore {
 class EventBus {
   constructor() {}
   listeners = new Map;
+  on(event, listener) {
+    return this.listen(event, listener);
+  }
   listen(event, listener) {
     const handlers = this.listeners.get(event) ?? new Set;
     handlers.add(listener);
@@ -1536,6 +1545,9 @@ class EventBus {
       }
     };
   }
+  async emit(event, payload) {
+    await this.dispatch(event, payload);
+  }
   async dispatch(event, payload) {
     const handlers = this.listeners.get(event);
     if (!handlers || handlers.size === 0) {
@@ -1707,7 +1719,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)})`);
@@ -1737,7 +1749,16 @@ function appendWhereParts(tableName, where, params) {
   }
   return clauses.join(" AND ");
 }
+function remapExistsSql(sql, existsParams, params) {
+  const offset = params.length;
+  params.push(...existsParams);
+  return sql.replace(/\$(\d+)/g, (_match, index) => `$${offset + Number(index)}`);
+}
 function buildWhereNodeClause(tableName, node, params) {
+  if ("exists" in node) {
+    const body = remapExistsSql(node.exists.sql, node.exists.params, params);
+    return `${node.exists.not ? "NOT " : ""}EXISTS (${body})`;
+  }
   if ("where" in node) {
     return appendWhereParts(tableName, node.where, params);
   }
@@ -2255,6 +2276,23 @@ class RepositoryQuery {
     this.queryOptions = { ...this.queryOptions, limit };
     return this;
   }
+  whereNull(column) {
+    return this.where({ [column]: null });
+  }
+  whereNotNull(column) {
+    return this.where({ [column]: { isNull: false } });
+  }
+  whereIn(column, values) {
+    return this.where({ [column]: values });
+  }
+  whereExists(sql, params = []) {
+    this.whereNodes.push({ kind: "and", exists: { sql, params } });
+    return this;
+  }
+  whereNotExists(sql, params = []) {
+    this.whereNodes.push({ kind: "and", exists: { sql, params, not: true } });
+    return this;
+  }
   offset(offset) {
     this.queryOptions = { ...this.queryOptions, offset };
     return this;
@@ -2324,13 +2362,30 @@ class RepositoryQuery {
     });
     return this;
   }
+  withBelongsToMany(as, relation, relatedRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsToMany",
+      as,
+      relation,
+      repository: relatedRepository,
+      options
+    });
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
   }
   async first() {
-    const rows = await this.get();
-    return rows[0] ?? null;
+    const rows = await this.repository.findAll({ ...this.buildOptions(), limit: 1 });
+    const attached = await this.attach(rows);
+    return attached[0] ?? null;
+  }
+  async count() {
+    return await this.repository.count(this.buildOptions());
+  }
+  async attachToRows(rows) {
+    return await this.attach(rows);
   }
   async paginate(options) {
     return await this.repository.paginate({
@@ -2402,6 +2457,15 @@ class RepositoryQuery {
         }));
         continue;
       }
+      if (load.kind === "belongsToMany") {
+        const relation2 = load.relation;
+        const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.parentKey]) ?? []
+        }));
+        continue;
+      }
       if (load.kind === "morphTo") {
         const relation2 = load.relation;
         const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
@@ -2430,6 +2494,10 @@ class BaseRepository {
     this.table = table;
     this.connection = connection;
   }
+  async count(options = {}) {
+    const { whereNodes, where, ...rest } = options;
+    return await this.countWhere(where ?? {}, rest, whereNodes ?? []);
+  }
   async findAll(options = {}) {
     return await withDatabaseErrorHandling(async () => {
       const { whereNodes, ...queryOptions } = options;
@@ -2737,6 +2805,23 @@ class BaseRepository {
     }
     return indexMorphToRelation(children, parentsByType, relation);
   }
+  async loadBelongsToManyForParents(parents, relation, relatedRepository, options = {}) {
+    if (parents.length === 0) {
+      return indexBelongsToManyRelation(parents, [], [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.parentKey]))];
+    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = ANY($1)`, [parentIds]);
+    if (pivotRows.length === 0) {
+      return indexBelongsToManyRelation(parents, [], [], relation);
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[relation.relatedPivotKey]))
+    ];
+    const relatedRows = await relatedRepository.withConnection(this.connection).findWhere({
+      [relation.relatedKey]: relatedIds
+    }, options);
+    return indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation);
+  }
 }
 var baseRepository_default = BaseRepository;
 // ../../src/core/database/bunSql.ts
@@ -2766,6 +2851,185 @@ function createDatabaseConnection(source) {
     }
   };
 }
+// ../../src/core/database/inflection.ts
+function singularize(word) {
+  if (word.endsWith("ies") && word.length > 3) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (/(ses|xes|zes|ches|shes)$/i.test(word)) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function foreignKeyFromTable(tableName) {
+  return `${singularize(tableName)}_id`;
+}
+function pivotTableName(leftTable, rightTable) {
+  return [singularize(leftTable), singularize(rightTable)].sort().join("_");
+}
+
+// ../../src/core/database/factory.ts
+function inferFactoryForeignKey(parent, explicit) {
+  if (explicit) {
+    if (explicit.endsWith("_id")) {
+      return explicit;
+    }
+    return `${explicit}_id`;
+  }
+  if (typeof parent.getRepository === "function") {
+    return foreignKeyFromTable(parent.getRepository().getTable().name);
+  }
+  throw new Error("Factory.for() requires a foreign key or a parent Model.");
+}
+
+class Factory {
+  quantity = 1;
+  counted = false;
+  sequenceIndex = 0;
+  stateTransforms = [];
+  sequenceItems = [];
+  parentAssociations = [];
+  children = [];
+  afterMakingCallbacks = [];
+  afterCreatingCallbacks = [];
+  model;
+  definition() {
+    throw new Error("Factory definition must be implemented by subclass.");
+  }
+  clone() {
+    const next = Object.create(Object.getPrototypeOf(this));
+    Object.assign(next, this);
+    next.stateTransforms = [...this.stateTransforms];
+    next.sequenceItems = [...this.sequenceItems];
+    next.parentAssociations = [...this.parentAssociations];
+    next.children = [...this.children];
+    next.afterMakingCallbacks = [...this.afterMakingCallbacks];
+    next.afterCreatingCallbacks = [...this.afterCreatingCallbacks];
+    return next;
+  }
+  count(quantity) {
+    if (!Number.isInteger(quantity) || quantity < 1) {
+      throw new Error("Factory.count() requires a positive integer.");
+    }
+    const next = this.clone();
+    next.quantity = quantity;
+    next.counted = true;
+    return next;
+  }
+  state(state) {
+    const next = this.clone();
+    next.stateTransforms = [...this.stateTransforms, state];
+    return next;
+  }
+  sequence(...items) {
+    if (items.length === 0) {
+      throw new Error("Factory.sequence() requires at least one attribute set.");
+    }
+    const next = this.clone();
+    next.sequenceItems = [...this.sequenceItems, ...items];
+    return next;
+  }
+  for(parent, foreignKey) {
+    if (parent.id === undefined || parent.id === null) {
+      throw new Error("Factory.for() requires a parent with an id.");
+    }
+    const key = inferFactoryForeignKey(parent, foreignKey);
+    const next = this.clone();
+    next.parentAssociations = [...this.parentAssociations, { foreignKey: key, value: parent.id }];
+    return next;
+  }
+  recycle(parent, foreignKey) {
+    return this.for(parent, foreignKey);
+  }
+  afterMaking(callback) {
+    const next = this.clone();
+    next.afterMakingCallbacks = [...this.afterMakingCallbacks, callback];
+    return next;
+  }
+  afterCreating(callback) {
+    const next = this.clone();
+    next.afterCreatingCallbacks = [...this.afterCreatingCallbacks, callback];
+    return next;
+  }
+  has(factory, foreignKey) {
+    const next = this.clone();
+    next.children = [
+      ...this.children,
+      { factory, foreignKey }
+    ];
+    return next;
+  }
+  make(overrides = {}) {
+    if (!this.counted) {
+      return this.makeOne(overrides);
+    }
+    return Array.from({ length: this.quantity }, () => this.makeOne(overrides));
+  }
+  async create(overrides = {}) {
+    if (!this.counted) {
+      return await this.createOne(overrides);
+    }
+    const records = [];
+    for (let index = 0;index < this.quantity; index += 1) {
+      records.push(await this.createOne(overrides));
+    }
+    return records;
+  }
+  makeOne(overrides = {}) {
+    let record = { ...this.definition() };
+    for (const state of this.stateTransforms) {
+      const patch = typeof state === "function" ? state(record) : state;
+      record = { ...record, ...patch };
+    }
+    if (this.sequenceItems.length > 0) {
+      const item = this.sequenceItems[this.sequenceIndex % this.sequenceItems.length];
+      const patch = typeof item === "function" ? item(this.sequenceIndex) : item;
+      record = { ...record, ...patch };
+      this.sequenceIndex += 1;
+    }
+    for (const association of this.parentAssociations) {
+      record[association.foreignKey] = association.value;
+    }
+    const made = {
+      ...record,
+      ...overrides
+    };
+    for (const callback of this.afterMakingCallbacks) {
+      callback(made);
+    }
+    return made;
+  }
+  async createOne(overrides = {}) {
+    const created = await this.persist(this.insertable(this.makeOne(overrides)));
+    for (const child of this.children) {
+      await child.factory.for(created, child.foreignKey).create();
+    }
+    for (const callback of this.afterCreatingCallbacks) {
+      await callback(created);
+    }
+    return created;
+  }
+  insertable(record) {
+    const values = { ...record };
+    if (values.id === 0 || values.id === undefined || values.id === null) {
+      delete values.id;
+    }
+    return values;
+  }
+  async persist(values) {
+    if (this.model) {
+      const created = await this.model.create(values);
+      if (created && typeof created.toObject === "function") {
+        return created.toObject();
+      }
+      return created;
+    }
+    throw new Error("Factory.persist() must be implemented to use create().");
+  }
+}
 // ../../src/core/database/migrations/advisoryLock.ts
 var MIGRATION_LOCK_KEY = 42424242;
 async function withMigrationLock(db, callback, lockKey = MIGRATION_LOCK_KEY) {
@@ -2878,10 +3142,591 @@ async function freshDatabase(db, migrations, options = {}) {
   }
   await runFresh();
 }
+// ../../src/core/database/relationQuery.ts
+function asWhere(where) {
+  return where;
+}
+function ownerId(owner, ownerKey) {
+  if (typeof owner.get === "function") {
+    return owner.get(ownerKey);
+  }
+  if (owner && typeof owner === "object" && "id" in owner && owner.id !== undefined) {
+    return owner.id;
+  }
+  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;
+  related;
+  relation;
+  kind = "hasMany";
+  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;
+  }
+  limit(limit) {
+    this.extraOptions = { ...this.extraOptions, limit };
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    query.withHasMany(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  hydrateEager(row, alias) {
+    const value = row[alias] ?? [];
+    const rows = Array.isArray(value) ? value : [];
+    return rows.map((item) => this.related.newFromRecord(item));
+  }
+  toExistsClause(parentTable) {
+    const childTable = this.related.repository().getTable().name;
+    const extra = buildAdvancedWhereClause(childTable, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(childTable)} WHERE ${qualifyColumn(childTable, this.relation.foreignKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
+  }
+  scopedQuery() {
+    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
+    let query = repository.query(asWhere({
+      [this.relation.foreignKey]: this.parent.get(this.relation.localKey),
+      ...this.extraWhere
+    }));
+    if (this.extraOptions.orderBy) {
+      query = query.orderBy(this.extraOptions.orderBy);
+    }
+    if (this.extraOptions.limit !== undefined) {
+      query = query.limit(this.extraOptions.limit);
+    }
+    return query;
+  }
+  async get() {
+    const rows = await this.scopedQuery().get();
+    return rows.map((row) => this.related.newFromRecord(row));
+  }
+  async first() {
+    const rows = await this.limit(1).get();
+    return rows[0] ?? null;
+  }
+  async count() {
+    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) {
+      created.push(await this.create(attributes));
+    }
+    return created;
+  }
+}
+
+class HasOneRelationQuery {
+  relation;
+  kind = "hasOne";
+  inner;
+  constructor(parent, related, relation) {
+    this.relation = relation;
+    this.inner = new HasManyRelationQuery(parent, related, {
+      type: "hasMany",
+      name: relation.name,
+      localKey: relation.localKey,
+      foreignKey: relation.foreignKey
+    });
+  }
+  where(where) {
+    this.inner.where(where);
+    return this;
+  }
+  orderBy(orderBy) {
+    this.inner.orderBy(orderBy);
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    this.inner.limit(1).applyEagerLoad(query, alias);
+  }
+  hydrateEager(row, alias) {
+    const hydrated = this.inner.hydrateEager(row, alias);
+    return hydrated[0];
+  }
+  toExistsClause(parentTable) {
+    return this.inner.toExistsClause(parentTable);
+  }
+  async get() {
+    return this.inner.limit(1).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);
+  }
+  async save(related) {
+    return this.inner.save(related);
+  }
+}
+
+class BelongsToRelationQuery {
+  parent;
+  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;
+  }
+  applyEagerLoad(query, alias) {
+    query.withBelongsTo(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  hydrateEager(row, alias) {
+    const value = row[alias];
+    return value ? this.related.newFromRecord(value) : value;
+  }
+  toExistsClause(parentTable) {
+    const relatedTable = this.related.repository().getTable().name;
+    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);
+    if (foreign === null || foreign === undefined) {
+      return null;
+    }
+    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
+    let query = repository.query(asWhere({ [this.relation.ownerKey]: foreign, ...this.extraWhere }));
+    if (this.extraOptions.orderBy) {
+      query = query.orderBy(this.extraOptions.orderBy);
+    }
+    const row = await query.first();
+    return row ? this.related.newFromRecord(row) : null;
+  }
+  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)
+    });
+  }
+  async dissociate() {
+    await this.parent.getRepository().updateById(this.parent.id, {
+      [this.relation.foreignKey]: null
+    });
+  }
+}
+
+class BelongsToManyRelationQuery {
+  parent;
+  related;
+  relation;
+  kind = "belongsToMany";
+  extraWhere = {};
+  extraOptions = {};
+  pivotValues = {};
+  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;
+  }
+  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 : [];
+    return rows.map((item) => this.related.newFromRecord(item));
+  }
+  toExistsClause(parentTable) {
+    const relatedTable = this.related.repository().getTable().name;
+    const extra = buildAdvancedWhereClause(relatedTable, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(relatedTable)} INNER JOIN ${quoteIdentifier(this.relation.pivotTable)} ON ${qualifyColumn(this.relation.pivotTable, this.relation.relatedPivotKey)} = ${qualifyColumn(relatedTable, this.relation.relatedKey)} WHERE ${qualifyColumn(this.relation.pivotTable, this.relation.foreignPivotKey)} = ${qualifyColumn(parentTable, this.relation.parentKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
+  }
+  connection() {
+    return this.parent.getRepository().getConnection();
+  }
+  async get() {
+    const parentId = this.parent.get(this.relation.parentKey);
+    const pivotRows = await this.connection().unsafe(`SELECT * FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
+    if (pivotRows.length === 0) {
+      return [];
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[this.relation.relatedPivotKey]))
+    ];
+    const repository = this.related.repository().withConnection(this.connection());
+    const rows = await repository.findAll({
+      ...this.extraOptions,
+      where: asWhere({
+        [this.relation.relatedKey]: relatedIds,
+        ...this.extraWhere
+      })
+    });
+    return rows.map((row) => this.related.newFromRecord(row));
+  }
+  async first() {
+    const rows = await this.get();
+    return rows[0] ?? null;
+  }
+  async count() {
+    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(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) {
+    const parentId = this.parent.get(this.relation.parentKey);
+    if (ids === undefined) {
+      await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
+      return;
+    }
+    const list = Array.isArray(ids) ? ids : [ids];
+    await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} = ANY($2)`, [parentId, list]);
+  }
+  async sync(ids) {
+    await this.detach();
+    if (ids.length > 0) {
+      await this.attach(ids);
+    }
+  }
+  async create(attributes = {}) {
+    const related = await this.related.create(attributes);
+    await this.attach(related.id);
+    return related;
+  }
+}
+
+class MorphManyRelationQuery {
+  parent;
+  related;
+  relation;
+  kind = "morphMany";
+  extraWhere = {};
+  extraOptions = {};
+  constructor(parent, related, relation) {
+    this.parent = parent;
+    this.related = related;
+    this.relation = relation;
+  }
+  where(where) {
+    this.extraWhere = { ...this.extraWhere, ...where };
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    query.withMorphMany(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  hydrateEager(row, alias) {
+    const value = row[alias] ?? [];
+    const rows = Array.isArray(value) ? value : [];
+    return rows.map((item) => this.related.newFromRecord(item));
+  }
+  toExistsClause(parentTable) {
+    const childTable = this.related.repository().getTable().name;
+    const extra = buildAdvancedWhereClause(childTable, {
+      [this.relation.morphTypeKey]: this.relation.morphType,
+      ...this.extraWhere
+    }, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(childTable)} WHERE ${qualifyColumn(childTable, this.relation.morphIdKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
+  }
+  async get() {
+    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
+    const rows = await repository.query(asWhere({
+      [this.relation.morphTypeKey]: this.relation.morphType,
+      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
+      ...this.extraWhere
+    })).get();
+    return rows.map((row) => this.related.newFromRecord(row));
+  }
+  async first() {
+    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,
+      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey)
+    });
+  }
+}
+
+class MorphOneRelationQuery {
+  relation;
+  kind = "morphOne";
+  inner;
+  constructor(parent, related, relation) {
+    this.relation = relation;
+    this.inner = new MorphManyRelationQuery(parent, related, {
+      type: "morphMany",
+      name: relation.name,
+      localKey: relation.localKey,
+      morphTypeKey: relation.morphTypeKey,
+      morphIdKey: relation.morphIdKey,
+      morphType: relation.morphType
+    });
+  }
+  where(where) {
+    this.inner.where(where);
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    this.inner.applyEagerLoad(query, alias);
+  }
+  hydrateEager(row, alias) {
+    const hydrated = this.inner.hydrateEager(row, alias);
+    return hydrated[0];
+  }
+  toExistsClause(parentTable) {
+    return this.inner.toExistsClause(parentTable);
+  }
+  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);
+  }
+}
+
+class MorphToRelationQuery {
+  parent;
+  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,
+      model.repository()
+    ]));
+    query.withMorphTo(alias, this.relation, repositories);
+  }
+  hydrateEager(row, alias) {
+    return row[alias];
+  }
+  toExistsClause(parentTable) {
+    const type = String(this.parent.get(this.relation.morphTypeKey) ?? "");
+    const related = this.relatedByType[type];
+    if (!related) {
+      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)}${extraSql ? ` AND ${extraSql}` : ""}`,
+      params: extra.params
+    };
+  }
+  async get() {
+    const type = String(this.parent.get(this.relation.morphTypeKey) ?? "");
+    const id = this.parent.get(this.relation.morphIdKey);
+    const related = this.relatedByType[type];
+    if (!related || id === null || id === undefined) {
+      return null;
+    }
+    const table = related.repository().getTable();
+    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/model.ts
 var modelRepositories = new WeakMap;
+var namedModels = new Map;
 var modelGlobalScopes = new WeakMap;
+var modelObservers = new WeakMap;
 var modelBooted = new WeakSet;
+async function runObservers(model, hook) {
+  const observers = modelObservers.get(model.constructor) ?? [];
+  for (const observer of observers) {
+    const handler = observer[hook];
+    if (handler && await handler(model) === false) {
+      return false;
+    }
+  }
+  return true;
+}
+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 isLoadableModel(value) {
+  return Boolean(value && typeof value === "object" && typeof value.load === "function" && typeof value.loaded === "function" && typeof value.setLoaded === "function");
+}
+async function eagerLoadOnModels(models, paths) {
+  if (models.length === 0 || paths.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);
+  }
+  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) {
@@ -2889,6 +3734,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;
 }
@@ -2918,6 +3805,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;
   }
@@ -2935,6 +3827,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;
   }
@@ -2989,6 +3886,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;
@@ -2996,11 +4040,23 @@ class Model {
   static $guarded;
   static $casts = {};
   static $timestamps = true;
+  static $hidden;
+  static $visible;
+  static $appends;
+  static $morphClass;
   _exists;
+  loadedRelations = {};
+  hiddenOverrides = [];
+  visibleOverrides = [];
+  appended = [];
   constructor(attributes, repository, exists = true) {
     this.attributes = attributes;
     this.repository = repository;
     this._exists = exists;
+    this.attributes = modelStatics(this.constructor).hydrateAttributes(attributes);
+  }
+  getRepository() {
+    return this.repository;
   }
   get $exists() {
     return this._exists;
@@ -3014,8 +4070,51 @@ class Model {
   toObject() {
     return { ...this.attributes };
   }
+  toArray() {
+    const ModelClass = modelStatics(this.constructor);
+    const hidden = new Set([...ModelClass.$hidden ?? [], ...this.hiddenOverrides]);
+    const visible = this.visibleOverrides.length > 0 ? this.visibleOverrides : ModelClass.$visible;
+    const data = { ...this.attributes };
+    if (visible && visible.length > 0) {
+      for (const key of Object.keys(data)) {
+        if (!visible.includes(key)) {
+          delete data[key];
+        }
+      }
+    }
+    for (const key of hidden) {
+      delete data[key];
+    }
+    for (const key of [...ModelClass.$appends ?? [], ...this.appended]) {
+      const accessor = this[accessorName(key)];
+      if (typeof accessor === "function") {
+        data[key] = accessor.call(this);
+      }
+    }
+    for (const [name, value] of Object.entries(this.loadedRelations)) {
+      if (!hidden.has(name) && (!visible || visible.includes(name) || this.appended.includes(name))) {
+        data[name] = value;
+      }
+    }
+    return data;
+  }
+  toJSON() {
+    return this.toArray();
+  }
+  makeHidden(...keys) {
+    this.hiddenOverrides.push(...keys);
+    return this;
+  }
+  makeVisible(...keys) {
+    this.visibleOverrides.push(...keys);
+    return this;
+  }
+  append(...keys) {
+    this.appended.push(...keys);
+    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;
@@ -3034,6 +4133,10 @@ class Model {
     return new statics(hydrated, repository, exists);
   }
   static boot() {}
+  static observe(observer) {
+    const existing = modelObservers.get(this) ?? [];
+    modelObservers.set(this, [...existing, observer]);
+  }
   static addGlobalScope(_name, scope) {
     ensureBooted(this);
     const existing = modelGlobalScopes.get(this) ?? [];
@@ -3052,26 +4155,55 @@ class Model {
     for (const scope of getGlobalScopes(this)) {
       query = scope(query);
     }
-    return query;
+    return new ModelQuery(this, query);
   }
-  static async create(attributes) {
+  static newFromRecord(record, exists = true) {
+    const repository = resolveModelRepository(this);
+    return modelStatics(this).fromRecord(record, repository, exists);
+  }
+  static async create(attributes, forced = {}) {
     const statics = modelStatics(this);
     ensureBooted(this);
     const repository = resolveModelRepository(this);
     const table = repository.getTable();
     const timestamps = statics.$timestamps ?? true;
-    const assignable = filterMassAssignable(statics.$fillable, statics.$guarded, attributes);
+    const assignable = {
+      ...filterMassAssignable(statics.$fillable, statics.$guarded, attributes),
+      ...forced
+    };
     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);
-    return statics.fromRecord(record, repository, true);
+    const created = statics.fromRecord(record, repository, true);
+    await runObservers(created, "created");
+    await runObservers(created, "saved");
+    return created;
+  }
+  static with(...relations) {
+    return Model.query.call(this).with(...relations);
+  }
+  static whereHas(name, constrain) {
+    return Model.query.call(this).whereHas(name, constrain);
+  }
+  static has(name) {
+    return Model.query.call(this).has(name);
+  }
+  static doesntHave(name) {
+    return Model.query.call(this).doesntHave(name);
+  }
+  static whereDoesntHave(name, constrain) {
+    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);
@@ -3081,8 +4213,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);
@@ -3090,28 +4220,57 @@ 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);
+    if (existing) {
+      return existing;
+    }
+    return modelStatics(this).newFromRecord({ ...where, ...values }, false);
+  }
+  static async firstOrCreate(where, values = {}) {
+    const existing = await Model.firstWhere.call(this, where);
+    if (existing) {
+      return existing;
+    }
+    return Model.create.call(this, { ...where, ...values });
+  }
+  static async updateOrCreate(where, values = {}) {
+    const existing = await Model.firstWhere.call(this, where);
+    if (existing) {
+      return existing.update(values);
+    }
+    return Model.create.call(this, { ...where, ...values });
   }
   async save() {
     const ModelClass = modelStatics(this.constructor);
     const timestamps = ModelClass.$timestamps ?? true;
     const casts = ModelClass.$casts ?? {};
     const table = this.repository.getTable();
-    if (this.$exists) {
+    const updating = this.$exists;
+    if (await runObservers(this, "saving") === false) {
+      return this;
+    }
+    if (await runObservers(this, updating ? "updating" : "creating") === false) {
+      return this;
+    }
+    if (updating) {
       const changes = applyTimestampsOnUpdate(table.columns, applyCasts(this.attributes, casts, "dehydrate"), timestamps);
       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);
@@ -3120,6 +4279,8 @@ class Model {
     const record = await this.repository.create(payload);
     this.attributes = ModelClass.hydrateAttributes(record);
     this._exists = true;
+    await runObservers(this, "created");
+    await runObservers(this, "saved");
     return this;
   }
   async update(changes) {
@@ -3129,10 +4290,14 @@ class Model {
     return await this.save();
   }
   async delete() {
-    if (resolveSoftDeleteColumn(this.repository.getTable())) {
-      return await this.repository.deleteById(this.id);
+    if (await runObservers(this, "deleting") === false) {
+      return false;
     }
-    return await this.repository.forceDeleteById(this.id);
+    const deleted = resolveSoftDeleteColumn(this.repository.getTable()) ? await this.repository.deleteById(this.id) : await this.repository.forceDeleteById(this.id);
+    if (deleted) {
+      await runObservers(this, "deleted");
+    }
+    return deleted;
   }
   async forceDelete() {
     return await this.repository.forceDeleteById(this.id);
@@ -3181,6 +4346,102 @@ class Model {
     const loaded = grouped.get(parentId) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
+  hasMany(related, foreignKey, localKey) {
+    const table = this.repository.getTable();
+    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();
+    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 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
+    }));
+  }
+  belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
+    const table = this.repository.getTable();
+    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,
+      relatedKey: relatedTable.primaryKey,
+      foreignPivotKey: foreignPivotKey ?? foreignKeyFromTable(table.name),
+      relatedPivotKey: relatedPivotKey ?? foreignKeyFromTable(relatedTable.name)
+    }));
+  }
+  morphMany(related, morphName, typeKey, idKey, morphType) {
+    const table = this.repository.getTable();
+    const relatedClass = resolveRelated(related);
+    return new MorphManyRelationQuery(this, relatedClass, morphMany({
+      name: morphName,
+      localKey: table.primaryKey,
+      morphTypeKey: typeKey ?? `${morphName}_type`,
+      morphIdKey: idKey ?? `${morphName}_id`,
+      morphType: morphType ?? morphClassOf(this)
+    }));
+  }
+  morphOne(related, morphName, typeKey, idKey, morphType) {
+    const table = this.repository.getTable();
+    const relatedClass = resolveRelated(related);
+    return new MorphOneRelationQuery(this, relatedClass, morphOne({
+      name: morphName,
+      localKey: table.primaryKey,
+      morphTypeKey: typeKey ?? `${morphName}_type`,
+      morphIdKey: idKey ?? `${morphName}_id`,
+      morphType: morphType ?? morphClassOf(this)
+    }));
+  }
+  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) {
+    for (const name of names) {
+      if (name.includes(".")) {
+        await loadNested(this, name);
+        continue;
+      }
+      const method = this[name];
+      if (typeof method !== "function") {
+        throw new Error(`${this.constructor.name} has no relation method ${name}().`);
+      }
+      const relationQuery = method.call(this);
+      this.loadedRelations[name] = await relationQuery.get();
+    }
+    return this;
+  }
+  loaded(name) {
+    return this.loadedRelations[name];
+  }
+  setLoaded(name, value) {
+    this.loadedRelations[name] = value;
+    return this;
+  }
   mergeAttributes(patch) {
     Object.assign(this.attributes, patch);
     return this;
@@ -3188,6 +4449,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;
 }
@@ -5079,6 +6348,70 @@ function createRequireAuthMiddleware(auth2) {
 function serializeDate(value) {
   return value instanceof Date ? value.toISOString() : value;
 }
+function whenLoaded(model, relation, transform) {
+  const value = model.loaded(relation);
+  if (value === undefined) {
+    return;
+  }
+  return transform ? transform(value) : value;
+}
+
+class JsonResource {
+  resource;
+  static wrap = "data";
+  extra = {};
+  constructor(resource) {
+    this.resource = resource;
+  }
+  static make(resource) {
+    return new JsonResource(resource);
+  }
+  static collection(items) {
+    return new ResourceCollection(items);
+  }
+  additional(data) {
+    this.extra = { ...this.extra, ...data };
+    return this;
+  }
+  when(condition, value) {
+    return condition ? value : undefined;
+  }
+  whenLoaded(relation, transform) {
+    const model = this.resource;
+    if (typeof model.loaded !== "function") {
+      return;
+    }
+    return whenLoaded(model, relation, transform);
+  }
+  toArray() {
+    if (this.resource && typeof this.resource === "object" && "toArray" in this.resource) {
+      return this.resource.toArray();
+    }
+    return { ...this.resource };
+  }
+  toResponse() {
+    const wrap = this.constructor.wrap;
+    const payload = this.toArray();
+    if (wrap === null) {
+      return { ...payload, ...this.extra };
+    }
+    return { [wrap]: payload, ...this.extra };
+  }
+}
+
+class ResourceCollection extends JsonResource {
+  toArray() {
+    const items = this.resource.map((item) => item instanceof JsonResource ? item.toArray() : { ...item });
+    const wrap = this.constructor.wrap;
+    if (wrap === null) {
+      return { data: items };
+    }
+    return { [wrap]: items };
+  }
+  toResponse() {
+    return { ...this.toArray(), ...this.extra };
+  }
+}
 function toResourceCollection(items, transformer) {
   return items.map(transformer);
 }
@@ -7161,6 +8494,8 @@ export {
   AuthManager,
   BadRequestError,
   baseRepository_default as BaseRepository,
+  BelongsToManyRelationQuery,
+  BelongsToRelationQuery,
   Blueprint,
   CACHE_TAGS,
   repository_default as CacheRepository,
@@ -7173,19 +8508,27 @@ export {
   DatabaseTokenGuard,
   EtaViewEngine,
   EventBus,
+  Factory,
   failedJobRepository_default as FailedJobRepository,
   failedJobService_default as FailedJobService,
   ForbiddenError,
   ForeignIdColumnDefinition,
   FormRequest,
   GuestGuard,
+  HasManyRelationQuery,
+  HasOneRelationQuery,
   HttpError,
   Job,
+  JsonResource,
   LocalStorageDriver,
   LogMailDriver,
   Mailer,
   membershipService_default as MembershipService,
   Model,
+  ModelQuery,
+  MorphManyRelationQuery,
+  MorphOneRelationQuery,
+  MorphToRelationQuery,
   MySqlGrammar,
   NotFoundError,
   Notification,
@@ -7200,6 +8543,7 @@ export {
   RedisQueue,
   RepositoryQuery,
   ResilientQueue,
+  ResourceCollection,
   Schedule,
   Schema,
   ServiceContainer,
@@ -7297,6 +8641,7 @@ export {
   eventBus,
   events,
   filterMassAssignable,
+  foreignKeyFromTable,
   formatAdminValue,
   freshDatabase,
   generateCspNonce,
@@ -7355,6 +8700,7 @@ export {
   parseMultipartUpload,
   parsePaginationQuery,
   parsePositiveIntParam,
+  pivotTableName,
   policyGate,
   prometheusRegistry,
   queue,
@@ -7367,6 +8713,7 @@ export {
   readTenancyDriver,
   redirectResponse,
   registerDefaultDatabasePool,
+  registerModelClass,
   registerModelRepository,
   registerShutdownHandler,
   renderKernelErrorChrome,
@@ -7423,6 +8770,7 @@ export {
   serverHtmxContentSecurityPolicy,
   setActiveApplicationContext,
   signedUrl,
+  singularize,
   spaContentSecurityPolicy,
   storageFacade as storage,
   strictApiContentSecurityPolicy,
@@ -7436,6 +8784,7 @@ export {
   trustForwardedFor,
   validateObject,
   verifyCsrfToken,
+  whenLoaded,
   withErrorHandling,
   withMiddleware,
   withMigrationLock,