velocious 1.0.650 → 1.0.651

package/README.md

@@ -13,7 +13,7 @@
 * External packages (engines) that contribute data models, frontend-model resources and migrations to a consuming app (see [docs/packages.md](docs/packages.md))
 * Optional Rampway-owned durable deployment control plane mounted through the standard routes DSL on Velocious 1.0.577 or newer (see [docs/rampway-integration.md](docs/rampway-integration.md))
 * Controllers and views for HTTP endpoints
-* Frontend-model transport for creating, updating, querying, and subscribing to query-filtered lifecycle events over HTTP/WebSocket, with structured per-attribute validation error responses, immutable per-operation remote request context, registration-local tenant subscription partitioning, and one-budget WebSocket startup controls (see [docs/frontend-models.md](docs/frontend-models.md), [docs/remote-request-context.md](docs/remote-request-context.md), and [docs/websocket-channels.md](docs/websocket-channels.md))
+* Frontend-model transport for creating, updating, querying, and subscribing to query-filtered lifecycle events over HTTP/WebSocket, including committed counter-cache parent updates, structured per-attribute validation error responses, immutable per-operation remote request context, registration-local tenant subscription partitioning, and one-budget WebSocket startup controls (see [docs/frontend-models.md](docs/frontend-models.md), [docs/remote-request-context.md](docs/remote-request-context.md), and [docs/websocket-channels.md](docs/websocket-channels.md))
 * Client-side offline sync mutation logs and frontend-model optimistic queueing primitives (see the [shared-resource sync developer guide](docs/shared-resource-sync-guide.md) and [offline sync architecture](docs/offline-sync.md))
 * Declarative client sync scopes with per-scope cursors, automatic mutation tracking, opt-in durable base-version conflict replay, realtime delivery, and immutable-handle project clients whose local database state plus remote pull/replay/realtime request context stay tenant-bound through reconnect (see [docs/sync-client.md](docs/sync-client.md), [docs/remote-request-context.md](docs/remote-request-context.md), and [docs/offline-sync.md](docs/offline-sync.md))
 * Reactive `useLiveQuery(Model.where(...))` queries for default databases plus immutable-handle tenant live-query sources whose committed events and refreshes stay on the captured physical tenant (see [docs/live-queries.md](docs/live-queries.md))
@@ -2124,7 +2124,9 @@ await client.close()
 
 For long-lived Node clients, the constructor also accepts opt-in liveness options (all default off, so browser/Expo usage is unchanged): `webSocketImplementation` (inject Node's `ws`, since the global/undici WebSocket exposes neither protocol ping nor an unref-able socket), `heartbeatIntervalMs` (a ping heartbeat that drops a socket whose peer stops ponging, so a client notices a vanished server), and `unref` (unref the underlying socket so an idle connection can't keep the process alive on its own). See [docs/websocket-channels.md](docs/websocket-channels.md).
 
-`await client.close()` is a final graceful shutdown that releases resumable server-session state; unexpected transport drops first attempt to resume that state. On a multi-worker server, the client automatically puts the prior session identity in the reconnect upgrade URL so the host can route it to its owning worker; routing is session-based and never source-IP-based. A successful resume retains the existing server-side connection and channel instances. If the server instead rejects the old session with `session-gone`, SnapReq promotes the already-established fresh session, reopens still-live one-to-one connection handles, and re-subscribes still-live channel handles. Those public handles remain usable and channel readiness resolves on the fresh session; explicitly closed handles stay closed. A channel that the server permanently closes or rejects remains terminal and is not automatically reopened; register a new listener after changing the authorization or request context. See [the WebSocket channel lifecycle guarantees](docs/websocket-channels.md#lifecycle-guarantees-phase-1b).
+`await client.close()` is a final graceful shutdown that releases resumable server-session state. Every channel subscription still tracked by the client, including a pending subscription, becomes closed and receives `onClose("client_close")`. A pending `subscription.ready` still rejects because no subscribe acknowledgement arrived, and its error identifies `client_close`. Throwing channel close callbacks do not stop the remaining handles or transport/base cleanup; after cleanup, `client.close()` rejects with the original error for one failed callback or teardown step, or with an `AggregateError` for multiple failures.
+
+Unexpected transport drops first attempt to resume server-session state. On a multi-worker server, the client automatically puts the prior session identity in the reconnect upgrade URL so the host can route it to its owning worker; routing is session-based and never source-IP-based. A successful resume retains the existing server-side connection and channel instances. If the server instead rejects the old session with `session-gone`, SnapReq promotes the already-established fresh session, reopens still-live one-to-one connection handles, and re-subscribes still-live channel handles. Those public handles remain usable and channel readiness resolves on the fresh session; explicitly closed handles stay closed. A channel that the server permanently closes or rejects remains terminal and is not automatically reopened; register a new listener after changing the authorization or request context. See [the WebSocket channel lifecycle guarantees](docs/websocket-channels.md#lifecycle-guarantees-phase-1b).
 
 ## Subscribe to events
 

package/build/database/record/counter-cache-magnitude.js

@@ -1,5 +1,7 @@
 // @ts-check
 
+import {prepareCounterCacheParentUpdate, scheduleCounterCacheParentUpdate} from "./counter-cache-parent-updates.js"
+
 /**
  * Reactive counter-cache driven by a per-record magnitude.
  *
@@ -206,17 +208,26 @@ async function incrementParentCounter(record, definition, parentId, amount) {
 
   // Resolve through the record so an operation both owns the parent write and
   // rejects a relationship whose parent routes to another database.
-  const db = record
-    .queryForModel(parentModelClass)
-    .driver
+  const parentQuery = record.queryForModel(parentModelClass)
+  const db = parentQuery.driver
   const counterColumnSql = db.quoteColumn(definition.counterColumn)
   const truncatedAmount = Math.trunc(amount)
+  const preparedParentUpdate = await prepareCounterCacheParentUpdate({
+    parentId,
+    parentModelClass,
+    parentPrimaryKey: relationship.getPrimaryKey(),
+    parentQuery
+  })
 
   await db.query(
     `UPDATE ${db.quoteTable(parentModelClass.tableName())} ` +
     `SET ${counterColumnSql} = COALESCE(${counterColumnSql}, 0) + ${truncatedAmount} ` +
     `WHERE ${db.quoteColumn(relationship.getPrimaryKey())} = ${db.quote(parentId)}`
   )
+  await scheduleCounterCacheParentUpdate({
+    preparedUpdate: preparedParentUpdate,
+    sourceRecord: record
+  })
 }
 
 /**

package/build/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/build/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/build/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/build/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)
+      }
+
+      try {
+        await super.close()
+      } catch (error) {
+        closeErrors.push(error)
       }
 
-      await super.close()
+      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

package/build/src/database/record/counter-cache-magnitude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"counter-cache-magnitude.d.ts","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-magnitude.js"],"names":[],"mappings":"AAkBG,YAKG,+BAA+B,GALxB;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,CAAA;CAClE,CAAiC;AAKlC,YAAgJ,qBAAqB,GAA3J;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;CAAC,CAAuB;AA1BxK;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAJ7C,cAAc,YAAY,EAAE,OAIiB,EAAE,UAAU,EAHzD,+BAGyD,GAFvD,IAAI,CAiDhB"}
+{"version":3,"file":"counter-cache-magnitude.d.ts","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-magnitude.js"],"names":[],"mappings":"AAoBG,YAKG,+BAA+B,GALxB;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,CAAA;CAClE,CAAiC;AAKlC,YAAgJ,qBAAqB,GAA3J;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IAAC,WAAW,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAA;CAAC,CAAuB;AA1BxK;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AAEH;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAJ7C,cAAc,YAAY,EAAE,OAIiB,EAAE,UAAU,EAHzD,+BAGyD,GAFvD,IAAI,CAiDhB"}

package/build/src/database/record/counter-cache-magnitude.js

@@ -1,4 +1,5 @@
 // @ts-check
+import { prepareCounterCacheParentUpdate, scheduleCounterCacheParentUpdate } from "./counter-cache-parent-updates.js";
 /**
  * Reactive counter-cache driven by a per-record magnitude.
  *
@@ -175,14 +176,23 @@ async function incrementParentCounter(record, definition, parentId, amount) {
     }
     // Resolve through the record so an operation both owns the parent write and
     // rejects a relationship whose parent routes to another database.
-    const db = record
-        .queryForModel(parentModelClass)
-        .driver;
+    const parentQuery = record.queryForModel(parentModelClass);
+    const db = parentQuery.driver;
     const counterColumnSql = db.quoteColumn(definition.counterColumn);
     const truncatedAmount = Math.trunc(amount);
+    const preparedParentUpdate = await prepareCounterCacheParentUpdate({
+        parentId,
+        parentModelClass,
+        parentPrimaryKey: relationship.getPrimaryKey(),
+        parentQuery
+    });
     await db.query(`UPDATE ${db.quoteTable(parentModelClass.tableName())} ` +
         `SET ${counterColumnSql} = COALESCE(${counterColumnSql}, 0) + ${truncatedAmount} ` +
         `WHERE ${db.quoteColumn(relationship.getPrimaryKey())} = ${db.quote(parentId)}`);
+    await scheduleCounterCacheParentUpdate({
+        preparedUpdate: preparedParentUpdate,
+        sourceRecord: record
+    });
 }
 /**
  * Resolves the column name backing an attribute name.
@@ -203,4 +213,4 @@ function attributeNameForColumn(record, columnName) {
     const map = record.getModelClass().getAttributeNameToColumnNameMap();
     return Object.keys(map).find((attributeName) => map[attributeName] === columnName) || columnName;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"counter-cache-magnitude.js","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-magnitude.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Reactive counter-cache driven by a per-record magnitude.\n *\n * Maintains a counter column on a `belongsTo` parent as the running sum of each\n * child's magnitude — a small number derived from one source attribute (e.g.\n * `1` while a build's `status` is `running`, else `0`). On every create, update\n * and destroy the change in magnitude is applied to the parent as a single\n * atomic increment (`SET col = col + delta`), and when the foreign key changes\n * the magnitude is moved from the old parent to the new one.\n *\n * Because the counter is derived from the source attribute and diffed on every\n * write, it follows that attribute automatically no matter which code path wrote\n * it — there is no per-transition increment/decrement to forget. The old value is\n * captured in `beforeSave` (Velocious clears `changes()` during the post-update\n * reload) and consumed in `afterSave`, so the increment commits atomically with\n * the row it reflects.\n * @typedef {{\n *   belongsTo: string,\n *   counterColumn: string,\n *   sourceAttribute: string,\n *   magnitude: (sourceValue: ReturnType<typeof JSON.parse>) => number\n * }} MagnitudeCounterCacheDefinition\n */\n\n/**\n * Captured pending magnitude change stashed on a record between beforeSave and afterSave.\n * @typedef {{newMagnitude: number, oldMagnitude: number, newParentId: ReturnType<typeof JSON.parse>, oldParentId: ReturnType<typeof JSON.parse>}} PendingMagnitudeDelta\n */\n\n/**\n * Registers a reactive magnitude counter-cache on a model class.\n * @param {typeof import(\"./index.js\").default} modelClass - Model class to add the counter cache to.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {void}\n */\nexport function registerMagnitudeCounterCache(modelClass, definition) {\n  /**\n   * Dynamic class.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const dynamicClass = modelClass\n  const registeredFlag = `_magnitudeCounterCacheRegistered_${definition.counterColumn}`\n\n  // Idempotent per counter column: re-declaring (or subclassing) must not double-register.\n  if (Object.prototype.hasOwnProperty.call(dynamicClass, registeredFlag) && dynamicClass[registeredFlag]) {\n    return\n  }\n\n  dynamicClass[registeredFlag] = true\n\n  const pendingKey = `_magnitudeCounterCachePending_${definition.counterColumn}`\n\n  modelClass.beforeSave(async function (record) {\n    /**\n     * Dynamic record.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicRecord = record\n\n    dynamicRecord[pendingKey] = computePendingMagnitudeDelta(record, definition)\n  })\n\n  modelClass.afterSave(async function (record) {\n    /**\n     * Dynamic record.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicRecord = record\n    const pending = /** @type {PendingMagnitudeDelta | null} */ (dynamicRecord[pendingKey])\n\n    dynamicRecord[pendingKey] = null\n\n    if (pending) {\n      await applyPendingMagnitudeDelta(record, definition, pending)\n    }\n  })\n\n  modelClass.afterDestroy(async function (record) {\n    const magnitude = definition.magnitude(record.readAttribute(definition.sourceAttribute))\n    const parentId = currentParentId(record, definition)\n\n    if (parentId && magnitude !== 0) {\n      await incrementParentCounter(record, definition, parentId, -magnitude)\n    }\n  })\n}\n\n/**\n * Diffs the source attribute (and foreign key) across the pending save to capture\n * how the parent counter should move. Runs in beforeSave, where `changes()` still\n * holds the pre-save values.\n * @param {import(\"./index.js\").default} record - Record being saved.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {PendingMagnitudeDelta} The captured magnitude change.\n */\nfunction computePendingMagnitudeDelta(record, definition) {\n  const changes = record.changes()\n  const sourceColumn = columnNameForAttribute(record, definition.sourceAttribute)\n  const foreignKeyColumn = record.getModelClass().getRelationshipByName(definition.belongsTo).getForeignKey()\n\n  const newSource = record.readAttribute(definition.sourceAttribute)\n  const oldSource = oldSourceValueThroughReadCast(record, definition.sourceAttribute, sourceColumn, changes, newSource)\n\n  const newParentId = currentParentId(record, definition)\n  const oldParentId = foreignKeyColumn in changes ? changes[foreignKeyColumn][0] : newParentId\n\n  return {\n    newMagnitude: definition.magnitude(newSource),\n    oldMagnitude: definition.magnitude(oldSource),\n    newParentId,\n    oldParentId\n  }\n}\n\n/**\n * Applies a captured magnitude change to the parent counter(s) as atomic increments.\n * @param {import(\"./index.js\").default} record - Record that was saved.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @param {PendingMagnitudeDelta} pending - The captured magnitude change.\n * @returns {Promise<void>}\n */\nasync function applyPendingMagnitudeDelta(record, definition, pending) {\n  const {newMagnitude, oldMagnitude, newParentId, oldParentId} = pending\n\n  if (oldParentId === newParentId) {\n    const delta = newMagnitude - oldMagnitude\n\n    if (newParentId && delta !== 0) {\n      await incrementParentCounter(record, definition, newParentId, delta)\n    }\n\n    return\n  }\n\n  // The foreign key moved: take the old magnitude off the old parent and put the\n  // new magnitude on the new parent.\n  if (oldParentId && oldMagnitude !== 0) {\n    await incrementParentCounter(record, definition, oldParentId, -oldMagnitude)\n  }\n\n  if (newParentId && newMagnitude !== 0) {\n    await incrementParentCounter(record, definition, newParentId, newMagnitude)\n  }\n}\n\n/**\n * Reads the pre-save value of the source attribute through the normal read/cast\n * path, so `magnitude` receives the old value in the same shape as the new one\n * (e.g. a declared boolean as `true`/`false`, not the raw stored `1`/`0`). Drops\n * the pending change so `readAttribute` falls back to the committed value and\n * applies the same cast a fresh read would, then restores the pending change.\n * @param {import(\"./index.js\").default} record - Record being saved.\n * @param {string} sourceAttribute - Source attribute name.\n * @param {string} sourceColumn - Source column name.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} changes - The record's pre-save changes (column-keyed).\n * @param {ReturnType<typeof JSON.parse>} currentValue - The current (new) read value, returned when the source did not change.\n * @returns {ReturnType<typeof JSON.parse>} The read-cast pre-save value.\n */\nfunction oldSourceValueThroughReadCast(record, sourceAttribute, sourceColumn, changes, currentValue) {\n  if (!(sourceColumn in changes)) {\n    return currentValue\n  }\n\n  /**\n   * Dynamic record.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const dynamicRecord = record\n  const pendingChange = dynamicRecord._changes[sourceColumn]\n\n  delete dynamicRecord._changes[sourceColumn]\n\n  try {\n    return record.readAttribute(sourceAttribute)\n  } finally {\n    dynamicRecord._changes[sourceColumn] = pendingChange\n  }\n}\n\n/**\n * Reads the record's current foreign-key value for the counter-cache parent.\n * @param {import(\"./index.js\").default} record - Record whose parent is targeted.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {ReturnType<typeof JSON.parse>} The current foreign-key value.\n */\nfunction currentParentId(record, definition) {\n  const foreignKeyColumn = record.getModelClass().getRelationshipByName(definition.belongsTo).getForeignKey()\n\n  return record.readAttribute(attributeNameForColumn(record, foreignKeyColumn))\n}\n\n/**\n * Atomically adds `amount` to the parent's counter column for one parent row.\n * @param {import(\"./index.js\").default} record - Child record (for connection + relationship metadata).\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @param {ReturnType<typeof JSON.parse>} parentId - Parent primary-key value.\n * @param {number} amount - Signed integer to add.\n * @returns {Promise<void>}\n */\nasync function incrementParentCounter(record, definition, parentId, amount) {\n  const modelClass = record.getModelClass()\n  const relationship = modelClass.getRelationshipByName(definition.belongsTo)\n  const parentModelClass = relationship.getTargetModelClass()\n\n  if (!parentModelClass) {\n    throw new Error(`magnitudeCounterCache on ${modelClass.getModelName()} could not resolve the \"${definition.belongsTo}\" parent model class`)\n  }\n\n  // Resolve through the record so an operation both owns the parent write and\n  // rejects a relationship whose parent routes to another database.\n  const db = record\n    .queryForModel(parentModelClass)\n    .driver\n  const counterColumnSql = db.quoteColumn(definition.counterColumn)\n  const truncatedAmount = Math.trunc(amount)\n\n  await db.query(\n    `UPDATE ${db.quoteTable(parentModelClass.tableName())} ` +\n    `SET ${counterColumnSql} = COALESCE(${counterColumnSql}, 0) + ${truncatedAmount} ` +\n    `WHERE ${db.quoteColumn(relationship.getPrimaryKey())} = ${db.quote(parentId)}`\n  )\n}\n\n/**\n * Resolves the column name backing an attribute name.\n * @param {import(\"./index.js\").default} record - Record.\n * @param {string} attributeName - Attribute name.\n * @returns {string} The column name for the attribute (falls back to the attribute name).\n */\nfunction columnNameForAttribute(record, attributeName) {\n  return record.getModelClass().getAttributeNameToColumnNameMap()[attributeName] || attributeName\n}\n\n/**\n * Resolves the attribute name backing a column name.\n * @param {import(\"./index.js\").default} record - Record.\n * @param {string} columnName - Column name.\n * @returns {string} The attribute name for the column (falls back to the column name).\n */\nfunction attributeNameForColumn(record, columnName) {\n  const map = record.getModelClass().getAttributeNameToColumnNameMap()\n\n  return Object.keys(map).find((attributeName) => map[attributeName] === columnName) || columnName\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"counter-cache-magnitude.js","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-magnitude.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {prepareCounterCacheParentUpdate, scheduleCounterCacheParentUpdate} from \"./counter-cache-parent-updates.js\"\n\n/**\n * Reactive counter-cache driven by a per-record magnitude.\n *\n * Maintains a counter column on a `belongsTo` parent as the running sum of each\n * child's magnitude — a small number derived from one source attribute (e.g.\n * `1` while a build's `status` is `running`, else `0`). On every create, update\n * and destroy the change in magnitude is applied to the parent as a single\n * atomic increment (`SET col = col + delta`), and when the foreign key changes\n * the magnitude is moved from the old parent to the new one.\n *\n * Because the counter is derived from the source attribute and diffed on every\n * write, it follows that attribute automatically no matter which code path wrote\n * it — there is no per-transition increment/decrement to forget. The old value is\n * captured in `beforeSave` (Velocious clears `changes()` during the post-update\n * reload) and consumed in `afterSave`, so the increment commits atomically with\n * the row it reflects.\n * @typedef {{\n *   belongsTo: string,\n *   counterColumn: string,\n *   sourceAttribute: string,\n *   magnitude: (sourceValue: ReturnType<typeof JSON.parse>) => number\n * }} MagnitudeCounterCacheDefinition\n */\n\n/**\n * Captured pending magnitude change stashed on a record between beforeSave and afterSave.\n * @typedef {{newMagnitude: number, oldMagnitude: number, newParentId: ReturnType<typeof JSON.parse>, oldParentId: ReturnType<typeof JSON.parse>}} PendingMagnitudeDelta\n */\n\n/**\n * Registers a reactive magnitude counter-cache on a model class.\n * @param {typeof import(\"./index.js\").default} modelClass - Model class to add the counter cache to.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {void}\n */\nexport function registerMagnitudeCounterCache(modelClass, definition) {\n  /**\n   * Dynamic class.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const dynamicClass = modelClass\n  const registeredFlag = `_magnitudeCounterCacheRegistered_${definition.counterColumn}`\n\n  // Idempotent per counter column: re-declaring (or subclassing) must not double-register.\n  if (Object.prototype.hasOwnProperty.call(dynamicClass, registeredFlag) && dynamicClass[registeredFlag]) {\n    return\n  }\n\n  dynamicClass[registeredFlag] = true\n\n  const pendingKey = `_magnitudeCounterCachePending_${definition.counterColumn}`\n\n  modelClass.beforeSave(async function (record) {\n    /**\n     * Dynamic record.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicRecord = record\n\n    dynamicRecord[pendingKey] = computePendingMagnitudeDelta(record, definition)\n  })\n\n  modelClass.afterSave(async function (record) {\n    /**\n     * Dynamic record.\n     * @type {ReturnType<typeof JSON.parse>} */\n    const dynamicRecord = record\n    const pending = /** @type {PendingMagnitudeDelta | null} */ (dynamicRecord[pendingKey])\n\n    dynamicRecord[pendingKey] = null\n\n    if (pending) {\n      await applyPendingMagnitudeDelta(record, definition, pending)\n    }\n  })\n\n  modelClass.afterDestroy(async function (record) {\n    const magnitude = definition.magnitude(record.readAttribute(definition.sourceAttribute))\n    const parentId = currentParentId(record, definition)\n\n    if (parentId && magnitude !== 0) {\n      await incrementParentCounter(record, definition, parentId, -magnitude)\n    }\n  })\n}\n\n/**\n * Diffs the source attribute (and foreign key) across the pending save to capture\n * how the parent counter should move. Runs in beforeSave, where `changes()` still\n * holds the pre-save values.\n * @param {import(\"./index.js\").default} record - Record being saved.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {PendingMagnitudeDelta} The captured magnitude change.\n */\nfunction computePendingMagnitudeDelta(record, definition) {\n  const changes = record.changes()\n  const sourceColumn = columnNameForAttribute(record, definition.sourceAttribute)\n  const foreignKeyColumn = record.getModelClass().getRelationshipByName(definition.belongsTo).getForeignKey()\n\n  const newSource = record.readAttribute(definition.sourceAttribute)\n  const oldSource = oldSourceValueThroughReadCast(record, definition.sourceAttribute, sourceColumn, changes, newSource)\n\n  const newParentId = currentParentId(record, definition)\n  const oldParentId = foreignKeyColumn in changes ? changes[foreignKeyColumn][0] : newParentId\n\n  return {\n    newMagnitude: definition.magnitude(newSource),\n    oldMagnitude: definition.magnitude(oldSource),\n    newParentId,\n    oldParentId\n  }\n}\n\n/**\n * Applies a captured magnitude change to the parent counter(s) as atomic increments.\n * @param {import(\"./index.js\").default} record - Record that was saved.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @param {PendingMagnitudeDelta} pending - The captured magnitude change.\n * @returns {Promise<void>}\n */\nasync function applyPendingMagnitudeDelta(record, definition, pending) {\n  const {newMagnitude, oldMagnitude, newParentId, oldParentId} = pending\n\n  if (oldParentId === newParentId) {\n    const delta = newMagnitude - oldMagnitude\n\n    if (newParentId && delta !== 0) {\n      await incrementParentCounter(record, definition, newParentId, delta)\n    }\n\n    return\n  }\n\n  // The foreign key moved: take the old magnitude off the old parent and put the\n  // new magnitude on the new parent.\n  if (oldParentId && oldMagnitude !== 0) {\n    await incrementParentCounter(record, definition, oldParentId, -oldMagnitude)\n  }\n\n  if (newParentId && newMagnitude !== 0) {\n    await incrementParentCounter(record, definition, newParentId, newMagnitude)\n  }\n}\n\n/**\n * Reads the pre-save value of the source attribute through the normal read/cast\n * path, so `magnitude` receives the old value in the same shape as the new one\n * (e.g. a declared boolean as `true`/`false`, not the raw stored `1`/`0`). Drops\n * the pending change so `readAttribute` falls back to the committed value and\n * applies the same cast a fresh read would, then restores the pending change.\n * @param {import(\"./index.js\").default} record - Record being saved.\n * @param {string} sourceAttribute - Source attribute name.\n * @param {string} sourceColumn - Source column name.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} changes - The record's pre-save changes (column-keyed).\n * @param {ReturnType<typeof JSON.parse>} currentValue - The current (new) read value, returned when the source did not change.\n * @returns {ReturnType<typeof JSON.parse>} The read-cast pre-save value.\n */\nfunction oldSourceValueThroughReadCast(record, sourceAttribute, sourceColumn, changes, currentValue) {\n  if (!(sourceColumn in changes)) {\n    return currentValue\n  }\n\n  /**\n   * Dynamic record.\n   * @type {ReturnType<typeof JSON.parse>} */\n  const dynamicRecord = record\n  const pendingChange = dynamicRecord._changes[sourceColumn]\n\n  delete dynamicRecord._changes[sourceColumn]\n\n  try {\n    return record.readAttribute(sourceAttribute)\n  } finally {\n    dynamicRecord._changes[sourceColumn] = pendingChange\n  }\n}\n\n/**\n * Reads the record's current foreign-key value for the counter-cache parent.\n * @param {import(\"./index.js\").default} record - Record whose parent is targeted.\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @returns {ReturnType<typeof JSON.parse>} The current foreign-key value.\n */\nfunction currentParentId(record, definition) {\n  const foreignKeyColumn = record.getModelClass().getRelationshipByName(definition.belongsTo).getForeignKey()\n\n  return record.readAttribute(attributeNameForColumn(record, foreignKeyColumn))\n}\n\n/**\n * Atomically adds `amount` to the parent's counter column for one parent row.\n * @param {import(\"./index.js\").default} record - Child record (for connection + relationship metadata).\n * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.\n * @param {ReturnType<typeof JSON.parse>} parentId - Parent primary-key value.\n * @param {number} amount - Signed integer to add.\n * @returns {Promise<void>}\n */\nasync function incrementParentCounter(record, definition, parentId, amount) {\n  const modelClass = record.getModelClass()\n  const relationship = modelClass.getRelationshipByName(definition.belongsTo)\n  const parentModelClass = relationship.getTargetModelClass()\n\n  if (!parentModelClass) {\n    throw new Error(`magnitudeCounterCache on ${modelClass.getModelName()} could not resolve the \"${definition.belongsTo}\" parent model class`)\n  }\n\n  // Resolve through the record so an operation both owns the parent write and\n  // rejects a relationship whose parent routes to another database.\n  const parentQuery = record.queryForModel(parentModelClass)\n  const db = parentQuery.driver\n  const counterColumnSql = db.quoteColumn(definition.counterColumn)\n  const truncatedAmount = Math.trunc(amount)\n  const preparedParentUpdate = await prepareCounterCacheParentUpdate({\n    parentId,\n    parentModelClass,\n    parentPrimaryKey: relationship.getPrimaryKey(),\n    parentQuery\n  })\n\n  await db.query(\n    `UPDATE ${db.quoteTable(parentModelClass.tableName())} ` +\n    `SET ${counterColumnSql} = COALESCE(${counterColumnSql}, 0) + ${truncatedAmount} ` +\n    `WHERE ${db.quoteColumn(relationship.getPrimaryKey())} = ${db.quote(parentId)}`\n  )\n  await scheduleCounterCacheParentUpdate({\n    preparedUpdate: preparedParentUpdate,\n    sourceRecord: record\n  })\n}\n\n/**\n * Resolves the column name backing an attribute name.\n * @param {import(\"./index.js\").default} record - Record.\n * @param {string} attributeName - Attribute name.\n * @returns {string} The column name for the attribute (falls back to the attribute name).\n */\nfunction columnNameForAttribute(record, attributeName) {\n  return record.getModelClass().getAttributeNameToColumnNameMap()[attributeName] || attributeName\n}\n\n/**\n * Resolves the attribute name backing a column name.\n * @param {import(\"./index.js\").default} record - Record.\n * @param {string} columnName - Column name.\n * @returns {string} The attribute name for the column (falls back to the column name).\n */\nfunction attributeNameForColumn(record, columnName) {\n  const map = record.getModelClass().getAttributeNameToColumnNameMap()\n\n  return Object.keys(map).find((attributeName) => map[attributeName] === columnName) || columnName\n}\n"]}

package/build/src/database/record/counter-cache-parent-updates.d.ts

@@ -0,0 +1,43 @@
+export type CounterCacheParentUpdateListener = (parent: import("./index.js").default, previousParent: import("./index.js").default | undefined) => void | Promise<void>;
+export type PreparedCounterCacheParentUpdate = {
+    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;
+};
+/**
+ * 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 declare function registerCounterCacheParentUpdateListener(parentModelClass: typeof import("./index.js").default, listener: CounterCacheParentUpdateListener): () => void;
+/**
+ * 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 declare function prepareCounterCacheParentUpdate({ parentId, parentModelClass, parentPrimaryKey, parentQuery }: {
+    parentId: ReturnType<typeof JSON.parse>;
+    parentModelClass: typeof import("./index.js").default;
+    parentPrimaryKey: string;
+    parentQuery: import("../query/model-class-query.js").default<typeof import("./index.js").default>;
+}): Promise<PreparedCounterCacheParentUpdate | undefined>;
+/**
+ * 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 declare function scheduleCounterCacheParentUpdate({ preparedUpdate, sourceRecord }: {
+    preparedUpdate: PreparedCounterCacheParentUpdate | undefined;
+    sourceRecord: import("./index.js").default;
+}): Promise<void>;
+//# sourceMappingURL=counter-cache-parent-updates.d.ts.map

package/build/src/database/record/counter-cache-parent-updates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"counter-cache-parent-updates.d.ts","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-parent-updates.js"],"names":[],"mappings":"AAKI,YAAoI,gCAAgC,GAA1J,CAAC,MAAM,EAAE,OAAO,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,YAAY,EAAE,OAAO,GAAG,SAAS,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAkC;AACpK,YAA2V,gCAAgC,GAAjX;IAAC,yBAAyB,EAAE,cAAc,YAAY,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,gCAAgC,EAAE,CAAC;IAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAO,+BAA+B,EAAE,OAAO,CAAC,cAAc,YAAY,EAAE,OAAO,CAAC,CAAC;IAAC,cAAc,EAAE,OAAO,YAAY,EAAE,OAAO,GAAG,SAAS,CAAA;CAAC,CAAkC;AAK/X;;;;;GAKG;AACH,wBAAgB,wCAAwC,CAAC,gBAAgB,EAJ9D,cAAc,YAAY,EAAE,OAIkC,EAAE,QAAQ,EAHxE,gCAGwE,GAFtE,MAAM,IAAI,CActB;AAED;;;;;;;;GAQG;AACH,wBAAsB,+BAA+B,CAAC,EAAC,QAAQ,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,WAAW,EAAC,EAN9G;IAA4C,QAAQ,EAA5C,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,CACrC;IAAkD,gBAAgB,EAA1D,cAAc,YAAY,EAAE,OAAO,CAC3C;IAAqB,gBAAgB,EAA7B,MAAM,CACd;IAAmG,WAAW,EAAtG,OAAO,+BAA+B,EAAE,OAAO,CAAC,cAAc,YAAY,EAAE,OAAO,CAAC,CAC5F;CAE8G,GAFpG,OAAO,CAAC,gCAAgC,GAAG,SAAS,CAAC,CAiBjE;AAED;;;;;;GAMG;AACH,wBAAsB,gCAAgC,CAAC,EAAC,cAAc,EAAE,YAAY,EAAC,EAJlF;IAA2D,cAAc,EAAjE,gCAAgC,GAAG,SAAS,CACpD;IAA2C,YAAY,EAA/C,OAAO,YAAY,EAAE,OAAO,CACpC;CAEkF,GAFxE,OAAO,CAAC,IAAI,CAAC,CA2BzB"}