@getstrata/core 2.2.36 → 2.2.38

package/dist/entries/auth/scimAuthMiddleware.js

@@ -568,6 +568,17 @@ var init_repositoryConnection = __esm(() => {
 
 // ../../src/core/database/transaction.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+function scopedConnection(source) {
+  const connection = createDatabaseConnection(source);
+  transactionAliases.set(connection, source);
+  return connection;
+}
+function isActiveTransactionConnection(connection) {
+  if (!hasActiveTransaction() || !hasActiveDatabaseConnection())
+    return false;
+  const active = getActiveDatabaseConnection(connection);
+  return connection === active || transactionAliases.get(connection) === active;
+}
 async function runInSavepoint(connection, operation) {
   const inherited = transactionFrame.getStore();
   let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
@@ -584,7 +595,7 @@ async function runInSavepoint(connection, operation) {
     return await settleTransaction(() => runWithDeferredModelEvents(async () => {
       await connection.unsafe(`SAVEPOINT ${name}`);
       try {
-        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(scopedConnection(connection)))));
         await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
         return result;
       } catch (error) {
@@ -607,9 +618,12 @@ async function runInTransaction(operation, options = {}) {
     signal?.throwIfAborted();
     return operation(connection);
   };
-  const pool = resolveRepositoryConnection();
+  const pool = options.connection ?? resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+    const active = getActiveDatabaseConnection(pool);
+    if (options.connection && options.connection !== active && options.connection !== transactionRoots.get(active) && transactionAliases.get(options.connection) !== active)
+      throw new Error("Cannot switch database connections within an active transaction.");
+    return await runInSavepoint(active, admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
@@ -628,14 +642,15 @@ async function runInTransaction(operation, options = {}) {
       if (!supportsTransactions(connection))
         throw new Error("Reserved database connection does not support transactions.");
       return await connection.begin(AsyncLocalStorage2.bind(async (transaction) => {
-        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+        transactionRoots.set(transaction, pool);
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(scopedConnection(transaction))))));
       }));
     } finally {
       await reserved?.release();
     }
   }));
 }
-var transactionFrame, outerFrames;
+var transactionFrame, outerFrames, transactionRoots, transactionAliases;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
@@ -647,6 +662,8 @@ var init_transaction = __esm(() => {
   init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
+  transactionRoots = new WeakMap;
+  transactionAliases = new WeakMap;
 });
 
 // ../../src/core/tenant/tenancyConfig.ts
@@ -968,7 +985,6 @@ function buildPaginationMeta(input) {
 }
 
 // ../../src/core/database/baseRepository.ts
-init_connectionContext();
 init_dialect();
 
 // ../../src/core/database/errors.ts
@@ -2515,7 +2531,7 @@ class BaseRepository {
   assertTransactionalEvent(action) {
     if (!eventBus.hasTransactionalListeners(modelEventName(this.table.name, action)))
       return;
-    if (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))
+    if (!hasActiveTransaction() || this.connection !== repositoryConnection && !isActiveTransactionConnection(this.connection))
       throw new Error("Transactional model listeners require runInTransaction and the framework-bound repository connection before writing.");
   }
   async runModelMutation(action, operation) {
@@ -2523,6 +2539,32 @@ class BaseRepository {
       return operation();
     return runInTransaction(operation);
   }
+  mysqlMutation(operation) {
+    return runInTransaction((db) => operation(this.withConnection(db)), this.connection === repositoryConnection ? {} : { connection: this.connection });
+  }
+  mysqlRow(id, onlyTrashed = false) {
+    if (id === undefined || id === null)
+      throw new Error(`MySQL write to ${this.table.name} did not identify its persisted primary key.`);
+    return this.firstOrNull({ [this.table.primaryKey]: id }, {
+      withTrashed: true,
+      ...onlyTrashed ? { onlyTrashed: true } : {}
+    });
+  }
+  mysqlAffected(row) {
+    const count = row?.affectedRows;
+    if (count === undefined || !Number.isSafeInteger(count) || count < 0)
+      throw new Error("MySQL mutations require affectedRows metadata from the framework adapter.");
+    return count;
+  }
+  async mysqlWriteById(query, id, onlyTrashed = false, allowUnchanged = false) {
+    const [row] = await this.connection.unsafe(query.text, query.params);
+    if (!this.mysqlAffected(row)) {
+      if (!allowUnchanged)
+        return null;
+      return this.findById(id);
+    }
+    return this.mysqlRow(id, onlyTrashed);
+  }
   async count(options = {}) {
     if (options.lock)
       throw new Error("Row locks require a row selection, not count().");
@@ -2531,7 +2573,7 @@ class BaseRepository {
   }
   async findAll(options = {}) {
     return await withDatabaseErrorHandling(async () => {
-      if (options.lock && (!hasActiveTransaction() || this.connection !== repositoryConnection && this.connection !== getActiveDatabaseConnection(repositoryConnection))) {
+      if (options.lock && (!hasActiveTransaction() || this.connection !== repositoryConnection && !isActiveTransactionConnection(this.connection))) {
         throw new Error("Row locks require the framework active transaction connection.");
       }
       const { whereNodes, ...queryOptions } = options;
@@ -2743,6 +2785,32 @@ class BaseRepository {
     return record ?? null;
   }
   async upsert(values, conflictColumns, updateColumns) {
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const where = {};
+        for (const column of conflictColumns) {
+          if (!this.table.columns.includes(column) || values[column] === undefined || values[column] === null)
+            throw new Error("MySQL upsert requires non-null supplied conflict-column values.");
+          where[column] = values[column];
+        }
+        const query = buildUpsertQuery(this.table, values, conflictColumns, updateColumns);
+        const supplied = this.table.columns.filter((column) => values[column] !== undefined);
+        const updates = updateColumns ?? supplied.filter((column) => !conflictColumns.includes(column));
+        const doNothing = !updates.some((column) => supplied.includes(column));
+        const existing = doNothing ? await repository.firstOrNull(where, {
+          withTrashed: true,
+          lock: { mode: "update" }
+        }) : null;
+        const [result] = await repository.connection.unsafe(query.text, query.params);
+        repository.mysqlAffected(result);
+        if (doNothing && existing)
+          return null;
+        const generated = result?.insertId;
+        const row = generated !== undefined && String(generated) !== "0" ? await repository.mysqlRow(generated) : await repository.firstOrNull(where, { withTrashed: true });
+        if (!row)
+          throw new Error("MySQL upsert could not resolve the persisted row; transaction rolled back.");
+        return row;
+      }));
     return await withDatabaseErrorHandling(async () => {
       const { text, params } = buildUpsertQuery(this.table, values, conflictColumns, updateColumns);
       const [record] = await this.connection.unsafe(text, params);
@@ -2750,6 +2818,8 @@ class BaseRepository {
     });
   }
   async incrementById(id, column, amount = 1, extra = {}) {
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(() => repository.mysqlWriteById(buildIncrementQuery(this.table, id, column, amount, extra), id, false, true)));
     return await withDatabaseErrorHandling(async () => {
       const { text, params } = buildIncrementQuery(this.table, id, column, amount, extra);
       const [record] = await this.connection.unsafe(text, params);
@@ -2761,6 +2831,18 @@ class BaseRepository {
   }
   async create(values) {
     this.assertTransactionalEvent("created");
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const query = buildInsertQuery(this.table, values);
+        const [result] = await repository.connection.unsafe(query.text, query.params);
+        repository.mysqlAffected(result);
+        const key = String(result?.insertId ?? "0") !== "0" ? result?.insertId : values[this.table.primaryKey];
+        const row = await repository.mysqlRow(key);
+        if (!row)
+          throw new Error(`Insert into ${this.table.name} did not return a record.`);
+        await dispatchModelEvent(modelEventName(this.table.name, "created"), row);
+        return row;
+      }));
     return await this.runModelMutation("created", () => withDatabaseErrorHandling(async () => {
       const { text, params } = buildInsertQuery(this.table, values);
       const [record] = await this.connection.unsafe(text, params);
@@ -2796,6 +2878,13 @@ class BaseRepository {
   }
   async updateById(id, changes) {
     this.assertTransactionalEvent("updated");
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const row = await repository.mysqlWriteById(buildUpdateQuery(this.table, id, changes), id, false, true);
+        if (row)
+          await dispatchModelEvent(modelEventName(this.table.name, "updated"), row);
+        return row;
+      }));
     return await this.runModelMutation("updated", () => withDatabaseErrorHandling(async () => {
       const { text, params } = buildUpdateQuery(this.table, id, changes);
       const [record] = await this.connection.unsafe(text, params);
@@ -2821,6 +2910,14 @@ class BaseRepository {
   }
   async softDeleteById(id) {
     this.assertTransactionalEvent("deleted");
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const row = await repository.mysqlWriteById(buildSoftDeleteByIdQuery(this.table, id, new Date), id, true);
+        if (!row)
+          return false;
+        await dispatchModelEvent(modelEventName(this.table.name, "deleted"), row);
+        return true;
+      }));
     return await this.runModelMutation("deleted", () => withDatabaseErrorHandling(async () => {
       const { text, params } = buildSoftDeleteByIdQuery(this.table, id, new Date);
       const [record] = await this.connection.unsafe(text, params);
@@ -2833,6 +2930,15 @@ class BaseRepository {
   }
   async forceDeleteById(id) {
     this.assertTransactionalEvent("force-deleted");
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const query = buildDeleteByIdQuery(this.table, id);
+        const [result] = await repository.connection.unsafe(query.text, query.params);
+        if (!repository.mysqlAffected(result))
+          return false;
+        await dispatchModelEvent(modelEventName(this.table.name, "force-deleted"), { id });
+        return true;
+      }));
     return await this.runModelMutation("force-deleted", () => withDatabaseErrorHandling(async () => {
       const { text, params } = buildDeleteByIdQuery(this.table, id);
       const [row] = await this.connection.unsafe(text, params);
@@ -2847,6 +2953,13 @@ class BaseRepository {
   }
   async restoreById(id) {
     this.assertTransactionalEvent("restored");
+    if (currentSqlDialect().driver === "mysql")
+      return this.mysqlMutation((repository) => withDatabaseErrorHandling(async () => {
+        const row = await repository.mysqlWriteById(buildRestoreByIdQuery(this.table, id), id);
+        if (row)
+          await dispatchModelEvent(modelEventName(this.table.name, "restored"), row);
+        return row;
+      }));
     return await this.runModelMutation("restored", () => withDatabaseErrorHandling(async () => {
       const { text, params } = buildRestoreByIdQuery(this.table, id);
       const [record] = await this.connection.unsafe(text, params);

package/dist/entries/jobs/exportAuditLogsJob.js

@@ -733,6 +733,17 @@ var init_repositoryConnection = __esm(() => {
 
 // ../../src/core/database/transaction.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+function scopedConnection(source) {
+  const connection = createDatabaseConnection(source);
+  transactionAliases.set(connection, source);
+  return connection;
+}
+function isActiveTransactionConnection(connection) {
+  if (!hasActiveTransaction() || !hasActiveDatabaseConnection())
+    return false;
+  const active = getActiveDatabaseConnection(connection);
+  return connection === active || transactionAliases.get(connection) === active;
+}
 async function runInSavepoint(connection, operation) {
   const inherited = transactionFrame.getStore();
   let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
@@ -749,7 +760,7 @@ async function runInSavepoint(connection, operation) {
     return await settleTransaction(() => runWithDeferredModelEvents(async () => {
       await connection.unsafe(`SAVEPOINT ${name}`);
       try {
-        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(scopedConnection(connection)))));
         await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
         return result;
       } catch (error) {
@@ -772,9 +783,12 @@ async function runInTransaction(operation, options = {}) {
     signal?.throwIfAborted();
     return operation(connection);
   };
-  const pool = resolveRepositoryConnection();
+  const pool = options.connection ?? resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+    const active = getActiveDatabaseConnection(pool);
+    if (options.connection && options.connection !== active && options.connection !== transactionRoots.get(active) && transactionAliases.get(options.connection) !== active)
+      throw new Error("Cannot switch database connections within an active transaction.");
+    return await runInSavepoint(active, admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
@@ -793,14 +807,15 @@ async function runInTransaction(operation, options = {}) {
       if (!supportsTransactions(connection))
         throw new Error("Reserved database connection does not support transactions.");
       return await connection.begin(AsyncLocalStorage3.bind(async (transaction) => {
-        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+        transactionRoots.set(transaction, pool);
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(scopedConnection(transaction))))));
       }));
     } finally {
       await reserved?.release();
     }
   }));
 }
-var transactionFrame, outerFrames;
+var transactionFrame, outerFrames, transactionRoots, transactionAliases;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
@@ -812,6 +827,8 @@ var init_transaction = __esm(() => {
   init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
+  transactionRoots = new WeakMap;
+  transactionAliases = new WeakMap;
 });
 
 // ../../src/core/tenant/databaseTenantContext.ts

package/dist/entries/queue/queueMetrics.js

@@ -808,6 +808,17 @@ var init_connection = () => {};
 
 // ../../src/core/database/transaction.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
+function scopedConnection(source) {
+  const connection = createDatabaseConnection(source);
+  transactionAliases.set(connection, source);
+  return connection;
+}
+function isActiveTransactionConnection(connection) {
+  if (!hasActiveTransaction() || !hasActiveDatabaseConnection())
+    return false;
+  const active = getActiveDatabaseConnection(connection);
+  return connection === active || transactionAliases.get(connection) === active;
+}
 async function runInSavepoint(connection, operation) {
   const inherited = transactionFrame.getStore();
   let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
@@ -824,7 +835,7 @@ async function runInSavepoint(connection, operation) {
     return await settleTransaction(() => runWithDeferredModelEvents(async () => {
       await connection.unsafe(`SAVEPOINT ${name}`);
       try {
-        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(scopedConnection(connection)))));
         await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
         return result;
       } catch (error) {
@@ -847,9 +858,12 @@ async function runInTransaction(operation, options = {}) {
     signal?.throwIfAborted();
     return operation(connection);
   };
-  const pool = resolveRepositoryConnection();
+  const pool = options.connection ?? resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+    const active = getActiveDatabaseConnection(pool);
+    if (options.connection && options.connection !== active && options.connection !== transactionRoots.get(active) && transactionAliases.get(options.connection) !== active)
+      throw new Error("Cannot switch database connections within an active transaction.");
+    return await runInSavepoint(active, admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
@@ -868,14 +882,15 @@ async function runInTransaction(operation, options = {}) {
       if (!supportsTransactions(connection))
         throw new Error("Reserved database connection does not support transactions.");
       return await connection.begin(AsyncLocalStorage4.bind(async (transaction) => {
-        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+        transactionRoots.set(transaction, pool);
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(scopedConnection(transaction))))));
       }));
     } finally {
       await reserved?.release();
     }
   }));
 }
-var transactionFrame, outerFrames;
+var transactionFrame, outerFrames, transactionRoots, transactionAliases;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
@@ -887,6 +902,8 @@ var init_transaction = __esm(() => {
   init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
+  transactionRoots = new WeakMap;
+  transactionAliases = new WeakMap;
 });
 
 // ../../src/core/queue/queueMetrics.ts

package/dist/entries/tenant/databaseTenantContext.js

@@ -733,6 +733,17 @@ var init_repositoryConnection = __esm(() => {
 
 // ../../src/core/database/transaction.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
+function scopedConnection(source) {
+  const connection = createDatabaseConnection(source);
+  transactionAliases.set(connection, source);
+  return connection;
+}
+function isActiveTransactionConnection(connection) {
+  if (!hasActiveTransaction() || !hasActiveDatabaseConnection())
+    return false;
+  const active = getActiveDatabaseConnection(connection);
+  return connection === active || transactionAliases.get(connection) === active;
+}
 async function runInSavepoint(connection, operation) {
   const inherited = transactionFrame.getStore();
   let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
@@ -749,7 +760,7 @@ async function runInSavepoint(connection, operation) {
     return await settleTransaction(() => runWithDeferredModelEvents(async () => {
       await connection.unsafe(`SAVEPOINT ${name}`);
       try {
-        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(scopedConnection(connection)))));
         await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
         return result;
       } catch (error) {
@@ -772,9 +783,12 @@ async function runInTransaction(operation, options = {}) {
     signal?.throwIfAborted();
     return operation(connection);
   };
-  const pool = resolveRepositoryConnection();
+  const pool = options.connection ?? resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+    const active = getActiveDatabaseConnection(pool);
+    if (options.connection && options.connection !== active && options.connection !== transactionRoots.get(active) && transactionAliases.get(options.connection) !== active)
+      throw new Error("Cannot switch database connections within an active transaction.");
+    return await runInSavepoint(active, admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
@@ -793,14 +807,15 @@ async function runInTransaction(operation, options = {}) {
       if (!supportsTransactions(connection))
         throw new Error("Reserved database connection does not support transactions.");
       return await connection.begin(AsyncLocalStorage3.bind(async (transaction) => {
-        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+        transactionRoots.set(transaction, pool);
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(scopedConnection(transaction))))));
       }));
     } finally {
       await reserved?.release();
     }
   }));
 }
-var transactionFrame, outerFrames;
+var transactionFrame, outerFrames, transactionRoots, transactionAliases;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
@@ -812,6 +827,8 @@ var init_transaction = __esm(() => {
   init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
+  transactionRoots = new WeakMap;
+  transactionAliases = new WeakMap;
 });
 
 // ../../src/core/tenant/databaseTenantContext.ts

package/dist/entries/tenant/tenantDatabaseScope.js

@@ -666,6 +666,17 @@ var init_repositoryConnection = __esm(() => {
 
 // ../../src/core/database/transaction.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+function scopedConnection(source) {
+  const connection = createDatabaseConnection(source);
+  transactionAliases.set(connection, source);
+  return connection;
+}
+function isActiveTransactionConnection(connection) {
+  if (!hasActiveTransaction() || !hasActiveDatabaseConnection())
+    return false;
+  const active = getActiveDatabaseConnection(connection);
+  return connection === active || transactionAliases.get(connection) === active;
+}
 async function runInSavepoint(connection, operation) {
   const inherited = transactionFrame.getStore();
   let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
@@ -682,7 +693,7 @@ async function runInSavepoint(connection, operation) {
     return await settleTransaction(() => runWithDeferredModelEvents(async () => {
       await connection.unsafe(`SAVEPOINT ${name}`);
       try {
-        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(scopedConnection(connection)))));
         await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
         return result;
       } catch (error) {
@@ -705,9 +716,12 @@ async function runInTransaction(operation, options = {}) {
     signal?.throwIfAborted();
     return operation(connection);
   };
-  const pool = resolveRepositoryConnection();
+  const pool = options.connection ?? resolveRepositoryConnection();
   if (hasActiveDatabaseConnection()) {
-    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+    const active = getActiveDatabaseConnection(pool);
+    if (options.connection && options.connection !== active && options.connection !== transactionRoots.get(active) && transactionAliases.get(options.connection) !== active)
+      throw new Error("Cannot switch database connections within an active transaction.");
+    return await runInSavepoint(active, admittedOperation);
   }
   if (!supportsTransactions(pool)) {
     throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
@@ -726,14 +740,15 @@ async function runInTransaction(operation, options = {}) {
       if (!supportsTransactions(connection))
         throw new Error("Reserved database connection does not support transactions.");
       return await connection.begin(AsyncLocalStorage2.bind(async (transaction) => {
-        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+        transactionRoots.set(transaction, pool);
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(scopedConnection(transaction))))));
       }));
     } finally {
       await reserved?.release();
     }
   }));
 }
-var transactionFrame, outerFrames;
+var transactionFrame, outerFrames, transactionRoots, transactionAliases;
 var init_transaction = __esm(() => {
   init_deferredModelEvents();
   init_asyncContextStore();
@@ -745,6 +760,8 @@ var init_transaction = __esm(() => {
   init_acquisitionMetrics();
   transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
   outerFrames = new WeakMap;
+  transactionRoots = new WeakMap;
+  transactionAliases = new WeakMap;
 });
 
 // ../../src/core/tenant/tenancyConfig.ts

package/dist/framework/public-api.d.ts

@@ -69,7 +69,7 @@ export type { Seeder, SeederDatabase } from "../core/database/seeders/types.ts";
 export { createSqliteConnection } from "../core/database/sqliteConnection.ts";
 export { defineTable } from "../core/database/table.ts";
 export type { TransactionOptions } from "../core/database/transaction.ts";
-export { hasActiveTransaction, requestTransactionRollback, runInTransaction, } from "../core/database/transaction.ts";
+export { hasActiveTransaction, isActiveTransactionConnection, requestTransactionRollback, runInTransaction, } from "../core/database/transaction.ts";
 export type { ModelWhere, ModelWriteValues, QueryJoin, QueryJoinOn, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, } from "../core/database/types.ts";
 export type { WhereNode } from "../core/database/whereBuilder.ts";
 export { WhereBuilder } from "../core/database/whereBuilder.ts";