@getstrata/core 0.5.97 → 0.5.98

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) {
@@ -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;
@@ -2766,6 +2804,162 @@ function createDatabaseConnection(source) {
     }
   };
 }
+// ../../src/core/database/factory.ts
+class Factory {
+  quantity = 1;
+  counted = false;
+  sequenceIndex = 0;
+  stateTransforms = [];
+  sequenceItems = [];
+  parentAssociations = [];
+  children = [];
+  afterMakingCallbacks = [];
+  afterCreatingCallbacks = [];
+  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 next = this.clone();
+    next.parentAssociations = [...this.parentAssociations, { foreignKey, 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;
+  }
+  persist(_values) {
+    throw new Error("Factory.persist() must be implemented to use create().");
+  }
+}
+// ../../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/migrations/advisoryLock.ts
 var MIGRATION_LOCK_KEY = 42424242;
 async function withMigrationLock(db, callback, lockKey = MIGRATION_LOCK_KEY) {
@@ -2878,10 +3072,479 @@ 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 }.");
+}
+
+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/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) {
@@ -2996,12 +3659,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;
   }
@@ -3014,6 +3687,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.`);
   }
@@ -3034,6 +3750,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) ?? [];
@@ -3054,17 +3774,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);
@@ -3093,6 +3885,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);
@@ -3103,15 +3898,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);
@@ -3120,6 +3941,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) {
@@ -3129,10 +3951,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 +4007,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;
@@ -5079,6 +5990,64 @@ 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() {
+    return {
+      data: this.resource.map((item) => item instanceof JsonResource ? item.toArray() : { ...item })
+    };
+  }
+}
 function toResourceCollection(items, transformer) {
   return items.map(transformer);
 }
@@ -7161,6 +8130,8 @@ export {
   AuthManager,
   BadRequestError,
   baseRepository_default as BaseRepository,
+  BelongsToManyRelationQuery,
+  BelongsToRelationQuery,
   Blueprint,
   CACHE_TAGS,
   repository_default as CacheRepository,
@@ -7173,19 +8144,26 @@ 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,
+  MorphManyRelationQuery,
+  MorphOneRelationQuery,
+  MorphToRelationQuery,
   MySqlGrammar,
   NotFoundError,
   Notification,
@@ -7200,6 +8178,7 @@ export {
   RedisQueue,
   RepositoryQuery,
   ResilientQueue,
+  ResourceCollection,
   Schedule,
   Schema,
   ServiceContainer,
@@ -7297,6 +8276,7 @@ export {
   eventBus,
   events,
   filterMassAssignable,
+  foreignKeyFromTable,
   formatAdminValue,
   freshDatabase,
   generateCspNonce,
@@ -7355,6 +8335,7 @@ export {
   parseMultipartUpload,
   parsePaginationQuery,
   parsePositiveIntParam,
+  pivotTableName,
   policyGate,
   prometheusRegistry,
   queue,
@@ -7423,6 +8404,7 @@ export {
   serverHtmxContentSecurityPolicy,
   setActiveApplicationContext,
   signedUrl,
+  singularize,
   spaContentSecurityPolicy,
   storageFacade as storage,
   strictApiContentSecurityPolicy,
@@ -7436,6 +8418,7 @@ export {
   trustForwardedFor,
   validateObject,
   verifyCsrfToken,
+  whenLoaded,
   withErrorHandling,
   withMiddleware,
   withMigrationLock,