@getstrata/core 2.2.35 → 2.2.37

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @getstrata/core changelog
 
+## 2.2.37
+
+Fix MySQL repository entity-returning mutations with transaction-pinned readback, persisted keys/defaults, honest null and deletion outcomes, complete model event payloads and injected connection ownership. Preserve native Postgres/SQLite RETURNING and conditional affected-row metadata. Close owned generated OpenAPI and failed-job command applications on success and failure before exit; retain both command and cleanup errors. Add mandatory packaged MySQL production column-tenancy CLI and HTTP auth/SCIM acceptance with an owned DML-only account, unchanged route/spec/SDK contracts, native ORM regressions and cleanup tests. Records dogfood issues #232 and #233 without application SQL workarounds.
+
+## 2.2.36
+
+Add a mandatory installed-package SQLite column-tenancy CLI/OpenAPI/HTTP profile, including cookie/token/JWT/Basic and repeated SCIM isolation, while preserving existing Postgres security, route inventories, compiler combinations and Docker gates. Reconcile observability/rotation trackers against shipped capabilities and remaining operational qualification.
+
+Fix declared default exports missing from nine published core subpaths. Preserve defaults in generated non-shared entries and alias the shared BaseRepository default to its canonical root constructor, retaining named exports and singleton/class identity. Extend declaration/runtime verification with value-default and type-only-default regressions; compile all nine imports across the existing 18 generated compiler combinations and execute them in every installed candidate app. Records the published 2.2.35 reproduction from Q01 dogfooding; no shop adapter or node_modules patch.
+
 ## 2.2.35
 
 Retire checked-in HiroApp applications after preserving security, CLI/OpenAPI/HTTP, source, migration and Docker acceptance in generated candidate-package fixtures. Keep all 23 security cases, 40 runtime operations, 22 API/protocol operations, three-engine migration cases and 18 compiler combinations. Make the private root CLI fixture-only, isolate post-commit HTTP databases, and validate the generated production image with restricted runtime credentials, Redis recovery and graceful shutdown. Remove obsolete app regeneration/selectors and update contributor, generator and deployment documentation; retain compatible example preset IDs and explicit application-owned deployment boundaries. Regenerate the sample SDK from the API-only snapshot and verify it against the installed candidate package. Core coverage retains 136 enforced files at 100%; remove only the two deleted private-entrypoint exemptions (272 remaining).

package/dist/core/database/baseRepository.d.ts

@@ -35,6 +35,10 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     constructor(table: TableDefinition<TEntity, PrimaryKey>, connection?: DatabaseConnection);
     private assertTransactionalEvent;
     private runModelMutation;
+    private mysqlMutation;
+    private mysqlRow;
+    private mysqlAffected;
+    private mysqlWriteById;
     count(options?: ExtendedQueryOptions<TEntity>): Promise<number>;
     findAll(options?: ExtendedQueryOptions<TEntity>): Promise<TEntity[]>;
     paginate(options: {

package/dist/core/database/index.d.ts

@@ -24,7 +24,7 @@ export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, For
 export { createSqliteConnection } from "./sqliteConnection.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
-export { runInTransaction } from "./transaction.ts";
+export { isActiveTransactionConnection, runInTransaction } from "./transaction.ts";
 export type { DatabaseComparable, DatabaseScalar, MutationValues, QueryFilterValue, QueryJoin, QueryJoinOn, QueryOperator, QueryOptions, QueryOrder, QuerySelectItem, QueryWhere, UpdateValues, } from "./types.ts";
 export type { WhereNode } from "./whereBuilder.ts";
 export { WhereBuilder } from "./whereBuilder.ts";

package/dist/core/database/transaction.d.ts

@@ -1,7 +1,11 @@
 import { type TransactionAcquisitionMetrics } from "./acquisitionMetrics.ts";
 import type { DatabaseConnection } from "./baseRepository.ts";
 import { hasActiveTransaction, requestTransactionRollback } from "./transactionControl.ts";
+/** Recognizes the callback handle without admitting an unrelated pool. */
+declare function isActiveTransactionConnection(connection: DatabaseConnection): boolean;
 interface TransactionOptions {
+    /** Explicit root pool for injected repositories; cannot switch an active transaction's owner. */
+    connection?: DatabaseConnection;
     /** Cancel admission/pool checkout only. Does not cancel SQL or an admitted business callback. */
     acquisitionSignal?: AbortSignal;
     /** Observe native checkout only; requires a reserve-capable adapter. */
@@ -11,4 +15,4 @@ declare function runInTransaction<TValue>(operation: (connection: DatabaseConnec
 export type { TransactionAcquisitionMetrics, TransactionAcquisitionSnapshot, } from "./acquisitionMetrics.ts";
 export { createTransactionAcquisitionMetrics, renderTransactionAcquisitionMetrics, } from "./acquisitionMetrics.ts";
 export type { TransactionOptions };
-export { hasActiveTransaction, requestTransactionRollback, runInTransaction };
+export { hasActiveTransaction, isActiveTransactionConnection, requestTransactionRollback, runInTransaction, };

package/dist/entries/audit/exportAuditLogs.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/auth/basicAuthGuard.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/auth/membershipService.js

@@ -182,5 +182,6 @@ class MembershipService {
 }
 var membershipService_default = MembershipService;
 export {
+  membershipService_default as default,
   resolveMembershipService
 };

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/cache/repository.js

@@ -60,6 +60,8 @@ class CacheRepository {
     return this.store.size();
   }
 }
+var repository_default = CacheRepository;
 export {
-  CacheRepository
+  CacheRepository,
+  repository_default as default
 };

package/dist/entries/cache/simpleCache.js

@@ -174,5 +174,6 @@ class SimpleCache {
 }
 var simpleCache_default = SimpleCache;
 export {
-  SimpleCache
+  SimpleCache,
+  simpleCache_default as default
 };

package/dist/entries/cache/simpleCacheStore.js

@@ -38,5 +38,6 @@ class SimpleCacheStore {
 }
 var simpleCacheStore_default = SimpleCacheStore;
 export {
-  SimpleCacheStore
+  SimpleCacheStore,
+  simpleCacheStore_default as default
 };

package/dist/entries/database/baseRepository.js

@@ -1 +1,2 @@
 export * from "../../index.js";
+export { BaseRepository as default } from "../../index.js";

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
@@ -1602,6 +1619,8 @@ class ExportAuditLogsJob extends Job {
     }
   }
 }
+var exportAuditLogsJob_default = ExportAuditLogsJob;
 export {
-  ExportAuditLogsJob
+  ExportAuditLogsJob,
+  exportAuditLogsJob_default as default
 };

package/dist/entries/jobs/invalidateCacheTagsJob.js

@@ -105,6 +105,8 @@ class InvalidateCacheTagsJob extends Job {
     await this.cache.tags(...payload.tags).flush();
   }
 }
+var invalidateCacheTagsJob_default = InvalidateCacheTagsJob;
 export {
-  InvalidateCacheTagsJob
+  InvalidateCacheTagsJob,
+  invalidateCacheTagsJob_default as default
 };

package/dist/entries/queue/failedJobRepository.js

@@ -19,5 +19,6 @@ class FailedJobRepository extends BaseRepository {
 }
 var failedJobRepository_default = FailedJobRepository;
 export {
-  FailedJobRepository
+  FailedJobRepository,
+  failedJobRepository_default as default
 };

package/dist/entries/queue/failedJobService.js

@@ -47,5 +47,6 @@ class FailedJobService {
 }
 var failedJobService_default = FailedJobService;
 export {
-  FailedJobService
+  FailedJobService,
+  failedJobService_default as default
 };

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";

package/dist/index.js

@@ -853,6 +853,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);
@@ -869,7 +880,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) {
@@ -892,9 +903,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.");
@@ -913,14 +927,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();
@@ -932,6 +947,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
@@ -3743,7 +3760,6 @@ function buildPaginationMeta(input) {
 }
 
 // ../../src/core/database/baseRepository.ts
-init_connectionContext();
 init_dialect();
 
 // ../../src/core/database/keyset.ts
@@ -5171,7 +5187,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) {
@@ -5179,6 +5195,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().");
@@ -5187,7 +5229,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;
@@ -5399,6 +5441,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);
@@ -5406,6 +5474,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);
@@ -5417,6 +5487,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);
@@ -5452,6 +5534,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);
@@ -5477,6 +5566,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);
@@ -5489,6 +5586,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);
@@ -5503,6 +5609,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);
@@ -17204,6 +17317,7 @@ export {
   indexMorphToRelation,
   inferReferencedTable,
   installGracefulShutdownSignals,
+  isActiveTransactionConnection,
   isBlockedHostname,
   isBlockedIpAddress,
   isDefaultDatabaseConnection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.35",
+  "version": "2.2.37",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",