velocious 1.0.643 → 1.0.645

package/build/database/drivers/sqlite/sql/update.js

@@ -22,9 +22,7 @@ export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends Up
     for (let columnName in this.conditions) {
       if (count > 0) sql += " AND "
 
-      sql += this.getOptions().quoteColumnName(columnName)
-      sql += " = "
-      sql += this.formatValue(this.conditions[columnName])
+      sql += this.formatCondition(columnName, this.conditions[columnName])
       count++
     }
 

package/build/database/query/index.js

@@ -481,7 +481,7 @@ export default class VelociousDatabaseQuery {
    * Runs execute query.
    * @param {object} [args] - Options object.
    * @param {string} [args.logName] - Query log name.
-   * @returns {Promise<Array<object>>} Array of results from the database
+   * @returns {Promise<import("../drivers/base.js").QueryResultType>} Array of results from the database
    */
   async _executeQuery({logName = this.queryLogName("Load")} = {}) {
     const sql = this.toSql()
@@ -503,7 +503,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * Runs results.
-   * @returns {Promise<Array<object>>} Array of results from the database
+   * @returns {Promise<import("../drivers/base.js").QueryResultType>} Array of results from the database
    */
   async results() {
     return await this._executeQuery()

package/build/database/query/model-class-query.js

@@ -15,6 +15,7 @@ import JoinTracker from "./join-tracker.js"
 import RecordNotFoundError from "../record/record-not-found-error.js"
 import {normalizeRansackGroup, parseRansackSort} from "../../utils/ransack.js"
 import {isModelScopeDescriptor} from "../../utils/model-scope.js"
+import {modelPrimaryKeyConditions, scalarModelPrimaryKey} from "../../utils/model-primary-key.js"
 import WhereCombinator from "./where-combinator.js"
 import WhereModelClassHash from "./where-model-class-hash.js"
 import WhereNot from "./where-not.js"
@@ -323,7 +324,8 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
     // setPrimaryKey([...]) on legacy tables — has no column COUNT can reference (an array primary key
     // cannot be quoted as a single COUNT(column), and primaryKey() falls back to "id" for the no-pk
     // case, so hasPrimaryKey() detects that one).
-    const hasSingleColumnPrimaryKey = this.getModelClass().hasPrimaryKey() && !Array.isArray(this.getModelClass().primaryKey())
+    const primaryKey = this.getModelClass().primaryKey()
+    const hasSingleColumnPrimaryKey = this.getModelClass().hasPrimaryKey() && !Array.isArray(primaryKey)
 
     // Pagination, or an ungrouped query on a model with no single primary-key column, counts via the
     // subquery form. It references no primary-key column and preserves DISTINCT over joins — which a
@@ -340,7 +342,7 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
 
     const distinctPrefix = this._distinct ? "DISTINCT " : ""
     const countExpression = hasSingleColumnPrimaryKey
-      ? `${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().primaryKey())}`
+      ? `${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(/** @type {string} */ (primaryKey))}`
       : "*"
     let sql = `COUNT(${distinctPrefix}${countExpression})`
 
@@ -807,7 +809,8 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
     if (joinsSql.length > 0) {
       // Use a subquery for cross-driver compatibility (SQLite
       // doesn't support UPDATE ... JOIN).
-      const pk = driver.quoteColumn(this.getModelClass().primaryKey())
+      const primaryKey = scalarModelPrimaryKey(this.getModelClass().primaryKey(), `${this.getModelClass().name}.updateAll() with joins`)
+      const pk = driver.quoteColumn(primaryKey)
       const qt = driver.quoteTable(tableName)
 
       sql = `UPDATE ${qt} SET ${setCols} WHERE ${pk} IN (SELECT ${qt}.${pk} FROM ${qt}${joinsSql}${whereSql})`
@@ -820,7 +823,7 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
 
   /**
    * Runs find.
-   * @param {number|string} recordId - Record id.
+   * @param {import("../../utils/model-primary-key.js").ModelPrimaryKeyValue} recordId - Record id.
    * @returns {Promise<InstanceType<MC>>} - Resolves with the find.
    */
   async find(recordId) {
@@ -829,7 +832,7 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
      * @type {{[key: string]: number | string}} */
     const conditions = {}
 
-    conditions[this.getModelClass().primaryKey()] = recordId
+    Object.assign(conditions, modelPrimaryKeyConditions(this.getModelClass().primaryKey(), recordId))
 
     const newQuery = /** @type {VelociousDatabaseQueryModelClassQuery<MC>} */ (this.clone())
 
@@ -838,7 +841,7 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
     const record = (await newQuery.first())
 
     if (!record) {
-      throw new RecordNotFoundError(`Couldn't find ${this.getModelClass().name} with '${this.getModelClass().primaryKey()}'=${recordId}`)
+      throw new RecordNotFoundError(`Couldn't find ${this.getModelClass().name} with '${this.getModelClass().primaryKey()}'=${JSON.stringify(recordId)}`)
     }
 
     return record
@@ -940,7 +943,7 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
    * @returns {Promise<InstanceType<MC> | null>} - Resolves with the first.
    */
   async first() {
-    const newQuery = this.clone().limit(1).reorder(`${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().orderableColumn())}`)
+    const newQuery = this.clone().limit(1).reorder(this._defaultIdentityOrder("ASC"))
     const results = await newQuery.toArray()
 
     return results[0] || null
@@ -951,13 +954,26 @@ export default class VelociousDatabaseQueryModelClassQuery extends DatabaseQuery
    * @returns {Promise<InstanceType<MC> | null>} - Resolves with the last.
    */
   async last() {
-    const primaryKey = this.getModelClass().primaryKey()
-    const tableName = this.getModelClass().tableName()
-    const results = await this.clone().reorder(`${this.driver.quoteTable(tableName)}.${this.driver.quoteColumn(primaryKey)} DESC`).limit(1).toArray()
+    const results = await this.clone().reorder(this._defaultIdentityOrder("DESC")).limit(1).toArray()
 
     return results[0] || null
   }
 
+  /**
+   * Builds the deterministic default order for the model identity.
+   * @param {"ASC" | "DESC"} direction - Sort direction.
+   * @returns {string} - SQL order expression.
+   */
+  _defaultIdentityOrder(direction) {
+    const ModelClass = this.getModelClass()
+    const primaryKey = ModelClass.primaryKey()
+    const orderableColumns = Array.isArray(primaryKey) ? primaryKey : [ModelClass.orderableColumn()]
+
+    return orderableColumns
+      .map((column) => `${this.driver.quoteTable(ModelClass.tableName())}.${this.driver.quoteColumn(column)} ${direction}`)
+      .join(", ")
+  }
+
   /**
    * Runs preload.
    * @param {import("./index.js").NestedPreloadRecord | string | Array<string | import("./index.js").NestedPreloadRecord>} data - Data payload.

package/build/database/query/preloader/has-many.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import {scalarModelPrimaryKey} from "../../../utils/model-primary-key.js"
+
 import ensureModelClassInitialized from "./ensure-model-class-initialized.js"
 import PreloaderSelection from "./selection.js"
 import preloadQueryForModel, { bindPreloadModelClass } from "./query-for-model.js"
@@ -185,7 +187,8 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
 
       for (const throughModel of throughModels) {
         const parentId = /** @type {string | number} */ (throughModel.readColumn(throughForeignKey))
-        const throughId = /** @type {string | number} */ (throughModel.readColumn(throughModelClass.primaryKey()))
+        const throughPrimaryKey = scalarModelPrimaryKey(throughModelClass.primaryKey(), `Has-many-through preload for ${throughModelClass.name}`)
+        const throughId = /** @type {string | number} */ (throughModel.readColumn(throughPrimaryKey))
 
         if (!(parentId in parentToTargetIds)) parentToTargetIds[parentId] = []
 

package/build/database/query/query-data.js

@@ -1,6 +1,7 @@
 // @ts-check
 
 import {isPlainObject} from "is-plain-object"
+import {scalarModelPrimaryKey} from "../../utils/model-primary-key.js"
 
 /**
  * QueryDataEntry type.
@@ -188,7 +189,7 @@ function resolveTargetModelClass(rootModelClass, chain) {
 export async function runQueryData({rootModelClass, rootModels, entries}) {
   if (rootModels.length === 0 || entries.length === 0) return
 
-  const primaryKey = rootModelClass.primaryKey()
+  const primaryKey = scalarModelPrimaryKey(rootModelClass.primaryKey(), `queryData for ${rootModelClass.name}`)
   const rootIds = rootModels.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)))
   const sourceModel = rootModels[0]
   const preparedEntries = entries.map((entry, entryIndex) => prepareEntry({

package/build/database/query/update-base.js

@@ -35,6 +35,20 @@ export default class VelociousDatabaseQueryUpdateBase {
     return this.getOptions().quote(value)
   }
 
+  /**
+   * Formats one hash condition with SQL null semantics.
+   * @param {string} columnName - Column name.
+   * @param {ReturnType<typeof JSON.parse>} value - Condition value.
+   * @returns {string} - SQL condition.
+   */
+  formatCondition(columnName, value) {
+    const column = this.getOptions().quoteColumnName(columnName)
+
+    if (value === null) return `${column} IS NULL`
+
+    return `${column} = ${this.formatValue(value)}`
+  }
+
   toSql() {
     throw new Error("'toSql' wasn't implemented")
   }

package/build/database/query/with-count.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import {scalarModelPrimaryKey} from "../../utils/model-primary-key.js"
+
 /**
  * WithCountEntry type.
  * @typedef {object} WithCountEntry
@@ -109,7 +111,7 @@ function entryFromName(name) {
 export async function runWithCount({models, modelClass, entries}) {
   if (models.length === 0 || entries.length === 0) return
 
-  const primaryKey = modelClass.primaryKey()
+  const primaryKey = scalarModelPrimaryKey(modelClass.primaryKey(), `withCount for ${modelClass.name}`)
   const parentIds = models.map((model) => /** @type {string | number} */ (model.readColumn(primaryKey)))
   const sourceModel = models[0]
   const queryGroups = new Map()

package/build/database/record/acts-as-list.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import {scalarModelPrimaryKey, scalarModelPrimaryKeyValue} from "../../utils/model-primary-key.js"
+
 /** @file Registers gap-less positional list callbacks on a model class. */
 
 /**
@@ -8,6 +10,24 @@
  */
 const ACTS_AS_LIST_SHIFTING = Symbol("actsAsListShifting")
 
+/**
+ * Returns the scalar primary-key column required by acts-as-list SQL.
+ * @param {typeof import("./index.js").default} modelClass - List model class.
+ * @returns {string} - Scalar primary-key column.
+ */
+function actsAsListPrimaryKey(modelClass) {
+  return scalarModelPrimaryKey(modelClass.primaryKey(), `actsAsList for ${modelClass.name}`)
+}
+
+/**
+ * Returns the scalar record id required by acts-as-list SQL.
+ * @param {import("./index.js").default} record - List record.
+ * @returns {string | number} - Scalar record id.
+ */
+function actsAsListRecordId(record) {
+  return scalarModelPrimaryKeyValue(record.id(), `actsAsList for ${record.getModelClass().name}`)
+}
+
 /**
  * Runs set shifting flag.
  * @param {import("./index.js").default} record - Model instance.
@@ -111,7 +131,7 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
       await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue})
       setShiftingFlag(record, false)
       await shiftPositionsDown({record, positionColumn, scope, scopeValue: oldScopeValue, fromPosition: oldPosition + 1})
-      await shiftPositionsUp({record, positionColumn, scope, scopeValue: newScopeValue, fromPosition: newPosition, excludeRecordId: record.id()})
+      await shiftPositionsUp({record, positionColumn, scope, scopeValue: newScopeValue, fromPosition: newPosition, excludeRecordId: actsAsListRecordId(record)})
       await placeMovedRecord({record, positionColumn, scope, scopeValue: newScopeValue, position: newPosition})
       return
     }
@@ -180,15 +200,17 @@ async function placeMovedRecord({record, positionColumn, scope, scopeValue, posi
   const preservedChanges = {...record._changes}
   const scopeColumnSql = connection.quoteColumn(scopeCol)
   const positionColumnSql = connection.quoteColumn(posCol)
-  const primaryKeySql = connection.quoteColumn(modelClass.primaryKey())
+  const primaryKey = actsAsListPrimaryKey(modelClass)
+  const primaryKeySql = connection.quoteColumn(primaryKey)
+  const recordId = actsAsListRecordId(record)
 
   delete preservedChanges[scopeCol]
   delete preservedChanges[posCol]
 
   await connection.query(
-    `UPDATE ${tableSql} SET ${scopeColumnSql} = ${connection.quote(scopeValue)}, ${positionColumnSql} = ${connection.quote(position)} WHERE ${primaryKeySql} = ${connection.quote(record.id())}`
+    `UPDATE ${tableSql} SET ${scopeColumnSql} = ${connection.quote(scopeValue)}, ${positionColumnSql} = ${connection.quote(position)} WHERE ${primaryKeySql} = ${connection.quote(recordId)}`
   )
-  await record._reloadWithId(record.id())
+  await record._reloadWithId(recordId)
   record._changes = preservedChanges
   clearBelongsToChangeForScope(record)
 }
@@ -234,21 +256,22 @@ async function shiftPositionsUp({record, positionColumn, scope, fromPosition, to
   const positionColumnName = modelClass.getColumnNameForAttributeName(positionColumn)
   const positionColumnSql = connection.quoteColumn(positionColumnName)
   const scopeColumnSql = connection.quoteColumn(scopeColumnName)
-  const primaryKeySql = connection.quoteColumn(modelClass.primaryKey())
+  const primaryKey = actsAsListPrimaryKey(modelClass)
+  const primaryKeySql = connection.quoteColumn(primaryKey)
   const tableSql = connection.quoteTable(tableName)
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in descending order so we bump the highest first
   let query = record
     .queryForModel(modelClass)
-    .select(modelClass.primaryKey())
+    .select(primaryKey)
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
     .where(`${positionColumnSql} >= ${connection.quote(fromPosition)}`)
     .where(`${positionColumnSql} > 0`)
     .order(`${positionColumnSql} DESC`)
 
-  const recordIdToExclude = excludeRecordId || (record.isPersisted() ? record.id() : null)
+  const recordIdToExclude = excludeRecordId || (record.isPersisted() ? actsAsListRecordId(record) : null)
 
   if (recordIdToExclude != null) {
     query = query.where(`${primaryKeySql} != ${connection.quote(recordIdToExclude)}`)
@@ -300,19 +323,20 @@ async function shiftPositionsDown({record, positionColumn, scope, fromPosition,
   const positionColumnName = modelClass.getColumnNameForAttributeName(positionColumn)
   const positionColumnSql = connection.quoteColumn(positionColumnName)
   const scopeColumnSql = connection.quoteColumn(scopeColumnName)
-  const primaryKeySql = connection.quoteColumn(modelClass.primaryKey())
+  const primaryKey = actsAsListPrimaryKey(modelClass)
+  const primaryKeySql = connection.quoteColumn(primaryKey)
   const tableSql = connection.quoteTable(tableName)
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in ascending order so we shift the lowest gap first
   let query = record
     .queryForModel(modelClass)
-    .select(modelClass.primaryKey())
+    .select(primaryKey)
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
     .where(`${positionColumnSql} >= ${connection.quote(fromPosition)}`)
     .where(`${positionColumnSql} > 0`)
-    .where(`${primaryKeySql} != ${connection.quote(record.id())}`)
+    .where(`${primaryKeySql} != ${connection.quote(actsAsListRecordId(record))}`)
     .order({column: positionColumnName, direction: "ASC"})
 
   if (toPosition != null) {
@@ -399,7 +423,7 @@ function resolveScopeValue(record, scope) {
     const loaded = instanceRelationship.loaded()
 
     if (loaded && !Array.isArray(loaded) && typeof loaded.id === "function") {
-      return loaded.id()
+      return scalarModelPrimaryKeyValue(loaded.id(), `actsAsList scope relationship for ${modelClass.name}`)
     }
   }
 
@@ -427,13 +451,13 @@ async function moveOutOfWay({record, positionColumn, scope, scopeValue}) {
   const positionColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(positionColumn))
   const scopeColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(scope))
   const tableSql = connection.quoteTable(tableName)
-  const pkSql = connection.quoteColumn(modelClass.primaryKey())
+  const pkSql = connection.quoteColumn(actsAsListPrimaryKey(modelClass))
 
   setShiftingFlag(record, true)
 
   try {
     await connection.query(
-      `UPDATE ${tableSql} SET ${positionColumnSql} = -${positionColumnSql} WHERE ${scopeColumnSql} = ${connection.quote(resolvedScopeValue)} AND ${pkSql} = ${connection.quote(record.id())}`
+      `UPDATE ${tableSql} SET ${positionColumnSql} = -${positionColumnSql} WHERE ${scopeColumnSql} = ${connection.quote(resolvedScopeValue)} AND ${pkSql} = ${connection.quote(actsAsListRecordId(record))}`
     )
   } finally {
     // Don't clear the flag here — the caller will do that after shifts