@getstrata/core 1.0.5 → 1.0.7

package/dist/entries/database/model.js

@@ -1,6 +1,6 @@
 // @bun
 // ../../src/core/database/model.ts
-import { NotFoundError } from "@getstrata/core/errors/http";
+import { ConflictError, NotFoundError } from "@getstrata/core/errors/http";
 
 // ../../src/core/database/inflection.ts
 function singularize(word) {
@@ -60,15 +60,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`);
   }
@@ -82,9 +99,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)}`);
   }
@@ -304,6 +331,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)}`;
@@ -398,6 +429,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]
@@ -458,6 +535,30 @@ function buildDeleteByIdQuery(table, id) {
   };
 }
 
+// ../../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;
@@ -474,6 +575,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;
@@ -539,6 +646,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);
   }
@@ -604,6 +717,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);
   }
@@ -650,6 +770,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;
@@ -659,11 +796,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);
@@ -751,6 +884,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);
   }
@@ -834,13 +992,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() {
@@ -848,12 +1008,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);
@@ -904,6 +1065,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);
   }
@@ -952,15 +1119,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);
@@ -1007,10 +1190,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() {
@@ -1021,6 +1201,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);
   }
@@ -1407,6 +1601,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;
@@ -1446,12 +1651,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);
@@ -1476,6 +1684,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;
@@ -1549,10 +1761,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;
@@ -1610,8 +1850,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);
@@ -1630,6 +1872,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();
@@ -1644,6 +1905,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);
@@ -1877,6 +2155,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) {
@@ -1892,11 +2180,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);

package/dist/entries/database/query.js

@@ -37,15 +37,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`);
   }
@@ -59,9 +76,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)}`);
   }
@@ -281,6 +308,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)}`;
@@ -375,6 +406,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]
@@ -440,6 +517,7 @@ export {
   buildCountQuery,
   buildDeleteByIdQuery,
   buildGroupedCountQuery,
+  buildIncrementQuery,
   buildInsertQuery,
   buildJoinClause,
   buildOrderByClause,
@@ -449,6 +527,7 @@ export {
   buildSelectQuery,
   buildSoftDeleteByIdQuery,
   buildUpdateQuery,
+  buildUpsertQuery,
   buildWhereClause,
   parseQualifiedColumn,
   qualifyColumn,