velocious 1.0.619 → 1.0.621

package/build/src/testing/shared-transaction-connection-coordinator.js

@@ -1,30 +1,73 @@
 // @ts-check
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol}} CoordinatorRegistration */
+/** @typedef {{ownedQueue: Promise<void>}} CoordinatorOwnerScope */
+/** @typedef {{connectionScope: CoordinatorOwnerScope, coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, owner: symbol, ownerScopes: Map<symbol, CoordinatorOwnerScope>}} CoordinatorRegistration */
 /** @type {WeakMap<object, CoordinatorRegistration>} */
 const coordinators = new WeakMap();
+/** @type {WeakMap<object, CoordinatorRegistration>} */
+const connectionRegistrations = new WeakMap();
+/**
+ * Runs work directly when only the connection-local queue remains registered.
+ * @param {() => Promise<unknown>} callback - Serialized operation.
+ * @returns {Promise<unknown>} - Operation result.
+ */
+async function inactiveCoordinator(callback) {
+    return await callback();
+}
 /**
  * Serializes sibling work that inherited one coordinator owner without re-entering the broker queue.
  * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
  * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {CoordinatorOwnerScope} ownerScope - Queue inherited from the current owner.
  * @param {() => Promise<T>} callback - Owned operation.
+ * @param {string} [ownerDescription] - Async owner description.
  * @returns {Promise<T>} - Operation result.
  */
-async function coordinateOwnedSharedTransactionConnection(registration, callback) {
-    const previous = registration.ownedQueue;
+async function coordinateOwnedSharedTransactionConnection(connection, registration, ownerScope, callback, ownerDescription = "shared-transaction-owned-operation") {
+    const previous = ownerScope.ownedQueue;
     /**
      * Releases the next owned sibling operation.
      * @type {() => void}
      */
     let release = () => { };
-    registration.ownedQueue = new Promise((resolve) => { release = resolve; });
+    ownerScope.ownedQueue = new Promise((resolve) => { release = resolve; });
     await previous;
+    const operationOwner = Symbol(ownerDescription);
+    const environmentHandler = connection.configuration.getEnvironmentHandler();
+    const operationScope = { ownedQueue: Promise.resolve() };
+    registration.ownerScopes.set(operationOwner, operationScope);
     try {
-        return await callback();
+        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback);
     }
     finally {
+        await drainOwnedSharedTransactionConnections(operationScope);
+        registration.ownerScopes.delete(operationOwner);
         release();
     }
 }
+/**
+ * Drains all inherited operations admitted before the root owner is revoked.
+ * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.
+ * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
+ */
+async function drainOwnedSharedTransactionConnections(ownerScope) {
+    let tail;
+    do {
+        tail = ownerScope.ownedQueue;
+        await tail;
+    } while (tail !== ownerScope.ownedQueue);
+}
+/**
+ * Runs one broker-serialized root while tracking and draining its inherited work.
+ * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
+ * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {() => Promise<T>} callback - Root operation.
+ * @returns {Promise<T>} - Operation result.
+ */
+async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback, "shared-transaction-root-operation");
+}
 /**
  * Registers test-only serialization owned by the active broker.
  * @param {object} connection - Parent physical connection.
@@ -33,7 +76,21 @@ async function coordinateOwnedSharedTransactionConnection(registration, callback
  */
 export function setSharedTransactionCoordinator(connection, coordinator) {
     const owner = Symbol("shared-transaction-coordinator");
-    coordinators.set(connection, { coordinator, ownedQueue: Promise.resolve(), owner });
+    let registration = connectionRegistrations.get(connection);
+    if (registration) {
+        registration.coordinator = coordinator;
+        registration.owner = owner;
+    }
+    else {
+        registration = {
+            connectionScope: { ownedQueue: Promise.resolve() },
+            coordinator,
+            owner,
+            ownerScopes: new Map()
+        };
+        connectionRegistrations.set(connection, registration);
+    }
+    coordinators.set(connection, registration);
     return owner;
 }
 /**
@@ -43,8 +100,11 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
  * @returns {void}
  */
 export function clearSharedTransactionCoordinator(connection, coordinator) {
-    if (coordinators.get(connection)?.coordinator === coordinator)
+    const registration = coordinators.get(connection);
+    if (registration?.coordinator === coordinator) {
         coordinators.delete(connection);
+        registration.coordinator = inactiveCoordinator;
+    }
 }
 /**
  * Runs parent work through broker serialization when registered.
@@ -55,17 +115,24 @@ export function clearSharedTransactionCoordinator(connection, coordinator) {
  * @returns {Promise<T>} - Operation result.
  */
 export async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {
-    const registration = coordinators.get(connection);
+    const activeRegistration = coordinators.get(connection);
+    const registration = activeRegistration || connectionRegistrations.get(connection);
     if (!registration)
         return await callback();
-    if (operationOwner === registration.owner)
-        return await callback();
     const environmentHandler = connection.configuration.getEnvironmentHandler();
-    if (environmentHandler.getSharedTransactionCoordinatorOwner(connection) === registration.owner) {
-        return await coordinateOwnedSharedTransactionConnection(registration, callback);
+    const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection);
+    const currentOwnerScope = currentOwner ? registration.ownerScopes.get(currentOwner) : undefined;
+    if (currentOwnerScope) {
+        return await coordinateOwnedSharedTransactionConnection(connection, registration, currentOwnerScope, callback);
+    }
+    if (!activeRegistration) {
+        return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback);
+    }
+    if (operationOwner === registration.owner) {
+        return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }
     return /** @type {T} */ (await registration.coordinator(async () => {
-        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, registration.owner, callback);
+        return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-connection-coordinator.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/** @typedef {{ownedQueue: Promise<void>}} CoordinatorOwnerScope */\n/** @typedef {{connectionScope: CoordinatorOwnerScope, coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, owner: symbol, ownerScopes: Map<symbol, CoordinatorOwnerScope>}} CoordinatorRegistration */\n\n/** @type {WeakMap<object, CoordinatorRegistration>} */\nconst coordinators = new WeakMap()\n/** @type {WeakMap<object, CoordinatorRegistration>} */\nconst connectionRegistrations = new WeakMap()\n\n/**\n * Runs work directly when only the connection-local queue remains registered.\n * @param {() => Promise<unknown>} callback - Serialized operation.\n * @returns {Promise<unknown>} - Operation result.\n */\nasync function inactiveCoordinator(callback) {\n  return await callback()\n}\n\n/**\n * Serializes sibling work that inherited one coordinator owner without re-entering the broker queue.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @param {CoordinatorOwnerScope} ownerScope - Queue inherited from the current owner.\n * @param {() => Promise<T>} callback - Owned operation.\n * @param {string} [ownerDescription] - Async owner description.\n * @returns {Promise<T>} - Operation result.\n */\nasync function coordinateOwnedSharedTransactionConnection(connection, registration, ownerScope, callback, ownerDescription = \"shared-transaction-owned-operation\") {\n  const previous = ownerScope.ownedQueue\n  /**\n   * Releases the next owned sibling operation.\n   * @type {() => void}\n   */\n  let release = () => {}\n\n  ownerScope.ownedQueue = new Promise((resolve) => { release = resolve })\n  await previous\n  const operationOwner = Symbol(ownerDescription)\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n  const operationScope = {ownedQueue: Promise.resolve()}\n\n  registration.ownerScopes.set(operationOwner, operationScope)\n  try {\n    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)\n  } finally {\n    await drainOwnedSharedTransactionConnections(operationScope)\n    registration.ownerScopes.delete(operationOwner)\n    release()\n  }\n}\n\n/**\n * Drains all inherited operations admitted before the root owner is revoked.\n * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.\n * @returns {Promise<void>} - Resolves when the owned queue stops advancing.\n */\nasync function drainOwnedSharedTransactionConnections(ownerScope) {\n  let tail\n\n  do {\n    tail = ownerScope.ownedQueue\n    await tail\n  } while (tail !== ownerScope.ownedQueue)\n}\n\n/**\n * Runs one broker-serialized root while tracking and draining its inherited work.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @param {() => Promise<T>} callback - Root operation.\n * @returns {Promise<T>} - Operation result.\n */\nasync function coordinateRootSharedTransactionConnection(connection, registration, callback) {\n  return await coordinateOwnedSharedTransactionConnection(\n    connection,\n    registration,\n    registration.connectionScope,\n    callback,\n    \"shared-transaction-root-operation\"\n  )\n}\n\n/**\n * Registers test-only serialization owned by the active broker.\n * @param {object} connection - Parent physical connection.\n * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Serializer.\n * @returns {symbol} - Opaque owner for broker-internal connection calls.\n */\nexport function setSharedTransactionCoordinator(connection, coordinator) {\n  const owner = Symbol(\"shared-transaction-coordinator\")\n  let registration = connectionRegistrations.get(connection)\n\n  if (registration) {\n    registration.coordinator = coordinator\n    registration.owner = owner\n  } else {\n    registration = {\n      connectionScope: {ownedQueue: Promise.resolve()},\n      coordinator,\n      owner,\n      ownerScopes: new Map()\n    }\n    connectionRegistrations.set(connection, registration)\n  }\n\n  coordinators.set(connection, registration)\n  return owner\n}\n\n/**\n * Removes a broker-owned coordinator without disturbing a replacement.\n * @param {object} connection - Parent physical connection.\n * @param {(callback: () => Promise<unknown>) => Promise<unknown>} coordinator - Expected serializer.\n * @returns {void}\n */\nexport function clearSharedTransactionCoordinator(connection, coordinator) {\n  const registration = coordinators.get(connection)\n\n  if (registration?.coordinator === coordinator) {\n    coordinators.delete(connection)\n    registration.coordinator = inactiveCoordinator\n  }\n}\n\n/**\n * Runs parent work through broker serialization when registered.\n * @template T\n * @param {import(\"../database/drivers/base.js\").default} connection - Parent physical connection.\n * @param {() => Promise<T>} callback - Parent operation.\n * @param {symbol} [operationOwner] - Broker owner for an already-coordinated operation.\n * @returns {Promise<T>} - Operation result.\n */\nexport async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {\n  const activeRegistration = coordinators.get(connection)\n  const registration = activeRegistration || connectionRegistrations.get(connection)\n\n  if (!registration) return await callback()\n\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n  const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection)\n  const currentOwnerScope = currentOwner ? registration.ownerScopes.get(currentOwner) : undefined\n\n  if (currentOwnerScope) {\n    return await coordinateOwnedSharedTransactionConnection(connection, registration, currentOwnerScope, callback)\n  }\n  if (!activeRegistration) {\n    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback)\n  }\n  if (operationOwner === registration.owner) {\n    return await coordinateRootSharedTransactionConnection(connection, registration, callback)\n  }\n\n  return /** @type {T} */ (await registration.coordinator(async () => {\n    return await coordinateRootSharedTransactionConnection(connection, registration, callback)\n  }))\n}\n"]}

package/build/src/testing/test.d.ts

@@ -1,5 +1,5 @@
+import { waitForEvent } from "@velocious/testing";
 import Expect from "./expect.js";
-import waitForEvent from "./wait-for-event.js";
 import { arrayContaining, objectContaining } from "./expect-utils.js";
 export type VelociousTestConfig = {
     /**

package/build/src/testing/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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"}

package/build/src/testing/test.js

@@ -1,9 +1,9 @@
 // @ts-check
 import path from "path";
 import { fileURLToPath } from "url";
+import { waitForEvent } from "@velocious/testing";
 import EventEmitter from "../utils/event-emitter.js";
 import Expect from "./expect.js";
-import waitForEvent from "./wait-for-event.js";
 import { arrayContaining, objectContaining } from "./expect-utils.js";
 /**
  * VelociousTestConfig type.
@@ -318,4 +318,4 @@ Object.assign(globalThis, {
     testEvents
 });
 export { afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport waitForEvent from \"./wait-for-event.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {ReturnType<typeof JSON.parse>} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nObject.assign(globalThis, {\n  afterAll,\n  afterEach,\n  beforeAll,\n  beforeEach,\n  configureTests,\n  describe,\n  expect,\n  fit,\n  it,\n  testEvents\n})\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.js","sourceRoot":"","sources":["../../../src/testing/test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from \"path\"\nimport {fileURLToPath} from \"url\"\nimport { waitForEvent } from \"@velocious/testing\"\nimport EventEmitter from \"../utils/event-emitter.js\"\nimport Expect from \"./expect.js\"\nimport {arrayContaining, objectContaining} from \"./expect-utils.js\"\n\n/**\n * VelociousTestConfig type.\n * @typedef {object} VelociousTestConfig\n * @property {\"failure\" | \"live\"} consoleOutput - Console output mode.\n * @property {string[]} excludeTags - Tags excluded by default.\n * @property {number} defaultTimeoutSeconds - Default timeout in seconds.\n * @property {number} failedConsoleOutputMaxLines - Maximum failed console lines to print inline.\n */\n/**\n * Tests.\n * @type {import(\"./test-runner.js\").TestsArgument} */\nconst tests = {\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  afterEaches: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  afterAlls: [],\n  args: {},\n\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").BeforeAfterAllCallbackObjectType[]} */\n  beforeAlls: [],\n  /**\n   * Narrows the runtime value to the documented type.\n   * @type {import(\"./test-runner.js\").AfterBeforeEachCallbackObjectType[]} */\n  beforeEaches: [],\n  filePath: undefined,\n  line: undefined,\n  subs: {},\n  tests: {}\n}\n\nconst testEvents = new EventEmitter()\n\nlet currentPath = [tests]\n\n/**\n * Runs capture location.\n * @returns {{filePath?: string, line?: number}} - Location.\n */\nfunction captureLocation() {\n  const error = new Error()\n  const stack = typeof error.stack === \"string\" ? error.stack.split(\"\\n\") : []\n\n  for (const line of stack) {\n    const trimmed = line.trim()\n\n    if (!trimmed.includes(\"at\")) continue\n    if (trimmed.includes(\"/src/testing/test.js\")) continue\n\n    const match = trimmed.match(/(?:\\(|\\s)(file:\\/\\/.*?|\\/.*?):(\\d+):(\\d+)\\)?$/)\n\n    if (!match) continue\n\n    const rawPath = match[1]\n    const lineNumber = Number(match[2])\n    const filePath = rawPath.startsWith(\"file://\")\n      ? fileURLToPath(rawPath)\n      : rawPath\n\n    return {\n      filePath: path.resolve(filePath),\n      line: Number.isFinite(lineNumber) ? lineNumber : undefined\n    }\n  }\n\n  return {}\n}\n\n/**\n * Runs normalize tags.\n * @param {string[] | string | undefined} tags - Tags.\n * @returns {string[]} - Normalized tags.\n */\nfunction normalizeTags(tags) {\n  if (!tags) return []\n\n  const values = []\n  const rawTags = Array.isArray(tags) ? tags : [tags]\n\n  for (const rawTag of rawTags) {\n    if (rawTag === undefined || rawTag === null) continue\n\n    const parts = String(rawTag).split(\",\")\n\n    for (const part of parts) {\n      const trimmed = part.trim()\n\n      if (trimmed) values.push(trimmed)\n    }\n  }\n\n  return Array.from(new Set(values))\n}\n\n/**\n * Test config.\n * @type {VelociousTestConfig} */\nconst testConfig = {\n  consoleOutput: \"failure\",\n  failedConsoleOutputMaxLines: 200,\n  excludeTags: [],\n  defaultTimeoutSeconds: 60\n}\n\n/**\n * Runs configure tests.\n * @param {object} args - Options.\n * @param {\"failure\" | \"live\"} [args.consoleOutput] - Console output mode.\n * @param {string[] | string} [args.excludeTags] - Tags to exclude.\n * @param {number} [args.defaultTimeoutSeconds] - Default timeout in seconds.\n * @param {number} [args.failedConsoleOutputMaxLines] - Maximum failed console lines to print inline.\n * @returns {void}\n */\nfunction configureTests({consoleOutput, excludeTags, defaultTimeoutSeconds, failedConsoleOutputMaxLines} = {}) {\n  if (excludeTags !== undefined) {\n    testConfig.excludeTags = normalizeTags(excludeTags)\n  }\n\n  if (consoleOutput !== undefined) {\n    if (consoleOutput !== \"failure\" && consoleOutput !== \"live\") {\n      throw new Error(`Invalid consoleOutput config: ${consoleOutput}`)\n    }\n\n    testConfig.consoleOutput = consoleOutput\n  }\n\n  if (typeof defaultTimeoutSeconds === \"number\") {\n    testConfig.defaultTimeoutSeconds = defaultTimeoutSeconds\n  }\n\n  if (typeof failedConsoleOutputMaxLines === \"number\") {\n    testConfig.failedConsoleOutputMaxLines = failedConsoleOutputMaxLines\n  }\n}\n\n/**\n * Runs merge test args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} baseArgs - Base args.\n * @param {Record<string, ReturnType<typeof JSON.parse>>} extraArgs - Extra args.\n * @returns {Record<string, ReturnType<typeof JSON.parse>>} - Merged args.\n */\nfunction mergeTestArgs(baseArgs, extraArgs) {\n  const merged = Object.assign({}, baseArgs, extraArgs)\n  const mergedTags = [...normalizeTags(baseArgs?.tags), ...normalizeTags(extraArgs?.tags)]\n\n  if (mergedTags.length > 0) {\n    merged.tags = Array.from(new Set(mergedTags))\n  } else if (\"tags\" in merged) {\n    delete merged.tags\n  }\n\n  return merged\n}\n\n/**\n * Runs before each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeEaches.push({callback})\n}\n\n/**\n * Runs before all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction beforeAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.beforeAlls.push({callback})\n}\n\n/**\n * Runs after each.\n * @param {import(\"./test-runner.js\").AfterBeforeEachCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterEach(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterEaches.push({callback})\n}\n\n/**\n * Runs after all.\n * @param {import(\"./test-runner.js\").BeforeAfterAllCallbackType} callback - Callback function.\n * @returns {void} - No return value.\n */\nfunction afterAll(callback) {\n  const currentTest = currentPath[currentPath.length - 1]\n\n  currentTest.afterAlls.push({callback})\n}\n\n/**\n * Runs describe.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {Promise<void>} - Resolves when complete.\n */\nasync function describe(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs, testFunction\n\n  if (typeof arg2 == \"function\") {\n    testFunction = arg2\n    testArgs = arg1\n  } else if (typeof arg1 == \"function\") {\n    testFunction = arg1\n    testArgs = {}\n  } else {\n    throw new Error(`Invalid arguments for describe: ${arg1}, ${arg2}`)\n  }\n\n  const currentTest = currentPath[currentPath.length - 1]\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  if (description in currentTest.subs) {\n    throw new Error(`Duplicate test description: ${description}`)\n  }\n\n  const location = captureLocation()\n  const newTestData = {\n    afterEaches: [],\n    afterAlls: [],\n    args: newTestArgs,\n    beforeAlls: [],\n    beforeEaches: [],\n    filePath: location.filePath,\n    line: location.line,\n    subs: {},\n    tests: {}\n  }\n\n  currentTest.subs[description] = newTestData\n  currentPath.push(newTestData)\n\n  try {\n    await testFunction()\n  } finally {\n    currentPath.pop()\n  }\n}\n\n/**\n * Runs expect.\n * @param {ReturnType<typeof JSON.parse>} arg - Arg.\n * @returns {Expect} - The expect.\n */\nfunction expect(arg) {\n  return new Expect(arg)\n}\n\nexpect.objectContaining = objectContaining\nexpect.arrayContaining = arrayContaining\n\n/**\n * Runs it.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction it(description, arg1, arg2) {\n  const currentTest = currentPath[currentPath.length - 1]\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = arg1\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  const newTestArgs = mergeTestArgs(currentTest.args, testArgs)\n\n  const location = captureLocation()\n\n  currentTest.tests[description] = {\n    args: newTestArgs,\n    function: testFunction,\n    filePath: location.filePath,\n    line: location.line\n  }\n}\n\n/**\n * Runs fit.\n * @param {string} description - Description.\n * @param {object|(() => (void|Promise<void>))} arg1 - Arg1.\n * @param {undefined|(() => (void|Promise<void>))} [arg2] - Arg2.\n * @returns {void} - No return value.\n */\nfunction fit(description, arg1, arg2) {\n  /**\n   * Defines testArgs.\n   * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n  let testArgs\n\n  /**\n   * Defines testFunction.\n   * @type {() => (void|Promise<void>)} */\n  let testFunction\n\n  if (typeof arg1 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg1)\n    testArgs = {focus: true}\n  } else if (typeof arg2 == \"function\") {\n    testFunction = /** @type {() => (void|Promise<void>)} */ (arg2)\n    testArgs = Object.assign({focus: true}, arg1)\n  } else {\n    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)\n  }\n\n  return it(description, testArgs, testFunction)\n}\n\n// Make the methods global so they can be used in test files\nObject.assign(globalThis, {\n  afterAll,\n  afterEach,\n  beforeAll,\n  beforeEach,\n  configureTests,\n  describe,\n  expect,\n  fit,\n  it,\n  testEvents\n})\n\nexport {afterAll, afterEach, beforeAll, beforeEach, configureTests, describe, expect, fit, it, arrayContaining, objectContaining, testConfig, testEvents, tests, waitForEvent}\n"]}

package/build/testing/shared-transaction-connection-coordinator.js

@@ -1,34 +1,88 @@
 // @ts-check
 
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol}} CoordinatorRegistration */
+/** @typedef {{ownedQueue: Promise<void>}} CoordinatorOwnerScope */
+/** @typedef {{connectionScope: CoordinatorOwnerScope, coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, owner: symbol, ownerScopes: Map<symbol, CoordinatorOwnerScope>}} CoordinatorRegistration */
 
 /** @type {WeakMap<object, CoordinatorRegistration>} */
 const coordinators = new WeakMap()
+/** @type {WeakMap<object, CoordinatorRegistration>} */
+const connectionRegistrations = new WeakMap()
+
+/**
+ * Runs work directly when only the connection-local queue remains registered.
+ * @param {() => Promise<unknown>} callback - Serialized operation.
+ * @returns {Promise<unknown>} - Operation result.
+ */
+async function inactiveCoordinator(callback) {
+  return await callback()
+}
 
 /**
  * Serializes sibling work that inherited one coordinator owner without re-entering the broker queue.
  * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
  * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {CoordinatorOwnerScope} ownerScope - Queue inherited from the current owner.
  * @param {() => Promise<T>} callback - Owned operation.
+ * @param {string} [ownerDescription] - Async owner description.
  * @returns {Promise<T>} - Operation result.
  */
-async function coordinateOwnedSharedTransactionConnection(registration, callback) {
-  const previous = registration.ownedQueue
+async function coordinateOwnedSharedTransactionConnection(connection, registration, ownerScope, callback, ownerDescription = "shared-transaction-owned-operation") {
+  const previous = ownerScope.ownedQueue
   /**
    * Releases the next owned sibling operation.
    * @type {() => void}
    */
   let release = () => {}
 
-  registration.ownedQueue = new Promise((resolve) => { release = resolve })
+  ownerScope.ownedQueue = new Promise((resolve) => { release = resolve })
   await previous
+  const operationOwner = Symbol(ownerDescription)
+  const environmentHandler = connection.configuration.getEnvironmentHandler()
+  const operationScope = {ownedQueue: Promise.resolve()}
+
+  registration.ownerScopes.set(operationOwner, operationScope)
   try {
-    return await callback()
+    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)
   } finally {
+    await drainOwnedSharedTransactionConnections(operationScope)
+    registration.ownerScopes.delete(operationOwner)
     release()
   }
 }
 
+/**
+ * Drains all inherited operations admitted before the root owner is revoked.
+ * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.
+ * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
+ */
+async function drainOwnedSharedTransactionConnections(ownerScope) {
+  let tail
+
+  do {
+    tail = ownerScope.ownedQueue
+    await tail
+  } while (tail !== ownerScope.ownedQueue)
+}
+
+/**
+ * Runs one broker-serialized root while tracking and draining its inherited work.
+ * @template T
+ * @param {import("../database/drivers/base.js").default} connection - Parent physical connection.
+ * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {() => Promise<T>} callback - Root operation.
+ * @returns {Promise<T>} - Operation result.
+ */
+async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
+  return await coordinateOwnedSharedTransactionConnection(
+    connection,
+    registration,
+    registration.connectionScope,
+    callback,
+    "shared-transaction-root-operation"
+  )
+}
+
 /**
  * Registers test-only serialization owned by the active broker.
  * @param {object} connection - Parent physical connection.
@@ -37,8 +91,22 @@ async function coordinateOwnedSharedTransactionConnection(registration, callback
  */
 export function setSharedTransactionCoordinator(connection, coordinator) {
   const owner = Symbol("shared-transaction-coordinator")
+  let registration = connectionRegistrations.get(connection)
+
+  if (registration) {
+    registration.coordinator = coordinator
+    registration.owner = owner
+  } else {
+    registration = {
+      connectionScope: {ownedQueue: Promise.resolve()},
+      coordinator,
+      owner,
+      ownerScopes: new Map()
+    }
+    connectionRegistrations.set(connection, registration)
+  }
 
-  coordinators.set(connection, {coordinator, ownedQueue: Promise.resolve(), owner})
+  coordinators.set(connection, registration)
   return owner
 }
 
@@ -49,7 +117,12 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
  * @returns {void}
  */
 export function clearSharedTransactionCoordinator(connection, coordinator) {
-  if (coordinators.get(connection)?.coordinator === coordinator) coordinators.delete(connection)
+  const registration = coordinators.get(connection)
+
+  if (registration?.coordinator === coordinator) {
+    coordinators.delete(connection)
+    registration.coordinator = inactiveCoordinator
+  }
 }
 
 /**
@@ -61,18 +134,26 @@ export function clearSharedTransactionCoordinator(connection, coordinator) {
  * @returns {Promise<T>} - Operation result.
  */
 export async function coordinateSharedTransactionConnection(connection, callback, operationOwner) {
-  const registration = coordinators.get(connection)
+  const activeRegistration = coordinators.get(connection)
+  const registration = activeRegistration || connectionRegistrations.get(connection)
 
   if (!registration) return await callback()
-  if (operationOwner === registration.owner) return await callback()
 
   const environmentHandler = connection.configuration.getEnvironmentHandler()
+  const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection)
+  const currentOwnerScope = currentOwner ? registration.ownerScopes.get(currentOwner) : undefined
 
-  if (environmentHandler.getSharedTransactionCoordinatorOwner(connection) === registration.owner) {
-    return await coordinateOwnedSharedTransactionConnection(registration, callback)
+  if (currentOwnerScope) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, currentOwnerScope, callback)
+  }
+  if (!activeRegistration) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback)
+  }
+  if (operationOwner === registration.owner) {
+    return await coordinateRootSharedTransactionConnection(connection, registration, callback)
   }
 
   return /** @type {T} */ (await registration.coordinator(async () => {
-    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, registration.owner, callback)
+    return await coordinateRootSharedTransactionConnection(connection, registration, callback)
   }))
 }

package/build/testing/test.js

@@ -2,9 +2,9 @@
 
 import path from "path"
 import {fileURLToPath} from "url"
+import { waitForEvent } from "@velocious/testing"
 import EventEmitter from "../utils/event-emitter.js"
 import Expect from "./expect.js"
-import waitForEvent from "./wait-for-event.js"
 import {arrayContaining, objectContaining} from "./expect-utils.js"
 
 /**