velocious 1.0.443 → 1.0.445

package/README.md

@@ -1597,6 +1597,8 @@ configuration.getErrorEvents().on("all-error", ({error, errorType}) => {
 })
 ```
 
+Genuinely unexpected frontend-model command failures reach this bus too. The frontend-model controller catches them to return a client-safe `Request failed.` response, but it also emits them as `framework-error`/`all-error` (with `context.frontendModelEndpoint === true`) so they are reported instead of being silently swallowed. Expected user-flow errors are excluded: validation failures are forwarded with their real message (for example `Name can't be blank`) rather than the generic one, and `error.velocious`-annotated / `safeToExpose` errors keep their own message — none of these reach the error bus.
+
 ## Use the Websocket client API (HTTP-like)
 
 ```js

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

@@ -67,14 +67,15 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
                          @type {typeof import("./index.js").default} */ (record.constructor)
     const posColumn = modelClass.getColumnNameForAttributeName(positionColumn)
     const scopeCol = modelClass.getColumnNameForAttributeName(scope)
-    const rawAttributes = /**
-                           * Narrows the runtime value to the documented type.
-                            @type {Record<string, ?>} */ (record._attributes || {})
-    const changes = /**
-                     * Narrows the runtime value to the documented type.
-                      @type {Record<string, ?>} */ (record._changes || {})
+    /** @type {Record<string, ?>} */
+    const rawAttributes = record._attributes || {}
+    /** @type {Record<string, ?>} */
+    const changes = record._changes || {}
+    /** @type {Set<string>} */
+    const assignedAttributeNames = record._assignedAttributeNames || new Set()
     const posChanged = posColumn in changes
     const scopeChanged = scopeCol in changes
+    const posAssigned = assignedAttributeNames.has(positionColumn)
 
     if (!posChanged && !scopeChanged) return
 
@@ -102,18 +103,13 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
     if (oldPosition == null || newPosition == null) return
     if (newPosition === oldPosition && newScopeValue === oldScopeValue) return
 
-    // Move the record out of the way before shifting others to avoid
-    // intermediate UNIQUE constraint violations. Use the old scope value
-    // for the move-out-of-way because the record is still in the old scope.
-    await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue})
-    setShiftingFlag(record, false)
-
     if (scopeChanged && oldScopeValue !== newScopeValue) {
-      let targetPosition = newPosition
-
       // When only the scope changes without a new position, append to the end
       // of the new scope. There is no target-scope row to shift out of the way.
-      if (!posChanged) {
+      if (!posAssigned) {
+        await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue})
+        setShiftingFlag(record, false)
+
         const highestNew = await highestPositionInScope({record, positionColumn, scope, scopeValue: newScopeValue})
         const nextPos = highestNew + 1
 
@@ -122,11 +118,17 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
         return
       }
 
+      await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue, targetScopeValue: newScopeValue})
+      setShiftingFlag(record, false)
       await shiftPositionsDown({record, positionColumn, scope, scopeValue: oldScopeValue, fromPosition: oldPosition + 1})
-      await shiftPositionsUp({record, positionColumn, scope, scopeValue: newScopeValue, fromPosition: targetPosition})
+      await shiftPositionsUp({record, positionColumn, scope, scopeValue: newScopeValue, fromPosition: newPosition, excludeRecordId: record.id()})
+      await placeMovedRecord({record, positionColumn, scope, scopeValue: newScopeValue, position: newPosition})
       return
     }
 
+    await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue})
+    setShiftingFlag(record, false)
+
     if (newPosition < oldPosition) {
       await shiftPositionsUp({record, positionColumn, scope, fromPosition: newPosition, toPosition: oldPosition})
     } else if (newPosition > oldPosition) {
@@ -146,6 +148,53 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
   })
 }
 
+/**
+ * Places a moved row after surrounding rows have shifted.
+ * @param {object} args - Arguments.
+ * @param {import("./index.js").default} args.record - Model instance.
+ * @param {string} args.positionColumn - Position attribute name.
+ * @param {string} args.scope - Scope attribute name.
+ * @param {string | number} args.scopeValue - Destination scope value.
+ * @param {number} args.position - Destination position.
+ * @returns {Promise<void>} Resolves after placement.
+ */
+async function placeMovedRecord({record, positionColumn, scope, scopeValue, position}) {
+  const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
+  const connection = modelClass.connection()
+  const tableSql = connection.quoteTable(modelClass._getTable().getName())
+  const scopeCol = modelClass.getColumnNameForAttributeName(scope)
+  const posCol = modelClass.getColumnNameForAttributeName(positionColumn)
+  const preservedChanges = {...record._changes}
+  const scopeColumnSql = connection.quoteColumn(scopeCol)
+  const positionColumnSql = connection.quoteColumn(posCol)
+  const primaryKeySql = connection.quoteColumn(modelClass.primaryKey())
+
+  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())}`
+  )
+  await record._reloadWithId(record.id())
+  record._changes = preservedChanges
+  clearBelongsToChangeForScope(record)
+}
+
+/**
+ * Clears dirty belongs-to state for the scope FK after direct placement.
+ * @param {import("./index.js").default} record - Model instance.
+ * @returns {void} Nothing.
+ */
+function clearBelongsToChangeForScope(record) {
+  for (const relationshipName in record._instanceRelationships || {}) {
+    const relationship = record._instanceRelationships[relationshipName]
+
+    if (relationship.getType() !== "belongsTo") continue
+
+    relationship.setDirty(false)
+  }
+}
+
 /**
  * Bumps positions UP by 1 in the range [fromPosition, toPosition) within the
  * same scope. Updates in descending order to avoid intermediate UNIQUE
@@ -157,9 +206,10 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
  * @param {number} args.fromPosition - Starting position (inclusive).
  * @param {number} [args.toPosition] - Ending position (exclusive).
  * @param {string | number} [args.scopeValue] - Explicit scope value.
+ * @param {string | number} [args.excludeRecordId] - Record id to exclude from shifts.
  * @returns {Promise<void>}
  */
-async function shiftPositionsUp({record, positionColumn, scope, fromPosition, toPosition, scopeValue}) {
+async function shiftPositionsUp({record, positionColumn, scope, fromPosition, toPosition, scopeValue, excludeRecordId}) {
   const modelClass = /**
                       * Narrows the runtime value to the documented type.
                        @type {typeof import("./index.js").default} */ (record.constructor)
@@ -173,16 +223,25 @@ 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 tableSql = connection.quoteTable(tableName)
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in descending order so we bump the highest first
   let query = modelClass
+    .select(modelClass.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)
+
+  if (recordIdToExclude != null) {
+    query = query.where(`${primaryKeySql} != ${connection.quote(recordIdToExclude)}`)
+  }
+
   if (toPosition != null) {
     query = query.where(`${positionColumnSql} < ${connection.quote(toPosition)}`)
   }
@@ -196,7 +255,7 @@ async function shiftPositionsUp({record, positionColumn, scope, fromPosition, to
       const currentPos = Number(row.readAttribute(positionColumn))
 
       await connection.query(
-        `UPDATE ${tableSql} SET ${positionColumnSql} = ${positionColumnSql} + 1 WHERE ${scopeColumnSql} = ${quotedScope} AND ${positionColumnSql} = ${connection.quote(currentPos)}`
+        `UPDATE ${tableSql} SET ${positionColumnSql} = ${positionColumnSql} + 1 WHERE ${primaryKeySql} = ${connection.quote(row.id())} AND ${scopeColumnSql} = ${quotedScope} AND ${positionColumnSql} = ${connection.quote(currentPos)}`
       )
     }
   } finally {
@@ -231,14 +290,18 @@ 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 tableSql = connection.quoteTable(tableName)
   const quotedScope = connection.quote(resolvedScopeValue)
 
   // Load rows in ascending order so we shift the lowest gap first
   let query = modelClass
+    .select(modelClass.primaryKey())
     .select(positionColumn)
     .where({[scopeColumnName]: resolvedScopeValue})
     .where(`${positionColumnSql} >= ${connection.quote(fromPosition)}`)
+    .where(`${positionColumnSql} > 0`)
+    .where(`${primaryKeySql} != ${connection.quote(record.id())}`)
     .order({column: positionColumnName, direction: "ASC"})
 
   if (toPosition != null) {
@@ -254,7 +317,7 @@ async function shiftPositionsDown({record, positionColumn, scope, fromPosition,
       const currentPos = Number(row.readAttribute(positionColumn))
 
       await connection.query(
-        `UPDATE ${tableSql} SET ${positionColumnSql} = ${positionColumnSql} - 1 WHERE ${scopeColumnSql} = ${quotedScope} AND ${positionColumnSql} = ${connection.quote(currentPos)}`
+        `UPDATE ${tableSql} SET ${positionColumnSql} = ${positionColumnSql} - 1 WHERE ${primaryKeySql} = ${connection.quote(row.id())} AND ${scopeColumnSql} = ${quotedScope} AND ${positionColumnSql} = ${connection.quote(currentPos)}`
       )
     }
   } finally {
@@ -342,21 +405,23 @@ function resolveScopeValue(record, scope) {
  * @param {import("./index.js").default} args.record - Model instance.
  * @param {string} args.positionColumn - camelCase position attribute.
  * @param {string} args.scope - camelCase scope attribute.
- * @param {string | number | null} [args.scopeValue] - Explicit scope value (defaults to resolveScopeValue).
+ * @param {string | number | null} [args.scopeValue] - Scope containing the record before move-out.
+ * @param {string | number | null} [args.targetScopeValue] - Temporary scope value to assign.
  * @returns {Promise<void>}
  */
-async function moveOutOfWay({record, positionColumn, scope, scopeValue}) {
+async function moveOutOfWay({record, positionColumn, scope, scopeValue, targetScopeValue}) {
   const modelClass = /**
                       * Narrows the runtime value to the documented type.
                        @type {typeof import("./index.js").default} */ (record.constructor)
   const connection = modelClass.connection()
   const tableName = modelClass._getTable().getName()
   const resolvedScopeValue = scopeValue != null ? scopeValue : resolveScopeValue(record, scope)
+  const resolvedTargetScopeValue = targetScopeValue != null ? targetScopeValue : resolvedScopeValue
 
   if (resolvedScopeValue == null) return
+  if (resolvedTargetScopeValue == null) return
 
-  const highest = await highestPositionInScope({record, positionColumn, scope, scopeValue: resolvedScopeValue})
-  const tempPosition = highest + 10000
+  const tempPosition = -record.id()
   const positionColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(positionColumn))
   const scopeColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(scope))
   const tableSql = connection.quoteTable(tableName)
@@ -366,7 +431,7 @@ async function moveOutOfWay({record, positionColumn, scope, scopeValue}) {
 
   try {
     await connection.query(
-      `UPDATE ${tableSql} SET ${positionColumnSql} = ${connection.quote(tempPosition)} WHERE ${scopeColumnSql} = ${connection.quote(resolvedScopeValue)} AND ${pkSql} = ${connection.quote(record.id())}`
+      `UPDATE ${tableSql} SET ${scopeColumnSql} = ${connection.quote(resolvedTargetScopeValue)}, ${positionColumnSql} = ${connection.quote(tempPosition)} WHERE ${scopeColumnSql} = ${connection.quote(resolvedScopeValue)} AND ${pkSql} = ${connection.quote(record.id())}`
     )
   } finally {
     // Don't clear the flag here — the caller will do that after shifts

package/build/database/record/index.js

@@ -435,6 +435,12 @@ class VelociousDatabaseRecord {
     @type {Record<string, ?>} */
   _changes = {}
 
+  /**
+   * Attribute names explicitly assigned in the current update call.
+    @type {Set<string> | undefined}
+   */
+  _assignedAttributeNames = undefined
+
   /**
    * Columns as hash.
     @type {Record<string, import("../drivers/base-column.js").default>} */
@@ -2414,6 +2420,8 @@ class VelociousDatabaseRecord {
       })
     })
 
+    this._assignedAttributeNames = undefined
+
     return result
   }
 
@@ -2512,7 +2520,7 @@ class VelociousDatabaseRecord {
 
   /**
    * Resolves a relationship foreign-key column to this model's public attribute name.
-   * @param {import("./instance-relationships/base.js").default<?, ?>} instanceRelationship - Relationship instance.
+   * @param {import("./instance-relationships/base.js").default<typeof VelociousDatabaseRecord, typeof VelociousDatabaseRecord>} instanceRelationship - Relationship instance.
    * @returns {string} Attribute name accepted by setAttribute/assign.
    */
   _relationshipForeignKeyAttribute(instanceRelationship) {
@@ -3374,7 +3382,9 @@ class VelociousDatabaseRecord {
    * @returns {void} - No return value.
    */
   assign(attributesToAssign) {
+    this._assignedAttributeNames ||= new Set()
     for (const attributeToAssign in attributesToAssign) {
+      this._assignedAttributeNames.add(attributeToAssign)
       this.setAttribute(attributeToAssign, attributesToAssign[attributeToAssign])
     }
   }
@@ -4178,6 +4188,7 @@ class VelociousDatabaseRecord {
 
     this._attributes = reloadedModel.rawAttributes()
     this._changes = {}
+    this._assignedAttributeNames = undefined
   }
 
   /**

package/build/frontend-model-controller.js

@@ -218,6 +218,14 @@ function frontendModelClientMessageForError(error) {
     return error.message
   }
 
+  // Validation failures are expected user-flow errors. Always forward the
+  // validation summary so the client shows the real reason (e.g. "Name can't
+  // be blank") instead of the generic "Request failed." message, regardless of
+  // whether the raising code also attached error.velocious metadata.
+  if (error instanceof ValidationError) {
+    return error.message
+  }
+
   if (frontendModelErrorHasVelociousMetadata(error) && error instanceof Error) {
     return error.message
   }
@@ -2827,6 +2835,24 @@ export default class FrontendModelController extends Controller {
       model: resolvedModel,
       requestId
     }])
+
+    // Surface genuinely unexpected backend failures on the framework-error
+    // channel so process-level bug reporters capture them, instead of the
+    // controller silently swallowing them behind the generic "Request
+    // failed." client message. Developer-annotated user-flow errors
+    // (`error.velocious` metadata — handled by the early return above),
+    // validation errors, and deliberately client-safe VelociousErrors are
+    // expected and must NOT be reported as framework errors.
+    if (!(error instanceof ValidationError) && !(error instanceof VelociousError && error.safeToExpose)) {
+      const errorPayload = {
+        context: {action, commandType, frontendModelEndpoint: true, model: resolvedModel, requestId},
+        error: error instanceof Error ? error : new Error(String(error)),
+        request: this.getRequest()
+      }
+
+      this.getConfiguration().getErrorEvents().emit("framework-error", errorPayload)
+      this.getConfiguration().getErrorEvents().emit("all-error", {...errorPayload, errorType: "framework-error"})
+    }
   }
 
   /**

package/build/frontend-models/base.js

@@ -3967,7 +3967,7 @@ export default class FrontendModelBase {
 
     const error = /**
                    * Narrows the runtime value to the documented type.
-                    @type {Error & {velocious?: Record<string, ?>, errorType?: string, validationErrors?: Record<string, ?>}} */ (new Error(errorMessage))
+                    @type {Error & {velocious?: Record<string, ?>, errorType?: string, validationErrors?: Record<string, ?>, debugErrorClass?: string, debugBacktrace?: string[]}} */ (new Error(errorMessage))
     if (response.velocious && typeof response.velocious === "object") {
       error.velocious = response.velocious
     }
@@ -3977,6 +3977,16 @@ export default class FrontendModelBase {
     if (response.validationErrors && typeof response.validationErrors === "object") {
       error.validationErrors = response.validationErrors
     }
+    // Forward server-provided debug detail (included only when the backend
+    // deems the requester allowed to see it, e.g. an admin) so callers can
+    // render the real error class and stack trace instead of the generic
+    // client-safe message.
+    if (typeof response.debugErrorClass === "string") {
+      error.debugErrorClass = response.debugErrorClass
+    }
+    if (Array.isArray(response.debugBacktrace)) {
+      error.debugBacktrace = response.debugBacktrace
+    }
     throw error
   }
 

package/build/src/database/record/acts-as-list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acts-as-list.d.ts","sourceRoot":"","sources":["../../../../src/database/record/acts-as-list.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;GAcG;AACH,gEANW,cAAc,YAAY,EAAE,OAAO,kBACnC,MAAM,aAEd;IAAwB,KAAK,EAArB,MAAM;CACd,GAAU,IAAI,CAuGhB"}
+{"version":3,"file":"acts-as-list.d.ts","sourceRoot":"","sources":["../../../../src/database/record/acts-as-list.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;GAcG;AACH,gEANW,cAAc,YAAY,EAAE,OAAO,kBACnC,MAAM,aAEd;IAAwB,KAAK,EAArB,MAAM;CACd,GAAU,IAAI,CAyGhB"}