velocious 1.0.668 → 1.0.670

package/build/testing/test.js

@@ -3,14 +3,17 @@
 import {
   afterAll,
   afterEach,
+  arrayContaining,
   beforeAll,
   beforeEach,
   configureTests,
   defaultTestContext,
   describe,
+  expect,
   fdescribe,
   fit,
   it,
+  objectContaining,
   test,
   waitForEvent,
   xdescribe,
@@ -18,8 +21,6 @@ import {
   xtest
 } from "@velocious/testing"
 import EventEmitter from "../utils/event-emitter.js"
-import Expect from "./expect.js"
-import {arrayContaining, objectContaining} from "./expect-utils.js"
 
 /** @typedef {(typeof defaultTestContext.registry.suites)[number]} PackageSuiteDeclaration */
 
@@ -32,18 +33,6 @@ import {arrayContaining, objectContaining} from "./expect-utils.js"
  * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.
  */
 
-/**
- * Runs expect.
- * @param {ReturnType<typeof JSON.parse>} arg - Arg.
- * @returns {Expect} - The expect.
- */
-function expect(arg) {
-  return new Expect(arg)
-}
-
-expect.objectContaining = objectContaining
-expect.arrayContaining = arrayContaining
-
 /** Velocious-owned awaited compatibility events. */
 const testEvents = new EventEmitter()
 

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.668",
+  "version": "1.0.670",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
@@ -82,7 +82,6 @@
     "proxy-addr": "^2.0.7",
     "pure-uuid": "^2.0.0",
     "require-context": "^1.1.0",
-    "set-state-compare": "^1.0.61",
     "snapreq": "^0.0.15",
     "sql-escape-string": "^1.1.0",
     "sql.js": "^1.12.0",
@@ -91,7 +90,7 @@
     "ws": "^8.21.3"
   },
   "peerDependencies": {
-    "@velocious/testing": "^0.0.14",
+    "@velocious/testing": "0.0.17",
     "react": ">=18",
     "smtp-connection": "^4.0.2",
     "sqlite": "^5.1.1",
@@ -121,7 +120,7 @@
     "@types/react-dom": "^19.2.3",
     "@types/strftime": "^0.9.8",
     "@types/ws": "^8.18.1",
-    "@velocious/testing": "0.0.14",
+    "@velocious/testing": "0.0.17",
     "chokidar-cli": "^3.0.0",
     "cpy-cli": "^7.0.0",
     "esbuild": "^0.28.0",

package/src/background-jobs/store.js

@@ -59,6 +59,16 @@ import {
  * @property {{failureMessage: string, name: string}} [advisoryLock] - Session lock held around the transaction.
  */
 
+/**
+ * BackgroundJobPruneCandidateMetadata type. Immutable metadata for one selected
+ * retention candidate batch, exposed to the optional prune barrier hook.
+ * @typedef {object} BackgroundJobPruneCandidateMetadata
+ * @property {Readonly<Array<string>>} candidates - Job ids selected for this batch.
+ * @property {string} status - Terminal status the candidates were selected by.
+ * @property {string} column - Terminal timestamp column compared against the cutoff.
+ * @property {number} cutoff - Cutoff timestamp the candidates were selected against.
+ */
+
 /**
  * BackgroundJobConcurrencyCountRow type.
  * @typedef {object} BackgroundJobConcurrencyCountRow
@@ -158,13 +168,15 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
    * @param {string} [args.databaseIdentifier] - Database identifier.
    * @param {{now: () => number}} [args.clock] - Injectable persistence clock.
    * @param {(producerProof: import("./types.js").BackgroundJobProducerProof) => void | Promise<void>} [args.afterOwnedProducerValidation] - Exact owned-enqueue validation hook.
+   * @param {(metadata: BackgroundJobPruneCandidateMetadata) => void | Promise<void>} [args.afterPruneCandidatesSelected] - Optional barrier invoked after one retention batch's candidate discovery and before its serialized delete transaction.
    */
-  constructor({configuration, databaseIdentifier, clock, afterOwnedProducerValidation}) {
+  constructor({configuration, databaseIdentifier, clock, afterOwnedProducerValidation, afterPruneCandidatesSelected}) {
     super()
     this.configuration = configuration
     this.databaseIdentifier = databaseIdentifier
     this.clock = clock || {now: () => Date.now()}
     this.afterOwnedProducerValidation = afterOwnedProducerValidation
+    this.afterPruneCandidatesSelected = afterPruneCandidatesSelected
     this.logger = new Logger(this)
     this._readyPromise = null
     this._queueConcurrencyReconciled = false
@@ -1790,7 +1802,14 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
 
   /**
    * Deletes rows of one terminal status older than a cutoff, batch by batch,
-   * until a page returns fewer than `batchSize` rows.
+   * until a candidate page returns fewer than `batchSize` rows. Candidate
+   * discovery runs on a plain connection — never inside the serialized count
+   * mutation — so a long scan cannot hold the count-revision lock and starve
+   * enqueue acknowledgements; only the short delete transaction is serialized.
+   * The delete revalidates status and cutoff for the selected ids, publishes
+   * the delta from the actual affected-row count, and a page whose candidates
+   * were already removed by a concurrent pruner still ends the pass only when
+   * the page itself is short.
    * @param {object} args - Options.
    * @param {string} args.status - Terminal status to prune.
    * @param {string} args.column - Timestamp column compared against the cutoff.
@@ -1802,22 +1821,37 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
     let deleted = 0
 
     for (;;) {
-      const removed = await this._serializedCountMutation(async (db) => {
-        const rows = await db
+      const candidates = await this._withDb(async (db) =>
+        await db
           .newQuery()
           .from(JOBS_TABLE)
           .select("id")
           .where({status})
           .where(`${db.quoteColumn(column)} <= ${db.quote(cutoff)}`)
+          .order({column, direction: "ASC"})
+          .order({column: "id", direction: "ASC"})
           .limit(batchSize)
           .results()
+      )
 
-        if (rows.length === 0) return 0
+      if (candidates.length === 0) break
 
-        const ids = rows.map((/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ row) => db.quote(String(row.id))).join(", ")
+      const candidateIds = Object.freeze(candidates.map((/** @type {Record<string, ReturnType<typeof JSON.parse>>} */ row) => String(row.id)))
+
+      if (this.afterPruneCandidatesSelected) {
+        await this.afterPruneCandidatesSelected(Object.freeze({
+          candidates: candidateIds,
+          column,
+          cutoff,
+          status
+        }))
+      }
+
+      const removed = await this._serializedCountMutation(async (db) => {
+        const ids = candidateIds.map((id) => db.quote(id)).join(", ")
 
         const removed = await db.affectedRows(
-          `DELETE FROM ${db.quoteTable(JOBS_TABLE)} WHERE ${db.quoteColumn("id")} IN (${ids})`
+          `DELETE FROM ${db.quoteTable(JOBS_TABLE)} WHERE ${db.quoteColumn("id")} IN (${ids}) AND ${db.quoteColumn("status")} = ${db.quote(status)} AND ${db.quoteColumn(column)} <= ${db.quote(cutoff)}`
         )
 
         await this._recordCountDelta(db, {all: -removed, [status]: -removed})
@@ -1826,7 +1860,7 @@ export default class BackgroundJobsStore extends BackgroundJobsAdapter {
       })
 
       deleted += removed
-      if (removed < batchSize) break
+      if (candidates.length < batchSize) break
     }
 
     return deleted

package/src/testing/expect-utils.js

@@ -1,246 +1,5 @@
 // @ts-check
 
-import {anythingDifferent} from "set-state-compare/build/diff-utils.js"
-
-/**
- * Runs object containing.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {{__velociousMatcher: string, value: ReturnType<typeof JSON.parse>}} - Matcher wrapper.
- */
-function objectContaining(value) {
-  if (value === null || typeof value !== "object") {
-    throw new Error(`Expected object but got ${typeof value}`)
-  }
-
-  return {
-    __velociousMatcher: "objectContaining",
-    value
-  }
-}
-
-/**
- * Runs array containing.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {{__velociousMatcher: string, value: ReturnType<typeof JSON.parse>}} - Matcher wrapper.
- */
-function arrayContaining(value) {
-  if (!Array.isArray(value)) {
-    throw new Error(`Expected array but got ${typeof value}`)
-  }
-
-  return {
-    __velociousMatcher: "arrayContaining",
-    value
-  }
-}
-
-/**
- * Runs is object like.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {boolean} - Whether object-like.
- */
-function isObjectLike(value) {
-  return value !== null && typeof value === "object"
-}
-
-/**
- * Runs is array containing.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {boolean} - Whether arrayContaining matcher.
- */
-function isArrayContaining(value) {
-  return !!value && typeof value === "object" && (/** @type {ReturnType<typeof JSON.parse>} */ (value)).__velociousMatcher === "arrayContaining"
-}
-
-/**
- * Runs is object containing.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {boolean} - Whether objectContaining matcher.
- */
-function isObjectContaining(value) {
-  return !!value && typeof value === "object" && (/** @type {ReturnType<typeof JSON.parse>} */ (value)).__velociousMatcher === "objectContaining"
-}
-
-/**
- * Runs is plain object.
- * @param {ReturnType<typeof JSON.parse>} value - Value.
- * @returns {boolean} - Whether plain object.
- */
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false
-
-  const prototype = Object.getPrototypeOf(value)
-
-  return prototype === Object.prototype || prototype === null
-}
-
-/**
- * Runs values equal.
- * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
- * @param {ReturnType<typeof JSON.parse>} expected - Expected value.
- * @returns {boolean} - Whether values are equal.
- */
-function valuesEqual(actual, expected) {
-  if (actual instanceof Date && expected instanceof Date) {
-    return actual.getTime() === expected.getTime()
-  }
-
-  if (actual instanceof RegExp && expected instanceof RegExp) {
-    return actual.source === expected.source && actual.flags === expected.flags
-  }
-
-  return Object.is(actual, expected)
-}
-
-/**
- * Runs collect match differences.
- * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
- * @param {ReturnType<typeof JSON.parse>} expected - Expected value.
- * @param {string} path - Path.
- * @param {Record<string, Array<ReturnType<typeof JSON.parse>>>} differences - Differences.
- * @returns {void} - No return value.
- */
-function collectMatchDifferences(actual, expected, path, differences) {
-  if (isObjectContaining(expected)) {
-    collectMatchDifferences(actual, /** @type {ReturnType<typeof JSON.parse>} */ (expected).value, path, differences)
-    return
-  }
-
-  if (isArrayContaining(expected)) {
-    const {matches} = matchArrayContaining(actual, /** @type {Array<ReturnType<typeof JSON.parse>>} */ (/** @type {ReturnType<typeof JSON.parse>} */ (expected).value))
-
-    if (!matches) {
-      differences[path || "$"] = [expected, actual]
-    }
-
-    return
-  }
-
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual)) {
-      differences[path || "$"] = [expected, actual]
-      return
-    }
-
-    for (let i = 0; i < expected.length; i++) {
-      const nextPath = `${path}[${i}]`
-      collectMatchDifferences(actual[i], expected[i], nextPath, differences)
-    }
-
-    return
-  }
-
-  if (isPlainObject(expected)) {
-    if (!isObjectLike(actual)) {
-      differences[path || "$"] = [expected, actual]
-      return
-    }
-
-    const expectedObject = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (expected)
-    const actualObject = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (actual)
-
-    for (const key of Object.keys(expectedObject)) {
-      const nextPath = path ? `${path}.${key}` : key
-
-      if (!Object.prototype.hasOwnProperty.call(actualObject, key)) {
-        differences[nextPath] = [expectedObject[key], undefined]
-        continue
-      }
-
-      collectMatchDifferences(actualObject[key], expectedObject[key], nextPath, differences)
-    }
-
-    return
-  }
-
-  if (!valuesEqual(actual, expected)) {
-    differences[path || "$"] = [expected, actual]
-  }
-}
-
-/**
- * Runs match object.
- * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
- * @param {Record<string, ReturnType<typeof JSON.parse>> | Array<ReturnType<typeof JSON.parse>>} expected - Expected value.
- * @returns {{matches: boolean, differences: Record<string, Array<ReturnType<typeof JSON.parse>>>}} - Match result.
- */
-function matchObject(actual, expected) {
-  /**
-   * Differences.
-   * @type {Record<string, Array<ReturnType<typeof JSON.parse>>>} */
-  const differences = {}
-
-  collectMatchDifferences(actual, expected, "", differences)
-
-  return {
-    matches: Object.keys(differences).length === 0,
-    differences
-  }
-}
-
-/**
- * Runs match array containing.
- * @param {ReturnType<typeof JSON.parse>} actual - Actual value.
- * @param {Array<ReturnType<typeof JSON.parse>>} expected - Expected values.
- * @returns {{matches: boolean, differences: Record<string, Array<ReturnType<typeof JSON.parse>>>}} - Match result.
- */
-function matchArrayContaining(actual, expected) {
-  /**
-   * Differences.
-   * @type {Record<string, Array<ReturnType<typeof JSON.parse>>>} */
-  const differences = {}
-
-  if (!Array.isArray(actual)) {
-    differences["$"] = [expected, actual]
-    return {matches: false, differences}
-  }
-
-  const usedIndexes = new Set()
-
-  for (const expectedItem of expected) {
-    let matchedIndex = -1
-
-    for (let i = 0; i < actual.length; i++) {
-      if (usedIndexes.has(i)) continue
-
-      if (isObjectContaining(expectedItem)) {
-        const {matches} = matchObject(actual[i], /** @type {ReturnType<typeof JSON.parse>} */ (expectedItem).value)
-        if (matches) {
-          matchedIndex = i
-          break
-        }
-        continue
-      }
-
-      if (isArrayContaining(expectedItem)) {
-        const {matches} = matchArrayContaining(actual[i], /** @type {ReturnType<typeof JSON.parse>} */ (expectedItem).value)
-        if (matches) {
-          matchedIndex = i
-          break
-        }
-        continue
-      }
-
-      if (!anythingDifferent(actual[i], expectedItem)) {
-        matchedIndex = i
-        break
-      }
-    }
-
-    if (matchedIndex >= 0) {
-      usedIndexes.add(matchedIndex)
-    } else {
-      differences["$"] = [expected, actual]
-      break
-    }
-  }
-
-  return {
-    matches: Object.keys(differences).length === 0,
-    differences
-  }
-}
-
 export {
   arrayContaining,
   isArrayContaining,
@@ -248,4 +7,4 @@ export {
   matchArrayContaining,
   matchObject,
   objectContaining
-}
+} from "@velocious/testing"