npm - velocious - Versions diffs - 1.0.620 → 1.0.621 - Mend

velocious 1.0.620 → 1.0.621

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/build/src/testing/shared-transaction-connection-coordinator.d.ts CHANGED Viewed

@@ -1,9 +1,11 @@
+export type CoordinatorOwnerScope = {
+    ownedQueue: Promise<void>;
+};
 export type CoordinatorRegistration = {
+    connectionScope: CoordinatorOwnerScope;
     coordinator: (callback: () => Promise<unknown>) => Promise<unknown>;
-    ownedQueue: Promise<void>;
     owner: symbol;
-    reentrantOwners: Set<symbol>;
-    rootOwners: Set<symbol>;
+    ownerScopes: Map<symbol, CoordinatorOwnerScope>;
 };
 /**
  * Registers test-only serialization owned by the active broker.

package/build/src/testing/shared-transaction-connection-coordinator.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAEI,~~YAAkL~~,uBAAuB,~~GAA/L~~;IAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,~~UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,~~KAAK,EAAE,MAAM,CAAC;IAAC,~~eAAe~~,EAAE,GAAG,CAAC,MAAM,~~CAAC,CAAC;IAAC,UAAU,~~EAAE,~~GAAG~~,CAAC,~~MAAM,CAAC,~~CAAA;CAAC,CAAyB;~~AAkF7M~~;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,MAAM,~~CAgBlB~~;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAShB;AAED;;;;;;;GAOG;AACH,wBAAsB,qCAAqC,CAN9C,CAAC,EAM8C,UAAU,EAL3D,OAAO,6BAA6B,EAAE,OAKqB,EAAE,QAAQ,EAJrE,MAAM,OAAO,CAAC,CAAC,CAIsD,EAAE,cAAc,AAH7F,CACA,EADQ,MAGqF,GAFnF,OAAO,CAAC,CAAC,CAAC,~~CAuBtB~~"}
1	+ {"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAEI,YAAuC,qBAAqB,GAAlD;IAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC,CAAuB;AAC5D,YAAyL,uBAAuB,GAAtM;IAAC,eAAe,EAAE,qBAAqB,CAAC;IAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAA;CAAC,CAAyB;AAkFpN;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,MAAM,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAShB;AAED;;;;;;;GAOG;AACH,wBAAsB,qCAAqC,CAN9C,CAAC,EAM8C,UAAU,EAL3D,OAAO,6BAA6B,EAAE,OAKqB,EAAE,QAAQ,EAJrE,MAAM,OAAO,CAAC,CAAC,CAIsD,EAAE,cAAc,AAH7F,CACA,EADQ,MAGqF,GAFnF,OAAO,CAAC,CAAC,CAAC,CAyBtB"}

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

@@ -1,5 +1,6 @@
 // @ts-check
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<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>} */
@@ -17,40 +18,44 @@ async function inactiveCoordinator(callback) {
  * @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(connection, 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("shared-transaction-owned-operation");
+    const operationOwner = Symbol(ownerDescription);
     const environmentHandler = connection.configuration.getEnvironmentHandler();
-    registration.reentrantOwners.add(operationOwner);
+    const operationScope = { ownedQueue: Promise.resolve() };
+    registration.ownerScopes.set(operationOwner, operationScope);
     try {
         return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback);
     }
     finally {
-        registration.reentrantOwners.delete(operationOwner);
+        await drainOwnedSharedTransactionConnections(operationScope);
+        registration.ownerScopes.delete(operationOwner);
         release();
     }
 }
 /**
  * Drains all inherited operations admitted before the root owner is revoked.
- * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.
  * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
  */
-async function drainOwnedSharedTransactionConnections(registration) {
+async function drainOwnedSharedTransactionConnections(ownerScope) {
     let tail;
     do {
-        tail = registration.ownedQueue;
+        tail = ownerScope.ownedQueue;
         await tail;
-    } while (tail !== registration.ownedQueue);
+    } while (tail !== ownerScope.ownedQueue);
 }
 /**
  * Runs one broker-serialized root while tracking and draining its inherited work.
@@ -61,17 +66,7 @@ async function drainOwnedSharedTransactionConnections(registration) {
  * @returns {Promise<T>} - Operation result.
  */
 async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
-    await drainOwnedSharedTransactionConnections(registration);
-    const rootOwner = Symbol("shared-transaction-root-operation");
-    const environmentHandler = connection.configuration.getEnvironmentHandler();
-    registration.rootOwners.add(rootOwner);
-    try {
-        return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback);
-    }
-    finally {
-        await drainOwnedSharedTransactionConnections(registration);
-        registration.rootOwners.delete(rootOwner);
-    }
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback, "shared-transaction-root-operation");
 }
 /**
  * Registers test-only serialization owned by the active broker.
@@ -87,7 +82,12 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
         registration.owner = owner;
     }
     else {
-        registration = { coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set() };
+        registration = {
+            connectionScope: { ownedQueue: Promise.resolve() },
+            coordinator,
+            owner,
+            ownerScopes: new Map()
+        };
         connectionRegistrations.set(connection, registration);
     }
     coordinators.set(connection, registration);
@@ -121,13 +121,13 @@ export async function coordinateSharedTransactionConnection(connection, callback
         return await callback();
     const environmentHandler = connection.configuration.getEnvironmentHandler();
     const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection);
-    if (currentOwner && registration.reentrantOwners.has(currentOwner))
-        return await callback();
-    if (currentOwner && registration.rootOwners.has(currentOwner)) {
-        return await coordinateOwnedSharedTransactionConnection(connection, registration, callback);
+    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 (!activeRegistration)
-        return await coordinateOwnedSharedTransactionConnection(connection, registration, callback);
     if (operationOwner === registration.owner) {
         return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }
@@ -135,4 +135,4 @@ export async function coordinateSharedTransactionConnection(connection, callback
         return await coordinateRootSharedTransactionConnection(connection, registration, callback);
     }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-connection-coordinator.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,gNAAgN;AAEhN,uDAAuD;AACvD,MAAM,YAAY,GAAG,IAAI,OAAO,EAAE,CAAA;AAClC,uDAAuD;AACvD,MAAM,uBAAuB,GAAG,IAAI,OAAO,EAAE,CAAA;AAE7C;;;;GAIG;AACH,KAAK,UAAU,mBAAmB,CAAC,QAAQ;IACzC,OAAO,MAAM,QAAQ,EAAE,CAAA;AACzB,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,0CAA0C,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ;IAC1F,MAAM,QAAQ,GAAG,YAAY,CAAC,UAAU,CAAA;IACxC;;;OAGG;IACH,IAAI,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAA;IAEtB,YAAY,CAAC,UAAU,GAAG,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,GAAG,OAAO,CAAA,CAAC,CAAC,CAAC,CAAA;IACzE,MAAM,QAAQ,CAAA;IACd,MAAM,cAAc,GAAG,MAAM,CAAC,oCAAoC,CAAC,CAAA;IACnE,MAAM,kBAAkB,GAAG,UAAU,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;IAE3E,YAAY,CAAC,eAAe,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;IAChD,IAAI,CAAC;QACH,OAAO,MAAM,kBAAkB,CAAC,wCAAwC,CAAC,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAA;IAChH,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,eAAe,CAAC,MAAM,CAAC,cAAc,CAAC,CAAA;QACnD,OAAO,EAAE,CAAA;IACX,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,KAAK,UAAU,sCAAsC,CAAC,YAAY;IAChE,IAAI,IAAI,CAAA;IAER,GAAG,CAAC;QACF,IAAI,GAAG,YAAY,CAAC,UAAU,CAAA;QAC9B,MAAM,IAAI,CAAA;IACZ,CAAC,QAAQ,IAAI,KAAK,YAAY,CAAC,UAAU,EAAC;AAC5C,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,yCAAyC,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ;IACzF,MAAM,sCAAsC,CAAC,YAAY,CAAC,CAAA;IAC1D,MAAM,SAAS,GAAG,MAAM,CAAC,mCAAmC,CAAC,CAAA;IAC7D,MAAM,kBAAkB,GAAG,UAAU,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;IAE3E,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;IACtC,IAAI,CAAC;QACH,OAAO,MAAM,kBAAkB,CAAC,wCAAwC,CAAC,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAA;IAC3G,CAAC;YAAS,CAAC;QACT,MAAM,sCAAsC,CAAC,YAAY,CAAC,CAAA;QAC1D,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC3C,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,+BAA+B,CAAC,UAAU,EAAE,WAAW;IACrE,MAAM,KAAK,GAAG,MAAM,CAAC,gCAAgC,CAAC,CAAA;IACtD,IAAI,YAAY,GAAG,uBAAuB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAE1D,IAAI,YAAY,EAAE,CAAC;QACjB,YAAY,CAAC,WAAW,GAAG,WAAW,CAAA;QACtC,YAAY,CAAC,KAAK,GAAG,KAAK,CAAA;IAC5B,CAAC;SAAM,CAAC;QACN,YAAY,GAAG,EAAC,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,IAAI,GAAG,EAAE,EAAE,UAAU,EAAE,IAAI,GAAG,EAAE,EAAC,CAAA;QACrH,uBAAuB,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IACvD,CAAC;IAED,YAAY,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;IAC1C,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAC,UAAU,EAAE,WAAW;IACvE,MAAM,YAAY,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAEjD,IAAI,YAAY,EAAE,WAAW,KAAK,WAAW,EAAE,CAAC;QAC9C,YAAY,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QAC/B,YAAY,CAAC,WAAW,GAAG,mBAAmB,CAAA;IAChD,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qCAAqC,CAAC,UAAU,EAAE,QAAQ,EAAE,cAAc;IAC9F,MAAM,kBAAkB,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IACvD,MAAM,YAAY,GAAG,kBAAkB,IAAI,uBAAuB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;IAElF,IAAI,CAAC,YAAY;QAAE,OAAO,MAAM,QAAQ,EAAE,CAAA;IAE1C,MAAM,kBAAkB,GAAG,UAAU,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;IAC3E,MAAM,YAAY,GAAG,kBAAkB,CAAC,oCAAoC,CAAC,UAAU,CAAC,CAAA;IAExF,IAAI,YAAY,IAAI,YAAY,CAAC,eAAe,CAAC,GAAG,CAAC,YAAY,CAAC;QAAE,OAAO,MAAM,QAAQ,EAAE,CAAA;IAC3F,IAAI,YAAY,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;QAC9D,OAAO,MAAM,0CAA0C,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAA;IAC7F,CAAC;IACD,IAAI,CAAC,kBAAkB;QAAE,OAAO,MAAM,0CAA0C,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAA;IACpH,IAAI,cAAc,KAAK,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1C,OAAO,MAAM,yCAAyC,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAA;IAC5F,CAAC;IAED,OAAO,gBAAgB,CAAC,CAAC,MAAM,YAAY,CAAC,WAAW,CAAC,KAAK,IAAI,EAAE;QACjE,OAAO,MAAM,yCAAyC,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAA;IAC5F,CAAC,CAAC,CAAC,CAAA;AACL,CAAC","sourcesContent":["// @ts-check\n\n/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<symbol>}} 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 {() => Promise<T>} callback - Owned operation.\n * @returns {Promise<T>} - Operation result.\n */\nasync function coordinateOwnedSharedTransactionConnection(connection, registration, callback) {\n  const previous = registration.ownedQueue\n  /**\n   * Releases the next owned sibling operation.\n   * @type {() => void}\n   */\n  let release = () => {}\n\n  registration.ownedQueue = new Promise((resolve) => { release = resolve })\n  await previous\n  const operationOwner = Symbol(\"shared-transaction-owned-operation\")\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n\n  registration.reentrantOwners.add(operationOwner)\n  try {\n    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)\n  } finally {\n    registration.reentrantOwners.delete(operationOwner)\n    release()\n  }\n}\n\n/**\n * Drains all inherited operations admitted before the root owner is revoked.\n * @param {CoordinatorRegistration} registration - Physical connection registration.\n * @returns {Promise<void>} - Resolves when the owned queue stops advancing.\n */\nasync function drainOwnedSharedTransactionConnections(registration) {\n  let tail\n\n  do {\n    tail = registration.ownedQueue\n    await tail\n  } while (tail !== registration.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  await drainOwnedSharedTransactionConnections(registration)\n  const rootOwner = Symbol(\"shared-transaction-root-operation\")\n  const environmentHandler = connection.configuration.getEnvironmentHandler()\n\n  registration.rootOwners.add(rootOwner)\n  try {\n    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback)\n  } finally {\n    await drainOwnedSharedTransactionConnections(registration)\n    registration.rootOwners.delete(rootOwner)\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 = {coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set()}\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\n  if (currentOwner && registration.reentrantOwners.has(currentOwner)) return await callback()\n  if (currentOwner && registration.rootOwners.has(currentOwner)) {\n    return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)\n  }\n  if (!activeRegistration) return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)\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"]}
+//# 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/testing/shared-transaction-connection-coordinator.js CHANGED Viewed

@@ -1,6 +1,7 @@
 // @ts-check
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<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()
@@ -21,43 +22,47 @@ async function inactiveCoordinator(callback) {
  * @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(connection, 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("shared-transaction-owned-operation")
+  const operationOwner = Symbol(ownerDescription)
   const environmentHandler = connection.configuration.getEnvironmentHandler()
+  const operationScope = {ownedQueue: Promise.resolve()}
-  registration.reentrantOwners.add(operationOwner)
+  registration.ownerScopes.set(operationOwner, operationScope)
   try {
     return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)
   } finally {
-    registration.reentrantOwners.delete(operationOwner)
+    await drainOwnedSharedTransactionConnections(operationScope)
+    registration.ownerScopes.delete(operationOwner)
     release()
   }
 }
 /**
  * Drains all inherited operations admitted before the root owner is revoked.
- * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.
  * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
  */
-async function drainOwnedSharedTransactionConnections(registration) {
+async function drainOwnedSharedTransactionConnections(ownerScope) {
   let tail
   do {
-    tail = registration.ownedQueue
+    tail = ownerScope.ownedQueue
     await tail
-  } while (tail !== registration.ownedQueue)
+  } while (tail !== ownerScope.ownedQueue)
 }
 /**
@@ -69,17 +74,13 @@ async function drainOwnedSharedTransactionConnections(registration) {
  * @returns {Promise<T>} - Operation result.
  */
 async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
-  await drainOwnedSharedTransactionConnections(registration)
-  const rootOwner = Symbol("shared-transaction-root-operation")
-  const environmentHandler = connection.configuration.getEnvironmentHandler()
-  registration.rootOwners.add(rootOwner)
-  try {
-    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback)
-  } finally {
-    await drainOwnedSharedTransactionConnections(registration)
-    registration.rootOwners.delete(rootOwner)
-  }
+  return await coordinateOwnedSharedTransactionConnection(
+    connection,
+    registration,
+    registration.connectionScope,
+    callback,
+    "shared-transaction-root-operation"
+  )
 }
 /**
@@ -96,7 +97,12 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
     registration.coordinator = coordinator
     registration.owner = owner
   } else {
-    registration = {coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set()}
+    registration = {
+      connectionScope: {ownedQueue: Promise.resolve()},
+      coordinator,
+      owner,
+      ownerScopes: new Map()
+    }
     connectionRegistrations.set(connection, registration)
   }
@@ -135,12 +141,14 @@ export async function coordinateSharedTransactionConnection(connection, callback
   const environmentHandler = connection.configuration.getEnvironmentHandler()
   const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection)
+  const currentOwnerScope = currentOwner ? registration.ownerScopes.get(currentOwner) : undefined
-  if (currentOwner && registration.reentrantOwners.has(currentOwner)) return await callback()
-  if (currentOwner && registration.rootOwners.has(currentOwner)) {
-    return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)
+  if (currentOwnerScope) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, currentOwnerScope, callback)
+  }
+  if (!activeRegistration) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback)
   }
-  if (!activeRegistration) return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)
   if (operationOwner === registration.owner) {
     return await coordinateRootSharedTransactionConnection(connection, registration, callback)
   }

package/package.json CHANGED Viewed

@@ -3,7 +3,7 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.620",
+  "version": "1.0.621",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [

package/src/background-jobs/store.js CHANGED Viewed

@@ -7,7 +7,7 @@ import TableData from "../database/table-data/index.js"
 import VelociousError from "../velocious-error.js"
 import BackgroundJobRecord from "./job-record.js"
 import normalizeBackgroundJobError from "./normalize-error.js"
-import {coordinateSharedTransactionConnection} from "../testing/shared-transaction-connection-coordinator.js"
+import { coordinateSharedTransactionConnection } from "../testing/shared-transaction-connection-coordinator.js"
 import stableJsonStringify from "../utils/stable-json.js"
 import {
   BACKGROUND_JOB_EXECUTION_MODES,

package/src/testing/shared-transaction-connection-coordinator.js CHANGED Viewed

@@ -1,6 +1,7 @@
 // @ts-check
-/** @typedef {{coordinator: (callback: () => Promise<unknown>) => Promise<unknown>, ownedQueue: Promise<void>, owner: symbol, reentrantOwners: Set<symbol>, rootOwners: Set<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()
@@ -21,43 +22,47 @@ async function inactiveCoordinator(callback) {
  * @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(connection, 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("shared-transaction-owned-operation")
+  const operationOwner = Symbol(ownerDescription)
   const environmentHandler = connection.configuration.getEnvironmentHandler()
+  const operationScope = {ownedQueue: Promise.resolve()}
-  registration.reentrantOwners.add(operationOwner)
+  registration.ownerScopes.set(operationOwner, operationScope)
   try {
     return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, operationOwner, callback)
   } finally {
-    registration.reentrantOwners.delete(operationOwner)
+    await drainOwnedSharedTransactionConnections(operationScope)
+    registration.ownerScopes.delete(operationOwner)
     release()
   }
 }
 /**
  * Drains all inherited operations admitted before the root owner is revoked.
- * @param {CoordinatorRegistration} registration - Physical connection registration.
+ * @param {CoordinatorOwnerScope} ownerScope - Owner scope to drain.
  * @returns {Promise<void>} - Resolves when the owned queue stops advancing.
  */
-async function drainOwnedSharedTransactionConnections(registration) {
+async function drainOwnedSharedTransactionConnections(ownerScope) {
   let tail
   do {
-    tail = registration.ownedQueue
+    tail = ownerScope.ownedQueue
     await tail
-  } while (tail !== registration.ownedQueue)
+  } while (tail !== ownerScope.ownedQueue)
 }
 /**
@@ -69,17 +74,13 @@ async function drainOwnedSharedTransactionConnections(registration) {
  * @returns {Promise<T>} - Operation result.
  */
 async function coordinateRootSharedTransactionConnection(connection, registration, callback) {
-  await drainOwnedSharedTransactionConnections(registration)
-  const rootOwner = Symbol("shared-transaction-root-operation")
-  const environmentHandler = connection.configuration.getEnvironmentHandler()
-  registration.rootOwners.add(rootOwner)
-  try {
-    return await environmentHandler.runWithSharedTransactionCoordinatorOwner(connection, rootOwner, callback)
-  } finally {
-    await drainOwnedSharedTransactionConnections(registration)
-    registration.rootOwners.delete(rootOwner)
-  }
+  return await coordinateOwnedSharedTransactionConnection(
+    connection,
+    registration,
+    registration.connectionScope,
+    callback,
+    "shared-transaction-root-operation"
+  )
 }
 /**
@@ -96,7 +97,12 @@ export function setSharedTransactionCoordinator(connection, coordinator) {
     registration.coordinator = coordinator
     registration.owner = owner
   } else {
-    registration = {coordinator, ownedQueue: Promise.resolve(), owner, reentrantOwners: new Set(), rootOwners: new Set()}
+    registration = {
+      connectionScope: {ownedQueue: Promise.resolve()},
+      coordinator,
+      owner,
+      ownerScopes: new Map()
+    }
     connectionRegistrations.set(connection, registration)
   }
@@ -135,12 +141,14 @@ export async function coordinateSharedTransactionConnection(connection, callback
   const environmentHandler = connection.configuration.getEnvironmentHandler()
   const currentOwner = environmentHandler.getSharedTransactionCoordinatorOwner(connection)
+  const currentOwnerScope = currentOwner ? registration.ownerScopes.get(currentOwner) : undefined
-  if (currentOwner && registration.reentrantOwners.has(currentOwner)) return await callback()
-  if (currentOwner && registration.rootOwners.has(currentOwner)) {
-    return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)
+  if (currentOwnerScope) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, currentOwnerScope, callback)
+  }
+  if (!activeRegistration) {
+    return await coordinateOwnedSharedTransactionConnection(connection, registration, registration.connectionScope, callback)
   }
-  if (!activeRegistration) return await coordinateOwnedSharedTransactionConnection(connection, registration, callback)
   if (operationOwner === registration.owner) {
     return await coordinateRootSharedTransactionConnection(connection, registration, callback)
   }