velocious 1.0.569 → 1.0.570

package/build/src/database/operation-connection.d.ts

@@ -46,6 +46,12 @@ export default class VelociousDatabaseOperationConnection {
      * @returns {Promise<T>} - Callback result.
      */
     transaction<T>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * Registers an operation-owned before-commit guard.
+     * @param {() => void | Promise<void>} callback - Guard callback.
+     * @returns {Promise<void>} - Resolves after registration.
+     */
+    beforeCommit(callback: () => void | Promise<void>): Promise<void>;
     /**
      * Registers an operation-owned after-commit callback.
      * @param {() => void | Promise<void>} callback - Callback.

package/build/src/database/operation-connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-connection.d.ts","sourceRoot":"","sources":["../../../src/database/operation-connection.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;;;;OAMG;IACH,8CAJG;QAAkD,UAAU,EAApD,OAAO,mBAAmB,EAAE,OAAO;QACI,SAAS,EAAhD,OAAO,gBAAgB,EAAE,OAAO;QACnB,KAAK,EAAlB,MAAM;KAChB,EA0BA;IAxBC,yDAAqC;IACrC,6CAA2B;IAC3B,eAAmB;IAwBrB;;;;;OAKG;IACH,WAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,GACtC,OAAO,CAAC,OAAO,mBAAmB,EAAE,eAAe,CAAC,CAMhE;IAED;;;;;OAKG;IACH,iBAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,2EAOlD;IAED;;;;;OAKG;IACH,kBAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,GACtC,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;;OAKG;IACH,YAJa,CAAC,YACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;;OAIG;IACH,sBAHW,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;CACF"}
+{"version":3,"file":"operation-connection.d.ts","sourceRoot":"","sources":["../../../src/database/operation-connection.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;;;;OAMG;IACH,8CAJG;QAAkD,UAAU,EAApD,OAAO,mBAAmB,EAAE,OAAO;QACI,SAAS,EAAhD,OAAO,gBAAgB,EAAE,OAAO;QACnB,KAAK,EAAlB,MAAM;KAChB,EA0BA;IAxBC,yDAAqC;IACrC,6CAA2B;IAC3B,eAAmB;IAwBrB;;;;;OAKG;IACH,WAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,GACtC,OAAO,CAAC,OAAO,mBAAmB,EAAE,eAAe,CAAC,CAMhE;IAED;;;;;OAKG;IACH,iBAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,2EAOlD;IAED;;;;;OAKG;IACH,kBAJW,MAAM,YACN,OAAO,mBAAmB,EAAE,YAAY,GACtC,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;;OAKG;IACH,YAJa,CAAC,YACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;;OAIG;IACH,uBAHW,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;OAIG;IACH,sBAHW,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,CAAC,CAM3B;CACF"}

package/build/src/database/operation-connection.js

@@ -72,6 +72,15 @@ export default class VelociousDatabaseOperationConnection {
         this._operation.assertActive();
         return /** @type {Promise<T>} */ (this._physicalConnection.transaction(callback, { operationOwner: this._owner }));
     }
+    /**
+     * Registers an operation-owned before-commit guard.
+     * @param {() => void | Promise<void>} callback - Guard callback.
+     * @returns {Promise<void>} - Resolves after registration.
+     */
+    async beforeCommit(callback) {
+        this._operation.assertActive();
+        await this._physicalConnection.beforeCommit(callback, { operationOwner: this._owner });
+    }
     /**
      * Registers an operation-owned after-commit callback.
      * @param {() => void | Promise<void>} callback - Callback.
@@ -90,4 +99,4 @@ export default class VelociousDatabaseOperationConnection {
         return await this._physicalConnection.lastInsertID({ operationOwner: this._owner });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation-connection.js","sourceRoot":"","sources":["../../../src/database/operation-connection.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,oCAAoC;IACvD;;;;;;OAMG;IACH,YAAY,EAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAC;QACxC,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAA;QACrC,IAAI,CAAC,UAAU,GAAG,SAAS,CAAA;QAC3B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAEnB,OAAO,IAAI,KAAK,CAAC,IAAI,EAAE;YACrB,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;gBAClC,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAClC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;oBAErD,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;gBACjE,CAAC;gBAED,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;gBAEzD,OAAO,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;YACnE,CAAC;YACD,GAAG,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;gBACzC,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC;oBAClC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAA;gBACvD,CAAC;gBAED,OAAO,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,CAAA;YAC7D,CAAC;SACF,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE;QAC3B,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,GAAG,EAAE,EAAC,GAAG,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAA;IAC7F,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,CAAC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE;QAClC,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,KAAK,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,GAAG,EAAE,EAAC,GAAG,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAA;IAC7F,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE;QAClC,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,GAAG,EAAE,EAAC,GAAG,OAAO,EAAE,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAA;IACpG,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,WAAW,CAAC,QAAQ;QACxB,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,OAAO,yBAAyB,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAC,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAC,CAAA;IAClH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,WAAW,CAAC,QAAQ;QACxB,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,MAAM,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAC,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAA;IACrF,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,YAAY;QAChB,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,CAAA;QAE9B,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,EAAC,cAAc,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAA;IACnF,CAAC;CACF","sourcesContent":["// @ts-check\n\n/**\n * Explicit connection facade that tags operation-owned asynchronous work while\n * forwarding the driver's synchronous SQL-builder and capability APIs.\n */\nexport default class VelociousDatabaseOperationConnection {\n  /**\n   * Runs constructor.\n   * @param {object} args - Connection ownership.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {import(\"./operation.js\").default} args.operation - Owning operation.\n   * @param {symbol} args.owner - Opaque lease owner token.\n   */\n  constructor({connection, operation, owner}) {\n    this._physicalConnection = connection\n    this._operation = operation\n    this._owner = owner\n\n    return new Proxy(this, {\n      get: (target, property, receiver) => {\n        if (Reflect.has(target, property)) {\n          const value = Reflect.get(target, property, receiver)\n\n          return typeof value === \"function\" ? value.bind(target) : value\n        }\n\n        const value = Reflect.get(connection, property, receiver)\n\n        return typeof value === \"function\" ? value.bind(receiver) : value\n      },\n      set: (target, property, value, receiver) => {\n        if (Reflect.has(target, property)) {\n          return Reflect.set(target, property, value, receiver)\n        }\n\n        return Reflect.set(connection, property, value, connection)\n      }\n    })\n  }\n\n  /**\n   * Runs a tagged SQL query on the pinned connection.\n   * @param {string} sql - SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @returns {Promise<import(\"./drivers/base.js\").QueryResultType>} - Query result.\n   */\n  async query(sql, options = {}) {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.query(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Streams an operation-owned SQL query.\n   * @param {string} sql - SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @yields {Record<string, unknown>} - Query rows.\n   */\n  async *queryStream(sql, options = {}) {\n    this._operation.assertActive()\n\n    yield* this._physicalConnection.queryStream(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Executes an operation-owned mutation and returns its affected row count.\n   * @param {string} sql - Mutation SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async affectedRows(sql, options = {}) {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.affectedRows(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Runs an operation-owned transaction or nested savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this._operation.assertActive()\n\n    return /** @type {Promise<T>} */ (this._physicalConnection.transaction(callback, {operationOwner: this._owner}))\n  }\n\n  /**\n   * Registers an operation-owned after-commit callback.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this._operation.assertActive()\n\n    await this._physicalConnection.afterCommit(callback, {operationOwner: this._owner})\n  }\n\n  /**\n   * Returns the last inserted identifier through the operation lease.\n   * @returns {Promise<number>} - Last inserted identifier.\n   */\n  async lastInsertID() {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.lastInsertID({operationOwner: this._owner})\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation-connection.js","sourceRoot":"","sources":["../../../src/database/operation-connection.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Explicit connection facade that tags operation-owned asynchronous work while\n * forwarding the driver's synchronous SQL-builder and capability APIs.\n */\nexport default class VelociousDatabaseOperationConnection {\n  /**\n   * Runs constructor.\n   * @param {object} args - Connection ownership.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {import(\"./operation.js\").default} args.operation - Owning operation.\n   * @param {symbol} args.owner - Opaque lease owner token.\n   */\n  constructor({connection, operation, owner}) {\n    this._physicalConnection = connection\n    this._operation = operation\n    this._owner = owner\n\n    return new Proxy(this, {\n      get: (target, property, receiver) => {\n        if (Reflect.has(target, property)) {\n          const value = Reflect.get(target, property, receiver)\n\n          return typeof value === \"function\" ? value.bind(target) : value\n        }\n\n        const value = Reflect.get(connection, property, receiver)\n\n        return typeof value === \"function\" ? value.bind(receiver) : value\n      },\n      set: (target, property, value, receiver) => {\n        if (Reflect.has(target, property)) {\n          return Reflect.set(target, property, value, receiver)\n        }\n\n        return Reflect.set(connection, property, value, connection)\n      }\n    })\n  }\n\n  /**\n   * Runs a tagged SQL query on the pinned connection.\n   * @param {string} sql - SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @returns {Promise<import(\"./drivers/base.js\").QueryResultType>} - Query result.\n   */\n  async query(sql, options = {}) {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.query(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Streams an operation-owned SQL query.\n   * @param {string} sql - SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @yields {Record<string, unknown>} - Query rows.\n   */\n  async *queryStream(sql, options = {}) {\n    this._operation.assertActive()\n\n    yield* this._physicalConnection.queryStream(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Executes an operation-owned mutation and returns its affected row count.\n   * @param {string} sql - Mutation SQL string.\n   * @param {import(\"./drivers/base.js\").QueryOptions} [options] - Query options.\n   * @returns {Promise<number>} - Affected row count.\n   */\n  async affectedRows(sql, options = {}) {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.affectedRows(sql, {...options, operationOwner: this._owner})\n  }\n\n  /**\n   * Runs an operation-owned transaction or nested savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Transaction callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this._operation.assertActive()\n\n    return /** @type {Promise<T>} */ (this._physicalConnection.transaction(callback, {operationOwner: this._owner}))\n  }\n\n  /**\n   * Registers an operation-owned before-commit guard.\n   * @param {() => void | Promise<void>} callback - Guard callback.\n   * @returns {Promise<void>} - Resolves after registration.\n   */\n  async beforeCommit(callback) {\n    this._operation.assertActive()\n\n    await this._physicalConnection.beforeCommit(callback, {operationOwner: this._owner})\n  }\n\n  /**\n   * Registers an operation-owned after-commit callback.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this._operation.assertActive()\n\n    await this._physicalConnection.afterCommit(callback, {operationOwner: this._owner})\n  }\n\n  /**\n   * Returns the last inserted identifier through the operation lease.\n   * @returns {Promise<number>} - Last inserted identifier.\n   */\n  async lastInsertID() {\n    this._operation.assertActive()\n\n    return await this._physicalConnection.lastInsertID({operationOwner: this._owner})\n  }\n}\n"]}

package/build/src/database/operation.d.ts

@@ -50,6 +50,14 @@ export default class VelociousDatabaseOperation {
      * @returns {Promise<void>} - Resolves after registration or execution.
      */
     afterCommit(callback: () => void | Promise<void>): Promise<void>;
+    /**
+     * Registers a guard owned by the current transaction/savepoint frame.
+     * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.
+     * @returns {Promise<void>} - Resolves after registration.
+     */
+    beforeCommit(callback: (context: {
+        operation: VelociousDatabaseOperation;
+    }) => void | Promise<void>): Promise<void>;
     /**
      * Runs a nested operation transaction/savepoint.
      * @template T

package/build/src/database/operation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6FANG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACxB,qBAAqB,EAAlC,MAAM;QACoC,UAAU,EAApD,OAAO,mBAAmB,EAAE,OAAO;QACtB,kBAAkB,EAA/B,MAAM;QACO,KAAK,EAAlB,MAAM;KAChB,EAWA;IATC,iBAAmB;IACnB,sDAAmC;IACnC,+BAAmD;IACnD,4BAA6C;IAC7C,iCAIE;IAGJ;;;;;OAKG;IACH,SAJ0D,EAAE,SAA/C,cAAe,mBAAmB,EAAE,OAAQ,cAC9C,EAAE,GACA,OAAO,8BAA8B,EAAE,OAAO,CAAC,EAAE,CAAC,CAU9D;IAED;;;;OAIG;IACH,wBAHW,cAAc,mBAAmB,EAAE,OAAO,GACxC,IAAI,CAYhB;IAED;;;;;OAKG;IACH,WAJmD,KAAK,SAA3C,OAAQ,mBAAmB,EAAE,OAAQ,UACvC,KAAK,GACH,KAAK,CAQjB;IAED;;;;OAIG;IACH,sBAHW,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;;OAKG;IACH,YAJa,CAAC,YACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,cAFa,OAAO,mBAAmB,EAAE,OAAO,CAY/C;IAED;;;OAGG;IACH,gBAFa,IAAI,CAahB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;CACF;gCAzI+B,2BAA2B"}
+{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IACE;;;;;;;;OAQG;IACH,6FANG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACxB,qBAAqB,EAAlC,MAAM;QACoC,UAAU,EAApD,OAAO,mBAAmB,EAAE,OAAO;QACtB,kBAAkB,EAA/B,MAAM;QACO,KAAK,EAAlB,MAAM;KAChB,EAWA;IATC,iBAAmB;IACnB,sDAAmC;IACnC,+BAAmD;IACnD,4BAA6C;IAC7C,iCAIE;IAGJ;;;;;OAKG;IACH,SAJ0D,EAAE,SAA/C,cAAe,mBAAmB,EAAE,OAAQ,cAC9C,EAAE,GACA,OAAO,8BAA8B,EAAE,OAAO,CAAC,EAAE,CAAC,CAU9D;IAED;;;;OAIG;IACH,wBAHW,cAAc,mBAAmB,EAAE,OAAO,GACxC,IAAI,CAYhB;IAED;;;;;OAKG;IACH,WAJmD,KAAK,SAA3C,OAAQ,mBAAmB,EAAE,OAAQ,UACvC,KAAK,GACH,KAAK,CAQjB;IAED;;;;OAIG;IACH,sBAHW,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;OAIG;IACH,uBAHW,CAAC,OAAO,EAAE;QAAC,SAAS,EAAE,0BAA0B,CAAA;KAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxE,OAAO,CAAC,IAAI,CAAC,CAKzB;IAED;;;;;OAKG;IACH,YAJa,CAAC,YACH,MAAM,OAAO,CAAC,CAAC,CAAC,GACd,OAAO,CAAC,CAAC,CAAC,CAMtB;IAED;;;OAGG;IACH,cAFa,OAAO,mBAAmB,EAAE,OAAO,CAY/C;IAED;;;OAGG;IACH,gBAFa,IAAI,CAahB;IAED;;;OAGG;IACH,YAFa,IAAI,CAIhB;CACF;gCAnJ+B,2BAA2B"}

package/build/src/database/operation.js

@@ -74,6 +74,15 @@ export default class VelociousDatabaseOperation {
         this.assertActive();
         await this.connection().afterCommit(callback);
     }
+    /**
+     * Registers a guard owned by the current transaction/savepoint frame.
+     * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.
+     * @returns {Promise<void>} - Resolves after registration.
+     */
+    async beforeCommit(callback) {
+        this.assertActive();
+        await this.connection().beforeCommit(() => callback({ operation: this }));
+    }
     /**
      * Runs a nested operation transaction/savepoint.
      * @template T
@@ -120,4 +129,4 @@ export default class VelociousDatabaseOperation {
         this._active = false;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation.js","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport OperationConnection from \"./operation-connection.js\"\n\n/**\n * Explicit owner for model work performed on one pinned transactional\n * connection.\n */\nexport default class VelociousDatabaseOperation {\n  /**\n   * Runs constructor.\n   * @param {object} args - Operation ownership.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {string} args.configurationReuseKey - Physical database configuration key captured at checkout.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {string} args.databaseIdentifier - Singular database identifier.\n   * @param {symbol} args.owner - Opaque pool lease owner.\n   */\n  constructor({configuration, configurationReuseKey, connection, databaseIdentifier, owner}) {\n    this._active = true\n    this._configuration = configuration\n    this._configurationReuseKey = configurationReuseKey\n    this._databaseIdentifier = databaseIdentifier\n    this._connection = new OperationConnection({\n      connection,\n      operation: this,\n      owner\n    })\n  }\n\n  /**\n   * Returns an operation-bound model query/create scope.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Model class to bind.\n   * @returns {import(\"./query/model-class-query.js\").default<MC>} - Operation-bound scope.\n   */\n  forModel(ModelClass) {\n    this.assertActive()\n    this.assertModel(ModelClass)\n\n    return ModelClass._newQuery({\n      driver: this.connection(),\n      operation: this\n    })\n  }\n\n  /**\n   * Verifies that a model belongs to this operation's configuration and database.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class to verify.\n   * @returns {void}\n   */\n  assertModel(ModelClass) {\n    if (ModelClass._getConfiguration() !== this._configuration) {\n      throw new Error(`${ModelClass.getModelName()} belongs to another Velocious configuration`)\n    }\n\n    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier()\n\n    if (modelDatabaseIdentifier !== this._databaseIdentifier) {\n      throw new Error(`${ModelClass.getModelName()} uses database ${JSON.stringify(modelDatabaseIdentifier)}, not operation database ${JSON.stringify(this._databaseIdentifier)}`)\n    }\n  }\n\n  /**\n   * Binds a loaded or built record to this operation.\n   * @template {import(\"./record/index.js\").default} Model\n   * @param {Model} record - Record to bind.\n   * @returns {Model} - Bound record.\n   */\n  bindRecord(record) {\n    this.assertActive()\n    this.assertModel(record.getModelClass())\n    record.bindDatabaseOperation(this)\n\n    return record\n  }\n\n  /**\n   * Registers a callback owned by the current operation transaction frame.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this.assertActive()\n    await this.connection().afterCommit(callback)\n  }\n\n  /**\n   * Runs a nested operation transaction/savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this.assertActive()\n\n    return await this.connection().transaction(callback)\n  }\n\n  /**\n   * Returns the deliberately exposed operation connection facade for raw SQL.\n   * @returns {import(\"./drivers/base.js\").default} - Operation-bound connection.\n   */\n  connection() {\n    this.assertActive()\n\n    /**\n     * Narrows the Proxy facade to the complete driver surface that it forwards.\n     * @type {import(\"./drivers/base.js\").default}\n     */\n    const connectionFacade = /** @type {?} */ (this._connection)\n\n    return connectionFacade\n  }\n\n  /**\n   * Raises when an operation handle has left its callback.\n   * @returns {void}\n   */\n  assertActive() {\n    if (!this._active) throw new Error(\"Database operation has completed\")\n\n    const currentReuseKey = this\n      ._configuration\n      .getDatabasePool(this._databaseIdentifier)\n      .getConfigurationReuseKey()\n\n    if (currentReuseKey !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than the current tenant context`)\n    }\n  }\n\n  /**\n   * Expires the operation and all scopes/records bound to it.\n   * @returns {void}\n   */\n  complete() {\n    this._active = false\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operation.js","sourceRoot":"","sources":["../../../src/database/operation.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport OperationConnection from \"./operation-connection.js\"\n\n/**\n * Explicit owner for model work performed on one pinned transactional\n * connection.\n */\nexport default class VelociousDatabaseOperation {\n  /**\n   * Runs constructor.\n   * @param {object} args - Operation ownership.\n   * @param {import(\"../configuration.js\").default} args.configuration - Owning configuration.\n   * @param {string} args.configurationReuseKey - Physical database configuration key captured at checkout.\n   * @param {import(\"./drivers/base.js\").default} args.connection - Pinned physical connection.\n   * @param {string} args.databaseIdentifier - Singular database identifier.\n   * @param {symbol} args.owner - Opaque pool lease owner.\n   */\n  constructor({configuration, configurationReuseKey, connection, databaseIdentifier, owner}) {\n    this._active = true\n    this._configuration = configuration\n    this._configurationReuseKey = configurationReuseKey\n    this._databaseIdentifier = databaseIdentifier\n    this._connection = new OperationConnection({\n      connection,\n      operation: this,\n      owner\n    })\n  }\n\n  /**\n   * Returns an operation-bound model query/create scope.\n   * @template {typeof import(\"./record/index.js\").default} MC\n   * @param {MC} ModelClass - Model class to bind.\n   * @returns {import(\"./query/model-class-query.js\").default<MC>} - Operation-bound scope.\n   */\n  forModel(ModelClass) {\n    this.assertActive()\n    this.assertModel(ModelClass)\n\n    return ModelClass._newQuery({\n      driver: this.connection(),\n      operation: this\n    })\n  }\n\n  /**\n   * Verifies that a model belongs to this operation's configuration and database.\n   * @param {typeof import(\"./record/index.js\").default} ModelClass - Model class to verify.\n   * @returns {void}\n   */\n  assertModel(ModelClass) {\n    if (ModelClass._getConfiguration() !== this._configuration) {\n      throw new Error(`${ModelClass.getModelName()} belongs to another Velocious configuration`)\n    }\n\n    const modelDatabaseIdentifier = ModelClass.getDatabaseIdentifier()\n\n    if (modelDatabaseIdentifier !== this._databaseIdentifier) {\n      throw new Error(`${ModelClass.getModelName()} uses database ${JSON.stringify(modelDatabaseIdentifier)}, not operation database ${JSON.stringify(this._databaseIdentifier)}`)\n    }\n  }\n\n  /**\n   * Binds a loaded or built record to this operation.\n   * @template {import(\"./record/index.js\").default} Model\n   * @param {Model} record - Record to bind.\n   * @returns {Model} - Bound record.\n   */\n  bindRecord(record) {\n    this.assertActive()\n    this.assertModel(record.getModelClass())\n    record.bindDatabaseOperation(this)\n\n    return record\n  }\n\n  /**\n   * Registers a callback owned by the current operation transaction frame.\n   * @param {() => void | Promise<void>} callback - Callback.\n   * @returns {Promise<void>} - Resolves after registration or execution.\n   */\n  async afterCommit(callback) {\n    this.assertActive()\n    await this.connection().afterCommit(callback)\n  }\n\n  /**\n   * Registers a guard owned by the current transaction/savepoint frame.\n   * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.\n   * @returns {Promise<void>} - Resolves after registration.\n   */\n  async beforeCommit(callback) {\n    this.assertActive()\n    await this.connection().beforeCommit(() => callback({operation: this}))\n  }\n\n  /**\n   * Runs a nested operation transaction/savepoint.\n   * @template T\n   * @param {() => Promise<T>} callback - Callback.\n   * @returns {Promise<T>} - Callback result.\n   */\n  async transaction(callback) {\n    this.assertActive()\n\n    return await this.connection().transaction(callback)\n  }\n\n  /**\n   * Returns the deliberately exposed operation connection facade for raw SQL.\n   * @returns {import(\"./drivers/base.js\").default} - Operation-bound connection.\n   */\n  connection() {\n    this.assertActive()\n\n    /**\n     * Narrows the Proxy facade to the complete driver surface that it forwards.\n     * @type {import(\"./drivers/base.js\").default}\n     */\n    const connectionFacade = /** @type {?} */ (this._connection)\n\n    return connectionFacade\n  }\n\n  /**\n   * Raises when an operation handle has left its callback.\n   * @returns {void}\n   */\n  assertActive() {\n    if (!this._active) throw new Error(\"Database operation has completed\")\n\n    const currentReuseKey = this\n      ._configuration\n      .getDatabasePool(this._databaseIdentifier)\n      .getConfigurationReuseKey()\n\n    if (currentReuseKey !== this._configurationReuseKey) {\n      throw new Error(`Database operation for ${JSON.stringify(this._databaseIdentifier)} belongs to a different physical database than the current tenant context`)\n    }\n  }\n\n  /**\n   * Expires the operation and all scopes/records bound to it.\n   * @returns {void}\n   */\n  complete() {\n    this._active = false\n  }\n}\n"]}

package/package.json

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

package/src/database/drivers/base.js

@@ -42,6 +42,12 @@
  * @typedef {Record<string, ?>} QueryRowType
  * @typedef {Array<QueryRowType>} QueryResultType
  */
+/**
+ * TransactionCallbackFrame type.
+ * @typedef {object} TransactionCallbackFrame
+ * @property {Array<() => void | Promise<void>>} afterCommitCallbacks - Callbacks to merge or run after commit.
+ * @property {Array<() => void | Promise<void>>} beforeCommitCallbacks - Guards to run before this frame completes.
+ */
 /**
  * RetryableDatabaseErrorResult type.
  * @typedef {object} RetryableDatabaseErrorResult
@@ -171,8 +177,8 @@ export default class VelociousDatabaseDriversBase {
   idSeq = undefined
   /**
    * Narrows the runtime value to the documented type.
-   * @type {Array<Array<() => void | Promise<void>>>} */
-  _afterCommitCallbackFrames
+   * @type {TransactionCallbackFrame[]} */
+  _transactionCallbackFrames
   /**
    * Narrows the runtime value to the documented type.
    * @type {Map<string, Promise<?>>} */
@@ -207,7 +213,7 @@ export default class VelociousDatabaseDriversBase {
     this.configuration = configuration
     this.mutex = new Mutex() // Can be used to lock this instance for exclusive use
     this.logger = new Logger(this)
-    this._afterCommitCallbackFrames = []
+    this._transactionCallbackFrames = []
     this._transactionsCount = 0
     this._transactionsActionsMutex = new Mutex()
     this._schemaCache = new Map()
@@ -1068,14 +1074,15 @@ export default class VelociousDatabaseDriversBase {
    */
   async _runTransactionAttempt(callback, options) {
     const savePointName = this.generateSavePointName()
-    /**
-     * Callback frame.
-     * @type {Array<() => void | Promise<void>>} */
-    const callbackFrame = []
+    /** @type {TransactionCallbackFrame} */
+    const callbackFrame = {
+      afterCommitCallbacks: [],
+      beforeCommitCallbacks: []
+    }
     let transactionStarted = false
     let savePointStarted = false
 
-    this._afterCommitCallbackFrames.push(callbackFrame)
+    this._transactionCallbackFrames.push(callbackFrame)
 
     try {
       if (this._transactionsCount == 0) {
@@ -1088,7 +1095,7 @@ export default class VelociousDatabaseDriversBase {
         savePointStarted = true
       }
     } catch (error) {
-      this._afterCommitCallbackFrames.pop()
+      this._transactionCallbackFrames.pop()
       throw error
     }
 
@@ -1096,6 +1103,7 @@ export default class VelociousDatabaseDriversBase {
 
     try {
       result = await callback()
+      await this._runBeforeCommitCallbacks(callbackFrame)
 
       if (savePointStarted) {
         this.logger.debug("Release savepoint", savePointName)
@@ -1113,42 +1121,44 @@ export default class VelociousDatabaseDriversBase {
         this.logger.debug("Transaction error", error)
       }
 
-      let transactionRolledBack = false
-
-      if (savePointStarted) {
-        this.logger.debug("Rollback savepoint", savePointName)
-        try {
-          await this.rollbackSavePoint(savePointName, options)
-        } catch (savePointError) {
-          const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`
-
-          // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction
-          if (message.includes("SAVEPOINT") || message.includes("ER_SP_DOES_NOT_EXIST")) {
-            this.logger.debug("Savepoint rollback failed; rolling back entire transaction instead")
-            await this.rollbackTransaction(options)
-            transactionRolledBack = true
-          } else {
-            throw savePointError
+      try {
+        let transactionRolledBack = false
+
+        if (savePointStarted) {
+          this.logger.debug("Rollback savepoint", savePointName)
+          try {
+            await this.rollbackSavePoint(savePointName, options)
+          } catch (savePointError) {
+            const message = savePointError instanceof Error ? savePointError.message : `${savePointError}`
+
+            // MySQL sometimes drops savepoints unexpectedly; fall back to rolling back the full transaction
+            if (message.includes("SAVEPOINT") || message.includes("ER_SP_DOES_NOT_EXIST")) {
+              this.logger.debug("Savepoint rollback failed; rolling back entire transaction instead")
+              await this.rollbackTransaction(options)
+              transactionRolledBack = true
+            } else {
+              throw savePointError
+            }
           }
         }
-      }
 
-      // Only roll back if a transaction is still open. A nested savepoint whose rollback failed
-      // falls back to rolling back the whole transaction (above), which already closed it and
-      // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive
-      // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.
-      if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {
-        this.logger.debug("Rollback transaction")
-        await this.rollbackTransaction(options)
+        // Only roll back if a transaction is still open. A nested savepoint whose rollback failed
+        // falls back to rolling back the whole transaction (above), which already closed it and
+        // dropped the count to 0; rolling back again here would issue a second ROLLBACK and drive
+        // `_transactionsCount` below zero, which would then defeat the outermost deadlock-retry guard.
+        if (transactionStarted && !transactionRolledBack && this._transactionsCount > 0) {
+          this.logger.debug("Rollback transaction")
+          await this.rollbackTransaction(options)
+        }
+      } finally {
+        this._transactionCallbackFrames.pop()
       }
 
-      this._afterCommitCallbackFrames.pop()
-
       throw error
     }
 
     try {
-      await this._commitAfterCommitCallbackFrame()
+      await this._commitTransactionCallbackFrame()
     } catch (error) {
       throw new VelociousDatabaseAfterCommitCallbackError(error)
     }
@@ -1156,6 +1166,23 @@ export default class VelociousDatabaseDriversBase {
     return result
   }
 
+  /**
+   * Registers a guard to run after the current transaction callback succeeds and before its
+   * outer commit or nested savepoint release.
+   * @param {() => void | Promise<void>} callback - Guard callback.
+   * @param {Pick<QueryOptions, "operationOwner">} [options] - Callback ownership.
+   * @returns {Promise<void>} - Resolves when the guard has been registered.
+   */
+  async beforeCommit(callback, options = {}) {
+    await this._waitForOperationLease(options.operationOwner)
+
+    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
+
+    if (!currentFrame) throw new Error("beforeCommit requires an active transaction")
+
+    currentFrame.beforeCommitCallbacks.push(callback)
+  }
+
   /**
    * Runs a callback after the surrounding transaction commits.
    * If no transaction is active, the callback runs immediately.
@@ -1166,14 +1193,14 @@ export default class VelociousDatabaseDriversBase {
   async afterCommit(callback, options = {}) {
     await this._waitForOperationLease(options.operationOwner)
 
-    const currentFrame = this._afterCommitCallbackFrames[this._afterCommitCallbackFrames.length - 1]
+    const currentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
 
     if (!currentFrame) {
       await callback()
       return
     }
 
-    currentFrame.push(callback)
+    currentFrame.afterCommitCallbacks.push(callback)
   }
 
   /**
@@ -1240,23 +1267,34 @@ export default class VelociousDatabaseDriversBase {
     await this.query("COMMIT", options)
   }
 
+  /**
+   * Runs every guard registered to the transaction frame.
+   * @param {TransactionCallbackFrame} callbackFrame - Frame whose guards are completing.
+   * @returns {Promise<void>} - Resolves when every guard accepts the commit.
+   */
+  async _runBeforeCommitCallbacks(callbackFrame) {
+    for (const callback of callbackFrame.beforeCommitCallbacks) {
+      await callback()
+    }
+  }
+
   /**
    * Merges committed callbacks into the parent transaction frame or runs them when the outermost commit completes.
    * @returns {Promise<void>} - Resolves when complete.
    */
-  async _commitAfterCommitCallbackFrame() {
-    const committedCallbacks = this._afterCommitCallbackFrames.pop()
+  async _commitTransactionCallbackFrame() {
+    const committedFrame = this._transactionCallbackFrames.pop()
 
-    if (!committedCallbacks || committedCallbacks.length === 0) return
+    if (!committedFrame || committedFrame.afterCommitCallbacks.length === 0) return
 
-    const parentFrame = this._afterCommitCallbackFrames[this._afterCommitCallbackFrames.length - 1]
+    const parentFrame = this._transactionCallbackFrames[this._transactionCallbackFrames.length - 1]
 
     if (parentFrame) {
-      parentFrame.push(...committedCallbacks)
+      parentFrame.afterCommitCallbacks.push(...committedFrame.afterCommitCallbacks)
       return
     }
 
-    for (const callback of committedCallbacks) {
+    for (const callback of committedFrame.afterCommitCallbacks) {
       await callback()
     }
   }

package/src/database/operation-connection.js

@@ -87,6 +87,17 @@ export default class VelociousDatabaseOperationConnection {
     return /** @type {Promise<T>} */ (this._physicalConnection.transaction(callback, {operationOwner: this._owner}))
   }
 
+  /**
+   * Registers an operation-owned before-commit guard.
+   * @param {() => void | Promise<void>} callback - Guard callback.
+   * @returns {Promise<void>} - Resolves after registration.
+   */
+  async beforeCommit(callback) {
+    this._operation.assertActive()
+
+    await this._physicalConnection.beforeCommit(callback, {operationOwner: this._owner})
+  }
+
   /**
    * Registers an operation-owned after-commit callback.
    * @param {() => void | Promise<void>} callback - Callback.

package/src/database/operation.js

@@ -85,6 +85,16 @@ export default class VelociousDatabaseOperation {
     await this.connection().afterCommit(callback)
   }
 
+  /**
+   * Registers a guard owned by the current transaction/savepoint frame.
+   * @param {(context: {operation: VelociousDatabaseOperation}) => void | Promise<void>} callback - Guard callback.
+   * @returns {Promise<void>} - Resolves after registration.
+   */
+  async beforeCommit(callback) {
+    this.assertActive()
+    await this.connection().beforeCommit(() => callback({operation: this}))
+  }
+
   /**
    * Runs a nested operation transaction/savepoint.
    * @template T