@getstrata/core 0.5.91 → 0.5.98

package/dist/entries/database/model.js

@@ -2,6 +2,26 @@
 // ../../src/core/database/model.ts
 import { NotFoundError } from "@getstrata/core/errors/http";
 
+// ../../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/query.ts
 function quoteIdentifier(identifier) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
@@ -115,7 +135,16 @@ function buildWhereClause(tableName, where = {}) {
     params
   };
 }
+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);
   }
@@ -416,6 +445,428 @@ function buildDeleteByIdQuery(table, id) {
   };
 }
 
+// ../../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 }.");
+}
+
+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 (await this.get()).length;
+  }
+  async create(attributes = {}) {
+    return this.related.create(attributes, {
+      [this.relation.foreignKey]: this.parent.get(this.relation.localKey)
+    });
+  }
+  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 await this.get() ? 1 : 0;
+  }
+  async create(attributes = {}) {
+    return this.inner.create(attributes);
+  }
+}
+
+class BelongsToRelationQuery {
+  parent;
+  related;
+  relation;
+  kind = "belongsTo";
+  extraOptions = {};
+  constructor(parent, related, relation) {
+    this.parent = parent;
+    this.related = related;
+    this.relation = relation;
+  }
+  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;
+    return {
+      sql: `SELECT 1 FROM ${quoteIdentifier(relatedTable)} WHERE ${qualifyColumn(relatedTable, this.relation.ownerKey)} = ${qualifyColumn(parentTable, this.relation.foreignKey)}`,
+      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 }));
+    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();
+  }
+  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 = {};
+  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) {}
+  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() {
+    return (await this.get()).length;
+  }
+  async attach(ids) {
+    const list = Array.isArray(ids) ? ids : [ids];
+    const parentId = this.parent.get(this.relation.parentKey);
+    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]);
+    }
+  }
+  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 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 create(attributes = {}) {
+    return this.inner.create(attributes);
+  }
+}
+
+class MorphToRelationQuery {
+  parent;
+  relatedByType;
+  relation;
+  kind = "morphTo";
+  constructor(parent, relatedByType, relation) {
+    this.parent = parent;
+    this.relatedByType = relatedByType;
+    this.relation = relation;
+  }
+  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();
+    return {
+      sql: `SELECT 1 FROM ${quoteIdentifier(relatedTable.name)} WHERE ${qualifyColumn(relatedTable.name, relatedTable.primaryKey)} = ${qualifyColumn(parentTable, this.relation.morphIdKey)}`,
+      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 })).first();
+    return row ? related.newFromRecord(row) : null;
+  }
+}
+
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
   return {
@@ -565,7 +1016,54 @@ function indexMorphToRelation(children, parentsByType, relation) {
 // ../../src/core/database/model.ts
 var modelRepositories = new WeakMap;
 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 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);
+}
+async function loadNested(model, path) {
+  const [head, ...rest] = path.split(".");
+  if (!head) {
+    return;
+  }
+  await model.load(head);
+  if (rest.length === 0) {
+    return;
+  }
+  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("."));
+    }
+  }
+}
 function resolveModelRepository(model) {
   const repository = modelRepositories.get(model);
   if (!repository) {
@@ -680,12 +1178,22 @@ class Model {
   static $guarded;
   static $casts = {};
   static $timestamps = true;
+  static $hidden;
+  static $visible;
+  static $appends;
   _exists;
+  loadedRelations = {};
+  hiddenOverrides = [];
+  visibleOverrides = [];
+  appended = [];
   constructor(attributes, repository, exists = true) {
     this.attributes = attributes;
     this.repository = repository;
     this._exists = exists;
   }
+  getRepository() {
+    return this.repository;
+  }
   get $exists() {
     return this._exists;
   }
@@ -698,6 +1206,49 @@ 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.`);
   }
@@ -718,6 +1269,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) ?? [];
@@ -738,17 +1293,89 @@ class Model {
     }
     return 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, "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");
+    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;
+      }
+    };
+  }
+  static whereHas(name, constrain) {
+    return constrainRelationExists(this, name, constrain, false);
+  }
+  static has(name) {
+    return constrainRelationExists(this, name, undefined, false);
+  }
+  static doesntHave(name) {
+    return constrainRelationExists(this, name, undefined, true);
+  }
+  static whereDoesntHave(name, constrain) {
+    return constrainRelationExists(this, name, constrain, true);
   }
   static async find(id) {
     const statics = modelStatics(this);
@@ -777,6 +1404,9 @@ class Model {
     const rows = await query.get();
     return rows.map((row) => statics.fromRecord(row, repository, true));
   }
+  static where(where) {
+    return Model.query.call(this).where(where);
+  }
   static async firstWhere(where, options = {}) {
     const statics = modelStatics(this);
     const repository = resolveModelRepository(this);
@@ -787,15 +1417,41 @@ class Model {
     const record = await query.first();
     return record ? statics.fromRecord(record, repository, true) : null;
   }
+  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, 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");
       return this;
     }
     const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
@@ -804,6 +1460,7 @@ class Model {
     const record = await this.repository.create(payload);
     this.attributes = ModelClass.hydrateAttributes(record);
     this._exists = true;
+    await runObservers(this, "created");
     return this;
   }
   async update(changes) {
@@ -813,10 +1470,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);
@@ -865,6 +1526,91 @@ class Model {
     const loaded = grouped.get(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,
+      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,
+      localKey: localKey ?? table.primaryKey,
+      foreignKey: foreignKey ?? foreignKeyFromTable(table.name)
+    }));
+  }
+  belongsTo(related, foreignKey, ownerKey) {
+    const relatedTable = related.repository().getTable();
+    return new BelongsToRelationQuery(this, related, belongsTo({
+      name: relatedTable.name,
+      foreignKey: foreignKey ?? foreignKeyFromTable(relatedTable.name),
+      ownerKey: ownerKey ?? relatedTable.primaryKey
+    }));
+  }
+  belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
+    const table = this.repository.getTable();
+    const relatedTable = related.repository().getTable();
+    return new BelongsToManyRelationQuery(this, related, 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) {
+    const table = this.repository.getTable();
+    return new MorphManyRelationQuery(this, related, morphMany({
+      name: morphName,
+      localKey: table.primaryKey,
+      morphTypeKey: typeKey ?? `${morphName}_type`,
+      morphIdKey: idKey ?? `${morphName}_id`,
+      morphType: table.name
+    }));
+  }
+  morphOne(related, morphName, typeKey, idKey) {
+    const table = this.repository.getTable();
+    return new MorphOneRelationQuery(this, related, morphOne({
+      name: morphName,
+      localKey: table.primaryKey,
+      morphTypeKey: typeKey ?? `${morphName}_type`,
+      morphIdKey: idKey ?? `${morphName}_id`,
+      morphType: table.name
+    }));
+  }
+  morphTo(relatedByType, morphName = "imageable", typeKey, idKey) {
+    return new MorphToRelationQuery(this, relatedByType, morphTo({
+      name: morphName,
+      morphTypeKey: typeKey ?? `${morphName}_type`,
+      morphIdKey: idKey ?? `${morphName}_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;
@@ -876,7 +1622,14 @@ function registerModelRepository(model, repository) {
   return model;
 }
 export {
+  BelongsToManyRelationQuery,
+  BelongsToRelationQuery,
+  HasManyRelationQuery,
+  HasOneRelationQuery,
   Model,
+  MorphManyRelationQuery,
+  MorphOneRelationQuery,
+  MorphToRelationQuery,
   applyCasts,
   dehydrateValue,
   filterMassAssignable,