@getstrata/core 2.2.1 → 2.2.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @getstrata/core changelog
 
+## 2.2.2
+
+- orm improvments
+
 ## 2.2.1
 
 F02 — complete queue durability. Queues have leased reservations, recovery and fenced acknowledgement, but still use Redis lists. Persisted retry schedules, execution deadlines, cancellation and the planned Streams migration remain unfinished. Retries currently wait inside the running worker.

package/dist/core/database/baseRepository.d.ts

@@ -45,6 +45,11 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     incrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     decrementById(id: TEntity[PrimaryKey], column: keyof TEntity & string, amount?: number, extra?: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     create(values: MutationValues<TEntity>): Promise<TEntity>;
+    /** Set-based writes intentionally bypass per-row model observers and write casts. */
+    updateWhere(changes: UpdateValues<TEntity, PrimaryKey>, options: QueryOptions<TEntity>): Promise<number>;
+    deleteWhere(options: QueryOptions<TEntity>): Promise<number>;
+    updateWhereReturning<K extends keyof TEntity & string>(changes: UpdateValues<TEntity, PrimaryKey>, columns: readonly K[], options: QueryOptions<TEntity>): Promise<Pick<TEntity, K>[]>;
+    private executeConditionalWrite;
     updateById(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>): Promise<TEntity | null>;
     updateByIdOrThrow(id: TEntity[PrimaryKey], changes: UpdateValues<TEntity, PrimaryKey>, errorFactory?: ErrorFactory<TEntity[PrimaryKey]>): Promise<TEntity>;
     deleteById(id: TEntity[PrimaryKey]): Promise<boolean>;

package/dist/core/database/model.d.ts

@@ -4,7 +4,7 @@ import { BelongsToManyRelationQuery, BelongsToRelationQuery, HasManyRelationQuer
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation } from "./relationships.ts";
 import type { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
-import type { ModelWhere, ModelWriteValues, QueryOptions, QueryWhere } from "./types.ts";
+import type { ModelWhere, ModelWriteValues, QueryLockOptions, QueryOptions, QueryWhere } from "./types.ts";
 type CastType = "date" | "datetime" | "json" | "bool" | "boolean" | "integer" | "int" | "hashed";
 type LoadedAttributes = Record<string, unknown>;
 type ModelCasts = Partial<Record<string, CastType>>;
@@ -70,6 +70,8 @@ declare class ModelQuery<TModel extends object = AnyModel, TCounts extends strin
     /** Qualified/dynamic filters retain existing SQL semantics through an explicit escape hatch. */
     whereDynamic(input: QueryWhere<object>): this;
     select<K extends keyof ModelAttributes<TModel> & string>(...columns: readonly K[]): ModelProjection<ModelAttributes<TModel>, K>;
+    lockForUpdate(options?: QueryLockOptions): this;
+    sharedLock(options?: QueryLockOptions): this;
     orderBy(orderBy: QueryOptions<ModelAttributes<TModel>>["orderBy"]): this;
     limit(limit: number): this;
     offset(offset: number): this;

package/dist/core/database/query.d.ts

@@ -68,4 +68,9 @@ declare function buildDeleteByIdQuery<TEntity extends object, PrimaryKey extends
     text: string;
     params: unknown[];
 };
-export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildIncrementQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildUpsertQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };
+/** Single-statement writes: predicates and protected scopes stay in the mutation. */
+declare function buildConditionalWriteQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string>(table: TableDefinition<TEntity, PrimaryKey>, operation: "update" | "delete", changes: UpdateValues<TEntity, PrimaryKey>, options: QueryOptions<TEntity>, returning?: readonly (keyof TEntity & string)[]): {
+    text: string;
+    params: unknown[];
+};
+export { assertSafeProjectionExpression, buildAdvancedWhereClause, buildConditionalWriteQuery, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildIncrementQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildUpsertQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, };

package/dist/core/database/repositoryQuery.d.ts

@@ -1,7 +1,7 @@
 import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
 import type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
-import type { QueryOptions, QueryWhere } from "./types.ts";
+import type { QueryLockOptions, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
 declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
@@ -16,6 +16,8 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     /** Preserve completed scope predicates separately from subsequent caller OR conditions. */
     protectWhere(): this;
     orWhere(input: QueryWhere<TEntity> | ((builder: WhereBuilder<TEntity>) => void)): this;
+    lockForUpdate(options?: QueryLockOptions): this;
+    sharedLock(options?: QueryLockOptions): this;
     orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
     limit(limit: number): this;
     whereNull(column: keyof TEntity & string): this;
@@ -39,6 +41,10 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     withHasManyThrough<TFar extends object, LocalKey extends keyof TEntity & string, SecondKey extends keyof TFar & string, Alias extends string>(as: Alias, relation: HasManyThroughRelation<TEntity, TFar, LocalKey, string, string, SecondKey>, farRepository: BaseRepository<TFar, keyof TFar & string>, options?: Omit<QueryOptions<TFar>, "where">): this;
     withTrashed(): this;
     onlyTrashed(): this;
+    update(changes: UpdateValues<TEntity, PrimaryKey>): Promise<number>;
+    updateReturning<K extends keyof TEntity & string>(changes: UpdateValues<TEntity, PrimaryKey>, ...columns: K[]): Promise<Pick<TEntity, K>[]>;
+    delete(): Promise<number>;
+    private assertNoMutationEagerLoads;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     count(): Promise<number>;

package/dist/core/database/schema/blueprint.d.ts

@@ -30,6 +30,8 @@ declare class Blueprint {
     readonly droppedIndexes: string[];
     constructor(table: string, action: BlueprintAction);
     id(name?: string): ColumnDefinition;
+    /** Generated 64-bit primary key; does not change existing id() migrations. */
+    bigId(name?: string): ColumnDefinition;
     string(name: string, length?: number): ColumnDefinition;
     text(name: string): ColumnDefinition;
     boolean(name: string): ColumnDefinition;

package/dist/core/database/schema/columnDefinition.d.ts

@@ -1,4 +1,4 @@
-type ColumnKind = "id" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
+type ColumnKind = "id" | "bigId" | "string" | "text" | "boolean" | "integer" | "bigInteger" | "timestamp" | "json" | "jsonb" | "foreignId";
 interface ForeignKeyOptions {
     referencesTable: string;
     referencesColumn: string;

package/dist/core/database/types.d.ts

@@ -78,7 +78,16 @@ type QuerySelectItem = {
     query: string;
     as: string;
 };
+type QueryLockOptions = {
+    wait?: "wait" | "nowait" | "skipLocked";
+    /** PostgreSQL table names in this query; aliases are not inferred. */
+    of?: readonly string[];
+};
+type QueryLock = QueryLockOptions & {
+    mode: "update" | "share";
+};
 interface QueryOptions<TEntity extends object> {
+    lock?: QueryLock;
     whereNodes?: WhereNode<TEntity>[];
     where?: QueryWhere<TEntity>;
     orderBy?: QueryOrder<TEntity> | QueryOrder<TEntity>[] | QueryOrderShorthand<TEntity>;
@@ -93,4 +102,4 @@ interface QueryOptions<TEntity extends object> {
 }
 type MutationValues<TEntity> = Partial<TEntity>;
 type UpdateValues<TEntity, PrimaryKey extends keyof TEntity & string = keyof TEntity & string> = Partial<Omit<TEntity, PrimaryKey>>;
-export type { DatabaseComparable, DatabaseScalar, ModelWhere, ModelWriteValues, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };
+export type { DatabaseComparable, DatabaseScalar, ModelWhere, ModelWriteValues, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryLock, QueryLockOptions, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, };

package/dist/entries/database/query.js

@@ -331,6 +331,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -341,8 +366,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -511,9 +537,52 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 export {
   assertSafeProjectionExpression,
   buildAdvancedWhereClause,
+  buildConditionalWriteQuery,
   buildCountQuery,
   buildDeleteByIdQuery,
   buildGroupedCountQuery,

package/dist/entries/database/repositoryQuery.js

@@ -355,6 +355,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -365,8 +390,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -535,6 +561,48 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
@@ -856,6 +924,20 @@ class RepositoryQuery {
     this.whereNodes.push({ kind: "or", where: input });
     return this;
   }
+  lockForUpdate(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "update" }
+    };
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "share" }
+    };
+    return this;
+  }
   orderBy(orderBy) {
     this.queryOptions = { ...this.queryOptions, orderBy };
     return this;
@@ -995,6 +1077,22 @@ class RepositoryQuery {
     this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
     return this;
   }
+  async update(changes) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhere(changes, this.buildOptions());
+  }
+  async updateReturning(changes, ...columns) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhereReturning(changes, columns, this.buildOptions());
+  }
+  async delete() {
+    this.assertNoMutationEagerLoads();
+    return this.repository.deleteWhere(this.buildOptions());
+  }
+  assertNoMutationEagerLoads() {
+    if (this.eagerLoads.length)
+      throw new Error("Conditional writes do not support eager loading.");
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);

package/dist/entries/database/schema.js

@@ -340,6 +340,13 @@ class Blueprint {
     this.columns.push(column);
     return column;
   }
+  bigId(name = "id") {
+    const column = new ColumnDefinition(name, "bigId");
+    column.primary();
+    column.autoIncrement = true;
+    this.columns.push(column);
+    return column;
+  }
   string(name, length) {
     if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
       throw new Error("String length must be a positive safe integer.");
@@ -486,6 +493,8 @@ init_dialect();
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
   switch (column.kind) {
+    case "bigId":
+      return driver === "pgsql" ? "BIGSERIAL" : compileIdType(driver);
     case "id":
       return compileIdType(driver);
     case "string":

package/dist/entries/database/sqliteConnection.js

@@ -69,7 +69,7 @@ function createSqliteConnection(filename) {
   const transactions = new WeakSet;
   function execute(query, params) {
     const statement = db.query(query);
-    const args = [...params];
+    const args = params.map((value) => value instanceof Date ? value.toISOString() : value);
     if (isRowReturning(query))
       return statement.all(...args);
     statement.run(...args);

package/dist/index.js

@@ -4463,6 +4463,31 @@ function getDefinedColumnEntries(table, values, options = {}) {
     return [[column, value]];
   });
 }
+function buildSelectLock(table, options) {
+  const lock = options.lock;
+  if (!lock)
+    return "";
+  const driver = currentSqlDialect().driver;
+  if (driver === "sqlite")
+    throw new Error("Row locks are not supported on SQLite; use an explicit write transaction.");
+  if (lock.mode !== "update" && lock.mode !== "share")
+    throw new TypeError("Invalid row lock mode.");
+  if (lock.wait !== undefined && !["wait", "nowait", "skipLocked"].includes(lock.wait))
+    throw new TypeError("Invalid row lock wait policy.");
+  if (options.groupBy || options.having)
+    throw new Error("Row locks cannot be combined with grouped/aggregate queries.");
+  let target = "";
+  if (lock.of !== undefined) {
+    if (driver !== "pgsql")
+      throw new Error("Row lock targets are supported only on PostgreSQL.");
+    const tables = [table.name, ...(options.joins ?? []).map((join) => join.table)];
+    if (!lock.of.length || lock.of.some((name) => !tables.includes(name)))
+      throw new TypeError("Row lock targets must name tables in this query.");
+    target = ` OF ${lock.of.map(quoteIdentifier).join(", ")}`;
+  }
+  const wait = lock.wait === "nowait" ? " NOWAIT" : lock.wait === "skipLocked" ? " SKIP LOCKED" : "";
+  return ` FOR ${lock.mode === "update" ? "UPDATE" : "SHARE"}${target}${wait}`;
+}
 function buildSelectQuery(table, options = {}, whereNodes = []) {
   const params = [];
   const columns = buildSelectList(table, options.select, params);
@@ -4473,8 +4498,9 @@ function buildSelectQuery(table, options = {}, whereNodes = []) {
   const orderBy = buildOrderByClause(table.name, options.orderBy ?? table.defaultOrderBy);
   const limit = buildLimitClause(options.limit);
   const offset = buildOffsetClause(options.offset);
+  const lock = buildSelectLock(table, options);
   return {
-    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}`,
+    text: `SELECT ${columns} FROM ${quoteIdentifier(table.name)}${joins}${clause}${groupBy}${havingClause}${orderBy}${limit}${offset}${lock}`,
     params
   };
 }
@@ -4643,6 +4669,48 @@ function buildDeleteByIdQuery(table, id) {
     params
   };
 }
+function buildConditionalWriteQuery(table, operation, changes, options, returning) {
+  for (const key of [
+    "joins",
+    "groupBy",
+    "having",
+    "select",
+    "orderBy",
+    "limit",
+    "offset",
+    "lock"
+  ]) {
+    if (options[key] !== undefined)
+      throw new Error(`Conditional writes do not support ${key}.`);
+  }
+  const params = [];
+  const predicate = buildAdvancedWhereClause(table.name, options.where ?? {}, options.whereNodes ?? []);
+  if (!predicate.clause)
+    throw new Error("Conditional writes require an explicit predicate.");
+  if (returning !== undefined && currentSqlDialect().driver === "mysql")
+    throw new Error("Mutation RETURNING is not supported on MySQL.");
+  const columns = returning ?? [table.primaryKey];
+  if (!columns.length || columns.some((column) => !table.columns.includes(column)))
+    throw new Error("RETURNING columns must be nonempty declared table columns.");
+  const deletedAt = resolveSoftDeleteColumn(table);
+  const values = operation === "delete" && deletedAt ? { [deletedAt]: new Date } : changes;
+  let prefix;
+  if (operation === "update" || deletedAt) {
+    const entries = Object.entries(values).filter(([, value]) => value !== undefined);
+    if (!entries.length)
+      throw new Error("Conditional updates require at least one value.");
+    if (entries.some(([column]) => column === table.primaryKey || !table.columns.includes(column)))
+      throw new Error("Conditional updates require declared non-primary-key columns.");
+    const assignments = entries.map(([column, value]) => `${quoteIdentifier(column)} = ${pushParam(params, value)}`);
+    prefix = `UPDATE ${quoteIdentifier(table.name)} SET ${assignments.join(", ")}`;
+  } else
+    prefix = `DELETE FROM ${quoteIdentifier(table.name)}`;
+  const { clause } = buildQueryWhereClause(table, options, options.whereNodes ?? [], params);
+  return {
+    text: prefix + clause + returningSuffix(columns.map(quoteIdentifier).join(", ")),
+    params
+  };
+}
 
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
@@ -4991,6 +5059,20 @@ class RepositoryQuery {
     this.whereNodes.push({ kind: "or", where: input });
     return this;
   }
+  lockForUpdate(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "update" }
+    };
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.queryOptions = {
+      ...this.queryOptions,
+      lock: { ...options, of: options.of ? [...options.of] : undefined, mode: "share" }
+    };
+    return this;
+  }
   orderBy(orderBy) {
     this.queryOptions = { ...this.queryOptions, orderBy };
     return this;
@@ -5130,6 +5212,22 @@ class RepositoryQuery {
     this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
     return this;
   }
+  async update(changes) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhere(changes, this.buildOptions());
+  }
+  async updateReturning(changes, ...columns) {
+    this.assertNoMutationEagerLoads();
+    return this.repository.updateWhereReturning(changes, columns, this.buildOptions());
+  }
+  async delete() {
+    this.assertNoMutationEagerLoads();
+    return this.repository.deleteWhere(this.buildOptions());
+  }
+  assertNoMutationEagerLoads() {
+    if (this.eagerLoads.length)
+      throw new Error("Conditional writes do not support eager loading.");
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -5335,11 +5433,16 @@ class BaseRepository {
     return runInTransaction(operation);
   }
   async count(options = {}) {
+    if (options.lock)
+      throw new Error("Row locks require a row selection, not count().");
     const { whereNodes, where, ...rest } = options;
     return await this.countWhere(where ?? {}, rest, whereNodes ?? []);
   }
   async findAll(options = {}) {
     return await withDatabaseErrorHandling(async () => {
+      if (options.lock && (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))) {
+        throw new Error("Row locks require the framework active transaction connection.");
+      }
       const { whereNodes, ...queryOptions } = options;
       const { text, params } = buildSelectQuery(this.table, queryOptions, whereNodes ?? []);
       return await this.connection.unsafe(text, params);
@@ -5509,6 +5612,28 @@ class BaseRepository {
       return entity;
     }));
   }
+  async updateWhere(changes, options) {
+    return this.executeConditionalWrite("update", changes, options);
+  }
+  async deleteWhere(options) {
+    return this.executeConditionalWrite("delete", {}, options);
+  }
+  async updateWhereReturning(changes, columns, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, "update", changes, options, columns);
+    return withDatabaseErrorHandling(() => this.connection.unsafe(text, params));
+  }
+  async executeConditionalWrite(operation, changes, options) {
+    const { text, params } = buildConditionalWriteQuery(this.table, operation, changes, options);
+    return withDatabaseErrorHandling(async () => {
+      const rows = await this.connection.unsafe(text, params);
+      if (currentSqlDialect().driver !== "mysql")
+        return rows.length;
+      const affected = rows[0]?.affectedRows;
+      if (!Number.isSafeInteger(affected) || affected === undefined || affected < 0)
+        throw new Error("MySQL conditional writes require affectedRows metadata from the framework adapter.");
+      return affected;
+    });
+  }
   async updateById(id, changes) {
     this.assertTransactionalEvent("updated");
     return await this.runModelMutation("updated", () => withDatabaseErrorHandling(async () => {
@@ -7172,6 +7297,14 @@ class ModelQuery {
       return rows.map((row) => applyCasts(row, modelStatics(this.modelClass).$casts, "hydrate"));
     });
   }
+  lockForUpdate(options = {}) {
+    this.query.lockForUpdate(options);
+    return this;
+  }
+  sharedLock(options = {}) {
+    this.query.sharedLock(options);
+    return this;
+  }
   orderBy(orderBy) {
     this.query.orderBy(orderBy);
     return this;
@@ -8200,6 +8333,13 @@ class Blueprint {
     this.columns.push(column);
     return column;
   }
+  bigId(name = "id") {
+    const column = new ColumnDefinition(name, "bigId");
+    column.primary();
+    column.autoIncrement = true;
+    this.columns.push(column);
+    return column;
+  }
   string(name, length) {
     if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0)) {
       throw new Error("String length must be a positive safe integer.");
@@ -8346,6 +8486,8 @@ init_dialect();
 // ../../src/core/database/schema/grammars/grammar.ts
 function compileColumnType(driver, column) {
   switch (column.kind) {
+    case "bigId":
+      return driver === "pgsql" ? "BIGSERIAL" : compileIdType(driver);
     case "id":
       return compileIdType(driver);
     case "string":
@@ -8781,7 +8923,7 @@ function createSqliteConnection(filename) {
   const transactions = new WeakSet;
   function execute(query, params) {
     const statement = db.query(query);
-    const args = [...params];
+    const args = params.map((value) => value instanceof Date ? value.toISOString() : value);
     if (isRowReturning(query))
       return statement.all(...args);
     statement.run(...args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",