@getstrata/core 1.0.5 → 1.0.7

package/dist/index.js

@@ -2071,6 +2071,9 @@ function assertSafeIdentifier(identifier) {
   }
   return identifier;
 }
+function quoteIdentifierFor(dialect, column) {
+  return dialect.quoteIdentifier(column);
+}
 var postgresDialect = {
   driver: "pgsql",
   placeholder(index) {
@@ -2096,6 +2099,17 @@ var postgresDialect = {
   },
   castToText(expression) {
     return `${expression}::text`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+    if (updateColumns.length === 0) {
+      return ` ON CONFLICT (${target}) DO NOTHING`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = excluded.${quoted}`;
+    }).join(", ");
+    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
   }
 };
 var mysqlDialect = {
@@ -2123,6 +2137,17 @@ var mysqlDialect = {
   },
   castToText(expression) {
     return `CAST(${expression} AS CHAR)`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    if (updateColumns.length === 0) {
+      const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
+      return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = VALUES(${quoted})`;
+    }).join(", ");
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
   }
 };
 var sqliteDialect = {
@@ -2150,6 +2175,17 @@ var sqliteDialect = {
   },
   castToText(expression) {
     return `CAST(${expression} AS TEXT)`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+    if (updateColumns.length === 0) {
+      return ` ON CONFLICT (${target}) DO NOTHING`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = excluded.${quoted}`;
+    }).join(", ");
+    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
   }
 };
 var dialects = {
@@ -2216,15 +2252,32 @@ function pushParam(values, value) {
   values.push(value);
   return currentSqlDialect().placeholder(values.length);
 }
-function buildInClause(column, values, params) {
+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 "1 = 0";
+    return negated ? "1 = 1" : "1 = 0";
   }
   const placeholders = values.map((value) => pushParam(params, value)).join(", ");
-  return `${column} IN (${placeholders})`;
+  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`);
   }
@@ -2238,9 +2291,19 @@ function buildOperatorClauses(column, operator, params) {
       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)}`);
   }
@@ -2460,6 +2523,10 @@ function buildSelectList(table, select, params = []) {
     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)}`;
@@ -2554,6 +2621,52 @@ function buildInsertQuery(table, values) {
     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]
@@ -2857,6 +2970,30 @@ function indexMorphToRelation(children, parentsByType, relation) {
   return result;
 }
 
+// ../../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/whereBuilder.ts
 class WhereBuilder {
   nodes = [];
@@ -2934,6 +3071,22 @@ class RepositoryQuery {
   whereNotNull(column) {
     return this.where({ [column]: { isNull: false } });
   }
+  whereNotIn(column, values) {
+    return this.where({ [column]: { notIn: values } });
+  }
+  withSubqueryCount(alias, sql, params = []) {
+    const table = this.repository.getTable();
+    const existing = this.queryOptions.select ?? table.columns.map((column) => ({
+      kind: "column",
+      table: table.name,
+      column
+    }));
+    this.queryOptions = {
+      ...this.queryOptions,
+      select: [...existing, { kind: "subqueryCount", sql, params, as: alias }]
+    };
+    return this;
+  }
   whereIn(column, values) {
     return this.where({ [column]: values });
   }
@@ -3054,6 +3207,28 @@ class RepositoryQuery {
   async count() {
     return await this.repository.count(this.buildOptions());
   }
+  async pluck(column, keyBy) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, keyBy === undefined || keyBy === column ? [column] : [column, keyBy])
+    });
+    if (keyBy === undefined) {
+      return projectPluck(rows, column);
+    }
+    return projectPluck(rows, column, keyBy);
+  }
+  async value(column) {
+    const rows = await this.repository.findAll({
+      ...this.buildOptions(),
+      select: uniqueColumnSelect(this.repository.getTable().name, [column]),
+      limit: 1
+    });
+    const row = rows[0];
+    if (row === undefined) {
+      return null;
+    }
+    return row[column];
+  }
   async attachToRows(rows) {
     return await this.attach(rows);
   }
@@ -3220,6 +3395,29 @@ class BaseRepository {
       offset += count;
     }
   }
+  async chunkById(count, callback, options = {}) {
+    if (!Number.isInteger(count) || count <= 0) {
+      throw new Error("Chunk size must be a positive integer.");
+    }
+    let cursor;
+    while (true) {
+      const { data, meta } = await this.cursorPaginate({
+        ...options,
+        perPage: count,
+        ...cursor === undefined ? {} : { cursor }
+      });
+      if (data.length === 0) {
+        return;
+      }
+      if (await callback(data) === false) {
+        return;
+      }
+      if (!meta.has_more || meta.next_cursor === null) {
+        return;
+      }
+      cursor = meta.next_cursor;
+    }
+  }
   async cursorPaginate(options) {
     const {
       perPage,
@@ -3283,6 +3481,23 @@ class BaseRepository {
     const [record] = await this.findAll({ ...options, where, limit: 1 });
     return record ?? null;
   }
+  async upsert(values, conflictColumns, updateColumns) {
+    return await withDatabaseErrorHandling(async () => {
+      const { text, params } = buildUpsertQuery(this.table, values, conflictColumns, updateColumns);
+      const [record] = await this.connection.unsafe(text, params);
+      return record ?? null;
+    });
+  }
+  async incrementById(id, column, amount = 1, extra = {}) {
+    return await withDatabaseErrorHandling(async () => {
+      const { text, params } = buildIncrementQuery(this.table, id, column, amount, extra);
+      const [record] = await this.connection.unsafe(text, params);
+      return record ?? null;
+    });
+  }
+  async decrementById(id, column, amount = 1, extra = {}) {
+    return await this.incrementById(id, column, -amount, extra);
+  }
   async create(values) {
     return await withDatabaseErrorHandling(async () => {
       const { text, params } = buildInsertQuery(this.table, values);
@@ -3385,7 +3600,23 @@ class BaseRepository {
   async averageExpression(expression, alias, where = {}) {
     const { text, params } = buildProjectionQuery(this.table, expression, alias, { where });
     const [row] = await this.connection.unsafe(text, params);
-    return Math.round(Number(row?.[alias] ?? 0));
+    return Number(row?.[alias] ?? 0);
+  }
+  async sum(column, where = {}) {
+    return await this.aggregateColumn("SUM", column, where);
+  }
+  async avg(column, where = {}) {
+    return await this.aggregateColumn("AVG", column, where);
+  }
+  async min(column, where = {}) {
+    return await this.aggregateColumn("MIN", column, where);
+  }
+  async max(column, where = {}) {
+    return await this.aggregateColumn("MAX", column, where);
+  }
+  async aggregateColumn(fn, column, where) {
+    const qualifiedColumn = qualifyColumn(this.table.name, column);
+    return await this.averageExpression(`${fn}(${qualifiedColumn})`, "value", where);
   }
   async pluckNumberValues(expression, alias, options = {}) {
     const { text, params } = buildProjectionQuery(this.table, expression, alias, options);
@@ -3882,6 +4113,12 @@ function ownerId(owner, ownerKey) {
 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;
@@ -3947,6 +4184,12 @@ class HasManyRelationQuery {
   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);
   }
@@ -4012,6 +4255,13 @@ class HasOneRelationQuery {
   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);
   }
@@ -4058,6 +4308,23 @@ class BelongsToRelationQuery {
     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;
@@ -4067,11 +4334,7 @@ class BelongsToRelationQuery {
     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();
+    return query;
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -4159,6 +4422,31 @@ class BelongsToManyRelationQuery {
     const rows = await this.connection().unsafe(`SELECT COUNT(*) AS count FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1`, [parentId]);
     return Number(rows[0]?.count ?? 0);
   }
+  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 ${this.relation.pivotTable} WHERE ${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);
   }
@@ -4242,13 +4530,15 @@ class MorphManyRelationQuery {
     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({
+  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
-    })).get();
+    }));
+  }
+  async get() {
+    const rows = await this.scopedQuery().get();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -4256,12 +4546,13 @@ class MorphManyRelationQuery {
     return rows[0] ?? null;
   }
   async count() {
-    const repository = this.related.repository().withConnection(this.parent.getRepository().getConnection());
-    return repository.query(asWhere({
-      [this.relation.morphTypeKey]: this.relation.morphType,
-      [this.relation.morphIdKey]: this.parent.get(this.relation.localKey),
-      ...this.extraWhere
-    })).count();
+    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);
@@ -4312,6 +4603,12 @@ class MorphOneRelationQuery {
   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);
   }
@@ -4360,15 +4657,31 @@ class MorphToRelationQuery {
     };
   }
   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.relatedByType[type];
+    const related = this.relatedForCurrentType();
     if (!related || id === null || id === undefined) {
       return null;
     }
     const table = related.repository().getTable();
-    const row = await related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere })).first();
-    return row ? related.newFromRecord(row) : null;
+    return related.repository().withConnection(this.parent.getRepository().getConnection()).query(asWhere({ [table.primaryKey]: id, ...this.extraWhere }));
   }
   then(onfulfilled, onrejected) {
     return thenGet(() => this.get(), onfulfilled, onrejected);
@@ -4415,10 +4728,7 @@ class HasManyThroughRelationQuery {
     return { sql, params: extra.params };
   }
   async get() {
-    const rows = await this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
-      ...this.extraOptions,
-      where: this.extraWhere
-    });
+    const rows = await this.farRows();
     return rows.map((row) => this.related.newFromRecord(row));
   }
   async first() {
@@ -4429,6 +4739,20 @@ class HasManyThroughRelationQuery {
     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);
   }
@@ -4572,6 +4896,17 @@ function ensureBooted(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: 10 });
+}
 function hydrateValue(value, cast) {
   if (value === null || value === undefined) {
     return value;
@@ -4611,12 +4946,15 @@ function dehydrateValue(value, cast) {
     case "int":
       return value === "" ? null : Number(value);
     case "hashed":
-      return value;
+      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);
@@ -4641,6 +4979,10 @@ function applyCasts(values, casts, direction) {
   }
   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;
@@ -4714,10 +5056,38 @@ class ModelQuery {
     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;
@@ -4775,8 +5145,10 @@ class ModelQuery {
     return this;
   }
   async get() {
+    return await this.hydrateRows(await this.query.get());
+  }
+  async hydrateRows(rows) {
     const statics = modelStatics(this.modelClass);
-    const rows = await this.query.get();
     const models = [];
     for (const row of rows) {
       const model = statics.newFromRecord(row, true);
@@ -4795,6 +5167,25 @@ class ModelQuery {
     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();
@@ -4809,6 +5200,23 @@ class ModelQuery {
   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);
@@ -5042,6 +5450,16 @@ class Model {
   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) {
@@ -5057,11 +5475,23 @@ class Model {
     return modelStatics(this).newFromRecord({ ...where, ...values }, false);
   }
   static async firstOrCreate(where, values = {}) {
-    const existing = await Model.firstWhere.call(this, where);
+    const findExisting = () => Model.firstWhere.call(this, where);
+    const existing = await findExisting();
     if (existing) {
       return existing;
     }
-    return Model.create.call(this, { ...where, ...values });
+    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);
@@ -7431,7 +7861,7 @@ function normalizeMimeType(mimeType) {
 function isAllowedMimeType(mimeType) {
   const normalized = normalizeMimeType(mimeType);
   if (!normalized || normalized === "application/octet-stream") {
-    return true;
+    return envFlagEnabled(process.env.UPLOAD_ALLOW_UNKNOWN_MIME);
   }
   return ALLOWED_UPLOAD_MIME_TYPES.has(normalized);
 }
@@ -10183,6 +10613,7 @@ export {
   parseQualifiedColumn,
   pivotTableName,
   policyGate,
+  projectPluck,
   prometheusRegistry,
   qualifyColumn,
   queue,
@@ -10300,6 +10731,7 @@ export {
   toResourceCollection,
   traceContextStorage,
   trustForwardedFor,
+  uniqueColumnSelect,
   unregisterNamedConnection,
   useSqlDialect,
   validateObject,