velocious 1.0.498 → 1.0.499

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

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

package/build/database/record/index.js

@@ -47,6 +47,8 @@ import {defineModelScope} from "../../utils/model-scope.js"
 import { normalizeDateStringForWrite, normalizeDateValueForRead, normalizeDateValueForWrite } from "../datetime-storage.js"
 import {formatValue} from "../../utils/format-value.js"
 import {captureCreateAuditChanges, captureUpdateAuditChanges, createAudit, createCreateAudit, createDestroyAudit, createUpdateAudit, registerAuditCallback, registerAuditing, withoutAudit} from "./auditing.js"
+import {registerMagnitudeCounterCache} from "./counter-cache-magnitude.js"
+import {stateMachine} from "./state-machine.js"
 import ValidatorsFormat from "./validators/format.js"
 import ValidatorsLength from "./validators/length.js"
 import ValidatorsPresence from "./validators/presence.js"
@@ -668,6 +670,30 @@ class VelociousDatabaseRecord {
     registerAuditing(this)
   }
 
+  /**
+   * Declares an aasm-style state machine on this model: named states, events
+   * (guarded transitions), and enter/exit + before/after transition hooks. See
+   * `state-machine.js`. Generates `event()` / `eventAndSave()` / `canEvent()`
+   * transition methods per declared event.
+   * @param {import("./state-machine.js").StateMachineDefinition} definition - State machine definition.
+   * @returns {void}
+   */
+  static stateMachine(definition) {
+    stateMachine(this, definition)
+  }
+
+  /**
+   * Maintains a counter column on a `belongsTo` parent as the sum of a per-record
+   * magnitude, kept current by atomic increments diffed on every create/update/
+   * destroy (and moved between parents when the foreign key changes). See
+   * `counter-cache-magnitude.js`.
+   * @param {import("./counter-cache-magnitude.js").MagnitudeCounterCacheDefinition} definition - Counter cache definition.
+   * @returns {void}
+   */
+  static magnitudeCounterCache(definition) {
+    registerMagnitudeCounterCache(this, definition)
+  }
+
   /**
    * Registers a callback invoked after this model writes an audit row for the action.
    * @template {typeof VelociousDatabaseRecord} MC

package/build/database/record/state-machine.js

@@ -10,7 +10,9 @@
  * }} StateMachineDefinition
  * @typedef {{
  *   beforeEnter?: (model: import("./index.js").default) => void | Promise<void>,
- *   afterEnter?: (model: import("./index.js").default) => void | Promise<void>
+ *   afterEnter?: (model: import("./index.js").default) => void | Promise<void>,
+ *   beforeExit?: (model: import("./index.js").default) => void | Promise<void>,
+ *   afterExit?: (model: import("./index.js").default) => void | Promise<void>
  * }} StateDefinition
  * @typedef {{
  *   from: string | string[],
@@ -68,6 +70,14 @@ export function stateMachine(ModelClass, definition) {
    * @type {?} */
   const dynamicClass = ModelClass
 
+  // Idempotent: re-declaring on the same class (or a re-evaluated module) must not
+  // register the before/after-save transition hooks twice. Guard on an own property
+  // so a subclass declaring its own machine is unaffected by the parent's flag.
+  if (Object.prototype.hasOwnProperty.call(dynamicClass, "_stateMachineRegistered") && dynamicClass._stateMachineRegistered) {
+    return
+  }
+
+  dynamicClass._stateMachineRegistered = true
   dynamicClass._stateMachineDefinition = definition
   dynamicClass._stateMachineColumn = column
 
@@ -229,7 +239,13 @@ export function stateMachine(ModelClass, definition) {
       await eventDef.before(model)
     }
 
-    // Run state-level beforeEnter callback
+    // Run the exited state's beforeExit, then the entered state's beforeEnter
+    const fromStateDefinition = definition.states[pending.from]
+
+    if (fromStateDefinition?.beforeExit) {
+      await fromStateDefinition.beforeExit(model)
+    }
+
     const stateDefinition = definition.states[pending.to]
 
     if (stateDefinition?.beforeEnter) {
@@ -252,13 +268,19 @@ export function stateMachine(ModelClass, definition) {
     // Clear the pending transition now that save is complete
     dynamicModel[PENDING_TRANSITION_KEY] = null
 
-    // Run state-level afterEnter callback
+    // Run the entered state's afterEnter, then the exited state's afterExit
     const stateDefinition = definition.states[pending.to]
 
     if (stateDefinition?.afterEnter) {
       await stateDefinition.afterEnter(model)
     }
 
+    const fromStateDefinition = definition.states[pending.from]
+
+    if (fromStateDefinition?.afterExit) {
+      await fromStateDefinition.afterExit(model)
+    }
+
     // Run event-level after callback
     const eventDef = definition.events[pending.eventName]
 

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

@@ -0,0 +1,67 @@
+/**
+ * Reactive counter-cache driven by a per-record magnitude.
+ *
+ * Maintains a counter column on a `belongsTo` parent as the running sum of each
+ * child's magnitude — a small number derived from one source attribute (e.g.
+ * `1` while a build's `status` is `running`, else `0`). On every create, update
+ * and destroy the change in magnitude is applied to the parent as a single
+ * atomic increment (`SET col = col + delta`), and when the foreign key changes
+ * the magnitude is moved from the old parent to the new one.
+ *
+ * Because the counter is derived from the source attribute and diffed on every
+ * write, it follows that attribute automatically no matter which code path wrote
+ * it — there is no per-transition increment/decrement to forget. The old value is
+ * captured in `beforeSave` (Velocious clears `changes()` during the post-update
+ * reload) and consumed in `afterSave`, so the increment commits atomically with
+ * the row it reflects.
+ * @typedef {{
+ *   belongsTo: string,
+ *   counterColumn: string,
+ *   sourceAttribute: string,
+ *   magnitude: (sourceValue: ?) => number
+ * }} MagnitudeCounterCacheDefinition
+ */
+/**
+ * Captured pending magnitude change stashed on a record between beforeSave and afterSave.
+ * @typedef {{newMagnitude: number, oldMagnitude: number, newParentId: ?, oldParentId: ?}} PendingMagnitudeDelta
+ */
+/**
+ * Registers a reactive magnitude counter-cache on a model class.
+ * @param {typeof import("./index.js").default} modelClass - Model class to add the counter cache to.
+ * @param {MagnitudeCounterCacheDefinition} definition - Counter cache definition.
+ * @returns {void}
+ */
+export function registerMagnitudeCounterCache(modelClass: typeof import("./index.js").default, definition: MagnitudeCounterCacheDefinition): void;
+/**
+ * Reactive counter-cache driven by a per-record magnitude.
+ *
+ * Maintains a counter column on a `belongsTo` parent as the running sum of each
+ * child's magnitude — a small number derived from one source attribute (e.g.
+ * `1` while a build's `status` is `running`, else `0`). On every create, update
+ * and destroy the change in magnitude is applied to the parent as a single
+ * atomic increment (`SET col = col + delta`), and when the foreign key changes
+ * the magnitude is moved from the old parent to the new one.
+ *
+ * Because the counter is derived from the source attribute and diffed on every
+ * write, it follows that attribute automatically no matter which code path wrote
+ * it — there is no per-transition increment/decrement to forget. The old value is
+ * captured in `beforeSave` (Velocious clears `changes()` during the post-update
+ * reload) and consumed in `afterSave`, so the increment commits atomically with
+ * the row it reflects.
+ */
+export type MagnitudeCounterCacheDefinition = {
+    belongsTo: string;
+    counterColumn: string;
+    sourceAttribute: string;
+    magnitude: (sourceValue: unknown) => number;
+};
+/**
+ * Captured pending magnitude change stashed on a record between beforeSave and afterSave.
+ */
+export type PendingMagnitudeDelta = {
+    newMagnitude: number;
+    oldMagnitude: number;
+    newParentId: unknown;
+    oldParentId: unknown;
+};
+//# sourceMappingURL=counter-cache-magnitude.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"counter-cache-magnitude.d.ts","sourceRoot":"","sources":["../../../../src/database/record/counter-cache-magnitude.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AAEH;;;;;GAKG;AACH,0DAJW,cAAc,YAAY,EAAE,OAAO,cACnC,+BAA+B,GAC7B,IAAI,CAiDhB;;;;;;;;;;;;;;;;;;8CAlEY;IACR,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,CAAC,WAAW,EAAE,OAAC,KAAK,MAAM,CAAA;CACtC;;;;oCAKS;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,OAAC,CAAC;IAAC,WAAW,EAAE,OAAC,CAAA;CAAC"}

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

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