velocious 1.0.564 → 1.0.566

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.564",
+  "version": "1.0.566",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/configuration-types.js

@@ -255,6 +255,7 @@
  * @property {boolean} [inProcess] - Run HTTP handlers in the main thread instead of worker threads.
  * @property {number} [maxWorkers] - Backward-compatible alias for workers.
  * @property {number} [port] - Port to bind the HTTP server to.
+ * @property {{maxPendingBytes?: number, maxPendingMessages?: number}} [websocketInboundQueue] - Per-session retained inbound WebSocket message limits.
  * @property {{maxPendingBytes?: number, maxPendingFrames?: number}} [websocketOutboundQueue] - Per-client retained outbound WebSocket frame limits.
  * @property {number} [workers] - Worker handlers to start for the HTTP server.
  */

package/src/configuration.js

@@ -114,6 +114,8 @@ function resolveBeaconUnreachableReportMs(value) {
   return 30_000
 }
 
+const DEFAULT_WEBSOCKET_INBOUND_MAX_PENDING_BYTES = 16 * 1024 * 1024
+const DEFAULT_WEBSOCKET_INBOUND_MAX_PENDING_MESSAGES = 256
 const DEFAULT_WEBSOCKET_OUTBOUND_MAX_PENDING_BYTES = 16 * 1024 * 1024
 const DEFAULT_WEBSOCKET_OUTBOUND_MAX_PENDING_FRAMES = 256
 
@@ -228,10 +230,15 @@ export default class VelociousConfiguration {
      * @type {Promise<void> | undefined}
      */
     this._initializePromise = undefined
+    const websocketInboundQueue = httpServer?.websocketInboundQueue
     const websocketOutboundQueue = httpServer?.websocketOutboundQueue
 
     this.httpServer = {
       ...(httpServer || {}),
+      websocketInboundQueue: {
+        maxPendingBytes: positiveSafeInteger(websocketInboundQueue?.maxPendingBytes, "httpServer.websocketInboundQueue.maxPendingBytes", DEFAULT_WEBSOCKET_INBOUND_MAX_PENDING_BYTES),
+        maxPendingMessages: positiveSafeInteger(websocketInboundQueue?.maxPendingMessages, "httpServer.websocketInboundQueue.maxPendingMessages", DEFAULT_WEBSOCKET_INBOUND_MAX_PENDING_MESSAGES)
+      },
       websocketOutboundQueue: {
         maxPendingBytes: positiveSafeInteger(websocketOutboundQueue?.maxPendingBytes, "httpServer.websocketOutboundQueue.maxPendingBytes", DEFAULT_WEBSOCKET_OUTBOUND_MAX_PENDING_BYTES),
         maxPendingFrames: positiveSafeInteger(websocketOutboundQueue?.maxPendingFrames, "httpServer.websocketOutboundQueue.maxPendingFrames", DEFAULT_WEBSOCKET_OUTBOUND_MAX_PENDING_FRAMES)
@@ -2370,6 +2377,19 @@ export default class VelociousConfiguration {
    */
   getWebsocketSessionHeartbeatSeconds() { return this._websocketSessionHeartbeatSeconds }
 
+  /**
+   * Gets per-session WebSocket inbound message queue limits.
+   * @returns {{maxBytes: number, maxMessages: number}} - Per-session inbound queue high-water marks.
+   */
+  getWebsocketInboundQueueLimits() {
+    const queue = this.httpServer.websocketInboundQueue
+
+    return {
+      maxBytes: queue.maxPendingBytes,
+      maxMessages: queue.maxPendingMessages
+    }
+  }
+
   /**
    * Gets per-client WebSocket outbound queue limits.
    * @returns {{maxBytes: number, maxFrames: number}} - Per-client outbound queue high-water marks.

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

@@ -50,6 +50,7 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
     const position = record.readAttribute(positionColumn)
 
     if (position != null) {
+      assertPositivePosition({position, positionColumn})
       await shiftPositionsUp({record, positionColumn, scope, fromPosition: position})
     } else {
       const nextPosition = await highestPositionInScope({record, positionColumn, scope})
@@ -77,12 +78,19 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
 
     if (!posChanged && !scopeChanged) return
 
+    assertPositivePosition({
+      position: rawAttributes[posColumn],
+      positionColumn,
+      persisted: true
+    })
+
     const oldPosition = posChanged ? /** @type {number} */ (rawAttributes[posColumn]) : /** @type {number} */ (record.readAttribute(positionColumn))
     const newPosition = posChanged ? /** @type {number} */ (changes[posColumn]) : /** @type {number} */ (record.readAttribute(positionColumn))
     const oldScopeValue = scopeChanged ? /** @type {number} */ (rawAttributes[scopeCol]) : /** @type {number} */ (record.readAttribute(scope))
     const newScopeValue = scopeChanged ? /** @type {number} */ (changes[scopeCol]) : /** @type {number} */ (record.readAttribute(scope))
 
-    if (oldPosition == null || newPosition == null) return
+    assertPositivePosition({position: newPosition, positionColumn})
+    if (oldPosition == null) return
     if (newPosition === oldPosition && newScopeValue === oldScopeValue) return
 
     if (scopeChanged && oldScopeValue !== newScopeValue) {
@@ -100,7 +108,7 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
         return
       }
 
-      await moveOutOfWay({record, positionColumn, scope, scopeValue: oldScopeValue, targetScopeValue: newScopeValue})
+      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()})
@@ -121,7 +129,14 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
   modelClass.beforeDestroy(async (record) => {
     const position = record.readAttribute(positionColumn)
 
-    if (position == null) return
+    if (position == null) {
+      const modelClass = /** @type {typeof import("./index.js").default} */ (record.constructor)
+      const posColumn = modelClass.getColumnNameForAttributeName(positionColumn)
+
+      if (posColumn in record._attributes) assertPositivePosition({position, positionColumn, persisted: true})
+      return
+    }
+    assertPositivePosition({position, positionColumn, persisted: true})
 
     await moveOutOfWay({record, positionColumn, scope})
     setShiftingFlag(record, false)
@@ -130,6 +145,22 @@ export default function registerActsAsListCallbacks(modelClass, positionColumn,
   })
 }
 
+/**
+ * Enforces the public gap-less list position invariant before any shifting.
+ * @param {object} args - Arguments.
+ * @param {number | null | undefined} args.position - Position to validate.
+ * @param {string} args.positionColumn - Position attribute name.
+ * @param {boolean} [args.persisted] - Whether the invalid value came from persisted state.
+ * @returns {void}
+ */
+function assertPositivePosition({position, positionColumn, persisted = false}) {
+  if (typeof position === "number" && Number.isInteger(position) && position > 0) return
+
+  const source = persisted ? "Persisted" : "Requested"
+
+  throw new Error(`${source} actsAsList ${positionColumn} must be a positive integer`)
+}
+
 /**
  * Places a moved row after surrounding rows have shifted.
  * @param {object} args - Arguments.
@@ -380,30 +411,26 @@ function resolveScopeValue(record, scope) {
  * @param {string} args.positionColumn - camelCase position attribute.
  * @param {string} args.scope - camelCase scope attribute.
  * @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, targetScopeValue}) {
+async function moveOutOfWay({record, positionColumn, scope, scopeValue}) {
   const modelClass = /** @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 tempPosition = -record.id()
   const positionColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(positionColumn))
   const scopeColumnSql = connection.quoteColumn(modelClass.getColumnNameForAttributeName(scope))
   const tableSql = connection.quoteTable(tableName)
-  const pkSql = connection.quoteColumn("id")
+  const pkSql = connection.quoteColumn(modelClass.primaryKey())
 
   setShiftingFlag(record, true)
 
   try {
     await connection.query(
-      `UPDATE ${tableSql} SET ${scopeColumnSql} = ${connection.quote(resolvedTargetScopeValue)}, ${positionColumnSql} = ${connection.quote(tempPosition)} 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(record.id())}`
     )
   } finally {
     // Don't clear the flag here — the caller will do that after shifts

package/src/environment-handlers/node/cli/commands/generate/base-models.js

@@ -154,16 +154,12 @@ export default class DbGenerateModel extends BaseCommand {
       // --- getModelClass() override (fixes polymorphic typing in JS/JSDoc) ---
       if (await fileExists(sourceModelFullFilePath)) {
         // Model file exists (e.g. src/models/ticket.js) → return typeof Ticket
-        fileContent += "  /**\n"
-        fileContent += `   * @returns {typeof import("${sourceModelFilePath}").default}\n`
-        fileContent += "   */\n"
+        fileContent += `  /** @returns {typeof import("${sourceModelFilePath}").default} */\n`
         fileContent += "  // @ts-ignore - override narrows return type for better IntelliSense in generated model bases\n"
         fileContent += `  getModelClass() { return /** @type {typeof import("${sourceModelFilePath}").default} */ (this.constructor) }\n\n`
       } else {
         // No model file yet → fall back to typeof TicketBase
-        fileContent += "  /**\n"
-        fileContent += `   * @returns {typeof ${modelNameCamelized}Base}\n`
-        fileContent += "   */\n"
+        fileContent += `  /** @returns {typeof ${modelNameCamelized}Base} */\n`
         fileContent += "  // @ts-ignore - override narrows return type for better IntelliSense in generated model bases\n"
         fileContent += `  getModelClass() { return /** @type {typeof ${modelNameCamelized}Base} */ (this.constructor) }\n\n`
       }
@@ -181,9 +177,7 @@ export default class DbGenerateModel extends BaseCommand {
         }
 
         if (jsdocType) {
-          fileContent += "  /**\n"
-          fileContent += `   * @returns {${jsdocType}${column.getNull() ? " | null" : ""}}\n`
-          fileContent += "   */\n"
+          fileContent += `  /** @returns {${jsdocType}${column.getNull() ? " | null" : ""}} */\n`
         }
 
         fileContent += `  ${camelizedColumnName}() { return this.readAttribute("${camelizedColumnName}") }\n\n`
@@ -199,9 +193,7 @@ export default class DbGenerateModel extends BaseCommand {
 
         fileContent += `  set${camelizedColumnNameBigFirst}(newValue) { return this._setColumnAttribute("${camelizedColumnName}", newValue) }\n\n`
 
-        fileContent += "  /**\n"
-        fileContent += "   * @returns {boolean}\n"
-        fileContent += "   */\n"
+        fileContent += "  /** @returns {boolean} */\n"
         fileContent += `  has${camelizedColumnNameBigFirst}() { return this._hasAttribute(this.${camelizedColumnName}()) }\n`
 
         methodsCount++