velocious 1.0.590 → 1.0.591

package/build/src/testing/shared-transaction-broker.js

@@ -0,0 +1,414 @@
+// @ts-check
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { EventEmitter } from "node:events";
+import { WebSocketServer } from "ws";
+import { decodeBrokerValue, encodeBrokerValue } from "./shared-transaction-codec.js";
+import { clearSharedTransactionCoordinator, setSharedTransactionCoordinator } from "./shared-transaction-connection-coordinator.js";
+/** @typedef {{queue: Promise<void>, rootSessions: Set<import("ws").WebSocket>, lease?: {operations: Promise<void>, release: () => void, savePointName: string, socket: import("ws").WebSocket}}} ConnectionState */
+const ALLOWED_METHODS = new Set([
+    "query",
+    "affectedRows",
+    "_queryActual",
+    "_affectedRowsActual",
+    "_startTransactionAction",
+    "_commitTransactionAction",
+    "_rollbackTransactionAction",
+    "startSavePoint",
+    "releaseSavePoint",
+    "rollbackSavePoint",
+    "getConnectionScopedValue",
+    "rootTransactionStart",
+    "rootTransactionRelease",
+    "rootTransactionRollback"
+]);
+/**
+ * Compares a presented capability without leaking matching prefix timing.
+ * @param {string} provided - Presented capability.
+ * @param {string} expected - Active capability.
+ * @returns {boolean} - Whether the capabilities match.
+ */
+function capabilityMatches(provided, expected) {
+    const providedBytes = Buffer.from(provided);
+    const expectedBytes = Buffer.from(expected);
+    return providedBytes.length === expectedBytes.length && timingSafeEqual(providedBytes, expectedBytes);
+}
+export default class SharedTransactionBroker extends EventEmitter {
+    /**
+     * Creates a broker around parent-owned physical connections.
+     * @param {{connections: Record<string, object>}} args - Parent-owned physical connections.
+     */
+    constructor({ connections }) {
+        super();
+        this.connections = connections;
+        this.secret = randomBytes(32).toString("base64url");
+        this.accepting = true;
+        /** @type {Map<object, ConnectionState>} */
+        this.connectionStates = new Map();
+        /** @type {Set<import("ws").WebSocket>} */
+        this.sessions = new Set();
+        /** @type {Map<import("ws").WebSocket, Promise<void>>} */
+        this.sessionCleanup = new Map();
+        /** @type {Array<Error>} */
+        this.cleanupErrors = [];
+        /** @type {Promise<void> | undefined} */
+        this.closePromise = undefined;
+        /** @type {Map<object, (callback: () => Promise<ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>>} */
+        this.connectionCoordinators = new Map();
+        for (const connection of new Set(Object.values(connections))) {
+            /**
+             * Serializes parent operations with child broker traffic.
+             * @param {() => Promise<unknown>} callback - Parent operation.
+             * @returns {Promise<unknown>} - Operation result.
+             */
+            const coordinator = async (callback) => await this.serialize(this.connectionState(connection), callback);
+            this.connectionCoordinators.set(connection, coordinator);
+            setSharedTransactionCoordinator(connection, coordinator);
+        }
+        this.httpServer = createServer();
+        this.websocketServer = new WebSocketServer({ server: this.httpServer, maxPayload: 16 * 1024 * 1024 });
+        this.websocketServer.on("connection", (socket) => {
+            this.sessions.add(socket);
+            socket.once("close", () => {
+                this.sessions.delete(socket);
+                this.scheduleSessionCleanup(socket);
+            });
+            socket.on("message", (data) => void this.handleRequest(socket, `${data}`));
+        });
+    }
+    /**
+     * Starts a broker on an ephemeral loopback port.
+     * @param {{connections: Record<string, object>}} args - Parent-owned physical connections.
+     * @returns {Promise<SharedTransactionBroker>} - Listening broker.
+     */
+    static async start(args) {
+        const broker = new SharedTransactionBroker(args);
+        await new Promise((resolve, reject) => {
+            broker.httpServer.once("error", reject);
+            broker.httpServer.listen({ host: "127.0.0.1", port: 0 }, () => resolve(undefined));
+        });
+        return broker;
+    }
+    /**
+     * Gets the loopback websocket address.
+     * @returns {string} - Loopback websocket address.
+     */
+    address() {
+        const address = this.httpServer.address();
+        if (!address || typeof address === "string")
+            throw new Error("Shared transaction broker is not listening");
+        return `ws://127.0.0.1:${address.port}`;
+    }
+    /**
+     * Gets the per-attempt unguessable capability.
+     * @returns {string} - Per-attempt unguessable capability.
+     */
+    capability() { return this.secret; }
+    /**
+     * Validates and handles one request.
+     * @param {import("ws").WebSocket} socket - Calling session.
+     * @param {string} serialized - Request JSON.
+     * @returns {Promise<void>} - Resolves after responding.
+     */
+    async handleRequest(socket, serialized) {
+        let requestId = 0;
+        try {
+            const request = /** @type {{requestId: number, capability: string, databaseIdentifier: string, method: string, args: import("./shared-transaction-codec.js").EncodedBrokerValue}} */ (JSON.parse(serialized));
+            requestId = request.requestId;
+            if (!this.accepting)
+                throw new Error("Shared transaction broker capability has been revoked");
+            if (!capabilityMatches(request.capability, this.secret))
+                throw new Error("Unknown shared transaction broker capability");
+            const connection = this.connections[request.databaseIdentifier];
+            if (!connection)
+                throw new Error(`Unknown shared transaction database identifier: ${request.databaseIdentifier}`);
+            if (!ALLOWED_METHODS.has(request.method))
+                throw new Error(`Unsupported shared transaction broker method: ${request.method}`);
+            const args = decodeBrokerValue(request.args);
+            if (!Array.isArray(args))
+                throw new TypeError("Shared transaction broker arguments must be an array");
+            this.emit("work-queued", { connection, databaseIdentifier: request.databaseIdentifier, method: request.method });
+            const result = await this.runConnectionRequest({ connection, method: request.method, savePointName: typeof args[0] === "string" ? args[0] : undefined, socket }, async () => {
+                if (!this.accepting)
+                    throw new Error("Shared transaction broker capability has been revoked");
+                if (request.method === "rootTransactionRollback") {
+                    await this.rollbackRootSavePoint(connection, /** @type {string} */ (args[0]));
+                    return undefined;
+                }
+                const physicalMethod = request.method === "rootTransactionStart"
+                    ? "startSavePoint"
+                    : request.method === "rootTransactionRelease"
+                        ? "releaseSavePoint"
+                        : request.method === "rootTransactionRollback"
+                            ? "rollbackSavePoint"
+                            : request.method;
+                const connectionMethods = /** @type {Record<string, (...methodArgs: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>>} */ (connection);
+                const method = connectionMethods[physicalMethod];
+                if (typeof method !== "function")
+                    throw new Error(`Connection does not support shared transaction method: ${request.method}`);
+                return await method.apply(connection, args);
+            });
+            if (socket.readyState === socket.OPEN)
+                socket.send(JSON.stringify({ requestId, result: encodeBrokerValue(result) }));
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            if (socket.readyState === socket.OPEN)
+                socket.send(JSON.stringify({ requestId, error: encodeBrokerValue(normalized) }));
+        }
+    }
+    /**
+     * Gets mutable serialization state for one physical connection.
+     * @param {object} connection - Physical connection.
+     * @returns {ConnectionState} - Connection state.
+     */
+    connectionState(connection) {
+        let state = this.connectionStates.get(connection);
+        if (!state) {
+            state = { queue: Promise.resolve(), rootSessions: new Set() };
+            this.connectionStates.set(connection, state);
+        }
+        return state;
+    }
+    /**
+     * Runs a validated request with root transaction lease semantics.
+     * @template T
+     * @param {{connection: object, method: string, savePointName: string | undefined, socket: import("ws").WebSocket}} args - Request identity.
+     * @param {() => Promise<T>} callback - Physical operation.
+     * @returns {Promise<T>} - Operation result.
+     */
+    async runConnectionRequest({ connection, method, savePointName, socket }, callback) {
+        const state = this.connectionState(connection);
+        if (method === "rootTransactionStart") {
+            if (!savePointName)
+                throw new Error("Shared transaction broker root transaction requires a savepoint name");
+            return await this.startRootLease({ callback, savePointName, state, socket });
+        }
+        if (method === "rootTransactionRelease" || method === "rootTransactionRollback") {
+            return await this.finishRootLease({ callback, savePointName, state, socket });
+        }
+        if (state.lease?.socket === socket)
+            return await this.serializeLease(state.lease, callback);
+        return await this.serialize(state, callback);
+    }
+    /**
+     * Acquires the FIFO physical connection lease and holds the queue until end.
+     * @template T
+     * @param {{callback: () => Promise<T>, savePointName: string, state: ConnectionState, socket: import("ws").WebSocket}} args - Lease request.
+     * @returns {Promise<T>} - Root savepoint start result.
+     */
+    async startRootLease({ callback, savePointName, state, socket }) {
+        if (state.rootSessions.has(socket))
+            throw new Error("Shared transaction broker root transaction is already active for this session");
+        state.rootSessions.add(socket);
+        const previous = state.queue;
+        /**
+         * Resolves the start response.
+         * @type {(value: T) => void}
+         */
+        let resolveStarted = () => { };
+        /**
+         * Rejects the start response.
+         * @type {(error: Error) => void}
+         */
+        let rejectStarted = () => { };
+        const started = new Promise((resolve, reject) => { resolveStarted = resolve; rejectStarted = reject; });
+        /**
+         * Releases the held connection queue.
+         * @type {(value?: void) => void}
+         */
+        let release = () => { };
+        const held = new Promise((resolve) => { release = resolve; });
+        state.queue = previous.then(async () => {
+            try {
+                if (!this.accepting || socket.readyState !== socket.OPEN)
+                    throw new Error("Shared transaction broker root transaction session closed before lease acquisition");
+                const result = await callback();
+                state.lease = { operations: Promise.resolve(), release, savePointName, socket };
+                resolveStarted(result);
+                await held;
+            }
+            catch (error) {
+                state.rootSessions.delete(socket);
+                rejectStarted(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        return await started;
+    }
+    /**
+     * Finishes the calling session's root lease.
+     * @template T
+     * @param {{callback: () => Promise<T>, savePointName: string | undefined, state: ConnectionState, socket: import("ws").WebSocket}} args - Lease end request.
+     * @returns {Promise<T>} - Savepoint end result.
+     */
+    async finishRootLease({ callback, savePointName, state, socket }) {
+        const lease = state.lease;
+        if (!lease || lease.socket !== socket)
+            throw new Error("Shared transaction broker session does not own the root transaction lease");
+        if (savePointName !== lease.savePointName)
+            throw new Error("Shared transaction broker root transaction savepoint does not match its lease");
+        try {
+            return await this.serializeLease(lease, callback);
+        }
+        finally {
+            state.lease = undefined;
+            state.rootSessions.delete(socket);
+            lease.release();
+        }
+    }
+    /**
+     * Serializes operations belonging to the active lease holder.
+     * @template T
+     * @param {{operations: Promise<void>}} lease - Active lease.
+     * @param {() => Promise<T>} callback - Operation.
+     * @returns {Promise<T>} - Result.
+     */
+    async serializeLease(lease, callback) {
+        const previous = lease.operations;
+        /**
+         * Releases the holder operation queue.
+         * @type {(value?: void) => void}
+         */
+        let release = () => { };
+        const current = new Promise((resolve) => { release = resolve; });
+        lease.operations = previous.then(() => current);
+        await previous;
+        try {
+            return await callback();
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Rolls back leases abandoned by a disconnected session.
+     * @param {import("ws").WebSocket} socket - Disconnected session.
+     * @returns {Promise<void>} - Resolves after all owned leases release.
+     */
+    async releaseDisconnectedLeases(socket) {
+        /** @type {Array<Error>} */
+        const errors = [];
+        for (const [connection, state] of this.connectionStates) {
+            const lease = state.lease;
+            if (!lease || lease.socket !== socket)
+                continue;
+            try {
+                await this.serializeLease(lease, async () => {
+                    await this.rollbackRootSavePoint(connection, lease.savePointName);
+                });
+            }
+            catch (error) {
+                errors.push(error instanceof Error ? error : new Error(String(error)));
+            }
+            finally {
+                state.lease = undefined;
+                state.rootSessions.delete(socket);
+                lease.release();
+            }
+        }
+        if (errors.length > 0) {
+            throw new AggregateError(errors, `Shared transaction broker lease cleanup failed: ${errors.map((error) => error.message).join("; ")}`);
+        }
+    }
+    /**
+     * Tracks detached socket cleanup and records its failure for close().
+     * @param {import("ws").WebSocket} socket - Closed session.
+     * @returns {Promise<void>} - Settled tracked cleanup.
+     */
+    scheduleSessionCleanup(socket) {
+        const existing = this.sessionCleanup.get(socket);
+        if (existing)
+            return existing;
+        const cleanup = this.releaseDisconnectedLeases(socket)
+            .catch((error) => {
+            this.cleanupErrors.push(error instanceof Error ? error : new Error(String(error)));
+        })
+            .finally(() => this.sessionCleanup.delete(socket));
+        this.sessionCleanup.set(socket, cleanup);
+        return cleanup;
+    }
+    /**
+     * Rolls back and removes a root savepoint so it cannot remain beneath the next lease.
+     * @param {object} connection - Parent physical connection.
+     * @param {string} savePointName - Root savepoint name.
+     * @returns {Promise<void>} - Resolves after rollback and release.
+     */
+    async rollbackRootSavePoint(connection, savePointName) {
+        const methods = /** @type {{releaseSavePoint: (name: string) => Promise<void>, rollbackSavePoint: (name: string) => Promise<void>}} */ (connection);
+        /** @type {Array<Error>} */
+        const errors = [];
+        try {
+            await methods.rollbackSavePoint(savePointName);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+        try {
+            await methods.releaseSavePoint(savePointName);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+        if (errors.length > 0) {
+            throw new AggregateError(errors, `Shared transaction broker could not clean root savepoint ${savePointName}: ${errors.map((error) => error.message).join("; ")}`);
+        }
+    }
+    /**
+     * Serializes ordinary non-holder work through the connection FIFO.
+     * @template T
+     * @param {ConnectionState} state - Connection state.
+     * @param {() => Promise<T>} callback - Work.
+     * @returns {Promise<T>} - Work result.
+     */
+    async serialize(state, callback) {
+        const previous = state.queue;
+        /**
+         * Resolves the current queue entry.
+         * @type {(value?: void) => void}
+         */
+        let release = () => { };
+        const current = new Promise((resolve) => { release = resolve; });
+        const queued = previous.then(() => current);
+        state.queue = queued;
+        await previous;
+        try {
+            return await callback();
+        }
+        finally {
+            release();
+        }
+    }
+    /**
+     * Stops admission, revokes capability, rejects clients, and drains active work.
+     * @returns {Promise<void>} - Resolves after transport shutdown.
+     */
+    async close() {
+        if (this.closePromise)
+            return await this.closePromise;
+        this.closePromise = this.closeTransport();
+        return await this.closePromise;
+    }
+    /**
+     * Performs deterministic transport shutdown and reports cleanup failures last.
+     * @returns {Promise<void>} - Resolves after shutdown or rejects with cleanup errors.
+     */
+    async closeTransport() {
+        this.accepting = false;
+        this.secret = randomBytes(32).toString("base64url");
+        const closingSessions = Array.from(this.sessions);
+        await Promise.all(closingSessions.map(async (socket) => await this.scheduleSessionCleanup(socket)));
+        for (const socket of closingSessions)
+            socket.close(1001, "Shared transaction broker closed");
+        await Promise.allSettled(Array.from(this.connectionStates.values()).map((state) => state.queue));
+        await new Promise((resolve) => this.websocketServer.close(() => resolve(undefined)));
+        await new Promise((resolve) => this.httpServer.close(() => resolve(undefined)));
+        await Promise.all(Array.from(this.sessionCleanup.values()));
+        for (const [connection, coordinator] of this.connectionCoordinators) {
+            clearSharedTransactionCoordinator(connection, coordinator);
+        }
+        if (this.cleanupErrors.length > 0) {
+            throw new AggregateError(this.cleanupErrors, `Shared transaction broker cleanup failed: ${this.cleanupErrors.map((error) => error.message).join("; ")}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-transaction-broker.js","sourceRoot":"","sources":["../../../src/testing/shared-transaction-broker.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { randomBytes, timingSafeEqual } from \"node:crypto\"\nimport { createServer } from \"node:http\"\nimport { EventEmitter } from \"node:events\"\nimport { WebSocketServer } from \"ws\"\nimport { decodeBrokerValue, encodeBrokerValue } from \"./shared-transaction-codec.js\"\nimport {clearSharedTransactionCoordinator, setSharedTransactionCoordinator} from \"./shared-transaction-connection-coordinator.js\"\n\n/** @typedef {{queue: Promise<void>, rootSessions: Set<import(\"ws\").WebSocket>, lease?: {operations: Promise<void>, release: () => void, savePointName: string, socket: import(\"ws\").WebSocket}}} ConnectionState */\n\nconst ALLOWED_METHODS = new Set([\n  \"query\",\n  \"affectedRows\",\n  \"_queryActual\",\n  \"_affectedRowsActual\",\n  \"_startTransactionAction\",\n  \"_commitTransactionAction\",\n  \"_rollbackTransactionAction\",\n  \"startSavePoint\",\n  \"releaseSavePoint\",\n  \"rollbackSavePoint\",\n  \"getConnectionScopedValue\",\n  \"rootTransactionStart\",\n  \"rootTransactionRelease\",\n  \"rootTransactionRollback\"\n])\n\n/**\n * Compares a presented capability without leaking matching prefix timing.\n * @param {string} provided - Presented capability.\n * @param {string} expected - Active capability.\n * @returns {boolean} - Whether the capabilities match.\n */\nfunction capabilityMatches(provided, expected) {\n  const providedBytes = Buffer.from(provided)\n  const expectedBytes = Buffer.from(expected)\n  return providedBytes.length === expectedBytes.length && timingSafeEqual(providedBytes, expectedBytes)\n}\n\nexport default class SharedTransactionBroker extends EventEmitter {\n  /**\n   * Creates a broker around parent-owned physical connections.\n   * @param {{connections: Record<string, object>}} args - Parent-owned physical connections.\n   */\n  constructor({connections}) {\n    super()\n    this.connections = connections\n    this.secret = randomBytes(32).toString(\"base64url\")\n    this.accepting = true\n    /** @type {Map<object, ConnectionState>} */\n    this.connectionStates = new Map()\n    /** @type {Set<import(\"ws\").WebSocket>} */\n    this.sessions = new Set()\n    /** @type {Map<import(\"ws\").WebSocket, Promise<void>>} */\n    this.sessionCleanup = new Map()\n    /** @type {Array<Error>} */\n    this.cleanupErrors = []\n    /** @type {Promise<void> | undefined} */\n    this.closePromise = undefined\n    /** @type {Map<object, (callback: () => Promise<ReturnType<typeof JSON.parse>>) => Promise<ReturnType<typeof JSON.parse>>>} */\n    this.connectionCoordinators = new Map()\n    for (const connection of new Set(Object.values(connections))) {\n      /**\n       * Serializes parent operations with child broker traffic.\n       * @param {() => Promise<unknown>} callback - Parent operation.\n       * @returns {Promise<unknown>} - Operation result.\n       */\n      const coordinator = async (callback) => await this.serialize(this.connectionState(connection), callback)\n      this.connectionCoordinators.set(connection, coordinator)\n      setSharedTransactionCoordinator(connection, coordinator)\n    }\n    this.httpServer = createServer()\n    this.websocketServer = new WebSocketServer({server: this.httpServer, maxPayload: 16 * 1024 * 1024})\n    this.websocketServer.on(\"connection\", (socket) => {\n      this.sessions.add(socket)\n      socket.once(\"close\", () => {\n        this.sessions.delete(socket)\n        this.scheduleSessionCleanup(socket)\n      })\n      socket.on(\"message\", (data) => void this.handleRequest(socket, `${data}`))\n    })\n  }\n\n  /**\n   * Starts a broker on an ephemeral loopback port.\n   * @param {{connections: Record<string, object>}} args - Parent-owned physical connections.\n   * @returns {Promise<SharedTransactionBroker>} - Listening broker.\n   */\n  static async start(args) {\n    const broker = new SharedTransactionBroker(args)\n    await new Promise((resolve, reject) => {\n      broker.httpServer.once(\"error\", reject)\n      broker.httpServer.listen({host: \"127.0.0.1\", port: 0}, () => resolve(undefined))\n    })\n    return broker\n  }\n\n  /**\n   * Gets the loopback websocket address.\n   * @returns {string} - Loopback websocket address.\n   */\n  address() {\n    const address = this.httpServer.address()\n    if (!address || typeof address === \"string\") throw new Error(\"Shared transaction broker is not listening\")\n    return `ws://127.0.0.1:${address.port}`\n  }\n\n  /**\n   * Gets the per-attempt unguessable capability.\n   * @returns {string} - Per-attempt unguessable capability.\n   */\n  capability() { return this.secret }\n\n  /**\n   * Validates and handles one request.\n   * @param {import(\"ws\").WebSocket} socket - Calling session.\n   * @param {string} serialized - Request JSON.\n   * @returns {Promise<void>} - Resolves after responding.\n   */\n  async handleRequest(socket, serialized) {\n    let requestId = 0\n    try {\n      const request = /** @type {{requestId: number, capability: string, databaseIdentifier: string, method: string, args: import(\"./shared-transaction-codec.js\").EncodedBrokerValue}} */ (JSON.parse(serialized))\n      requestId = request.requestId\n      if (!this.accepting) throw new Error(\"Shared transaction broker capability has been revoked\")\n      if (!capabilityMatches(request.capability, this.secret)) throw new Error(\"Unknown shared transaction broker capability\")\n      const connection = this.connections[request.databaseIdentifier]\n      if (!connection) throw new Error(`Unknown shared transaction database identifier: ${request.databaseIdentifier}`)\n      if (!ALLOWED_METHODS.has(request.method)) throw new Error(`Unsupported shared transaction broker method: ${request.method}`)\n      const args = decodeBrokerValue(request.args)\n      if (!Array.isArray(args)) throw new TypeError(\"Shared transaction broker arguments must be an array\")\n      this.emit(\"work-queued\", {connection, databaseIdentifier: request.databaseIdentifier, method: request.method})\n      const result = await this.runConnectionRequest({connection, method: request.method, savePointName: typeof args[0] === \"string\" ? args[0] : undefined, socket}, async () => {\n        if (!this.accepting) throw new Error(\"Shared transaction broker capability has been revoked\")\n        if (request.method === \"rootTransactionRollback\") {\n          await this.rollbackRootSavePoint(connection, /** @type {string} */ (args[0]))\n          return undefined\n        }\n        const physicalMethod = request.method === \"rootTransactionStart\"\n          ? \"startSavePoint\"\n          : request.method === \"rootTransactionRelease\"\n            ? \"releaseSavePoint\"\n            : request.method === \"rootTransactionRollback\"\n              ? \"rollbackSavePoint\"\n              : request.method\n        const connectionMethods = /** @type {Record<string, (...methodArgs: Array<ReturnType<typeof JSON.parse>>) => ReturnType<typeof JSON.parse>>} */ (connection)\n        const method = connectionMethods[physicalMethod]\n        if (typeof method !== \"function\") throw new Error(`Connection does not support shared transaction method: ${request.method}`)\n        return await method.apply(connection, args)\n      })\n      if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({requestId, result: encodeBrokerValue(result)}))\n    } catch (error) {\n      const normalized = error instanceof Error ? error : new Error(String(error))\n      if (socket.readyState === socket.OPEN) socket.send(JSON.stringify({requestId, error: encodeBrokerValue(normalized)}))\n    }\n  }\n\n  /**\n   * Gets mutable serialization state for one physical connection.\n   * @param {object} connection - Physical connection.\n   * @returns {ConnectionState} - Connection state.\n   */\n  connectionState(connection) {\n    let state = this.connectionStates.get(connection)\n    if (!state) {\n      state = {queue: Promise.resolve(), rootSessions: new Set()}\n      this.connectionStates.set(connection, state)\n    }\n    return state\n  }\n\n  /**\n   * Runs a validated request with root transaction lease semantics.\n   * @template T\n   * @param {{connection: object, method: string, savePointName: string | undefined, socket: import(\"ws\").WebSocket}} args - Request identity.\n   * @param {() => Promise<T>} callback - Physical operation.\n   * @returns {Promise<T>} - Operation result.\n   */\n  async runConnectionRequest({connection, method, savePointName, socket}, callback) {\n    const state = this.connectionState(connection)\n    if (method === \"rootTransactionStart\") {\n      if (!savePointName) throw new Error(\"Shared transaction broker root transaction requires a savepoint name\")\n      return await this.startRootLease({callback, savePointName, state, socket})\n    }\n    if (method === \"rootTransactionRelease\" || method === \"rootTransactionRollback\") {\n      return await this.finishRootLease({callback, savePointName, state, socket})\n    }\n    if (state.lease?.socket === socket) return await this.serializeLease(state.lease, callback)\n    return await this.serialize(state, callback)\n  }\n\n  /**\n   * Acquires the FIFO physical connection lease and holds the queue until end.\n   * @template T\n   * @param {{callback: () => Promise<T>, savePointName: string, state: ConnectionState, socket: import(\"ws\").WebSocket}} args - Lease request.\n   * @returns {Promise<T>} - Root savepoint start result.\n   */\n  async startRootLease({callback, savePointName, state, socket}) {\n    if (state.rootSessions.has(socket)) throw new Error(\"Shared transaction broker root transaction is already active for this session\")\n    state.rootSessions.add(socket)\n    const previous = state.queue\n    /**\n     * Resolves the start response.\n     * @type {(value: T) => void}\n     */\n    let resolveStarted = () => {}\n    /**\n     * Rejects the start response.\n     * @type {(error: Error) => void}\n     */\n    let rejectStarted = () => {}\n    const started = new Promise((resolve, reject) => { resolveStarted = resolve; rejectStarted = reject })\n    /**\n     * Releases the held connection queue.\n     * @type {(value?: void) => void}\n     */\n    let release = () => {}\n    const held = new Promise((resolve) => { release = resolve })\n\n    state.queue = previous.then(async () => {\n      try {\n        if (!this.accepting || socket.readyState !== socket.OPEN) throw new Error(\"Shared transaction broker root transaction session closed before lease acquisition\")\n        const result = await callback()\n        state.lease = {operations: Promise.resolve(), release, savePointName, socket}\n        resolveStarted(result)\n        await held\n      } catch (error) {\n        state.rootSessions.delete(socket)\n        rejectStarted(error instanceof Error ? error : new Error(String(error)))\n      }\n    })\n    return await started\n  }\n\n  /**\n   * Finishes the calling session's root lease.\n   * @template T\n   * @param {{callback: () => Promise<T>, savePointName: string | undefined, state: ConnectionState, socket: import(\"ws\").WebSocket}} args - Lease end request.\n   * @returns {Promise<T>} - Savepoint end result.\n   */\n  async finishRootLease({callback, savePointName, state, socket}) {\n    const lease = state.lease\n    if (!lease || lease.socket !== socket) throw new Error(\"Shared transaction broker session does not own the root transaction lease\")\n    if (savePointName !== lease.savePointName) throw new Error(\"Shared transaction broker root transaction savepoint does not match its lease\")\n    try {\n      return await this.serializeLease(lease, callback)\n    } finally {\n      state.lease = undefined\n      state.rootSessions.delete(socket)\n      lease.release()\n    }\n  }\n\n  /**\n   * Serializes operations belonging to the active lease holder.\n   * @template T\n   * @param {{operations: Promise<void>}} lease - Active lease.\n   * @param {() => Promise<T>} callback - Operation.\n   * @returns {Promise<T>} - Result.\n   */\n  async serializeLease(lease, callback) {\n    const previous = lease.operations\n    /**\n     * Releases the holder operation queue.\n     * @type {(value?: void) => void}\n     */\n    let release = () => {}\n    const current = new Promise((resolve) => { release = resolve })\n    lease.operations = previous.then(() => current)\n    await previous\n    try { return await callback() } finally { release() }\n  }\n\n  /**\n   * Rolls back leases abandoned by a disconnected session.\n   * @param {import(\"ws\").WebSocket} socket - Disconnected session.\n   * @returns {Promise<void>} - Resolves after all owned leases release.\n   */\n  async releaseDisconnectedLeases(socket) {\n    /** @type {Array<Error>} */\n    const errors = []\n    for (const [connection, state] of this.connectionStates) {\n      const lease = state.lease\n      if (!lease || lease.socket !== socket) continue\n      try {\n        await this.serializeLease(lease, async () => {\n          await this.rollbackRootSavePoint(connection, lease.savePointName)\n        })\n      } catch (error) {\n        errors.push(error instanceof Error ? error : new Error(String(error)))\n      } finally {\n        state.lease = undefined\n        state.rootSessions.delete(socket)\n        lease.release()\n      }\n    }\n    if (errors.length > 0) {\n      throw new AggregateError(errors, `Shared transaction broker lease cleanup failed: ${errors.map((error) => error.message).join(\"; \")}`)\n    }\n  }\n\n  /**\n   * Tracks detached socket cleanup and records its failure for close().\n   * @param {import(\"ws\").WebSocket} socket - Closed session.\n   * @returns {Promise<void>} - Settled tracked cleanup.\n   */\n  scheduleSessionCleanup(socket) {\n    const existing = this.sessionCleanup.get(socket)\n    if (existing) return existing\n    const cleanup = this.releaseDisconnectedLeases(socket)\n      .catch((error) => {\n        this.cleanupErrors.push(error instanceof Error ? error : new Error(String(error)))\n      })\n      .finally(() => this.sessionCleanup.delete(socket))\n    this.sessionCleanup.set(socket, cleanup)\n    return cleanup\n  }\n\n  /**\n   * Rolls back and removes a root savepoint so it cannot remain beneath the next lease.\n   * @param {object} connection - Parent physical connection.\n   * @param {string} savePointName - Root savepoint name.\n   * @returns {Promise<void>} - Resolves after rollback and release.\n   */\n  async rollbackRootSavePoint(connection, savePointName) {\n    const methods = /** @type {{releaseSavePoint: (name: string) => Promise<void>, rollbackSavePoint: (name: string) => Promise<void>}} */ (connection)\n    /** @type {Array<Error>} */\n    const errors = []\n    try {\n      await methods.rollbackSavePoint(savePointName)\n    } catch (error) {\n      errors.push(error instanceof Error ? error : new Error(String(error)))\n    }\n    try {\n      await methods.releaseSavePoint(savePointName)\n    } catch (error) {\n      errors.push(error instanceof Error ? error : new Error(String(error)))\n    }\n    if (errors.length > 0) {\n      throw new AggregateError(errors, `Shared transaction broker could not clean root savepoint ${savePointName}: ${errors.map((error) => error.message).join(\"; \")}`)\n    }\n  }\n\n  /**\n   * Serializes ordinary non-holder work through the connection FIFO.\n   * @template T\n   * @param {ConnectionState} state - Connection state.\n   * @param {() => Promise<T>} callback - Work.\n   * @returns {Promise<T>} - Work result.\n   */\n  async serialize(state, callback) {\n    const previous = state.queue\n    /**\n     * Resolves the current queue entry.\n     * @type {(value?: void) => void}\n     */\n    let release = () => {}\n    const current = new Promise((resolve) => { release = resolve })\n    const queued = previous.then(() => current)\n    state.queue = queued\n    await previous\n    try {\n      return await callback()\n    } finally {\n      release()\n    }\n  }\n\n  /**\n   * Stops admission, revokes capability, rejects clients, and drains active work.\n   * @returns {Promise<void>} - Resolves after transport shutdown.\n   */\n  async close() {\n    if (this.closePromise) return await this.closePromise\n    this.closePromise = this.closeTransport()\n    return await this.closePromise\n  }\n\n  /**\n   * Performs deterministic transport shutdown and reports cleanup failures last.\n   * @returns {Promise<void>} - Resolves after shutdown or rejects with cleanup errors.\n   */\n  async closeTransport() {\n    this.accepting = false\n    this.secret = randomBytes(32).toString(\"base64url\")\n    const closingSessions = Array.from(this.sessions)\n    await Promise.all(closingSessions.map(async (socket) => await this.scheduleSessionCleanup(socket)))\n    for (const socket of closingSessions) socket.close(1001, \"Shared transaction broker closed\")\n    await Promise.allSettled(Array.from(this.connectionStates.values()).map((state) => state.queue))\n    await new Promise((resolve) => this.websocketServer.close(() => resolve(undefined)))\n    await new Promise((resolve) => this.httpServer.close(() => resolve(undefined)))\n    await Promise.all(Array.from(this.sessionCleanup.values()))\n    for (const [connection, coordinator] of this.connectionCoordinators) {\n      clearSharedTransactionCoordinator(connection, coordinator)\n    }\n    if (this.cleanupErrors.length > 0) {\n      throw new AggregateError(this.cleanupErrors, `Shared transaction broker cleanup failed: ${this.cleanupErrors.map((error) => error.message).join(\"; \")}`)\n    }\n  }\n}\n"]}

package/build/src/testing/shared-transaction-codec.d.ts

@@ -0,0 +1,21 @@
+export type EncodedBrokerValue = {
+    [TAG]: string;
+    value?: string | number | boolean | EncodedBrokerValue[] | Record<string, EncodedBrokerValue>;
+};
+/** @typedef {{[TAG]: string, value?: string | number | boolean | EncodedBrokerValue[] | Record<string, EncodedBrokerValue>}} EncodedBrokerValue */
+declare const TAG = "$velociousSharedTransaction";
+/**
+ * Encodes values crossing the test-only shared-transaction transport without
+ * relying on JSON's lossy Date, bigint, non-finite-number, or undefined rules.
+ * @param {ReturnType<typeof JSON.parse> | bigint | Buffer | Date | Error | undefined} value - Runtime value.
+ * @returns {EncodedBrokerValue} - Tagged transport value.
+ */
+export declare function encodeBrokerValue(value: ReturnType<typeof JSON.parse> | bigint | Buffer | Date | Error | undefined): EncodedBrokerValue;
+/**
+ * Decodes a tagged broker transport value.
+ * @param {EncodedBrokerValue} encoded - Tagged transport value.
+ * @returns {ReturnType<typeof JSON.parse> | bigint | Buffer | Date | Error | undefined} - Runtime value.
+ */
+export declare function decodeBrokerValue(encoded: EncodedBrokerValue): ReturnType<typeof JSON.parse> | bigint | Buffer | Date | Error | undefined;
+export {};
+//# sourceMappingURL=shared-transaction-codec.d.ts.map

package/build/src/testing/shared-transaction-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-transaction-codec.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-codec.js"],"names":[],"mappings":"AAEI,YAA0H,kBAAkB,GAAlI;IAAC,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,kBAAkB,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;CAAC,CAAoB;AAAhJ,mJAAmJ;AAEnJ,QAAA,MAAM,GAAG,gCAAgC,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAH5B,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,SAGrC,GAF1B,kBAAkB,CAwC9B;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAH9B,kBAG8B,GAF5B,UAAU,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,GAAG,SAAS,CAwBtF"}