velocious 1.0.650 → 1.0.652

package/src/database/record/counter-cache-parent-updates.js

@@ -0,0 +1,137 @@
+// @ts-check
+
+import Logger from "../../logger.js"
+import {ensureError} from "typanic"
+
+/** @typedef {(parent: import("./index.js").default, previousParent: import("./index.js").default | undefined) => void | Promise<void>} CounterCacheParentUpdateListener */
+/** @typedef {{canonicalParentModelClass: typeof import("./index.js").default, listeners: CounterCacheParentUpdateListener[], parentId: ReturnType<typeof JSON.parse>, parentPrimaryKey: string, parentQuery: import("../query/model-class-query.js").default<typeof import("./index.js").default>, previousParent: import("./index.js").default | undefined}} PreparedCounterCacheParentUpdate */
+
+/** @type {WeakMap<typeof import("./index.js").default, Set<CounterCacheParentUpdateListener>>} */
+const listenersByParentModelClass = new WeakMap()
+
+/**
+ * Registers an internal listener for committed counter-cache parent updates.
+ * @param {typeof import("./index.js").default} parentModelClass - Parent model class.
+ * @param {CounterCacheParentUpdateListener} listener - Committed-parent listener.
+ * @returns {() => void} - Listener removal callback.
+ */
+export function registerCounterCacheParentUpdateListener(parentModelClass, listener) {
+  const canonicalParentModelClass = parentModelClass.canonicalRecordMetadataModelClass()
+  let listeners = listenersByParentModelClass.get(canonicalParentModelClass)
+
+  if (!listeners) {
+    listeners = new Set()
+    listenersByParentModelClass.set(canonicalParentModelClass, listeners)
+  }
+
+  listeners.add(listener)
+
+  return () => listeners.delete(listener)
+}
+
+/**
+ * Captures one counter-cache parent's pre-mutation state when listeners are registered.
+ * @param {object} args - Parent update arguments.
+ * @param {ReturnType<typeof JSON.parse>} args.parentId - Parent relationship identity.
+ * @param {typeof import("./index.js").default} args.parentModelClass - Parent model class.
+ * @param {string} args.parentPrimaryKey - Parent relationship primary key.
+ * @param {import("../query/model-class-query.js").default<typeof import("./index.js").default>} args.parentQuery - Source-owned parent query.
+ * @returns {Promise<PreparedCounterCacheParentUpdate | undefined>} - Prepared delivery, or undefined when no listener is registered.
+ */
+export async function prepareCounterCacheParentUpdate({parentId, parentModelClass, parentPrimaryKey, parentQuery}) {
+  const canonicalParentModelClass = parentModelClass.canonicalRecordMetadataModelClass()
+  const registeredListeners = listenersByParentModelClass.get(canonicalParentModelClass)
+
+  if (!registeredListeners || registeredListeners.size == 0) return
+  const previousParent = await parentQuery.findBy({[parentPrimaryKey]: parentId}) || undefined
+
+  return {
+    canonicalParentModelClass,
+    listeners: [...registeredListeners],
+    parentId,
+    parentPrimaryKey,
+    parentQuery,
+    previousParent
+  }
+}
+
+/**
+ * Schedules one non-coalesced parent reload and notification on the source record's commit lifecycle.
+ * @param {object} args - Parent update arguments.
+ * @param {PreparedCounterCacheParentUpdate | undefined} args.preparedUpdate - Pre-mutation parent delivery state.
+ * @param {import("./index.js").default} args.sourceRecord - Source record that owns the transaction lifecycle.
+ * @returns {Promise<void>} - Resolves after registration or immediate delivery.
+ */
+export async function scheduleCounterCacheParentUpdate({preparedUpdate, sourceRecord}) {
+  if (!preparedUpdate) return
+
+  const {canonicalParentModelClass, listeners, parentId, parentPrimaryKey, parentQuery, previousParent} = preparedUpdate
+
+  await sourceRecord.connection().afterCommit(async () => {
+    let parent
+
+    try {
+      parent = await parentQuery.findBy({[parentPrimaryKey]: parentId})
+    } catch (error) {
+      await reportCounterCacheParentUpdateError(canonicalParentModelClass._getConfiguration(), error)
+      return
+    }
+
+    if (!parent) return
+
+    for (const listener of listeners) {
+      try {
+        await listener(parent, previousParent)
+      } catch (error) {
+        await reportCounterCacheParentUpdateError(parent._getConfiguration(), error)
+      }
+    }
+  })
+}
+
+/**
+ * Reports a post-commit delivery failure without rejecting the durable source operation.
+ * @param {import("../../configuration.js").default} configuration - Owning configuration.
+ * @param {ReturnType<typeof JSON.parse>} caughtError - Reload or listener failure.
+ * @returns {Promise<void>} - Resolves after best-effort reporting.
+ */
+async function reportCounterCacheParentUpdateError(configuration, caughtError) {
+  const error = ensureError(caughtError)
+  const payload = {
+    context: {stage: "counter-cache-parent-update-after-commit"},
+    error
+  }
+  /** @type {ReturnType<typeof JSON.parse>[]} */
+  const reportingErrors = []
+  let errorEvents
+
+  try {
+    errorEvents = configuration.getErrorEvents()
+  } catch (reportingError) {
+    reportingErrors.push(reportingError)
+  }
+
+  if (errorEvents) {
+    try {
+      errorEvents.emit("framework-error", payload)
+    } catch (reportingError) {
+      reportingErrors.push(reportingError)
+    }
+
+    try {
+      errorEvents.emit("all-error", {...payload, errorType: "framework-error"})
+    } catch (reportingError) {
+      reportingErrors.push(reportingError)
+    }
+  }
+
+  if (reportingErrors.length == 0) return
+
+  try {
+    const logger = new Logger("CounterCacheParentUpdates", {configuration})
+
+    await logger.error("Counter-cache parent update error reporting failed", {error, reportingErrors})
+  } catch {
+    console.error("Counter-cache parent update error reporting failed")
+  }
+}

package/src/database/record/index.js

@@ -56,6 +56,7 @@ import {formatValue} from "../../utils/format-value.js"
 import {modelPrimaryKeyCacheKey, modelPrimaryKeyConditions, readModelPrimaryKeyValue, scalarModelPrimaryKey, scalarModelPrimaryKeyValue} from "../../utils/model-primary-key.js"
 import {captureCreateAuditChanges, captureUpdateAuditChanges, createAudit, createCreateAudit, createDestroyAudit, createUpdateAudit, initializeAuditing, registerAuditCallback, registerAuditing, withoutAudit} from "./auditing.js"
 import {registerMagnitudeCounterCache} from "./counter-cache-magnitude.js"
+import {prepareCounterCacheParentUpdate, scheduleCounterCacheParentUpdate} from "./counter-cache-parent-updates.js"
 import {stateMachine} from "./state-machine.js"
 import ValidatorsFormat from "./validators/format.js"
 import ValidatorsLength from "./validators/length.js"
@@ -999,14 +1000,23 @@ class VelociousDatabaseRecord {
       const parentTable = ParentModel.tableName()
       const childTable = ChildModel.tableName()
       const pkColumn = inflection.underscore(primaryKey)
-      const connection = record
-        .queryForModel(ParentModel)
-        .driver
+      const parentQuery = record.queryForModel(ParentModel)
+      const connection = parentQuery.driver
       const quoted = connection.quote(parentId)
+      const preparedParentUpdate = await prepareCounterCacheParentUpdate({
+        parentId,
+        parentModelClass: ParentModel,
+        parentPrimaryKey: primaryKey,
+        parentQuery
+      })
 
       const sql = `UPDATE ${connection.quoteTable(parentTable)} SET ${connection.quoteColumn(counterColumn)} = (SELECT COUNT(*) FROM ${connection.quoteTable(childTable)} WHERE ${connection.quoteColumn(fk)} = ${quoted}) WHERE ${connection.quoteColumn(pkColumn)} = ${quoted}`
 
       await connection.query(sql, {logName: `${ParentModel.name} Update`})
+      await scheduleCounterCacheParentUpdate({
+        preparedUpdate: preparedParentUpdate,
+        sourceRecord: record
+      })
     }
 
     /**

package/src/frontend-models/websocket-publishers.js

@@ -5,12 +5,14 @@ import {frontendModelResourcesWithBuiltInsForBackendProject} from "./built-in-re
 import {frontendModelResourceDefinitionIsClass} from "./resource-definition.js"
 import {serializeFrontendModelTransportValue} from "./transport-serialization.js"
 import {modelPrimaryKeyCacheKey, readModelPrimaryKeyValue} from "../utils/model-primary-key.js"
+import {registerCounterCacheParentUpdateListener} from "../database/record/counter-cache-parent-updates.js"
 
 /** @typedef {{primaryKey: import("../utils/model-primary-key.js").ModelPrimaryKeyDefinition}} FrontendModelPublisherResource */
 /** @typedef {Record<string, import("./query.js").FrontendModelTransportValue>} FrontendModelDestroyAuthorizationRecord */
 /** @typedef {import("../database/record/index.js").default & {__frontendModelWebsocketAction?: "create" | "update", __frontendModelWebsocketDestroyAuthorizationRecord?: FrontendModelDestroyAuthorizationRecord, __frontendModelWebsocketPreviousIds?: Map<string, import("../utils/model-primary-key.js").ModelPrimaryKeyValue>}} FrontendModelWebsocketRecord */
 
 const modelClassesWithRegisteredHooks = new WeakSet()
+const modelClassesWithRegisteredCounterCacheParentListeners = new WeakSet()
 const channelClassRegisteredConfigurations = new WeakSet()
 /** @type {WeakMap<import("../configuration.js").default, WeakMap<typeof import("../database/record/index.js").default, Map<string, FrontendModelPublisherResource>>>} */
 const publisherResourcesByConfiguration = new WeakMap()
@@ -127,6 +129,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
     if (!resourceClass.ModelClass) continue
 
     const modelClass = resourceClass.modelClass()
+    const canonicalModelClass = modelClass.canonicalRecordMetadataModelClass()
     const resourceConfiguration = resourceClass.resourceConfig()
     const configuredPrimaryKey = resourceConfiguration.primaryKey
     const modelPrimaryKey = modelClass.primaryKey()
@@ -140,38 +143,47 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
       publisherResourcesByConfiguration.set(configuration, publisherResourcesByModelClass)
     }
 
-    let publisherResources = publisherResourcesByModelClass.get(modelClass)
+    let publisherResources = publisherResourcesByModelClass.get(canonicalModelClass)
 
     if (!publisherResources) {
       publisherResources = new Map()
-      publisherResourcesByModelClass.set(modelClass, publisherResources)
+      publisherResourcesByModelClass.set(canonicalModelClass, publisherResources)
     }
 
     publisherResources.set(modelName, {
       primaryKey
     })
 
+    if (!modelClassesWithRegisteredCounterCacheParentListeners.has(canonicalModelClass)) {
+      modelClassesWithRegisteredCounterCacheParentListeners.add(canonicalModelClass)
+      registerCounterCacheParentUpdateListener(canonicalModelClass, (parent, previousParent) => {
+        const previousIds = previousParent ? frontendModelResourceIdentities(previousParent) : undefined
+
+        broadcastFrontendModelEvents(parent, "update", previousIds)
+      })
+    }
+
     // Register lifecycle hooks once per model class, not per configuration. A model class belongs to a
     // single backend project/config in production, so per-config registration only differs in tests where
     // the same model class is reachable from multiple configs — there it attaches duplicate beforeCreate/
     // afterSave/afterDestroy hooks that double-fire broadcasts (and leak across specs). The hooks read the
     // model's runtime configuration when broadcasting, so a single registration is sufficient.
-    if (modelClassesWithRegisteredHooks.has(modelClass)) continue
+    if (modelClassesWithRegisteredHooks.has(canonicalModelClass)) continue
 
-    modelClassesWithRegisteredHooks.add(modelClass)
+    modelClassesWithRegisteredHooks.add(canonicalModelClass)
 
-    modelClass.beforeCreate((model) => {
+    canonicalModelClass.beforeCreate((model) => {
       /** @type {FrontendModelWebsocketRecord} */ (model).__frontendModelWebsocketAction = "create"
     })
 
-    modelClass.beforeUpdate(async (model) => {
+    canonicalModelClass.beforeUpdate(async (model) => {
       const websocketModel = /** @type {FrontendModelWebsocketRecord} */ (model)
 
       websocketModel.__frontendModelWebsocketAction = "update"
       websocketModel.__frontendModelWebsocketPreviousIds = await frontendModelPreviousResourceIdentities(model)
     })
 
-    modelClass.beforeDestroy(async (model) => {
+    canonicalModelClass.beforeDestroy(async (model) => {
       const websocketModel = /** @type {FrontendModelWebsocketRecord} */ (model)
       const persistedModel = await model
         .queryForModel(model.getModelClass())
@@ -183,7 +195,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
       websocketModel.__frontendModelWebsocketDestroyAuthorizationRecord = frontendModelDestroyAuthorizationRecord(persistedModel)
     })
 
-    modelClass.afterSave((model) => {
+    canonicalModelClass.afterSave((model) => {
       const modelWithWebsocketAction = /** @type {FrontendModelWebsocketRecord} */ (model)
       const action = modelWithWebsocketAction.__frontendModelWebsocketAction
 
@@ -197,7 +209,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
       delete modelWithWebsocketAction.__frontendModelWebsocketPreviousIds
     })
 
-    modelClass.afterDestroy((model) => {
+    canonicalModelClass.afterDestroy((model) => {
       const websocketModel = /** @type {FrontendModelWebsocketRecord} */ (model)
       const destroyAuthorizationRecord = websocketModel.__frontendModelWebsocketDestroyAuthorizationRecord
       const previousIds = websocketModel.__frontendModelWebsocketPreviousIds
@@ -217,7 +229,7 @@ export async function ensureFrontendModelWebsocketPublishersRegistered(configura
  * @returns {Promise<Map<string, import("../utils/model-primary-key.js").ModelPrimaryKeyValue>>} - Previous identities by resource name.
  */
 async function frontendModelPreviousResourceIdentities(model) {
-  const publisherResources = publisherResourcesByConfiguration.get(model._getConfiguration())?.get(model.getModelClass())
+  const publisherResources = publisherResourcesForModel(model)
   /** @type {Map<string, import("../utils/model-primary-key.js").ModelPrimaryKeyValue>} */
   const previousIds = new Map()
 
@@ -252,7 +264,7 @@ async function frontendModelPreviousResourceIdentities(model) {
  * @returns {Map<string, import("../utils/model-primary-key.js").ModelPrimaryKeyValue>} - Identities by resource name.
  */
 function frontendModelResourceIdentities(model) {
-  const publisherResources = publisherResourcesByConfiguration.get(model._getConfiguration())?.get(model.getModelClass())
+  const publisherResources = publisherResourcesForModel(model)
   /** @type {Map<string, import("../utils/model-primary-key.js").ModelPrimaryKeyValue>} */
   const identities = new Map()
 
@@ -267,6 +279,17 @@ function frontendModelResourceIdentities(model) {
   return identities
 }
 
+/**
+ * Returns publisher resources through the backing model's canonical registry owner.
+ * @param {import("../database/record/index.js").default} model - Backing model instance.
+ * @returns {Map<string, FrontendModelPublisherResource> | undefined} - Publisher resources for the model.
+ */
+function publisherResourcesForModel(model) {
+  const canonicalModelClass = model.getModelClass().canonicalRecordMetadataModelClass()
+
+  return publisherResourcesByConfiguration.get(model._getConfiguration())?.get(canonicalModelClass)
+}
+
 /**
  * Serializes the persisted record for server-side destroy authorization. Binary values
  * use a dedicated byte-array marker because the shared transport serializer otherwise
@@ -337,7 +360,7 @@ function frontendModelResourceIdentity({model, previous = false, primaryKey}) {
  */
 function broadcastFrontendModelEvents(model, action, previousIds, destroyAuthorizationRecord) {
   const configuration = model._getConfiguration()
-  const publisherResources = publisherResourcesByConfiguration.get(configuration)?.get(model.getModelClass())
+  const publisherResources = publisherResourcesForModel(model)
 
   if (!publisherResources) return
 

package/src/http-client/websocket-client.js

@@ -118,19 +118,51 @@ export default class VelociousWebsocketClient extends SnapReqWebSocketClient {
     if (this.gracefulClosePromise) return await this.gracefulClosePromise
 
     this.autoReconnect = false
+    const channelSubscriptions = [...this._channelSubscriptions.values()]
     const socket = this.socket
+
+    this._channelSubscriptions.clear()
+    const {promise: publishedClosePromise, reject: rejectPublishedClose, resolve: resolvePublishedClose} = Promise.withResolvers()
+
+    this.gracefulClosePromise = publishedClosePromise
+    // This internal bridge exists only for synchronous reentrancy. Its rejection
+    // duplicates closePromise, which remains the public error source below.
+    void publishedClosePromise.catch(() => {})
     const closePromise = (async () => {
-      if (socket && socket.readyState === socket.OPEN) {
-        await new Promise((resolve) => {
-          socket.addEventListener("close", () => resolve(undefined), {once: true})
-          socket.close(1000)
-        })
+      /** @type {unknown[]} */
+      const closeErrors = []
+
+      for (const subscription of channelSubscriptions) {
+        try {
+          subscription._handleClosed("client_close")
+        } catch (error) {
+          closeErrors.push(error)
+        }
+      }
+
+      try {
+        if (socket && socket.readyState === socket.OPEN) {
+          await new Promise((resolve) => {
+            socket.addEventListener("close", () => resolve(undefined), {once: true})
+            socket.close(1000)
+          })
+        }
+      } catch (error) {
+        closeErrors.push(error)
       }
 
-      await super.close()
+      try {
+        await super.close()
+      } catch (error) {
+        closeErrors.push(error)
+      }
+
+      if (closeErrors.length === 1) throw closeErrors[0]
+      if (closeErrors.length > 1) throw new AggregateError(closeErrors, "Failed to close WebSocket client")
     })()
 
     this.gracefulClosePromise = closePromise
+    void closePromise.then(resolvePublishedClose, rejectPublishedClose)
 
     try {
       await closePromise
@@ -148,12 +180,12 @@ export default class VelociousWebsocketClient extends SnapReqWebSocketClient {
     this.reconnectGeneration += 1
     await super.disconnectAndStopReconnect()
 
-    if (this.runningReconnectTasks.size === 0) return
-
     while (this.runningReconnectTasks.size > 0) {
       await Promise.all(this.runningReconnectTasks)
     }
 
+    // A stale attempt may have finished during the first close after changing
+    // stopped state, even when the task set is already empty here.
     await super.disconnectAndStopReconnect()
   }
 }