@getstrata/core 2.0.9 → 2.2.0

package/dist/entries/database/model.js

@@ -1,2465 +1 @@
-// @bun
-// ../../src/core/database/model.ts
-import { ConflictError, 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
-import { currentSqlDialect } from "@getstrata/core/database/dialect";
-function quoteIdentifier(identifier) {
-  return currentSqlDialect().quoteIdentifier(identifier);
-}
-function returningSuffix(columns) {
-  return currentSqlDialect().returningClause(columns);
-}
-function qualifyColumn(tableName, column) {
-  return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
-}
-function resolveQualifiedColumn(defaultTable, columnName) {
-  if (columnName.includes(".")) {
-    const [table, column] = columnName.split(".", 2);
-    if (!table || !column) {
-      throw new Error(`Invalid qualified column: ${columnName}`);
-    }
-    return qualifyColumn(table, column);
-  }
-  return qualifyColumn(defaultTable, columnName);
-}
-function parseQualifiedColumn(reference) {
-  const [table, column] = reference.split(".", 2);
-  if (!table || !column) {
-    throw new Error(`Join columns must be qualified as table.column: ${reference}`);
-  }
-  return { table, column };
-}
-function normalizeDirection(direction = "ASC") {
-  return direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
-}
-function isQueryOperator(value) {
-  return value !== null && !Array.isArray(value) && !(value instanceof Date) && typeof value === "object";
-}
-function pushParam(values, value) {
-  values.push(value);
-  return currentSqlDialect().placeholder(values.length);
-}
-var SUPPORTED_OPERATORS = new Set([
-  "eq",
-  "ne",
-  "in",
-  "notIn",
-  "gt",
-  "gte",
-  "lt",
-  "lte",
-  "isNull",
-  "ilike",
-  "tsMatch"
-]);
-function buildInClause(column, values, params, negated = false) {
-  if (values.length === 0) {
-    return negated ? "1 = 1" : "1 = 0";
-  }
-  const placeholders = values.map((value) => pushParam(params, value)).join(", ");
-  return `${column}${negated ? " NOT" : ""} IN (${placeholders})`;
-}
-function buildOperatorClauses(column, operator, params) {
-  const clauses = [];
-  const unsupported = Object.keys(operator).filter((key) => !SUPPORTED_OPERATORS.has(key));
-  if (unsupported.length > 0) {
-    throw new Error(`Unsupported query operator(s) for ${column}: ${unsupported.join(", ")}. Supported: ${[...SUPPORTED_OPERATORS].join(", ")}.`);
-  }
-  if (operator.isNull === true) {
-    clauses.push(`${column} IS NULL`);
-  }
-  if (operator.isNull === false) {
-    clauses.push(`${column} IS NOT NULL`);
-  }
-  if (operator.eq !== undefined) {
-    if (operator.eq === null) {
-      clauses.push(`${column} IS NULL`);
-    } else {
-      clauses.push(`${column} = ${pushParam(params, operator.eq)}`);
-    }
-  }
-  if (operator.ne !== undefined) {
-    if (operator.ne === null) {
-      clauses.push(`${column} IS NOT NULL`);
-    } else {
-      clauses.push(`${column} <> ${pushParam(params, operator.ne)}`);
-    }
-  }
-  if (operator.in !== undefined) {
-    clauses.push(buildInClause(column, operator.in, params));
-  }
-  if (operator.notIn !== undefined) {
-    clauses.push(buildInClause(column, operator.notIn, params, true));
-  }
-  if (operator.gt !== undefined) {
-    clauses.push(`${column} > ${pushParam(params, operator.gt)}`);
-  }
-  if (operator.gte !== undefined) {
-    clauses.push(`${column} >= ${pushParam(params, operator.gte)}`);
-  }
-  if (operator.lt !== undefined) {
-    clauses.push(`${column} < ${pushParam(params, operator.lt)}`);
-  }
-  if (operator.lte !== undefined) {
-    clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
-  }
-  if (operator.ilike !== undefined) {
-    clauses.push(`${column} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
-  }
-  if (operator.tsMatch !== undefined) {
-    if (currentSqlDialect().driver !== "pgsql") {
-      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
-    }
-    clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
-  }
-  return clauses;
-}
-function appendWhereParts(tableName, where, params) {
-  const clauses = [];
-  for (const [columnName, filterValue] of Object.entries(where)) {
-    if (filterValue === undefined) {
-      continue;
-    }
-    const column = resolveQualifiedColumn(tableName, columnName);
-    if (Array.isArray(filterValue)) {
-      clauses.push(buildInClause(column, filterValue, params));
-      continue;
-    }
-    if (isQueryOperator(filterValue)) {
-      clauses.push(...buildOperatorClauses(column, filterValue, params));
-      continue;
-    }
-    if (filterValue === null) {
-      clauses.push(`${column} IS NULL`);
-      continue;
-    }
-    clauses.push(`${column} = ${pushParam(params, filterValue)}`);
-  }
-  return clauses.join(" AND ");
-}
-function buildWhereClause(tableName, where = {}) {
-  const params = [];
-  const body = appendWhereParts(tableName, where, params);
-  return {
-    clause: body.length > 0 ? ` WHERE ${body}` : "",
-    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);
-  }
-  const grouped = buildWhereGroupClause(tableName, node.group, params);
-  if (!grouped) {
-    return "";
-  }
-  return grouped.includes(" OR ") ? `(${grouped})` : grouped;
-}
-function buildWhereGroupClause(tableName, nodes, params) {
-  let result = "";
-  for (const node of nodes) {
-    const part = buildWhereNodeClause(tableName, node, params);
-    if (!part) {
-      continue;
-    }
-    if (!result) {
-      result = part;
-      continue;
-    }
-    result = node.kind === "or" ? `${result} OR ${part}` : `${result} AND ${part}`;
-  }
-  if (!result) {
-    return "";
-  }
-  return result;
-}
-function buildAdvancedWhereClause(tableName, where = {}, whereNodes = [], params = []) {
-  const nodes = [];
-  if (Object.keys(where).length > 0) {
-    nodes.push({ kind: "and", where });
-  }
-  nodes.push(...whereNodes);
-  const combined = buildWhereGroupClause(tableName, nodes, params);
-  return {
-    clause: combined ? ` WHERE ${combined}` : "",
-    params
-  };
-}
-function resolveSoftDeleteColumn(table) {
-  if (!table.softDeletes) {
-    return null;
-  }
-  if (table.softDeletes === true) {
-    return "deleted_at";
-  }
-  return table.softDeletes.column ?? "deleted_at";
-}
-function appendSoftDeleteScope(table, options, clauses) {
-  const column = resolveSoftDeleteColumn(table);
-  if (!column) {
-    return;
-  }
-  const qualifiedColumn = qualifyColumn(table.name, column);
-  if (options.onlyTrashed) {
-    clauses.push(`${qualifiedColumn} IS NOT NULL`);
-    return;
-  }
-  if (!options.withTrashed) {
-    clauses.push(`${qualifiedColumn} IS NULL`);
-  }
-}
-function buildQueryWhereClause(table, options = {}, whereNodes = [], params = []) {
-  const { clause, params: whereParams } = buildAdvancedWhereClause(table.name, options.where ?? {}, whereNodes, params);
-  const softDeleteClauses = [];
-  appendSoftDeleteScope(table, options, softDeleteClauses);
-  if (softDeleteClauses.length === 0) {
-    return { clause, params: whereParams };
-  }
-  const base = clause.replace(/^ WHERE /, "");
-  const scope = softDeleteClauses.join(" AND ");
-  return {
-    clause: base ? ` WHERE (${base}) AND ${scope}` : ` WHERE ${scope}`,
-    params: whereParams
-  };
-}
-function isQueryOrder(value) {
-  return "column" in value;
-}
-function normalizeOrderBy(orderBy) {
-  if (!orderBy) {
-    return [];
-  }
-  if (Array.isArray(orderBy)) {
-    return orderBy;
-  }
-  if (isQueryOrder(orderBy)) {
-    return [orderBy];
-  }
-  return Object.entries(orderBy).map(([column, direction]) => ({
-    column,
-    direction
-  }));
-}
-function buildOrderByClause(tableName, orderBy) {
-  const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
-    return `${resolveQualifiedColumn(tableName, column)} ${normalizeDirection(direction)}`;
-  });
-  return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
-}
-function buildGroupByClause(tableName, groupBy) {
-  if (!groupBy) {
-    return "";
-  }
-  const columns = (Array.isArray(groupBy) ? groupBy : [groupBy]).map((column) => String(column));
-  const parts = columns.map((column) => resolveQualifiedColumn(tableName, column));
-  return parts.length > 0 ? ` GROUP BY ${parts.join(", ")}` : "";
-}
-function buildHavingClause(tableName, having, params) {
-  if (!having) {
-    return "";
-  }
-  const body = appendWhereParts(tableName, having, params);
-  return body.length > 0 ? ` HAVING ${body}` : "";
-}
-function buildJoinClause(joins = []) {
-  return joins.map((join) => {
-    const joinType = join.type === "left" ? "LEFT JOIN" : "INNER JOIN";
-    const onClause = join.on.map(({ left, right }) => `${qualifyColumn(left.table, left.column)} = ${qualifyColumn(right.table, right.column)}`).join(" AND ");
-    return ` ${joinType} ${quoteIdentifier(join.table)} ON ${onClause}`;
-  }).join("");
-}
-function buildLimitClause(limit) {
-  if (limit === undefined) {
-    return "";
-  }
-  if (!Number.isInteger(limit) || limit <= 0) {
-    throw new Error("Query limit must be a positive integer.");
-  }
-  return ` LIMIT ${limit}`;
-}
-function buildOffsetClause(offset) {
-  if (offset === undefined) {
-    return "";
-  }
-  if (!Number.isInteger(offset) || offset < 0) {
-    throw new Error("Query offset must be a non-negative integer.");
-  }
-  return ` OFFSET ${offset}`;
-}
-function buildReturningColumns(table) {
-  return table.columns.map((column) => qualifyColumn(table.name, column)).join(", ");
-}
-function buildSelectList(table, select, params = []) {
-  if (!select || select.length === 0) {
-    return buildReturningColumns(table);
-  }
-  return select.map((item) => {
-    if (item.kind === "column") {
-      const column = qualifyColumn(item.table, item.column);
-      return item.as ? `${column} AS ${quoteIdentifier(item.as)}` : column;
-    }
-    if (item.kind === "literalText") {
-      return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
-    }
-    if (item.kind === "subqueryCount") {
-      const body = remapExistsSql(item.sql, item.params, params);
-      return `(${body}) AS ${quoteIdentifier(item.as)}`;
-    }
-    const column = qualifyColumn(item.table, item.column);
-    const placeholder = pushParam(params, item.query);
-    return `ts_rank(${column}, plainto_tsquery('english', ${placeholder})) AS ${quoteIdentifier(item.as)}`;
-  }).join(", ");
-}
-function getDefinedColumnEntries(table, values, options = {}) {
-  const record = values;
-  const excluded = new Set(options.exclude ?? []);
-  return table.columns.flatMap((column) => {
-    if (excluded.has(column) || !Object.hasOwn(record, column)) {
-      return [];
-    }
-    const value = record[column];
-    if (value === undefined) {
-      return [];
-    }
-    return [[column, value]];
-  });
-}
-function buildSelectQuery(table, options = {}, whereNodes = []) {
-  const params = [];
-  const columns = buildSelectList(table, options.select, params);
-  const { clause } = buildQueryWhereClause(table, options, whereNodes, params);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  const havingClause = buildHavingClause(table.name, options.having, params);
-  const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
-  const limit = buildLimitClause(options.limit);
-  const offset = buildOffsetClause(options.offset);
-  return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
-    params
-  };
-}
-function buildCountQuery(table, where = {}, options = {}, whereNodes = []) {
-  const params = [];
-  const { clause, params: whereParams } = buildQueryWhereClause(table, {
-    where,
-    withTrashed: options.withTrashed,
-    onlyTrashed: options.onlyTrashed
-  }, whereNodes);
-  params.push(...whereParams);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  return {
-    text: `SELECT COUNT(*) AS count FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}`,
-    params
-  };
-}
-function buildProjectionQuery(table, expression, alias, options = {}, whereNodes = []) {
-  assertSafeProjectionExpression(expression);
-  const params = [];
-  const { clause, params: whereParams } = buildQueryWhereClause(table, options, whereNodes);
-  params.push(...whereParams);
-  const joins = buildJoinClause(options.joins);
-  const groupBy = buildGroupByClause(table.name, options.groupBy);
-  const orderBy = buildOrderByClause(table.name, options.orderBy);
-  const limit = buildLimitClause(options.limit);
-  return {
-    text: `SELECT ${expression} AS ${quoteIdentifier(alias)} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${orderBy}${limit}`,
-    params
-  };
-}
-var SAFE_PROJECTION_EXPRESSION = /^(COUNT\(\*\)|(?:"[\w_]+"(?:\."[\w_]+")?)|(?:AVG|SUM|MIN|MAX)\((?:"[\w_]+"(?:\."[\w_]+")?)\))$/;
-function assertSafeProjectionExpression(expression) {
-  if (!SAFE_PROJECTION_EXPRESSION.test(expression.trim())) {
-    throw new Error(`Unsafe projection expression: ${expression}`);
-  }
-}
-function buildGroupedCountQuery(table, column, where = {}, options = {}) {
-  const qualifiedColumn = qualifyColumn(table.name, column);
-  const { clause, params } = buildQueryWhereClause(table, {
-    where,
-    ...options
-  });
-  return {
-    text: `SELECT ${qualifiedColumn} AS ${quoteIdentifier("value")}, COUNT(*) AS ${quoteIdentifier("count")} FROM ${quoteIdentifier(table.name)}${clause} GROUP BY ${qualifiedColumn} ORDER BY ${qualifiedColumn} ASC`,
-    params
-  };
-}
-function buildInsertQuery(table, values) {
-  const entries = getDefinedColumnEntries(table, values);
-  if (entries.length === 0) {
-    throw new Error(`Cannot insert into ${table.name} without any column values.`);
-  }
-  const params = [];
-  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
-  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
-  const returningColumns = buildReturningColumns(table);
-  return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildUpsertQuery(table, values, conflictColumns, updateColumns) {
-  const entries = getDefinedColumnEntries(table, values);
-  if (entries.length === 0) {
-    throw new Error(`Cannot upsert into ${table.name} without any column values.`);
-  }
-  if (conflictColumns.length === 0) {
-    throw new Error(`Cannot upsert into ${table.name} without any conflict columns.`);
-  }
-  const insertable = new Set(entries.map(([column]) => column));
-  const conflict = new Set(conflictColumns);
-  const updatable = (updateColumns ?? entries.map(([column]) => column).filter((c) => !conflict.has(c))).filter((column) => insertable.has(column));
-  const params = [];
-  const columns = entries.map(([column]) => quoteIdentifier(column)).join(", ");
-  const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
-  const returningColumns = buildReturningColumns(table);
-  const suffix = currentSqlDialect().upsertSuffix(conflictColumns, updatable);
-  return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${suffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildIncrementQuery(table, id, column, amount, extra = {}) {
-  if (!Number.isFinite(amount)) {
-    throw new Error("Increment amount must be a finite number.");
-  }
-  if (!table.columns.includes(column)) {
-    throw new Error(`Unknown column ${String(column)} on ${table.name}.`);
-  }
-  const params = [];
-  const target = quoteIdentifier(column);
-  const assignments = [`${target} = ${target} + ${pushParam(params, amount)}`];
-  for (const [name, value] of getDefinedColumnEntries(table, extra, {
-    exclude: [table.primaryKey, column]
-  })) {
-    assignments.push(`${quoteIdentifier(name)} = ${pushParam(params, value)}`);
-  }
-  const primaryKeyPlaceholder = pushParam(params, id);
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildUpdateQuery(table, id, changes) {
-  const entries = getDefinedColumnEntries(table, changes, {
-    exclude: [table.primaryKey]
-  });
-  if (entries.length === 0) {
-    throw new Error(`Cannot update ${table.name} without any changed column values.`);
-  }
-  const params = [];
-  const setClause = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`).join(", ");
-  const primaryKeyPlaceholder = pushParam(params, id);
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildSoftDeleteByIdQuery(table, id, deletedAt) {
-  const deletedAtColumn = resolveSoftDeleteColumn(table);
-  if (!deletedAtColumn) {
-    throw new Error(`Table ${table.name} does not support soft deletes.`);
-  }
-  const returningColumns = buildReturningColumns(table);
-  const scopeClauses = [];
-  appendSoftDeleteScope(table, {}, scopeClauses);
-  const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
-  const params = [];
-  const deletedAtPlaceholder = pushParam(params, deletedAt);
-  const idPlaceholder = pushParam(params, id);
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildRestoreByIdQuery(table, id) {
-  const deletedAtColumn = resolveSoftDeleteColumn(table);
-  if (!deletedAtColumn) {
-    throw new Error(`Table ${table.name} does not support soft deletes.`);
-  }
-  const returningColumns = buildReturningColumns(table);
-  const params = [];
-  const deletedAtPlaceholder = pushParam(params, null);
-  const idPlaceholder = pushParam(params, id);
-  return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder} AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL${returningSuffix(returningColumns)}`,
-    params
-  };
-}
-function buildDeleteByIdQuery(table, id) {
-  const params = [];
-  const idPlaceholder = pushParam(params, id);
-  const returning = returningSuffix(`${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`);
-  return {
-    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${returning}`,
-    params
-  };
-}
-
-// ../../src/core/database/pluck.ts
-function uniqueColumnSelect(table, columns) {
-  const seen = new Set;
-  const select = [];
-  for (const column of columns) {
-    if (seen.has(column)) {
-      continue;
-    }
-    seen.add(column);
-    select.push({ kind: "column", table, column, as: column });
-  }
-  return select;
-}
-function projectPluck(rows, column, keyBy) {
-  if (keyBy === undefined) {
-    return rows.map((row) => row[column]);
-  }
-  const keyed = new Map;
-  for (const row of rows) {
-    keyed.set(row[keyBy], row[column]);
-  }
-  return keyed;
-}
-
-// ../../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);
-}
-function pluckFromQuery(query, column, keyBy) {
-  if (!query) {
-    return Promise.resolve(keyBy === undefined ? [] : new Map);
-  }
-  return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
-}
-
-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();
-  }
-  async pluck(column, keyBy) {
-    return pluckFromQuery(this.scopedQuery(), column, keyBy);
-  }
-  async value(column) {
-    return this.scopedQuery().value(column);
-  }
-  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) {
-    return Promise.all(records.map((attributes) => this.create(attributes)));
-  }
-}
-
-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();
-  }
-  async pluck(column, keyBy) {
-    const query = this.inner.limit(1);
-    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
-  }
-  async value(column) {
-    return this.inner.limit(1).value(column);
-  }
-  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 query = this.relatedQuery();
-    if (!query) {
-      return null;
-    }
-    const row = await query.first();
-    return row ? this.related.newFromRecord(row) : null;
-  }
-  async first() {
-    return this.get();
-  }
-  async pluck(column, keyBy) {
-    return pluckFromQuery(this.relatedQuery(), column, keyBy);
-  }
-  async value(column) {
-    return this.relatedQuery()?.value(column) ?? null;
-  }
-  relatedQuery() {
-    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);
-    }
-    return query;
-  }
-  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 ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(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 ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1`, [parentId]);
-    return Number(rows[0]?.count ?? 0);
-  }
-  async pluck(column, keyBy) {
-    return pluckFromQuery(await this.relatedQuery(), column, keyBy);
-  }
-  async value(column) {
-    const query = await this.relatedQuery();
-    return query ? query.value(column) : null;
-  }
-  async relatedQuery() {
-    const parentId = this.parent.get(this.relation.parentKey);
-    const pivotRows = await this.connection().unsafe(`SELECT * FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1`, [parentId]);
-    if (pivotRows.length === 0) {
-      return null;
-    }
-    const relatedIds = [
-      ...new Set(pivotRows.map((row) => row[this.relation.relatedPivotKey]))
-    ];
-    let query = this.related.repository().withConnection(this.connection()).query(asWhere({
-      [this.relation.relatedKey]: relatedIds,
-      ...this.extraWhere
-    }));
-    if (this.extraOptions.orderBy) {
-      query = query.orderBy(this.extraOptions.orderBy);
-    }
-    return query;
-  }
-  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.map((key) => quoteIdentifier(key)).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 ${quoteIdentifier(this.relation.pivotTable)} (${quoteIdentifier(String(this.relation.foreignPivotKey))}, ${quoteIdentifier(String(this.relation.relatedPivotKey))}${extraColumns}) VALUES ($1, $2, ${extraPlaceholders})` : `INSERT INTO ${quoteIdentifier(this.relation.pivotTable)} (${quoteIdentifier(String(this.relation.foreignPivotKey))}, ${quoteIdentifier(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 ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1 AND ${quoteIdentifier(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 ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1`, [parentId]);
-      return;
-    }
-    const list = Array.isArray(ids) ? ids : [ids];
-    const placeholders = list.map((_, index) => `$${index + 2}`).join(", ");
-    await this.connection().unsafe(`DELETE FROM ${quoteIdentifier(this.relation.pivotTable)} WHERE ${quoteIdentifier(String(this.relation.foreignPivotKey))} = $1 AND ${quoteIdentifier(String(this.relation.relatedPivotKey))} IN (${placeholders})`, [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 };
-  }
-  scopedQuery() {
-    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({
-      [this.relation.morphTypeKey]: this.relation.morphType,
-      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
-      ...this.extraWhere
-    }));
-  }
-  async get() {
-    const rows = await this.scopedQuery().get();
-    return rows.map((row) => this.related.newFromRecord(row));
-  }
-  async first() {
-    const rows = await this.get();
-    return rows[0] ?? null;
-  }
-  async count() {
-    return this.scopedQuery().count();
-  }
-  async pluck(column, keyBy) {
-    return pluckFromQuery(this.scopedQuery(), column, keyBy);
-  }
-  async value(column) {
-    return this.scopedQuery().value(column);
-  }
-  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();
-  }
-  async pluck(column, keyBy) {
-    return keyBy === undefined ? this.inner.pluck(column) : this.inner.pluck(column, keyBy);
-  }
-  async value(column) {
-    return this.inner.value(column);
-  }
-  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 query = this.relatedQuery();
-    if (!query) {
-      return null;
-    }
-    const row = await query.first();
-    return row ? this.relatedForCurrentType()?.newFromRecord(row) ?? null : null;
-  }
-  async pluck(column, keyBy) {
-    return pluckFromQuery(this.relatedQuery(), column, keyBy);
-  }
-  async value(column) {
-    return this.relatedQuery()?.value(column) ?? null;
-  }
-  relatedForCurrentType() {
-    const type = String(this.parent.get(this.relation.morphTypeKey) ?? "");
-    return this.relatedByType[type];
-  }
-  relatedQuery() {
-    const id = this.parent.get(this.relation.morphIdKey);
-    const related = this.relatedForCurrentType();
-    if (!related || id === null || id === undefined) {
-      return null;
-    }
-    const table = related.repository().getTable();
-    return related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere }));
-  }
-  then(onfulfilled, onrejected) {
-    return thenGet(() => this.get(), onfulfilled, onrejected);
-  }
-}
-
-class HasManyThroughRelationQuery {
-  parent;
-  related;
-  relation;
-  kind = "hasManyThrough";
-  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.withHasManyThrough(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 farTable = this.related.repository().getTable().name;
-    const extra = buildAdvancedWhereClause(farTable, this.extraWhere, [], []);
-    const extraSql = extra.clause.replace(/^ WHERE /, "");
-    const sql = `SELECT 1 FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(this.relation.throughTable)} ON ${qualifyColumn(this.relation.throughTable, this.relation.secondLocalKey)} = ${qualifyColumn(farTable, this.relation.secondKey)} WHERE ${qualifyColumn(this.relation.throughTable, this.relation.firstKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
-    return { sql, params: extra.params };
-  }
-  async get() {
-    const rows = await this.farRows();
-    return rows.map((row) => this.related.newFromRecord(row));
-  }
-  async first() {
-    const rows = await this.limit(1).get();
-    return rows[0] ?? null;
-  }
-  async count() {
-    const rows = await this.get();
-    return rows.length;
-  }
-  async pluck(column, keyBy) {
-    const rows = await this.farRows();
-    return keyBy === undefined ? projectPluck(rows, column) : projectPluck(rows, column, keyBy);
-  }
-  async value(column) {
-    const values = await this.limit(1).pluck(column);
-    return values[0] ?? null;
-  }
-  async farRows() {
-    return this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
-      ...this.extraOptions,
-      where: this.extraWhere
-    });
-  }
-  then(onfulfilled, onrejected) {
-    return thenGet(() => this.get(), onfulfilled, onrejected);
-  }
-}
-
-// ../../src/core/database/relationships.ts
-function hasMany(definition) {
-  return {
-    type: "hasMany",
-    ...definition
-  };
-}
-function hasOne(definition) {
-  return {
-    type: "hasOne",
-    ...definition
-  };
-}
-function belongsTo(definition) {
-  return {
-    type: "belongsTo",
-    ...definition
-  };
-}
-function hasManyThrough(definition) {
-  return {
-    type: "hasManyThrough",
-    throughParentKey: "__through_parent_id",
-    ...definition
-  };
-}
-function belongsToMany(definition) {
-  return {
-    type: "belongsToMany",
-    ...definition
-  };
-}
-function relationMatchKey(value) {
-  if (value === null || value === undefined) {
-    return "";
-  }
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
-  }
-  if (typeof value === "string" && /^-?\d+$/.test(value)) {
-    return BigInt(value).toString();
-  }
-  return String(value);
-}
-var relationLookupCache = new WeakMap;
-function indexedRelationLookup(map) {
-  const cached = relationLookupCache.get(map);
-  if (cached) {
-    return cached;
-  }
-  const indexed = new Map;
-  for (const [existing, value] of map) {
-    indexed.set(relationMatchKey(existing), value);
-  }
-  relationLookupCache.set(map, indexed);
-  return indexed;
-}
-function getByRelationKey(map, key) {
-  if (map.has(key)) {
-    return map.get(key);
-  }
-  const want = relationMatchKey(key);
-  if (want === "") {
-    return;
-  }
-  return indexedRelationLookup(map).get(want);
-}
-function indexHasManyRelation(parents, children, relation) {
-  const groups = new Map;
-  const originalKeys = new Map;
-  for (const parent of parents) {
-    const key = relationMatchKey(parent[relation.localKey]);
-    if (!groups.has(key)) {
-      groups.set(key, []);
-      originalKeys.set(key, parent[relation.localKey]);
-    }
-  }
-  for (const child of children) {
-    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
-    if (!group) {
-      continue;
-    }
-    group.push(child);
-  }
-  const result = new Map;
-  for (const [key, group] of groups) {
-    const original = originalKeys.get(key);
-    if (original !== undefined) {
-      result.set(original, group);
-    }
-  }
-  return result;
-}
-function indexHasOneRelation(parents, children, relation) {
-  const grouped = indexHasManyRelation(parents, children, relation);
-  const result = new Map;
-  for (const parent of parents) {
-    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
-    result.set(parent[relation.localKey], matches[0]);
-  }
-  return result;
-}
-function indexBelongsToRelation(children, parents, relation) {
-  const parentsById = new Map;
-  for (const parent of parents) {
-    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
-  }
-  const result = new Map;
-  for (const child of children) {
-    const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(relationMatchKey(foreignKey));
-    if (parent) {
-      result.set(foreignKey, parent);
-    }
-  }
-  return result;
-}
-function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
-  const relatedById = new Map;
-  for (const related of relatedRows) {
-    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
-  }
-  const groups = new Map;
-  const originalKeys = new Map;
-  for (const parent of parents) {
-    const key = relationMatchKey(parent[relation.parentKey]);
-    if (!groups.has(key)) {
-      groups.set(key, []);
-      originalKeys.set(key, parent[relation.parentKey]);
-    }
-  }
-  for (const pivot of pivotRows) {
-    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
-    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
-    if (!group || !related) {
-      continue;
-    }
-    group.push(related);
-  }
-  const result = new Map;
-  for (const [key, group] of groups) {
-    const original = originalKeys.get(key);
-    if (original !== undefined) {
-      result.set(original, group);
-    }
-  }
-  return result;
-}
-function morphMany(definition) {
-  return {
-    type: "morphMany",
-    ...definition
-  };
-}
-function morphOne(definition) {
-  return {
-    type: "morphOne",
-    ...definition
-  };
-}
-function morphTo(definition) {
-  return {
-    type: "morphTo",
-    ...definition
-  };
-}
-function indexMorphManyRelation(parents, children, relation) {
-  const groups = new Map;
-  const originalKeys = new Map;
-  for (const parent of parents) {
-    const key = relationMatchKey(parent[relation.localKey]);
-    if (!groups.has(key)) {
-      groups.set(key, []);
-      originalKeys.set(key, parent[relation.localKey]);
-    }
-  }
-  for (const child of children) {
-    if (child[relation.morphTypeKey] !== relation.morphType) {
-      continue;
-    }
-    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
-    if (!group) {
-      continue;
-    }
-    group.push(child);
-  }
-  const result = new Map;
-  for (const [key, group] of groups) {
-    const original = originalKeys.get(key);
-    if (original !== undefined) {
-      result.set(original, group);
-    }
-  }
-  return result;
-}
-function indexMorphOneRelation(parents, children, relation) {
-  const grouped = indexMorphManyRelation(parents, children, relation);
-  const result = new Map;
-  for (const parent of parents) {
-    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
-    result.set(parent[relation.localKey], matches[0]);
-  }
-  return result;
-}
-function indexHasManyThroughRelation(parents, children, relation) {
-  const throughKey = relation.throughParentKey ?? "__through_parent_id";
-  const grouped = new Map;
-  for (const child of children) {
-    const key = relationMatchKey(child[throughKey]);
-    if (key === "") {
-      continue;
-    }
-    const existing = grouped.get(key) ?? [];
-    const { [throughKey]: _through, ...far } = child;
-    existing.push(far);
-    grouped.set(key, existing);
-  }
-  const result = new Map;
-  for (const parent of parents) {
-    const key = relationMatchKey(parent[relation.localKey]);
-    result.set(parent[relation.localKey], grouped.get(key) ?? []);
-  }
-  return result;
-}
-function indexMorphToRelation(children, parentsByType, relation) {
-  const result = new Map;
-  for (const child of children) {
-    const morphType = String(child[relation.morphTypeKey]);
-    const parents = parentsByType.get(morphType);
-    if (!parents) {
-      continue;
-    }
-    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
-    if (parent) {
-      result.set(child[relation.morphIdKey], parent);
-    }
-  }
-  return result;
-}
-
-// ../../src/core/database/model.ts
-var modelRepositories = new WeakMap;
-var namedModels = new Map;
-var modelGlobalScopes = new WeakMap;
-var modelObservers = new WeakMap;
-var modelBooted = new WeakSet;
-function flattenRelationNames(relations) {
-  const names = [];
-  for (const item of relations) {
-    if (typeof item === "string") {
-      if (item.length > 0) {
-        names.push(item);
-      }
-      continue;
-    }
-    if (Array.isArray(item)) {
-      for (const nested of item) {
-        if (typeof nested === "string" && nested.length > 0) {
-          names.push(nested);
-        }
-      }
-    }
-  }
-  return names;
-}
-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);
-  }
-  await Promise.all([...grouped.entries()].map(async ([head, nested]) => {
-    const unloaded = models.filter((model) => model.loaded(head) === undefined);
-    if (unloaded.length > 0) {
-      const first = unloaded[0];
-      if (!first) {
-        return;
-      }
-      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) {
-      return;
-    }
-    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) {
-    throw new Error(`${model.name}.repository() is not implemented.`);
-  }
-  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;
-}
-function ensureBooted(model) {
-  if (modelBooted.has(model)) {
-    return;
-  }
-  modelBooted.add(model);
-  const boot = model.boot;
-  if (typeof boot === "function") {
-    boot.call(model);
-  }
-}
-function getGlobalScopes(model) {
-  return modelGlobalScopes.get(model) ?? [];
-}
-var PASSWORD_HASH_PATTERN = /^\$(?:2[aby]?|argon2(?:i|d|id)?)\$/;
-function isAlreadyHashed(value) {
-  return PASSWORD_HASH_PATTERN.test(value);
-}
-function hashCastValue(value) {
-  const plain = String(value);
-  if (isAlreadyHashed(plain)) {
-    return plain;
-  }
-  return Bun.password.hashSync(plain, { algorithm: "bcrypt", cost: 12 });
-}
-function hydrateValue(value, cast) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  switch (cast) {
-    case "date":
-    case "datetime":
-      return value instanceof Date ? value : new Date(String(value));
-    case "json":
-      return typeof value === "string" ? JSON.parse(value) : value;
-    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;
-  }
-}
-function dehydrateValue(value, cast) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  switch (cast) {
-    case "date":
-    case "datetime":
-      return value instanceof Date ? value : new Date(String(value));
-    case "json":
-      return typeof value === "string" ? value : JSON.stringify(value);
-    case "bool":
-    case "boolean":
-      return Boolean(value);
-    case "integer":
-    case "int":
-      return value === "" ? null : Number(value);
-    case "hashed":
-      return hashCastValue(value);
-    default:
-      return value;
-  }
-}
-function filterMassAssignable(fillable, guarded, input) {
-  if (fillable === undefined && guarded === undefined && Object.keys(input).length > 0) {
-    throw new Error("Mass assignment is not configured for this model. Declare static $fillable = [...] to allow specific columns, or static $guarded = [] to allow all of them.");
-  }
-  const resolvedGuarded = guarded ?? true;
-  if (fillable && fillable.length > 0) {
-    const allowed = new Set(fillable);
-    return Object.fromEntries(Object.entries(input).filter(([key]) => allowed.has(key)));
-  }
-  if (resolvedGuarded === true || resolvedGuarded.includes("*")) {
-    return {};
-  }
-  const blocked = new Set(resolvedGuarded);
-  return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
-}
-function applyCasts(values, casts, direction) {
-  if (Object.keys(casts).length === 0) {
-    return values;
-  }
-  const result = { ...values };
-  const castFn = direction === "hydrate" ? hydrateValue : dehydrateValue;
-  for (const [key, cast] of Object.entries(casts)) {
-    if (key in result && cast) {
-      result[key] = castFn(result[key], cast);
-    }
-  }
-  return result;
-}
-function castPluckedValue(modelClass, column, value) {
-  const cast = modelStatics(modelClass).$casts?.[column];
-  return cast ? hydrateValue(value, cast) : value;
-}
-function applyTimestampsOnCreate(columns, values, enabled) {
-  if (!enabled) {
-    return values;
-  }
-  const now = new Date;
-  const result = { ...values };
-  if (columns.includes("created_at")) {
-    result.created_at = now;
-  }
-  if (columns.includes("updated_at")) {
-    result.updated_at = now;
-  }
-  return result;
-}
-function applyTimestampsOnUpdate(columns, values, enabled) {
-  if (!enabled) {
-    return values;
-  }
-  const result = { ...values };
-  if (columns.includes("updated_at")) {
-    result.updated_at = new Date;
-  }
-  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 flattenRelationNames(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;
-  }
-  whereNotNull(column) {
-    this.query.whereNotNull(column);
-    return this;
-  }
-  whereIn(column, values) {
-    this.query.whereIn(column, values);
-    return this;
-  }
-  whereNotIn(column, values) {
-    this.query.whereNotIn(column, values);
-    return this;
-  }
-  groupBy(groupBy) {
-    this.query.groupBy(groupBy);
-    return this;
-  }
-  having(having) {
-    this.query.having(having);
-    return this;
-  }
-  join(left, right) {
-    this.query.join(left, right);
-    return this;
-  }
-  leftJoin(left, right) {
-    this.query.leftJoin(left, right);
-    return this;
-  }
-  async paginate(options) {
-    const { data, meta } = await this.query.paginate(options);
-    return { data: await this.hydrateRows(data), meta };
-  }
-  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;
-  }
-  withHasManyThrough(...args) {
-    this.query.withHasManyThrough(...args);
-    return this;
-  }
-  withTrashed() {
-    this.query.withTrashed();
-    return this;
-  }
-  onlyTrashed() {
-    this.query.onlyTrashed();
-    return this;
-  }
-  async get() {
-    return await this.hydrateRows(await this.query.get());
-  }
-  async hydrateRows(rows) {
-    const statics = modelStatics(this.modelClass);
-    const models = [];
-    for (const row of rows) {
-      const model = statics.newFromRecord(row, true);
-      for (const { name, relationQuery } of this.eager) {
-        model.setLoaded(name, relationQuery.hydrateEager(row, name));
-      }
-      models.push(model);
-    }
-    await Promise.all(models.map((model) => runObservers(model, "retrieved")));
-    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 count() {
-    return this.query.count();
-  }
-  async pluck(column, keyBy) {
-    if (keyBy === undefined) {
-      const values = await this.query.pluck(column);
-      return values.map((value) => castPluckedValue(this.modelClass, column, value));
-    }
-    const keyed = await this.query.pluck(column, keyBy);
-    const result = new Map;
-    for (const [key, value] of keyed) {
-      result.set(castPluckedValue(this.modelClass, keyBy, key), castPluckedValue(this.modelClass, column, value));
-    }
-    return result;
-  }
-  async value(column) {
-    const value = await this.query.value(column);
-    return castPluckedValue(this.modelClass, column, value);
-  }
-  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);
-  }
-  withCount(name, alias = `${name}_count`) {
-    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);
-    const exists = relationQuery.toExistsClause(repository.getTable().name);
-    if (!exists.sql.startsWith("SELECT 1 ")) {
-      throw new Error(`Cannot count relation ${name}: unexpected subquery shape.`);
-    }
-    this.query.withSubqueryCount(alias, `SELECT COUNT(*) ${exists.sql.slice("SELECT 1 ".length)}`, exists.params);
-    return this;
-  }
-  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;
-  static $fillable;
-  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;
-  }
-  get(key) {
-    return this.attributes[key];
-  }
-  get id() {
-    return this.attributes[this.primaryKey()];
-  }
-  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() {
-    return this.repository.getTable().primaryKey;
-  }
-  static primaryKeyField() {
-    return resolveModelRepository(this).getTable().primaryKey;
-  }
-  static hydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
-    return applyCasts(attributes, casts, "hydrate");
-  }
-  static dehydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
-    return applyCasts(attributes, casts, "dehydrate");
-  }
-  static fromRecord(record, repository, exists = true) {
-    const statics = modelStatics(this);
-    const hydrated = statics.hydrateAttributes(record);
-    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) ?? [];
-    modelGlobalScopes.set(this, [
-      ...existing,
-      scope
-    ]);
-  }
-  static repository() {
-    return resolveModelRepository(this);
-  }
-  static query() {
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
-    let query = repository.query();
-    for (const scope of getGlobalScopes(this)) {
-      query = scope(query);
-    }
-    return new ModelQuery(this, query);
-  }
-  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),
-      ...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);
-    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 withTrashed() {
-    return Model.query.call(this).withTrashed();
-  }
-  static onlyTrashed() {
-    return Model.query.call(this).onlyTrashed();
-  }
-  static async chunk(count, callback) {
-    const statics = modelStatics(this);
-    ensureBooted(this);
-    await resolveModelRepository(this).chunk(count, async (rows) => {
-      return await callback(rows.map((row) => statics.newFromRecord(row, true)));
-    });
-  }
-  static async cursorPaginate(options) {
-    const statics = modelStatics(this);
-    ensureBooted(this);
-    const page = await resolveModelRepository(this).cursorPaginate({
-      perPage: options.perPage,
-      cursor: options.cursor
-    });
-    return {
-      data: page.data.map((row) => statics.newFromRecord(row, true)),
-      meta: page.meta
-    };
-  }
-  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 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);
-    if (model) {
-      return model;
-    }
-    throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
-  }
-  static async all(options = {}) {
-    let query = Model.query.call(this);
-    if (options.orderBy) {
-      query = query.orderBy(options.orderBy);
-    }
-    if (options.limit !== undefined) {
-      query = query.limit(options.limit);
-    }
-    return query.get();
-  }
-  static where(where) {
-    return Model.query.call(this).where(where);
-  }
-  static async count() {
-    return Model.query.call(this).count();
-  }
-  static pluck(column, keyBy) {
-    const query = Model.query.call(this);
-    return keyBy === undefined ? query.pluck(column) : query.pluck(column, keyBy);
-  }
-  static value(column) {
-    return Model.query.call(this).value(column);
-  }
-  static async firstWhere(where, options = {}) {
-    let query = Model.query.call(this).where(where);
-    if (options.orderBy) {
-      query = query.orderBy(options.orderBy);
-    }
-    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 findExisting = () => Model.firstWhere.call(this, where);
-    const existing = await findExisting();
-    if (existing) {
-      return existing;
-    }
-    try {
-      return await Model.create.call(this, { ...where, ...values });
-    } catch (error) {
-      if (!(error instanceof ConflictError)) {
-        throw error;
-      }
-      const raced = await findExisting();
-      if (!raced) {
-        throw error;
-      }
-      return raced;
-    }
-  }
-  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();
-    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 record = await this.repository.updateByIdOrThrow(this.id, changes);
-      this.attributes = ModelClass.hydrateAttributes(record);
-      await runObservers(this, "updated");
-      await runObservers(this, "saved");
-      return this;
-    }
-    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
-    const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = ModelClass.dehydrateAttributes(withTimestamps);
-    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) {
-    const ModelClass = modelStatics(this.constructor);
-    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, changes);
-    Object.assign(this.attributes, assignable);
-    return await this.save();
-  }
-  async delete() {
-    if (await runObservers(this, "deleting") === false) {
-      return false;
-    }
-    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);
-  }
-  async restore() {
-    const ModelClass = modelStatics(this.constructor);
-    const record = await this.repository.restoreById(this.id);
-    if (!record) {
-      return null;
-    }
-    this.attributes = ModelClass.hydrateAttributes(record);
-    return this;
-  }
-  async loadHasMany(as, relation, childRepository, options = {}) {
-    const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = getByRelationKey(grouped, this.attributes[relation.localKey]) ?? [];
-    return Object.assign(this, { [as]: loaded });
-  }
-  async loadHasOne(as, relation, childRepository, options = {}) {
-    const loaded = await this.loadHasMany(as, relation, childRepository, { ...options, limit: 1 });
-    const value = loaded[as]?.[0];
-    return Object.assign(this, { [as]: value });
-  }
-  async loadBelongsTo(as, relation, parentRepository, options = {}) {
-    const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = getByRelationKey(grouped, this.attributes[relation.foreignKey]);
-    return Object.assign(this, { [as]: loaded });
-  }
-  async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
-    const connection = this.repository.getConnection();
-    const parentId = this.attributes[relation.parentKey];
-    const pivotRows = await connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = $1`, [parentId]);
-    if (pivotRows.length === 0) {
-      return Object.assign(this, { [as]: [] });
-    }
-    const relatedIds = [
-      ...new Set(pivotRows.map((row) => row[relation.relatedPivotKey]))
-    ];
-    const relatedRows = await relatedRepository.withConnection(connection).findAll({
-      ...options,
-      where: {
-        [relation.relatedKey]: relatedIds
-      }
-    });
-    const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = getByRelationKey(grouped, 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
-    }));
-  }
-  hasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
-    const table = this.repository.getTable();
-    const relatedClass = resolveRelated(related);
-    const throughClass = resolveRelated(through);
-    const throughTable = throughClass.repository().getTable();
-    return new HasManyThroughRelationQuery(this, relatedClass, hasManyThrough({
-      name: relatedClass.repository().getTable().name,
-      throughTable: throughTable.name,
-      localKey: localKey ?? table.primaryKey,
-      firstKey: firstKey ?? foreignKeyFromTable(table.name),
-      secondLocalKey: secondLocalKey ?? throughTable.primaryKey,
-      secondKey: secondKey ?? foreignKeyFromTable(throughTable.name)
-    }));
-  }
-  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 (the calling method name is not available at runtime).`);
-    }
-    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 flattenRelationNames(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;
-  }
-}
-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;
-}
-export {
-  BelongsToManyRelationQuery,
-  BelongsToRelationQuery,
-  HasManyRelationQuery,
-  HasManyThroughRelationQuery,
-  HasOneRelationQuery,
-  Model,
-  ModelQuery,
-  MorphManyRelationQuery,
-  MorphOneRelationQuery,
-  MorphToRelationQuery,
-  applyCasts,
-  dehydrateValue,
-  filterMassAssignable,
-  hydrateValue,
-  registerModelClass,
-  registerModelRepository
-};
+export * from "../../index.js";