@nestjs-transactional/typeorm 1.0.0-alpha.0

package/dist/patching/entity-manager-patches.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Wrap `EntityManager.prototype.getRepository` so the resulting
+ * `Repository` instance carries the {@link TYPEORM_ENTITY_MANAGER_NAME}
+ * stamp pointing at this `EntityManager`. The patched
+ * `Repository.prototype.manager` getter then has a stable fallback
+ * (the original, non-active manager) and a way to discover the
+ * dataSource name (via `original.connection`).
+ *
+ * This wrap matters specifically for the
+ * `@InjectEntityManager() em.getRepository(Entity).save(...)` user
+ * pattern (Phase 14.20 Q1 Option A coverage proof): the injected
+ * `EntityManager` is the DataSource's default (non-transactional)
+ * manager. Calling `em.getRepository(Entity)` would, without this
+ * wrap, return a Repository whose only `manager` reference is `em`
+ * itself — and the patched `Repository.prototype.manager` getter
+ * would have nothing to read. With the wrap, the returned repo
+ * carries `em` under the stash symbol, the getter resolves the
+ * dataSource name from `em.connection`, and the lookup proceeds
+ * normally. Net effect: even when reaching a Repository through
+ * `@InjectEntityManager`, the active transactional EntityManager is
+ * still used.
+ *
+ * `@InjectEntityManager` + direct method call (`em.save(Entity, ...)`)
+ * is NOT covered by this patch — that is the documented limitation
+ * (Phase 14.20 Q5). Use `getCurrentEntityManager()` as the escape
+ * hatch.
+ */
+export declare function applyEntityManagerPatches(): void;
+/** Predicate exported for unit tests. @internal */
+export declare function areEntityManagerPatchesApplied(): boolean;
+//# sourceMappingURL=entity-manager-patches.d.ts.map

package/dist/patching/entity-manager-patches.js

@@ -0,0 +1,86 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/unbound-method */
+// The patching machinery wraps `EntityManager.prototype.getRepository`
+// and stamps hidden symbol-keyed properties on returned
+// `Repository` instances. These properties live outside TypeORM's
+// public types by design, so unsafe-access and unbound-method
+// lint rules fire on every access. File-level disable keeps the
+// patch code readable; the runtime contract is documented in the
+// JSDoc above each patch.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyEntityManagerPatches = applyEntityManagerPatches;
+exports.areEntityManagerPatchesApplied = areEntityManagerPatchesApplied;
+const typeorm_1 = require("typeorm");
+const symbols_1 = require("./symbols");
+/**
+ * Tracks whether `EntityManager.prototype.getRepository` has been
+ * wrapped. Idempotent install pattern matching
+ * `repository-patches.ts` — once installed, the wrap lives for the
+ * remainder of the process. See repository-patches.ts JSDoc for
+ * the design-note rationale.
+ */
+let installed = false;
+/**
+ * Captured original of `EntityManager.prototype.getRepository` for
+ * the wrapper to delegate into.
+ */
+let originalGetRepository;
+/**
+ * Wrap `EntityManager.prototype.getRepository` so the resulting
+ * `Repository` instance carries the {@link TYPEORM_ENTITY_MANAGER_NAME}
+ * stamp pointing at this `EntityManager`. The patched
+ * `Repository.prototype.manager` getter then has a stable fallback
+ * (the original, non-active manager) and a way to discover the
+ * dataSource name (via `original.connection`).
+ *
+ * This wrap matters specifically for the
+ * `@InjectEntityManager() em.getRepository(Entity).save(...)` user
+ * pattern (Phase 14.20 Q1 Option A coverage proof): the injected
+ * `EntityManager` is the DataSource's default (non-transactional)
+ * manager. Calling `em.getRepository(Entity)` would, without this
+ * wrap, return a Repository whose only `manager` reference is `em`
+ * itself — and the patched `Repository.prototype.manager` getter
+ * would have nothing to read. With the wrap, the returned repo
+ * carries `em` under the stash symbol, the getter resolves the
+ * dataSource name from `em.connection`, and the lookup proceeds
+ * normally. Net effect: even when reaching a Repository through
+ * `@InjectEntityManager`, the active transactional EntityManager is
+ * still used.
+ *
+ * `@InjectEntityManager` + direct method call (`em.save(Entity, ...)`)
+ * is NOT covered by this patch — that is the documented limitation
+ * (Phase 14.20 Q5). Use `getCurrentEntityManager()` as the escape
+ * hatch.
+ */
+function applyEntityManagerPatches() {
+    if (installed) {
+        return;
+    }
+    originalGetRepository = typeorm_1.EntityManager.prototype.getRepository;
+    // The generic shape of `getRepository<Entity>` resists clean
+    // typing on a wrapper; cast through `any` to keep the wrap a
+    // single statement. Runtime contract is unchanged.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeorm_1.EntityManager.prototype.getRepository = function patchedGetRepository(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    target) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const repo = originalGetRepository.call(this, target);
+        // Stamp the EM if not already set. EntityManager has internal
+        // caching, so the same Repository may be returned for repeat
+        // calls — re-stamping with the same value is a no-op, but the
+        // guard makes the intent explicit.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (repo[symbols_1.TYPEORM_ENTITY_MANAGER_NAME] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            repo[symbols_1.TYPEORM_ENTITY_MANAGER_NAME] = this;
+        }
+        return repo;
+    };
+    installed = true;
+}
+/** Predicate exported for unit tests. @internal */
+function areEntityManagerPatchesApplied() {
+    return installed;
+}
+//# sourceMappingURL=entity-manager-patches.js.map

package/dist/patching/entity-manager-patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-manager-patches.js","sourceRoot":"","sources":["../../src/patching/entity-manager-patches.ts"],"names":[],"mappings":";AAAA,2IAA2I;AAC3I,uEAAuE;AACvE,wDAAwD;AACxD,kEAAkE;AAClE,8DAA8D;AAC9D,gEAAgE;AAChE,iEAAiE;AACjE,0BAA0B;;AAgD1B,8DA+BC;AAGD,wEAEC;AAlFD,qCAAwC;AAExC,uCAAwD;AAExD;;;;;;GAMG;AACH,IAAI,SAAS,GAAG,KAAK,CAAC;AAEtB;;;GAGG;AACH,IAAI,qBAA+E,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,SAAgB,yBAAyB;IACvC,IAAI,SAAS,EAAE,CAAC;QACd,OAAO;IACT,CAAC;IAED,qBAAqB,GAAG,uBAAa,CAAC,SAAS,CAAC,aAAa,CAAC;IAE9D,6DAA6D;IAC7D,6DAA6D;IAC7D,mDAAmD;IACnD,8DAA8D;IAC7D,uBAAa,CAAC,SAAiB,CAAC,aAAa,GAAG,SAAS,oBAAoB;IAE5E,8DAA8D;IAC9D,MAAW;QAEX,oEAAoE;QACpE,MAAM,IAAI,GAAG,qBAAsB,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvD,8DAA8D;QAC9D,6DAA6D;QAC7D,8DAA8D;QAC9D,mCAAmC;QACnC,8DAA8D;QAC9D,IAAK,IAAY,CAAC,qCAA2B,CAAC,KAAK,SAAS,EAAE,CAAC;YAC7D,8DAA8D;YAC7D,IAAY,CAAC,qCAA2B,CAAC,GAAG,IAAI,CAAC;QACpD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC;IAEF,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC;AAED,mDAAmD;AACnD,SAAgB,8BAA8B;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/patching/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Phase 14.20 transparent transactional repositories — patching
+ * machinery. Exported so the module layer can drive `applyAllPatches`
+ * in `forRoot`, and so unit tests can probe state directly. None of
+ * these symbols are intended for application code — public API stays
+ * `getCurrentEntityManager` / `@Transactional` / `@InjectRepository`.
+ *
+ * @internal
+ */
+export { applyRepositoryPatches, areRepositoryPatchesApplied, } from './repository-patches';
+export { applyEntityManagerPatches, areEntityManagerPatchesApplied, } from './entity-manager-patches';
+export { patchDataSourceInstance } from './data-source-patches';
+export { getActiveEntityManager, getManagedDataSourceName, isManaged, markAsManaged, resetManagedRegistry, } from './managed-registry';
+export { TYPEORM_DATA_SOURCE_NAME, TYPEORM_DATA_SOURCE_PATCHED, TYPEORM_ENTITY_MANAGER_NAME, } from './symbols';
+/**
+ * Apply both prototype-level patch families in one call. Used by
+ * `TypeOrmTransactionalModule.forRoot`'s registration factory.
+ * Idempotent — calling more than once is a no-op (each install
+ * routine guards on its own `installed` flag).
+ *
+ * Per-instance DataSource patches ({@link patchDataSourceInstance})
+ * are NOT included here because they apply to a specific instance
+ * and are driven separately at registration time, also idempotent.
+ */
+export declare function applyAllPatches(): void;
+/**
+ * Test-only — drop the managed-DataSources WeakSet so cached
+ * repositories from a prior test fall through the patched getter
+ * to their captured original manager (autocommit), as if the
+ * patches were never engaged.
+ *
+ * Prototype-level patches are NOT removed — they were installed
+ * once-and-stay (see `repository-patches.ts` design note for the
+ * rationale: removing a prototype getter would silently break
+ * Repository instances constructed under the patched setter that
+ * have no own-property `manager`).
+ *
+ * Per-instance DataSource patches survive on those DataSource
+ * instances; tests that destroy and recreate the DataSource
+ * between cases (the typical pattern) are unaffected. The
+ * idempotent-marker design (`TYPEORM_DATA_SOURCE_PATCHED`)
+ * additionally makes re-registering the SAME `DataSource` after
+ * `resetManagedRegistry` safe — `patchDataSourceInstance` becomes
+ * a no-op.
+ *
+ * @internal
+ */
+export declare function resetPatchingForTesting(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/patching/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Phase 14.20 transparent transactional repositories — patching
+ * machinery. Exported so the module layer can drive `applyAllPatches`
+ * in `forRoot`, and so unit tests can probe state directly. None of
+ * these symbols are intended for application code — public API stays
+ * `getCurrentEntityManager` / `@Transactional` / `@InjectRepository`.
+ *
+ * @internal
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPEORM_ENTITY_MANAGER_NAME = exports.TYPEORM_DATA_SOURCE_PATCHED = exports.TYPEORM_DATA_SOURCE_NAME = exports.resetManagedRegistry = exports.markAsManaged = exports.isManaged = exports.getManagedDataSourceName = exports.getActiveEntityManager = exports.patchDataSourceInstance = exports.areEntityManagerPatchesApplied = exports.applyEntityManagerPatches = exports.areRepositoryPatchesApplied = exports.applyRepositoryPatches = void 0;
+exports.applyAllPatches = applyAllPatches;
+exports.resetPatchingForTesting = resetPatchingForTesting;
+const entity_manager_patches_1 = require("./entity-manager-patches");
+const managed_registry_1 = require("./managed-registry");
+const repository_patches_1 = require("./repository-patches");
+var repository_patches_2 = require("./repository-patches");
+Object.defineProperty(exports, "applyRepositoryPatches", { enumerable: true, get: function () { return repository_patches_2.applyRepositoryPatches; } });
+Object.defineProperty(exports, "areRepositoryPatchesApplied", { enumerable: true, get: function () { return repository_patches_2.areRepositoryPatchesApplied; } });
+var entity_manager_patches_2 = require("./entity-manager-patches");
+Object.defineProperty(exports, "applyEntityManagerPatches", { enumerable: true, get: function () { return entity_manager_patches_2.applyEntityManagerPatches; } });
+Object.defineProperty(exports, "areEntityManagerPatchesApplied", { enumerable: true, get: function () { return entity_manager_patches_2.areEntityManagerPatchesApplied; } });
+var data_source_patches_1 = require("./data-source-patches");
+Object.defineProperty(exports, "patchDataSourceInstance", { enumerable: true, get: function () { return data_source_patches_1.patchDataSourceInstance; } });
+var managed_registry_2 = require("./managed-registry");
+Object.defineProperty(exports, "getActiveEntityManager", { enumerable: true, get: function () { return managed_registry_2.getActiveEntityManager; } });
+Object.defineProperty(exports, "getManagedDataSourceName", { enumerable: true, get: function () { return managed_registry_2.getManagedDataSourceName; } });
+Object.defineProperty(exports, "isManaged", { enumerable: true, get: function () { return managed_registry_2.isManaged; } });
+Object.defineProperty(exports, "markAsManaged", { enumerable: true, get: function () { return managed_registry_2.markAsManaged; } });
+Object.defineProperty(exports, "resetManagedRegistry", { enumerable: true, get: function () { return managed_registry_2.resetManagedRegistry; } });
+var symbols_1 = require("./symbols");
+Object.defineProperty(exports, "TYPEORM_DATA_SOURCE_NAME", { enumerable: true, get: function () { return symbols_1.TYPEORM_DATA_SOURCE_NAME; } });
+Object.defineProperty(exports, "TYPEORM_DATA_SOURCE_PATCHED", { enumerable: true, get: function () { return symbols_1.TYPEORM_DATA_SOURCE_PATCHED; } });
+Object.defineProperty(exports, "TYPEORM_ENTITY_MANAGER_NAME", { enumerable: true, get: function () { return symbols_1.TYPEORM_ENTITY_MANAGER_NAME; } });
+/**
+ * Apply both prototype-level patch families in one call. Used by
+ * `TypeOrmTransactionalModule.forRoot`'s registration factory.
+ * Idempotent — calling more than once is a no-op (each install
+ * routine guards on its own `installed` flag).
+ *
+ * Per-instance DataSource patches ({@link patchDataSourceInstance})
+ * are NOT included here because they apply to a specific instance
+ * and are driven separately at registration time, also idempotent.
+ */
+function applyAllPatches() {
+    (0, repository_patches_1.applyRepositoryPatches)();
+    (0, entity_manager_patches_1.applyEntityManagerPatches)();
+}
+/**
+ * Test-only — drop the managed-DataSources WeakSet so cached
+ * repositories from a prior test fall through the patched getter
+ * to their captured original manager (autocommit), as if the
+ * patches were never engaged.
+ *
+ * Prototype-level patches are NOT removed — they were installed
+ * once-and-stay (see `repository-patches.ts` design note for the
+ * rationale: removing a prototype getter would silently break
+ * Repository instances constructed under the patched setter that
+ * have no own-property `manager`).
+ *
+ * Per-instance DataSource patches survive on those DataSource
+ * instances; tests that destroy and recreate the DataSource
+ * between cases (the typical pattern) are unaffected. The
+ * idempotent-marker design (`TYPEORM_DATA_SOURCE_PATCHED`)
+ * additionally makes re-registering the SAME `DataSource` after
+ * `resetManagedRegistry` safe — `patchDataSourceInstance` becomes
+ * a no-op.
+ *
+ * @internal
+ */
+function resetPatchingForTesting() {
+    (0, managed_registry_1.resetManagedRegistry)();
+}
+//# sourceMappingURL=index.js.map

package/dist/patching/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/patching/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAsCH,0CAGC;AAwBD,0DAEC;AAjED,qEAAqE;AACrE,yDAA0D;AAC1D,6DAA8D;AAE9D,2DAG8B;AAF5B,4HAAA,sBAAsB,OAAA;AACtB,iIAAA,2BAA2B,OAAA;AAE7B,mEAGkC;AAFhC,mIAAA,yBAAyB,OAAA;AACzB,wIAAA,8BAA8B,OAAA;AAEhC,6DAAgE;AAAvD,8HAAA,uBAAuB,OAAA;AAChC,uDAM4B;AAL1B,0HAAA,sBAAsB,OAAA;AACtB,4HAAA,wBAAwB,OAAA;AACxB,6GAAA,SAAS,OAAA;AACT,iHAAA,aAAa,OAAA;AACb,wHAAA,oBAAoB,OAAA;AAEtB,qCAImB;AAHjB,mHAAA,wBAAwB,OAAA;AACxB,sHAAA,2BAA2B,OAAA;AAC3B,sHAAA,2BAA2B,OAAA;AAG7B;;;;;;;;;GASG;AACH,SAAgB,eAAe;IAC7B,IAAA,2CAAsB,GAAE,CAAC;IACzB,IAAA,kDAAyB,GAAE,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAgB,uBAAuB;IACrC,IAAA,uCAAoB,GAAE,CAAC;AACzB,CAAC"}

package/dist/patching/managed-registry.d.ts

@@ -0,0 +1,59 @@
+import type { DataSource, EntityManager } from 'typeorm';
+/**
+ * Register `dataSource` as a "managed" DataSource under the supplied
+ * `name`. Stamps the name as a hidden property on the DataSource
+ * (under {@link TYPEORM_DATA_SOURCE_NAME}) and adds the instance to
+ * the {@link managedDataSources} WeakSet.
+ *
+ * Both pieces of state are read by the patched `Repository.prototype.manager`
+ * getter and by the per-instance `DataSource.manager` getter — the
+ * WeakSet membership decides whether the dispatch is transactional at
+ * all, and the stamped name resolves the
+ * `TransactionContext.getActiveTransactionByDataSource(name)` lookup.
+ *
+ * Idempotent — calling twice with the same `(dataSource, name)` pair
+ * is a no-op. Calling twice with different names overwrites the
+ * stamped name silently; in practice every callsite is
+ * `TypeOrmTransactionalModule.forRoot`, which dedups upstream via its
+ * own static-Map mechanism, so this collision should never occur in
+ * production.
+ */
+export declare function markAsManaged(dataSource: DataSource, name: string): void;
+/** Predicate: is `dataSource` registered as managed? */
+export declare function isManaged(dataSource: DataSource): boolean;
+/**
+ * Read the dataSource name stamped on `dataSource` by
+ * {@link markAsManaged}. Returns `undefined` if the DataSource has
+ * not been registered as managed.
+ */
+export declare function getManagedDataSourceName(dataSource: DataSource): string | undefined;
+/**
+ * Resolve the active transactional `EntityManager` for the given
+ * dataSource name from {@link TransactionContext}. Returns
+ * `undefined` when there is no active transaction on the current
+ * async chain for this dataSource — the patched getters use that
+ * to fall back to the original manager (autocommit semantics).
+ *
+ * Centralised here so every patch site goes through the same
+ * resolution rule — one place to evolve when the underlying lookup
+ * changes.
+ */
+export declare function getActiveEntityManager(dataSourceName: string): EntityManager | undefined;
+/**
+ * Test-only — drop every managed DataSource registration so a fresh
+ * test starts from a clean slate. Recreates the `WeakSet` (no
+ * `.clear()` API on `WeakSet`).
+ *
+ * NOTE: this does NOT undo the {@link TYPEORM_DATA_SOURCE_NAME} stamp
+ * on individual DataSource instances, nor does it revert the
+ * per-instance patches applied by {@link patchDataSourceInstance}.
+ * Tests that build a fresh `DataSource` per case are unaffected
+ * (the stale stamp is never observed). Tests that reuse a
+ * `DataSource` across `TransactionalModule.resetForTesting()` calls
+ * are not supported — destroy and recreate the DataSource between
+ * cases instead.
+ *
+ * @internal
+ */
+export declare function resetManagedRegistry(): void;
+//# sourceMappingURL=managed-registry.d.ts.map

package/dist/patching/managed-registry.js

@@ -0,0 +1,112 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-return */
+// The patching machinery stamps and reads hidden symbol-keyed
+// properties on TypeORM internals (`DataSource`, `EntityManager`,
+// `Repository`). These properties live outside TypeORM's public
+// types by design, so unsafe-access lint rules fire on every
+// access. File-level disable keeps the patch code readable; the
+// runtime contract is documented in JSDoc above each patch.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markAsManaged = markAsManaged;
+exports.isManaged = isManaged;
+exports.getManagedDataSourceName = getManagedDataSourceName;
+exports.getActiveEntityManager = getActiveEntityManager;
+exports.resetManagedRegistry = resetManagedRegistry;
+const core_1 = require("@nestjs-transactional/core");
+const symbols_1 = require("./symbols");
+/**
+ * Process-wide set of `DataSource` instances we have registered as
+ * "managed" via {@link markAsManaged}. The patched
+ * `Repository.prototype.manager` getter consults this set to decide
+ * whether to dispatch transactionally or pass through unchanged —
+ * non-managed DataSources (e.g. those a user created manually outside
+ * `TypeOrmTransactionalModule`) MUST behave exactly as TypeORM does
+ * normally.
+ *
+ * `WeakSet` over `Set`: a managed DataSource that is destroyed and
+ * eligible for GC should not be retained by us.
+ *
+ * `let` not `const` so {@link resetManagedRegistry} can swap in a
+ * fresh empty `WeakSet` — the standard `WeakSet` API offers no
+ * `.clear()` method, and recreating the reference is the cleanest
+ * way to drop every managed entry at once for test isolation.
+ */
+let managedDataSources = new WeakSet();
+/**
+ * Register `dataSource` as a "managed" DataSource under the supplied
+ * `name`. Stamps the name as a hidden property on the DataSource
+ * (under {@link TYPEORM_DATA_SOURCE_NAME}) and adds the instance to
+ * the {@link managedDataSources} WeakSet.
+ *
+ * Both pieces of state are read by the patched `Repository.prototype.manager`
+ * getter and by the per-instance `DataSource.manager` getter — the
+ * WeakSet membership decides whether the dispatch is transactional at
+ * all, and the stamped name resolves the
+ * `TransactionContext.getActiveTransactionByDataSource(name)` lookup.
+ *
+ * Idempotent — calling twice with the same `(dataSource, name)` pair
+ * is a no-op. Calling twice with different names overwrites the
+ * stamped name silently; in practice every callsite is
+ * `TypeOrmTransactionalModule.forRoot`, which dedups upstream via its
+ * own static-Map mechanism, so this collision should never occur in
+ * production.
+ */
+function markAsManaged(dataSource, name) {
+    managedDataSources.add(dataSource);
+    // Stamp the name as a hidden property. Cast to any to avoid a
+    // TypeORM type-shape change: we intentionally augment the runtime
+    // object without touching its public surface.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dataSource[symbols_1.TYPEORM_DATA_SOURCE_NAME] = name;
+}
+/** Predicate: is `dataSource` registered as managed? */
+function isManaged(dataSource) {
+    return managedDataSources.has(dataSource);
+}
+/**
+ * Read the dataSource name stamped on `dataSource` by
+ * {@link markAsManaged}. Returns `undefined` if the DataSource has
+ * not been registered as managed.
+ */
+function getManagedDataSourceName(dataSource) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return dataSource[symbols_1.TYPEORM_DATA_SOURCE_NAME];
+}
+/**
+ * Resolve the active transactional `EntityManager` for the given
+ * dataSource name from {@link TransactionContext}. Returns
+ * `undefined` when there is no active transaction on the current
+ * async chain for this dataSource — the patched getters use that
+ * to fall back to the original manager (autocommit semantics).
+ *
+ * Centralised here so every patch site goes through the same
+ * resolution rule — one place to evolve when the underlying lookup
+ * changes.
+ */
+function getActiveEntityManager(dataSourceName) {
+    const activeTx = core_1.TransactionContext.getActiveTransactionByDataSource(dataSourceName);
+    if (activeTx === undefined) {
+        return undefined;
+    }
+    return activeTx.handle.entityManager;
+}
+/**
+ * Test-only — drop every managed DataSource registration so a fresh
+ * test starts from a clean slate. Recreates the `WeakSet` (no
+ * `.clear()` API on `WeakSet`).
+ *
+ * NOTE: this does NOT undo the {@link TYPEORM_DATA_SOURCE_NAME} stamp
+ * on individual DataSource instances, nor does it revert the
+ * per-instance patches applied by {@link patchDataSourceInstance}.
+ * Tests that build a fresh `DataSource` per case are unaffected
+ * (the stale stamp is never observed). Tests that reuse a
+ * `DataSource` across `TransactionalModule.resetForTesting()` calls
+ * are not supported — destroy and recreate the DataSource between
+ * cases instead.
+ *
+ * @internal
+ */
+function resetManagedRegistry() {
+    managedDataSources = new WeakSet();
+}
+//# sourceMappingURL=managed-registry.js.map

package/dist/patching/managed-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"managed-registry.js","sourceRoot":"","sources":["../../src/patching/managed-registry.ts"],"names":[],"mappings":";AAAA,oGAAoG;AACpG,8DAA8D;AAC9D,kEAAkE;AAClE,gEAAgE;AAChE,6DAA6D;AAC7D,gEAAgE;AAChE,4DAA4D;;AA+C5D,sCAOC;AAGD,8BAEC;AAOD,4DAGC;AAaD,wDAMC;AAkBD,oDAEC;AA1GD,qDAAgE;AAKhE,uCAAqD;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,IAAI,kBAAkB,GAAG,IAAI,OAAO,EAAc,CAAC;AAEnD;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,aAAa,CAAC,UAAsB,EAAE,IAAY;IAChE,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACnC,8DAA8D;IAC9D,kEAAkE;IAClE,8CAA8C;IAC9C,8DAA8D;IAC7D,UAAkB,CAAC,kCAAwB,CAAC,GAAG,IAAI,CAAC;AACvD,CAAC;AAED,wDAAwD;AACxD,SAAgB,SAAS,CAAC,UAAsB;IAC9C,OAAO,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAgB,wBAAwB,CAAC,UAAsB;IAC7D,8DAA8D;IAC9D,OAAQ,UAAkB,CAAC,kCAAwB,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,sBAAsB,CAAC,cAAsB;IAC3D,MAAM,QAAQ,GAAG,yBAAkB,CAAC,gCAAgC,CAAC,cAAc,CAAC,CAAC;IACrF,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAQ,QAAQ,CAAC,MAAmC,CAAC,aAAa,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,SAAgB,oBAAoB;IAClC,kBAAkB,GAAG,IAAI,OAAO,EAAc,CAAC;AACjD,CAAC"}

package/dist/patching/repository-patches.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Install the prototype-level patches that make every `Repository`
+ * instance transactionally aware. Idempotent — calling more than
+ * once per process is a no-op.
+ *
+ * Two patches:
+ *
+ * 1. `Repository.prototype.manager` — replaced with a getter/setter
+ *    pair. The setter intercepts the constructor's
+ *    `this.manager = manager` assignment and stashes the value
+ *    under {@link TYPEORM_ENTITY_MANAGER_NAME}; the getter consults
+ *    `TransactionContext` and returns the active transactional
+ *    `EntityManager` when one exists for this repository's
+ *    dataSource (falling back to the stashed original otherwise).
+ *
+ *    Since TypeORM's `Repository` methods are all of the shape
+ *    `return this.manager.<method>(this.metadata.target, ...)`, this
+ *    single getter patch transparently routes every public Repository
+ *    operation (save, find, findOne, update, delete, query,
+ *    createQueryBuilder, count, exists, sum, average, ...) through
+ *    the transactional EntityManager when a transaction is active.
+ *
+ * 2. `Repository.prototype.extend` — wrapped so that a custom
+ *    repository class produced via `repo.extend(...)` keeps the
+ *    {@link TYPEORM_ENTITY_MANAGER_NAME} stamp on each constructed
+ *    instance. Without this wrap, `.extend()` chains end up with
+ *    `this.manager` undefined inside the patched getter (because the
+ *    extended class re-runs the assignment that the patched setter
+ *    consumes — but the setter only stashes; nothing else
+ *    initializes the stash on the extended subclass).
+ *
+ *    The mirror `EntityManager.prototype.getRepository` wrap lives
+ *    in `entity-manager-patches.ts` so the symmetry is obvious from
+ *    the file layout.
+ *
+ * **Design note — no revert path.** Reverting a prototype patch by
+ * deleting the descriptor would silently break every `Repository`
+ * instance constructed under the patched setter — those instances
+ * have no own-property `manager` (the setter only stashed the
+ * value); deleting the prototype descriptor leaves their
+ * `repo.manager` as `undefined`. Tests that need isolation should
+ * destroy and recreate the `DataSource` instead, which causes
+ * `TypeORM`'s `EntityManager`/`Repository` cache to be replaced
+ * along with the DataSource. The `WeakSet`-based managed-DataSource
+ * registry (see `managed-registry.ts`) provides the test-isolation
+ * lever that *is* safe to flip: after `resetManagedRegistry()`,
+ * cached repositories from the prior test fall through the
+ * patched getter to their captured original manager (autocommit) —
+ * never a broken `undefined`.
+ */
+export declare function applyRepositoryPatches(): void;
+/**
+ * Predicate exported for unit tests. @internal
+ */
+export declare function areRepositoryPatchesApplied(): boolean;
+//# sourceMappingURL=repository-patches.d.ts.map

package/dist/patching/repository-patches.js

@@ -0,0 +1,150 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/unbound-method */
+// The patching machinery stamps and reads hidden symbol-keyed
+// properties on TypeORM `Repository` instances. These properties
+// live outside TypeORM's public types by design, so unsafe-access
+// and unbound-method lint rules fire on every access. File-level
+// disable keeps the patch code readable; the runtime contract is
+// documented in the JSDoc above each patch.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyRepositoryPatches = applyRepositoryPatches;
+exports.areRepositoryPatchesApplied = areRepositoryPatchesApplied;
+const typeorm_1 = require("typeorm");
+const managed_registry_1 = require("./managed-registry");
+const symbols_1 = require("./symbols");
+/**
+ * Tracks whether the prototype patch has been installed on
+ * `Repository.prototype`. Once installed, the patch lives for the
+ * remainder of the process — there is no `revert` story (see
+ * design note below). The only re-entry path is calling
+ * `applyRepositoryPatches` again after install, which is a no-op.
+ */
+let installed = false;
+/**
+ * Captured original of `Repository.prototype.extend` for the wrapper
+ * to delegate into. Captured once at install-time; never restored.
+ */
+let originalExtend;
+/**
+ * Install the prototype-level patches that make every `Repository`
+ * instance transactionally aware. Idempotent — calling more than
+ * once per process is a no-op.
+ *
+ * Two patches:
+ *
+ * 1. `Repository.prototype.manager` — replaced with a getter/setter
+ *    pair. The setter intercepts the constructor's
+ *    `this.manager = manager` assignment and stashes the value
+ *    under {@link TYPEORM_ENTITY_MANAGER_NAME}; the getter consults
+ *    `TransactionContext` and returns the active transactional
+ *    `EntityManager` when one exists for this repository's
+ *    dataSource (falling back to the stashed original otherwise).
+ *
+ *    Since TypeORM's `Repository` methods are all of the shape
+ *    `return this.manager.<method>(this.metadata.target, ...)`, this
+ *    single getter patch transparently routes every public Repository
+ *    operation (save, find, findOne, update, delete, query,
+ *    createQueryBuilder, count, exists, sum, average, ...) through
+ *    the transactional EntityManager when a transaction is active.
+ *
+ * 2. `Repository.prototype.extend` — wrapped so that a custom
+ *    repository class produced via `repo.extend(...)` keeps the
+ *    {@link TYPEORM_ENTITY_MANAGER_NAME} stamp on each constructed
+ *    instance. Without this wrap, `.extend()` chains end up with
+ *    `this.manager` undefined inside the patched getter (because the
+ *    extended class re-runs the assignment that the patched setter
+ *    consumes — but the setter only stashes; nothing else
+ *    initializes the stash on the extended subclass).
+ *
+ *    The mirror `EntityManager.prototype.getRepository` wrap lives
+ *    in `entity-manager-patches.ts` so the symmetry is obvious from
+ *    the file layout.
+ *
+ * **Design note — no revert path.** Reverting a prototype patch by
+ * deleting the descriptor would silently break every `Repository`
+ * instance constructed under the patched setter — those instances
+ * have no own-property `manager` (the setter only stashed the
+ * value); deleting the prototype descriptor leaves their
+ * `repo.manager` as `undefined`. Tests that need isolation should
+ * destroy and recreate the `DataSource` instead, which causes
+ * `TypeORM`'s `EntityManager`/`Repository` cache to be replaced
+ * along with the DataSource. The `WeakSet`-based managed-DataSource
+ * registry (see `managed-registry.ts`) provides the test-isolation
+ * lever that *is* safe to flip: after `resetManagedRegistry()`,
+ * cached repositories from the prior test fall through the
+ * patched getter to their captured original manager (autocommit) —
+ * never a broken `undefined`.
+ */
+function applyRepositoryPatches() {
+    if (installed) {
+        return;
+    }
+    // (1) Repository.prototype.manager — getter/setter pair.
+    Object.defineProperty(typeorm_1.Repository.prototype, 'manager', {
+        configurable: true,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        get() {
+            // The original (non-active) manager is stashed under our
+            // symbol by either: (a) the patched `set` below, when
+            // TypeORM's Repository constructor runs `this.manager = manager`,
+            // or (b) the `EntityManager.prototype.getRepository` wrapper
+            // when it stamps newly-resolved repositories.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const original = this[symbols_1.TYPEORM_ENTITY_MANAGER_NAME];
+            // Defensive: a Repository ending up here without ever having
+            // had its setter called (shouldn't happen in practice) yields
+            // `undefined`, mirroring the pre-patch behaviour for an
+            // unconstructed/zombie instance.
+            if (original === undefined) {
+                return undefined;
+            }
+            const ds = original.connection;
+            if (!(0, managed_registry_1.isManaged)(ds)) {
+                return original;
+            }
+            const dsName = (0, managed_registry_1.getManagedDataSourceName)(ds);
+            if (dsName === undefined) {
+                return original;
+            }
+            const active = (0, managed_registry_1.getActiveEntityManager)(dsName);
+            return active ?? original;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        set(manager) {
+            // Constructor's `this.manager = manager` reaches us here.
+            // Stash under the hidden symbol so the getter has a fallback.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this[symbols_1.TYPEORM_ENTITY_MANAGER_NAME] = manager;
+        },
+    });
+    // (2) Repository.prototype.extend — wrap to preserve the stash on
+    // extended instances. The generic shape of the original
+    // `extend` resists clean typing on the wrapper; cast through
+    // `any` to keep the wrap a single statement (the runtime
+    // contract is unchanged).
+    originalExtend = typeorm_1.Repository.prototype.extend;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    typeorm_1.Repository.prototype.extend = function patchedExtend(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    customs) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const result = originalExtend.call(this, customs);
+        // The freshly-extended Repository was constructed via the
+        // patched setter, so the stash is already in place. Defensive
+        // copy in case TypeORM's internal extension shape changes.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (result[symbols_1.TYPEORM_ENTITY_MANAGER_NAME] === undefined) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            result[symbols_1.TYPEORM_ENTITY_MANAGER_NAME] = this[symbols_1.TYPEORM_ENTITY_MANAGER_NAME];
+        }
+        return result;
+    };
+    installed = true;
+}
+/**
+ * Predicate exported for unit tests. @internal
+ */
+function areRepositoryPatchesApplied() {
+    return installed;
+}
+//# sourceMappingURL=repository-patches.js.map

package/dist/patching/repository-patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository-patches.js","sourceRoot":"","sources":["../../src/patching/repository-patches.ts"],"names":[],"mappings":";AAAA,2IAA2I;AAC3I,8DAA8D;AAC9D,iEAAiE;AACjE,kEAAkE;AAClE,iEAAiE;AACjE,iEAAiE;AACjE,4CAA4C;;AAyE5C,wDA2EC;AAKD,kEAEC;AAzJD,qCAAqC;AAGrC,yDAAiG;AACjG,uCAAwD;AAExD;;;;;;GAMG;AACH,IAAI,SAAS,GAAG,KAAK,CAAC;AAEtB;;;GAGG;AACH,IAAI,cAA8D,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,SAAgB,sBAAsB;IACpC,IAAI,SAAS,EAAE,CAAC;QACd,OAAO;IACT,CAAC;IAED,yDAAyD;IACzD,MAAM,CAAC,cAAc,CAAC,oBAAU,CAAC,SAAS,EAAE,SAAS,EAAE;QACrD,YAAY,EAAE,IAAI;QAClB,8DAA8D;QAC9D,GAAG;YACD,yDAAyD;YACzD,sDAAsD;YACtD,kEAAkE;YAClE,6DAA6D;YAC7D,8CAA8C;YAC9C,8DAA8D;YAC9D,MAAM,QAAQ,GAA+B,IAAY,CAAC,qCAA2B,CAAC,CAAC;YAEvF,6DAA6D;YAC7D,8DAA8D;YAC9D,wDAAwD;YACxD,iCAAiC;YACjC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,OAAO,SAAqC,CAAC;YAC/C,CAAC;YAED,MAAM,EAAE,GAAG,QAAQ,CAAC,UAAU,CAAC;YAC/B,IAAI,CAAC,IAAA,4BAAS,EAAC,EAAE,CAAC,EAAE,CAAC;gBACnB,OAAO,QAAQ,CAAC;YAClB,CAAC;YAED,MAAM,MAAM,GAAG,IAAA,2CAAwB,EAAC,EAAE,CAAC,CAAC;YAC5C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,OAAO,QAAQ,CAAC;YAClB,CAAC;YAED,MAAM,MAAM,GAAG,IAAA,yCAAsB,EAAC,MAAM,CAAC,CAAC;YAC9C,OAAO,MAAM,IAAI,QAAQ,CAAC;QAC5B,CAAC;QACD,8DAA8D;QAC9D,GAAG,CAAwB,OAAsB;YAC/C,0DAA0D;YAC1D,8DAA8D;YAC9D,8DAA8D;YAC7D,IAAY,CAAC,qCAA2B,CAAC,GAAG,OAAO,CAAC;QACvD,CAAC;KACF,CAAC,CAAC;IAEH,kEAAkE;IAClE,wDAAwD;IACxD,6DAA6D;IAC7D,yDAAyD;IACzD,0BAA0B;IAC1B,cAAc,GAAG,oBAAU,CAAC,SAAS,CAAC,MAAM,CAAC;IAC7C,8DAA8D;IAC7D,oBAAU,CAAC,SAAiB,CAAC,MAAM,GAAG,SAAS,aAAa;IAG3D,8DAA8D;IAC9D,OAAY;QAEZ,oEAAoE;QACpE,MAAM,MAAM,GAAG,cAAe,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACnD,0DAA0D;QAC1D,8DAA8D;QAC9D,2DAA2D;QAC3D,8DAA8D;QAC9D,IAAK,MAAc,CAAC,qCAA2B,CAAC,KAAK,SAAS,EAAE,CAAC;YAC/D,8DAA8D;YAC7D,MAAc,CAAC,qCAA2B,CAAC,GAAI,IAAY,CAAC,qCAA2B,CAAC,CAAC;QAC5F,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,SAAS,GAAG,IAAI,CAAC;AACnB,CAAC;AAED;;GAEG;AACH,SAAgB,2BAA2B;IACzC,OAAO,SAAS,CAAC;AACnB,CAAC"}