@nestjs-transactional/typeorm 1.0.0-alpha.0

package/dist/module/typeorm-transactional.module.d.ts

@@ -0,0 +1,157 @@
+import { type DynamicModule, type InjectionToken, type ModuleMetadata } from '@nestjs/common';
+/**
+ * Options accepted by {@link TypeOrmTransactionalModule.forRoot}.
+ *
+ * Phase 14.20 reshape: this module now resolves the actual TypeORM
+ * `DataSource` via DI (using `getDataSourceToken` from
+ * `@nestjs/typeorm`) instead of taking it as a constructor argument.
+ * The new contract is "TypeORM is configured by `@nestjs/typeorm`'s
+ * `TypeOrmModule.forRoot(...)`; we just bind to it by name."
+ */
+export interface TypeOrmTransactionalOptions {
+    /**
+     * DataSource name as used by `@nestjs/typeorm`'s
+     * `TypeOrmModule.forRoot({ name })`. Defaults to `'default'`. The
+     * actual `DataSource` instance is resolved from DI under
+     * `getDataSourceToken(this.dataSource)`.
+     */
+    readonly dataSource?: string;
+    /**
+     * Mark this adapter as the registry-level default. Affects
+     * `@Transactional()` calls that omit the `dataSource` option.
+     * Defaults to `false`; the first registered adapter becomes the
+     * default automatically (per {@link AdapterRegistry.register}).
+     */
+    readonly isDefault?: boolean;
+}
+/**
+ * Asynchronous flavour of {@link TypeOrmTransactionalOptions}.
+ *
+ * **Per-DS DI token limitation**: the per-dataSource adapter token
+ * (`getTransactionalAdapterToken(ds)`) is NOT registered for
+ * `forRootAsync` because the dataSource name is only known after
+ * the async factory runs, while NestJS provider tokens must be
+ * declared statically. If per-DS injection of the adapter matters,
+ * use sync `forRoot({ dataSource })` instead. The
+ * `AdapterRegistry`-based access path
+ * (`@Transactional({ dataSource })`,
+ * `getCurrentEntityManager(dataSource)`,
+ * `manager.run({ dataSource })`) is unaffected — those route
+ * through the registry, which the eager-registration factory
+ * populates as a side effect.
+ *
+ * Mirrors the documented limitation on
+ * `TransactionalModule.forRootAsync` (Phase 14.10).
+ */
+export interface TypeOrmTransactionalAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    readonly useFactory: (...args: never[]) => Promise<TypeOrmTransactionalOptions> | TypeOrmTransactionalOptions;
+    readonly inject?: readonly InjectionToken[];
+}
+/**
+ * NestJS module that binds a TypeORM {@link DataSource} to the core
+ * {@link AdapterRegistry} as a transactional adapter AND activates
+ * the transparent transactional patching machinery (Phase 14.20).
+ * Once registered:
+ *
+ * - Every `Repository` reachable via `@InjectRepository`,
+ *   `dataSource.getRepository(...)`, `entityManager.getRepository(...)`,
+ *   or `repo.extend(...)` automatically dispatches inside the active
+ *   `@Transactional()` scope.
+ * - `dataSource.query(...)` and `dataSource.createQueryBuilder(...)`
+ *   pick up the transactional `QueryRunner`.
+ * - `@InjectEntityManager() em.getRepository(E).save(...)` works
+ *   transactionally (the wrapped `EntityManager.prototype.getRepository`
+ *   stamps the manager reference). Direct
+ *   `@InjectEntityManager() em.save(E, ...)` is a documented
+ *   limitation — use the Repository pattern or
+ *   `getCurrentEntityManager()` as escape hatch.
+ *
+ * Multi-dataSource deployments call {@link forRoot} once per
+ * dataSource (mirrors `OutboxModule` per ADR-019 and
+ * `TransactionalModule` per ADR-018):
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ type: 'postgres', ... }),
+ *     TypeOrmModule.forRoot({ type: 'postgres', name: 'billing', ... }),
+ *
+ *     TransactionalModule.forRoot({}),                           // infra
+ *     TypeOrmTransactionalModule.forRoot(),                      // default
+ *     TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Patches are applied process-wide on the first `forRoot`/`forRootAsync`
+ * call (idempotent on re-entry). DataSource instances are tracked in
+ * a `WeakSet`; non-managed DataSources are never touched by the
+ * patches — they continue to behave as TypeORM does normally.
+ */
+export declare class TypeOrmTransactionalModule {
+    /**
+     * @internal
+     * Counter for `forRootAsync`-only token uniqueness. Mirrors the
+     * pattern used in `TransactionalModule.forRootAsync` — every
+     * async call gets a unique provider symbol so consecutive calls
+     * don't collide.
+     */
+    private static asyncCounter;
+    /**
+     * Test-only — drop the managed-DataSources `WeakSet` so cached
+     * repositories from a prior test fall through to their original
+     * (autocommit) manager. Prototype-level patches are NOT removed;
+     * they were installed once-and-stay, by design (see
+     * `repository-patches.ts` JSDoc). Per-instance `DataSource`
+     * patches survive on those `DataSource` instances — tests that
+     * destroy and recreate the `DataSource` between cases (the
+     * typical pattern) are unaffected.
+     *
+     * Re-registering the SAME `DataSource` after a reset is safe:
+     * `patchDataSourceInstance` is idempotent via a marker symbol,
+     * and `markAsManaged` re-stamps the same name harmlessly.
+     *
+     * Production code should never call this.
+     *
+     * @internal
+     */
+    static resetForTesting(): void;
+    /**
+     * Synchronous registration. Each call binds one DataSource (by
+     * name) to the transactional infrastructure. Patches are
+     * activated idempotently on the first call.
+     *
+     * @example Default DataSource
+     * ```ts
+     * TypeOrmTransactionalModule.forRoot()
+     * ```
+     *
+     * @example Named DataSource
+     * ```ts
+     * TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' })
+     * ```
+     */
+    static forRoot(options?: TypeOrmTransactionalOptions): DynamicModule;
+    /**
+     * Asynchronous registration. Resolves
+     * {@link TypeOrmTransactionalOptions} via a NestJS-style async
+     * factory before binding the adapter. See
+     * {@link TypeOrmTransactionalAsyncOptions} for the per-DS-token
+     * limitation.
+     *
+     * @example
+     * ```ts
+     * TypeOrmTransactionalModule.forRootAsync({
+     *   imports: [ConfigModule],
+     *   inject: [ConfigService],
+     *   useFactory: (cfg: ConfigService) => ({
+     *     dataSource: cfg.get('DATA_SOURCE_NAME'),
+     *     isDefault: true,
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options: TypeOrmTransactionalAsyncOptions): DynamicModule;
+}
+//# sourceMappingURL=typeorm-transactional.module.d.ts.map

package/dist/module/typeorm-transactional.module.js

@@ -0,0 +1,289 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TypeOrmTransactionalModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmTransactionalModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const typeorm_1 = require("@nestjs/typeorm");
+const core_2 = require("@nestjs-transactional/core");
+const typeorm_adapter_1 = require("../adapter/typeorm.adapter");
+const patching_1 = require("../patching");
+// ---------------------------------------------------------------
+// Apply Repository / EntityManager prototype patches at MODULE-LOAD
+// time, NOT at `forRoot` factory time.
+//
+// Why module-load: NestJS resolves providers in dependency order
+// during `compile()`. A `useFactory` provider that calls
+// `dataSource.getRepository(Entity)` (e.g. `@InjectRepository`'s
+// internal factory) runs BEFORE `TypeOrmTransactionalModule.forRoot`'s
+// factory if it has no DI dependency on the latter. A Repository
+// constructed before the patches are installed gets its
+// `this.manager = manager` assignment as an own-property, which
+// permanently shadows the prototype getter — that Repository
+// instance can never dispatch through the active transactional
+// EntityManager.
+//
+// Installing the patches as a side effect of importing this file
+// guarantees they're in place before any DI factory could ever
+// observe an unpatched `Repository.prototype`. Idempotent: a second
+// import (e.g. a stale duplicate copy on disk under pnpm hoist
+// glitches) is a no-op via the install-once flag inside each patch.
+// ---------------------------------------------------------------
+(0, patching_1.applyAllPatches)();
+const ASYNC_OPTIONS_TOKEN = (id) => Symbol(`TYPEORM_TRANSACTIONAL_ASYNC_OPTIONS[${id}]`);
+/**
+ * NestJS module that binds a TypeORM {@link DataSource} to the core
+ * {@link AdapterRegistry} as a transactional adapter AND activates
+ * the transparent transactional patching machinery (Phase 14.20).
+ * Once registered:
+ *
+ * - Every `Repository` reachable via `@InjectRepository`,
+ *   `dataSource.getRepository(...)`, `entityManager.getRepository(...)`,
+ *   or `repo.extend(...)` automatically dispatches inside the active
+ *   `@Transactional()` scope.
+ * - `dataSource.query(...)` and `dataSource.createQueryBuilder(...)`
+ *   pick up the transactional `QueryRunner`.
+ * - `@InjectEntityManager() em.getRepository(E).save(...)` works
+ *   transactionally (the wrapped `EntityManager.prototype.getRepository`
+ *   stamps the manager reference). Direct
+ *   `@InjectEntityManager() em.save(E, ...)` is a documented
+ *   limitation — use the Repository pattern or
+ *   `getCurrentEntityManager()` as escape hatch.
+ *
+ * Multi-dataSource deployments call {@link forRoot} once per
+ * dataSource (mirrors `OutboxModule` per ADR-019 and
+ * `TransactionalModule` per ADR-018):
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ type: 'postgres', ... }),
+ *     TypeOrmModule.forRoot({ type: 'postgres', name: 'billing', ... }),
+ *
+ *     TransactionalModule.forRoot({}),                           // infra
+ *     TypeOrmTransactionalModule.forRoot(),                      // default
+ *     TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Patches are applied process-wide on the first `forRoot`/`forRootAsync`
+ * call (idempotent on re-entry). DataSource instances are tracked in
+ * a `WeakSet`; non-managed DataSources are never touched by the
+ * patches — they continue to behave as TypeORM does normally.
+ */
+let TypeOrmTransactionalModule = class TypeOrmTransactionalModule {
+    static { TypeOrmTransactionalModule_1 = this; }
+    /**
+     * @internal
+     * Counter for `forRootAsync`-only token uniqueness. Mirrors the
+     * pattern used in `TransactionalModule.forRootAsync` — every
+     * async call gets a unique provider symbol so consecutive calls
+     * don't collide.
+     */
+    static asyncCounter = 0;
+    /**
+     * Test-only — drop the managed-DataSources `WeakSet` so cached
+     * repositories from a prior test fall through to their original
+     * (autocommit) manager. Prototype-level patches are NOT removed;
+     * they were installed once-and-stay, by design (see
+     * `repository-patches.ts` JSDoc). Per-instance `DataSource`
+     * patches survive on those `DataSource` instances — tests that
+     * destroy and recreate the `DataSource` between cases (the
+     * typical pattern) are unaffected.
+     *
+     * Re-registering the SAME `DataSource` after a reset is safe:
+     * `patchDataSourceInstance` is idempotent via a marker symbol,
+     * and `markAsManaged` re-stamps the same name harmlessly.
+     *
+     * Production code should never call this.
+     *
+     * @internal
+     */
+    static resetForTesting() {
+        (0, patching_1.resetPatchingForTesting)();
+        this.asyncCounter = 0;
+    }
+    /**
+     * Synchronous registration. Each call binds one DataSource (by
+     * name) to the transactional infrastructure. Patches are
+     * activated idempotently on the first call.
+     *
+     * @example Default DataSource
+     * ```ts
+     * TypeOrmTransactionalModule.forRoot()
+     * ```
+     *
+     * @example Named DataSource
+     * ```ts
+     * TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' })
+     * ```
+     */
+    static forRoot(options = {}) {
+        const dataSourceName = options.dataSource ?? 'default';
+        const dataSourceToken = (0, typeorm_1.getDataSourceToken)(dataSourceName);
+        const adapterToken = (0, core_2.getTransactionalAdapterToken)(dataSourceName);
+        const adapterProvider = {
+            provide: adapterToken,
+            useFactory: (ds, registry) => registerManagedDataSource({
+                dataSource: ds,
+                dataSourceName,
+                isDefault: options.isDefault ?? false,
+                registry,
+            }),
+            inject: [dataSourceToken, core_2.ADAPTER_REGISTRY],
+        };
+        return {
+            module: TypeOrmTransactionalModule_1,
+            providers: [adapterProvider],
+            exports: [adapterToken],
+        };
+    }
+    /**
+     * Asynchronous registration. Resolves
+     * {@link TypeOrmTransactionalOptions} via a NestJS-style async
+     * factory before binding the adapter. See
+     * {@link TypeOrmTransactionalAsyncOptions} for the per-DS-token
+     * limitation.
+     *
+     * @example
+     * ```ts
+     * TypeOrmTransactionalModule.forRootAsync({
+     *   imports: [ConfigModule],
+     *   inject: [ConfigService],
+     *   useFactory: (cfg: ConfigService) => ({
+     *     dataSource: cfg.get('DATA_SOURCE_NAME'),
+     *     isDefault: true,
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options) {
+        const id = this.asyncCounter++;
+        const asyncToken = ASYNC_OPTIONS_TOKEN(id);
+        const asyncOptionsProvider = {
+            provide: asyncToken,
+            useFactory: options.useFactory,
+            inject: options.inject ? [...options.inject] : undefined,
+        };
+        // The DataSource token depends on the async-resolved name, so
+        // we cannot put `getDataSourceToken(...)` into the registration
+        // provider's `inject` array statically. We also cannot resolve
+        // it inside a `useFactory` provider via `ModuleRef` — at the
+        // time `useFactory` providers run, NestJS has not yet
+        // initialised siblings whose DI dependencies do not point at
+        // them, so `@nestjs/typeorm`'s DataSource provider may still be
+        // a pending Promise. The historical use of `moduleRef.resolve`
+        // (or even `moduleRef.get`) cascaded into a hard-to-diagnose
+        // `Invalid value used in weak set` followed by
+        // `this.postgres.Pool is not a constructor` when paired with
+        // `TypeOrmModule.forRootAsync` (Phase 14.8e Convention #22).
+        //
+        // The robust pattern is `OnModuleInit`: by the time the hook
+        // runs, every provider in the module tree has been instantiated
+        // (including async DataSource factories from `@nestjs/typeorm`).
+        // `moduleRef.get(...)` then returns the real DataSource
+        // instance, and `registerManagedDataSource` succeeds.
+        const RegistrationCls = createAsyncRegistrationClass(id, asyncToken);
+        const providers = [asyncOptionsProvider, RegistrationCls];
+        return {
+            module: TypeOrmTransactionalModule_1,
+            imports: options.imports ?? [],
+            providers,
+            // Nothing exports `registrationToken` for this path — the
+            // service runs side-effect-only via OnModuleInit. Export
+            // the registration class so consumers wanting explicit
+            // ordering can depend on it being initialised.
+            exports: [RegistrationCls],
+        };
+    }
+};
+exports.TypeOrmTransactionalModule = TypeOrmTransactionalModule;
+exports.TypeOrmTransactionalModule = TypeOrmTransactionalModule = TypeOrmTransactionalModule_1 = __decorate([
+    (0, common_1.Module)({})
+], TypeOrmTransactionalModule);
+/**
+ * Generate a unique `OnModuleInit` registration class per
+ * `forRootAsync` call. The class injects the async-resolved
+ * `TypeOrmTransactionalOptions`, the global `AdapterRegistry`, and
+ * `ModuleRef`. In `onModuleInit()` it resolves the actual
+ * `DataSource` (every DI provider is ready by then) and calls
+ * {@link registerManagedDataSource}.
+ *
+ * Uniqueness per `id` matters because each `forRootAsync` call
+ * registers its OWN provider class — multiple async registrations
+ * in the same app must not collide on the same constructor token.
+ *
+ * Module-level `Reflect` metadata required by NestJS DI is set up
+ * via `@Inject(asyncToken)` on the constructor parameter.
+ */
+function createAsyncRegistrationClass(id, asyncToken) {
+    let TypeOrmTransactionalAsyncRegistration = class TypeOrmTransactionalAsyncRegistration {
+        resolved;
+        registry;
+        moduleRef;
+        constructor(resolved, registry, moduleRef) {
+            this.resolved = resolved;
+            this.registry = registry;
+            this.moduleRef = moduleRef;
+        }
+        onModuleInit() {
+            const dataSourceName = this.resolved.dataSource ?? 'default';
+            const dataSourceToken = (0, typeorm_1.getDataSourceToken)(dataSourceName);
+            const ds = this.moduleRef.get(dataSourceToken, {
+                strict: false,
+            });
+            registerManagedDataSource({
+                dataSource: ds,
+                dataSourceName,
+                isDefault: this.resolved.isDefault ?? false,
+                registry: this.registry,
+            });
+        }
+    };
+    TypeOrmTransactionalAsyncRegistration = __decorate([
+        (0, common_1.Injectable)(),
+        __param(0, (0, common_1.Inject)(asyncToken)),
+        __param(1, (0, common_1.Inject)(core_2.ADAPTER_REGISTRY)),
+        __metadata("design:paramtypes", [Object, core_2.AdapterRegistry,
+            core_1.ModuleRef])
+    ], TypeOrmTransactionalAsyncRegistration);
+    // Distinguish each generated class so a TypeScript reflection /
+    // logging consumer can tell them apart. Class identity itself is
+    // already unique per call (each `class` expression yields a fresh
+    // constructor), but a meaningful `name` helps with stack traces.
+    Object.defineProperty(TypeOrmTransactionalAsyncRegistration, 'name', {
+        value: `TypeOrmTransactionalAsyncRegistration_${id}`,
+    });
+    return TypeOrmTransactionalAsyncRegistration;
+}
+/**
+ * Common registration path used by both `forRoot`'s factory
+ * provider and the `forRootAsync` `OnModuleInit` registration
+ * class. Centralises the four-step dance of patch-on-first-use,
+ * mark-as-managed, instance-patch, and register-with-AdapterRegistry
+ * so the two entry points cannot drift out of step.
+ */
+function registerManagedDataSource(args) {
+    const { dataSource, dataSourceName, isDefault, registry } = args;
+    (0, patching_1.applyAllPatches)();
+    (0, patching_1.markAsManaged)(dataSource, dataSourceName);
+    (0, patching_1.patchDataSourceInstance)(dataSource);
+    const adapter = new typeorm_adapter_1.TypeOrmTransactionAdapter(dataSource, dataSourceName);
+    registry.register({ adapterName: 'typeorm', instanceName: dataSourceName, adapter }, isDefault);
+    return adapter;
+}
+//# sourceMappingURL=typeorm-transactional.module.js.map

package/dist/module/typeorm-transactional.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm-transactional.module.js","sourceRoot":"","sources":["../../src/module/typeorm-transactional.module.ts"],"names":[],"mappings":"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"}

package/dist/patching/data-source-patches.d.ts

@@ -0,0 +1,48 @@
+import type { DataSource } from 'typeorm';
+/**
+ * Apply per-instance patches to a single `DataSource` at the time
+ * it's registered as managed. Three patches go on the instance
+ * itself (NOT the prototype) because TypeORM sets the affected
+ * properties as own-properties in the `DataSource` constructor —
+ * patching `DataSource.prototype` would be shadowed by every
+ * instance.
+ *
+ * Patches applied:
+ *
+ * 1. `dataSource.manager` — replaced with a getter/setter pair.
+ *    The getter returns the active transactional `EntityManager`
+ *    when one is registered for this dataSource's name; otherwise
+ *    falls back to the original (closure-captured) manager. The
+ *    setter is preserved so any TypeORM-internal reassignment
+ *    updates the captured original.
+ *
+ * 2. `dataSource.query(sql, params, queryRunner?)` — wrapped to
+ *    default the `queryRunner` argument from the active
+ *    transactional EntityManager when one is available. Without
+ *    this wrap, raw SQL via `dataSource.query(...)` would always
+ *    run on the autocommit pool, even inside a `@Transactional()`.
+ *
+ * 3. `dataSource.createQueryBuilder(entity?, alias?, queryRunner?)`
+ *    — wrapped likewise, so query builders created via the
+ *    DataSource (rather than via a Repository) also pick up the
+ *    transactional QueryRunner.
+ *
+ * `dataSource.transaction(...)` is NOT patched — it delegates to
+ * `manager.transaction(...)` internally (which already uses the
+ * patched `manager` getter), and re-routing it through any of our
+ * machinery would just be a no-op forward.
+ *
+ * **Idempotent**: a marker symbol ({@link TYPEORM_DATA_SOURCE_PATCHED})
+ * is stamped on each patched DataSource so that double registration
+ * (e.g. test reset followed by re-registration of the same
+ * DataSource) does not stack getter/setter pairs. Calling this
+ * function on an already-patched DataSource is a no-op.
+ *
+ * Note: the patches are applied to a specific `DataSource` instance
+ * and survive on that instance until garbage collection. There is
+ * no per-instance revert API; tests that need a clean slate
+ * destroy the DataSource and create a fresh one (the standard
+ * pattern; integration tests already do this in `afterAll`).
+ */
+export declare function patchDataSourceInstance(dataSource: DataSource): void;
+//# sourceMappingURL=data-source-patches.d.ts.map

package/dist/patching/data-source-patches.js

@@ -0,0 +1,139 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment */
+// The patching machinery overrides instance-level methods on
+// TypeORM `DataSource` objects (`manager` getter/setter,
+// `query`, `createQueryBuilder`) via runtime property descriptors.
+// The inputs and outputs are intentionally typed as `any` because
+// TypeORM's generic signatures don't survive the wrap; the runtime
+// contract is documented in JSDoc above each patch. File-level
+// disable keeps the patch code readable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchDataSourceInstance = patchDataSourceInstance;
+const managed_registry_1 = require("./managed-registry");
+const symbols_1 = require("./symbols");
+/**
+ * Apply per-instance patches to a single `DataSource` at the time
+ * it's registered as managed. Three patches go on the instance
+ * itself (NOT the prototype) because TypeORM sets the affected
+ * properties as own-properties in the `DataSource` constructor —
+ * patching `DataSource.prototype` would be shadowed by every
+ * instance.
+ *
+ * Patches applied:
+ *
+ * 1. `dataSource.manager` — replaced with a getter/setter pair.
+ *    The getter returns the active transactional `EntityManager`
+ *    when one is registered for this dataSource's name; otherwise
+ *    falls back to the original (closure-captured) manager. The
+ *    setter is preserved so any TypeORM-internal reassignment
+ *    updates the captured original.
+ *
+ * 2. `dataSource.query(sql, params, queryRunner?)` — wrapped to
+ *    default the `queryRunner` argument from the active
+ *    transactional EntityManager when one is available. Without
+ *    this wrap, raw SQL via `dataSource.query(...)` would always
+ *    run on the autocommit pool, even inside a `@Transactional()`.
+ *
+ * 3. `dataSource.createQueryBuilder(entity?, alias?, queryRunner?)`
+ *    — wrapped likewise, so query builders created via the
+ *    DataSource (rather than via a Repository) also pick up the
+ *    transactional QueryRunner.
+ *
+ * `dataSource.transaction(...)` is NOT patched — it delegates to
+ * `manager.transaction(...)` internally (which already uses the
+ * patched `manager` getter), and re-routing it through any of our
+ * machinery would just be a no-op forward.
+ *
+ * **Idempotent**: a marker symbol ({@link TYPEORM_DATA_SOURCE_PATCHED})
+ * is stamped on each patched DataSource so that double registration
+ * (e.g. test reset followed by re-registration of the same
+ * DataSource) does not stack getter/setter pairs. Calling this
+ * function on an already-patched DataSource is a no-op.
+ *
+ * Note: the patches are applied to a specific `DataSource` instance
+ * and survive on that instance until garbage collection. There is
+ * no per-instance revert API; tests that need a clean slate
+ * destroy the DataSource and create a fresh one (the standard
+ * pattern; integration tests already do this in `afterAll`).
+ */
+function patchDataSourceInstance(dataSource) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (dataSource[symbols_1.TYPEORM_DATA_SOURCE_PATCHED] === true) {
+        return;
+    }
+    // (1) `manager` — getter/setter on the instance.
+    let originalManager = dataSource.manager;
+    Object.defineProperty(dataSource, 'manager', {
+        configurable: true,
+        get() {
+            const dsName = (0, managed_registry_1.getManagedDataSourceName)(dataSource);
+            if (dsName === undefined) {
+                return originalManager;
+            }
+            const active = (0, managed_registry_1.getActiveEntityManager)(dsName);
+            return active ?? originalManager;
+        },
+        set(manager) {
+            originalManager = manager;
+        },
+    });
+    // (2) `query(sql, params, queryRunner?)` — pick up the active QR
+    // when none is supplied. The wrapper bypasses the generic type
+    // shape of `DataSource.query` via `any` casts; the runtime
+    // contract is unchanged (sql first, params second, qr third).
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const originalQuery = dataSource.query.bind(dataSource);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dataSource.query = function patchedQuery(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ...args) {
+        if (args.length >= 3) {
+            // Caller passed a queryRunner explicitly — respect it.
+            return originalQuery(...args);
+        }
+        const activeQueryRunner = pickActiveQueryRunner(this);
+        if (activeQueryRunner !== undefined) {
+            return originalQuery(args[0], args[1], activeQueryRunner);
+        }
+        return originalQuery(...args);
+    };
+    // (3) `createQueryBuilder(entity?, alias?, queryRunner?)` —
+    // mirror logic for QB creation.
+    const originalCreateQueryBuilder = dataSource.createQueryBuilder.bind(dataSource);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dataSource.createQueryBuilder = function patchedCreateQueryBuilder(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ...args) {
+        const activeQueryRunner = pickActiveQueryRunner(this);
+        if (args.length === 0) {
+            return activeQueryRunner !== undefined
+                ? originalCreateQueryBuilder(activeQueryRunner)
+                : originalCreateQueryBuilder();
+        }
+        if (args.length >= 3) {
+            return originalCreateQueryBuilder(...args);
+        }
+        if (activeQueryRunner !== undefined) {
+            return originalCreateQueryBuilder(args[0], args[1], activeQueryRunner);
+        }
+        return originalCreateQueryBuilder(...args);
+    };
+    // Stamp marker so re-entry is a no-op.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dataSource[symbols_1.TYPEORM_DATA_SOURCE_PATCHED] = true;
+}
+/**
+ * Helper — look up the active transactional EntityManager for this
+ * DataSource and return its `queryRunner` (or `undefined` if no
+ * transaction is active). Centralised so the `query` and
+ * `createQueryBuilder` patches share one resolution rule.
+ */
+function pickActiveQueryRunner(ds) {
+    const dsName = (0, managed_registry_1.getManagedDataSourceName)(ds);
+    if (dsName === undefined) {
+        return undefined;
+    }
+    const active = (0, managed_registry_1.getActiveEntityManager)(dsName);
+    return active?.queryRunner;
+}
+//# sourceMappingURL=data-source-patches.js.map

package/dist/patching/data-source-patches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-source-patches.js","sourceRoot":"","sources":["../../src/patching/data-source-patches.ts"],"names":[],"mappings":"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"}