@getstrata/core 2.2.0 → 2.2.2

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);