@nestjs-transactional/typeorm 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Igor Golovanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,361 @@
+# @nestjs-transactional/typeorm
+
+[![npm version](https://img.shields.io/npm/v/%40nestjs-transactional%2Ftypeorm/alpha?style=flat-square&label=npm)](https://www.npmjs.com/package/@nestjs-transactional/typeorm)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/LICENSE)
+
+TypeORM adapter for [`@nestjs-transactional/core`](../core).
+
+## Overview
+
+- `TypeOrmTransactionAdapter` — implements the core
+  `TransactionAdapter` SPI over TypeORM's `DataSource`. Handles
+  BEGIN / COMMIT / ROLLBACK via `DataSource.transaction(...)` and
+  issues raw `SAVEPOINT` / `ROLLBACK TO SAVEPOINT` /
+  `RELEASE SAVEPOINT` SQL for nested transactions.
+- **Transparent transactional repositories** —
+  `@InjectRepository(Entity)` instances,
+  `@InjectEntityManager() em.getRepository(E)`,
+  `@InjectDataSource() ds.manager.save(...)`, and
+  `ds.getRepository(E).save(...)` automatically dispatch through the
+  active `@Transactional()` scope's `EntityManager`. No
+  `getCurrentEntityManager()` boilerplate. Custom repositories via
+  `Repository.extend(...)` and `TreeRepository` work transparently.
+  See [Transparent transactional behaviour](#transparent-transactional-behaviour)
+  below.
+- `getCurrentEntityManager(dataSource?, fallback?)` — escape-hatch
+  helper that returns the transaction-aware `EntityManager` from the
+  current async context (or falls back to `dataSource.manager`
+  outside a transaction). Mostly needed for the documented
+  limitations below; standard injection paths cover everything else.
+- `isInTransaction(dataSource?)` — predicate for the current
+  context.
+- `TypeOrmTransactionalModule.forRoot({ dataSource?, isDefault? })` —
+  NestJS dynamic module that activates the transparent patches and
+  registers an adapter with the core `AdapterRegistry`. The
+  `DataSource` itself resolves from DI under
+  `getDataSourceToken(dataSource)` — the same convention
+  `@nestjs/typeorm` uses for `@InjectRepository(E, dataSource)`.
+- `TypeOrmTransactionalModule.forRootAsync({ useFactory, inject?, imports? })`
+  — async variant for `ConfigService`-driven setups. Registers via
+  `OnModuleInit` to defer DataSource resolution past `@nestjs/typeorm`'s
+  async DataSource provider settling
+  ([Convention #22](../../docs/status/conventions.md)).
+- Multi-DataSource: call `forRoot` once per dataSource. Mirrors
+  [`OutboxModule`](../outbox) (ADR-019) and
+  [`TransactionalModule`](../core).
+
+## Installation
+
+```bash
+pnpm add @nestjs-transactional/typeorm @nestjs-transactional/core typeorm @nestjs/typeorm reflect-metadata
+```
+
+## Quick start
+
+Minimal single-DataSource setup:
+
+```ts
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { TransactionalModule } from '@nestjs-transactional/core';
+import { TypeOrmTransactionalModule } from '@nestjs-transactional/typeorm';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({
+      type: 'postgres',
+      url: process.env.DATABASE_URL,
+      entities: [User],
+      synchronize: false,
+    }),
+    TypeOrmModule.forFeature([User]),
+
+    TransactionalModule.forRoot({ isGlobal: true }),
+    TypeOrmTransactionalModule.forRoot(),
+  ],
+})
+export class AppModule {}
+```
+
+**Import order matters** — `TransactionalModule.forRoot({ isGlobal: true })`
+must be present (with `isGlobal`) so the `AdapterRegistry` is visible
+inside `TypeOrmTransactionalModule`'s DI scope. The actual
+`DataSource` is resolved via `@nestjs/typeorm`'s
+`getDataSourceToken(name)` — `TypeOrmModule.forRoot(...)` registers
+it globally, so `TypeOrmTransactionalModule.forRoot` finds it
+automatically.
+
+## Transparent transactional behaviour
+
+Once the module is imported, every Repository reachable through the
+standard `@nestjs/typeorm` injection paths automatically dispatches
+through the active `@Transactional()` scope. No
+`getCurrentEntityManager()` calls in user code:
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Transactional } from '@nestjs-transactional/core';
+import { Repository } from 'typeorm';
+import { Order } from './order.entity';
+
+@Injectable()
+export class OrderService {
+  constructor(
+    @InjectRepository(Order)
+    private readonly orderRepo: Repository<Order>,
+  ) {}
+
+  @Transactional()
+  async placeOrder(dto: PlaceOrderDto): Promise<Order> {
+    // `orderRepo.save(...)` automatically uses the transactional
+    // EntityManager. If the method throws, the save rolls back.
+    // Outside a @Transactional scope, the same call autocommits.
+    return this.orderRepo.save(dto);
+  }
+}
+```
+
+Supported transparent patterns:
+
+- `@InjectRepository(Entity) repo` — the headline case.
+- `@InjectEntityManager() em.getRepository(E).save(...)`.
+- `@InjectDataSource() ds.getRepository(E).save(...)`.
+- `@InjectDataSource() ds.manager.save(Entity, ...)` (the patched
+  DataSource manager getter routes through the active EM).
+- Custom repositories via `Repository.extend(...)`.
+- `TreeRepository` and `MongoRepository` (inherit from `Repository`).
+
+The mechanism is prototype-level patching modelled on the
+`typeorm-transactional` library; patches install at module-load
+time so they cover Repositories constructed by any DI factory,
+regardless of resolution order.
+
+### Documented limitations
+
+Two patterns are NOT covered by the patches and require an escape
+hatch:
+
+1. **`@InjectEntityManager() em.save(Entity, ...)` direct call** is
+   NOT transactional. The patches cover `em.getRepository(E).save(...)`
+   (the typical pattern) but not direct method calls on the injected
+   `EntityManager`. Use the Repository pattern instead, or call
+   `getCurrentEntityManager()`:
+
+   ```ts
+   @Transactional()
+   async createUser(name: string) {
+     // Option A — Repository pattern (recommended).
+     return this.em.getRepository(User).save({ name });
+
+     // Option B — escape hatch.
+     // const em = getCurrentEntityManager();
+     // return em.save(User, { name });
+   }
+   ```
+
+2. **`BaseEntity` static methods** (`User.save(...)` etc.) are NOT
+   supported. The `BaseEntity.useDataSource(...)` API stores a
+   captured DataSource reference that bypasses the patches. Use the
+   Repository pattern.
+
+The escape hatch:
+
+```ts
+import { getCurrentEntityManager } from '@nestjs-transactional/typeorm';
+
+@Injectable()
+export class RawSqlService {
+  constructor(@InjectDataSource() private readonly ds: DataSource) {}
+
+  @Transactional()
+  async runRawSql() {
+    // Pass `ds` as fallback so the helper returns ds.manager when
+    // no transaction is active (autocommit). Inside a tx, returns
+    // the transactional EM.
+    const em = getCurrentEntityManager('default', this.ds);
+    await em.query(
+      'UPDATE accounts SET balance = balance - $1 WHERE id = $2',
+      [100, 1],
+    );
+  }
+}
+```
+
+## Multi-DataSource
+
+```ts
+@Module({
+  imports: [
+    TypeOrmModule.forRoot({ name: 'default', /* ... */ }),
+    TypeOrmModule.forRoot({ name: 'billing',  /* ... */ }),
+
+    TransactionalModule.forRoot({ isGlobal: true }),
+    TypeOrmTransactionalModule.forRoot({ isDefault: true }),       // 'default'
+    TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }), // 'billing'
+  ],
+})
+export class AppModule {}
+```
+
+Target a specific dataSource in a transactional method:
+
+```ts
+import { Transactional } from '@nestjs-transactional/core';
+
+@Injectable()
+export class BillingService {
+  constructor(
+    @InjectRepository(Invoice, 'billing')
+    private readonly invoiceRepo: Repository<Invoice>,
+  ) {}
+
+  @Transactional({ dataSource: 'billing' })
+  async chargeCard(/* ... */) {
+    // Repository is bound to 'billing' DS — saves go to billing.
+    return this.invoiceRepo.save(/* ... */);
+  }
+}
+```
+
+**Cross-DS isolation (DD-023)**: a Repository bound to dataSource A
+inside a `@Transactional({ dataSource: 'B' })` method autocommits —
+its patched `manager` getter looks up the active transaction for
+dataSource A, finds none, and falls back to its captured original
+manager. Distributed transactions across dataSources are explicitly
+NOT supported; cross-DS atomicity goes through the outbox.
+
+Each `forRoot` call registers its adapter under
+`typeorm:${dataSource}` in the core `AdapterRegistry`.
+`TransactionManager` routes based on `options.dataSource`.
+
+## Async configuration
+
+```ts
+@Module({
+  imports: [
+    ConfigModule,
+    TypeOrmModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: (cfg: ConfigService) => ({
+        type: 'postgres',
+        url: cfg.get('DATABASE_URL'),
+        entities: [User],
+      }),
+    }),
+
+    TransactionalModule.forRoot({ isGlobal: true }),
+    TypeOrmTransactionalModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: (cfg: ConfigService) => ({
+        dataSource: cfg.get('DATA_SOURCE_NAME', 'default'),
+        isDefault: true,
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+`forRootAsync` defers resolution of the dataSource name until the
+factory runs. Per-DS DI tokens (`getTransactionalAdapterToken(ds)`)
+are NOT registered in the async path because NestJS provider tokens
+must be declared statically — if you need direct adapter injection
+by per-DS token, use sync `forRoot({ dataSource })` instead.
+
+The async path uses an `OnModuleInit`-driven registration class so
+the DataSource resolves correctly even when paired with
+`TypeOrmModule.forRootAsync` (whose own DataSource provider is
+async). Pinned by
+[`packages/typeorm/test/integration/forrootasync.integration.spec.ts`](test/integration/forrootasync.integration.spec.ts).
+
+## Testing
+
+### Unit tests — in-memory SQLite
+
+For fast unit tests that don't need a real database, use TypeORM's
+`sqljs` driver:
+
+```ts
+import { DataSource } from 'typeorm';
+import { TypeOrmTransactionAdapter } from '@nestjs-transactional/typeorm';
+
+const ds = new DataSource({
+  type: 'sqljs',
+  synchronize: true,
+  entities: [YourEntity],
+});
+await ds.initialize();
+
+const adapter = new TypeOrmTransactionAdapter(ds, 'default');
+```
+
+### Integration tests — testcontainers-node + real Postgres
+
+Bundled helper for real Postgres integration:
+
+```ts
+import {
+  startPostgresContainer,
+  stopPostgresContainer,
+  createAdditionalDatabase,
+} from '@nestjs-transactional/typeorm/test/setup-testcontainers';
+
+let ctx;
+beforeAll(async () => {
+  ctx = await startPostgresContainer({ entities: [User], synchronize: true });
+});
+afterAll(async () => {
+  await stopPostgresContainer(ctx);
+});
+
+// Multi-DS: a second database inside the same container.
+const secondary = await createAdditionalDatabase(ctx, 'billing_test', {
+  entities: [User],
+  synchronize: true,
+});
+```
+
+Run integration tests:
+
+```bash
+pnpm --filter @nestjs-transactional/typeorm test:integration
+```
+
+The bundled `docker-compose.yml` is for manual local use (`psql`
+against a persistent instance). Testcontainers manages its own
+containers and does not require compose.
+
+## Savepoints and NESTED propagation
+
+When a method uses `PropagationMode.NESTED` from inside an existing
+TypeORM transaction, the adapter issues a `SAVEPOINT sp_<uuid-30>`
+statement. Rollback rolls back to the savepoint; the outer
+transaction continues. Savepoint names are at most 33 characters
+long — valid on Postgres, MySQL, MariaDB, SQLite, and Oracle's
+identifier limit.
+
+## Worked examples
+
+- [`basic-transactional`](../../examples/basic-transactional) —
+  `@Transactional()` on `@InjectRepository`, single DataSource.
+  Transparent repository showcase.
+- [`multi-datasource-basic`](../../examples/multi-datasource-basic)
+  — two DataSources with `@Transactional({ dataSource })`, no
+  outbox.
+- [`read-write-separation`](../../examples/read-write-separation) —
+  master + replica, only the master gets
+  `TypeOrmTransactionalModule`.
+- [`async-config-from-environment`](../../examples/async-config-from-environment)
+  — `TypeOrmTransactionalModule.forRootAsync` end-to-end with
+  `ConfigService` + Joi profiles.
+- [`e-commerce-orders`](../../examples/e-commerce-orders) —
+  three-DataSource flagship combining transparent repositories +
+  per-DS outbox + CQRS + REST + Kafka externalization.
+
+Full catalogue: [examples/README.md](../../examples/README.md).
+
+## Status
+
+Alpha. Public API may change between 0.x releases.

package/dist/adapter/typeorm.adapter.d.ts

@@ -0,0 +1,39 @@
+import type { TransactionAdapter, TransactionOptions } from '@nestjs-transactional/core';
+import type { DataSource } from 'typeorm';
+import type { TypeOrmTransactionHandle } from '../types/typeorm-transaction-handle';
+/**
+ * TypeORM implementation of {@link TransactionAdapter}. Delegates begin /
+ * commit / rollback to `DataSource.transaction` and emits raw `SAVEPOINT`
+ * SQL for nested transactions through the transactional
+ * {@link EntityManager}.
+ *
+ * Only `isolation` from {@link TransactionOptions} is forwarded today.
+ * `readOnly` and `timeout` are accepted for forward compatibility but do
+ * not yet map to per-dialect statements.
+ */
+export declare class TypeOrmTransactionAdapter implements TransactionAdapter<TypeOrmTransactionHandle> {
+    private readonly dataSource;
+    /**
+     * Adapter instance name this adapter was created for (e.g.
+     * `'primary'`, `'billing'`). Exposed so observability / diagnostics
+     * can correlate events back to the registered instance.
+     */
+    readonly instanceName: string;
+    readonly name = "typeorm";
+    constructor(dataSource: DataSource, 
+    /**
+     * Adapter instance name this adapter was created for (e.g.
+     * `'primary'`, `'billing'`). Exposed so observability / diagnostics
+     * can correlate events back to the registered instance.
+     */
+    instanceName: string);
+    /**
+     * Public dataSource name (DD-021). For TypeORM the dataSource name
+     * IS the adapter instance name — the constructor's `instanceName`
+     * argument is the single user-supplied identifier.
+     */
+    get dataSourceName(): string;
+    runInTransaction<T>(options: TransactionOptions, fn: (handle: TypeOrmTransactionHandle) => Promise<T>): Promise<T>;
+    runInSavepoint<T>(parent: TypeOrmTransactionHandle, fn: (handle: TypeOrmTransactionHandle) => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=typeorm.adapter.d.ts.map

package/dist/adapter/typeorm.adapter.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeOrmTransactionAdapter = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * TypeORM implementation of {@link TransactionAdapter}. Delegates begin /
+ * commit / rollback to `DataSource.transaction` and emits raw `SAVEPOINT`
+ * SQL for nested transactions through the transactional
+ * {@link EntityManager}.
+ *
+ * Only `isolation` from {@link TransactionOptions} is forwarded today.
+ * `readOnly` and `timeout` are accepted for forward compatibility but do
+ * not yet map to per-dialect statements.
+ */
+class TypeOrmTransactionAdapter {
+    dataSource;
+    instanceName;
+    name = 'typeorm';
+    constructor(dataSource, 
+    /**
+     * Adapter instance name this adapter was created for (e.g.
+     * `'primary'`, `'billing'`). Exposed so observability / diagnostics
+     * can correlate events back to the registered instance.
+     */
+    instanceName) {
+        this.dataSource = dataSource;
+        this.instanceName = instanceName;
+    }
+    /**
+     * Public dataSource name (DD-021). For TypeORM the dataSource name
+     * IS the adapter instance name — the constructor's `instanceName`
+     * argument is the single user-supplied identifier.
+     */
+    get dataSourceName() {
+        return this.instanceName;
+    }
+    async runInTransaction(options, fn) {
+        const isolation = mapIsolation(options.isolation);
+        const runner = async (entityManager) => {
+            const handle = {
+                id: (0, node_crypto_1.randomUUID)(),
+                adapterName: this.name,
+                entityManager,
+            };
+            return fn(handle);
+        };
+        if (isolation !== undefined) {
+            return this.dataSource.transaction(isolation, runner);
+        }
+        return this.dataSource.transaction(runner);
+    }
+    async runInSavepoint(parent, fn) {
+        const savepointName = `sp_${(0, node_crypto_1.randomUUID)().replace(/-/g, '_').substring(0, 30)}`;
+        await parent.entityManager.query(`SAVEPOINT ${savepointName}`);
+        try {
+            const result = await fn(parent);
+            await parent.entityManager.query(`RELEASE SAVEPOINT ${savepointName}`);
+            return result;
+        }
+        catch (err) {
+            await parent.entityManager.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+            throw err;
+        }
+    }
+}
+exports.TypeOrmTransactionAdapter = TypeOrmTransactionAdapter;
+/**
+ * Map the core's underscore-style {@link IsolationLevel} to TypeORM's
+ * space-separated string. Returns `undefined` when no level is set so the
+ * caller can invoke the `DataSource.transaction` overload that leaves the
+ * database default in place.
+ */
+function mapIsolation(level) {
+    if (level === undefined) {
+        return undefined;
+    }
+    return level.replace(/_/g, ' ');
+}
+//# sourceMappingURL=typeorm.adapter.js.map

package/dist/adapter/typeorm.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeorm.adapter.js","sourceRoot":"","sources":["../../src/adapter/typeorm.adapter.ts"],"names":[],"mappings":";;;AAAA,6CAAyC;AAsBzC;;;;;;;;;GASG;AACH,MAAa,yBAAyB;IAIjB;IAMR;IATF,IAAI,GAAG,SAAS,CAAC;IAE1B,YACmB,UAAsB;IACvC;;;;OAIG;IACM,YAAoB;QANZ,eAAU,GAAV,UAAU,CAAY;QAM9B,iBAAY,GAAZ,YAAY,CAAQ;IAC5B,CAAC;IAEJ;;;;OAIG;IACH,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,gBAAgB,CACpB,OAA2B,EAC3B,EAAoD;QAEpD,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAElD,MAAM,MAAM,GAAG,KAAK,EAAE,aAA4B,EAAc,EAAE;YAChE,MAAM,MAAM,GAA6B;gBACvC,EAAE,EAAE,IAAA,wBAAU,GAAE;gBAChB,WAAW,EAAE,IAAI,CAAC,IAAI;gBACtB,aAAa;aACd,CAAC;YACF,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC,CAAC;QAEF,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,cAAc,CAClB,MAAgC,EAChC,EAAoD;QAEpD,MAAM,aAAa,GAAG,MAAM,IAAA,wBAAU,GAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QAE/E,MAAM,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,aAAa,aAAa,EAAE,CAAC,CAAC;QAE/D,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;YAChC,MAAM,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,qBAAqB,aAAa,EAAE,CAAC,CAAC;YACvE,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,yBAAyB,aAAa,EAAE,CAAC,CAAC;YAC3E,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;CACF;AA5DD,8DA4DC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,KAAiC;IACrD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAA0B,CAAC;AAC3D,CAAC"}

package/dist/helpers/get-entity-manager.d.ts

@@ -0,0 +1,27 @@
+import type { DataSource, EntityManager } from 'typeorm';
+/**
+ * Return the TypeORM {@link EntityManager} bound to the currently active
+ * transaction on the given adapter instance. Repositories and services
+ * call this to stay inside the surrounding `@Transactional` scope without
+ * having to thread the EntityManager through their arguments.
+ *
+ * Resolution order:
+ * 1. If a transaction is active on `typeorm:${adapterInstance}`, return
+ *    its EntityManager — every write goes through the transaction.
+ * 2. Otherwise, if `fallback` is provided, return `fallback.manager` —
+ *    writes execute autocommit.
+ * 3. Otherwise throw {@link IllegalTransactionStateError}. Passing no
+ *    fallback is a deliberate assertion that the caller MUST be inside
+ *    a transaction.
+ *
+ * @param adapterInstance - Adapter instance name. Defaults to `'default'`.
+ * @param fallback - DataSource used when no transaction is active.
+ */
+export declare function getCurrentEntityManager(adapterInstance?: string, fallback?: DataSource): EntityManager;
+/**
+ * Predicate: is there an active TypeORM transaction on this adapter
+ * instance? Useful to guard side effects that must only fire inside a
+ * transaction.
+ */
+export declare function isInTransaction(adapterInstance?: string): boolean;
+//# sourceMappingURL=get-entity-manager.d.ts.map

package/dist/helpers/get-entity-manager.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentEntityManager = getCurrentEntityManager;
+exports.isInTransaction = isInTransaction;
+const core_1 = require("@nestjs-transactional/core");
+/**
+ * Compose the `TransactionContext` lookup key for the TypeORM adapter.
+ * Must match the `${adapterName}:${instanceName}` format that
+ * `TransactionManager` in core writes under. Keeping it private forces
+ * all helper call-sites to go through the same builder.
+ */
+function typeOrmContextKey(adapterInstance) {
+    return `typeorm:${adapterInstance}`;
+}
+/**
+ * Return the TypeORM {@link EntityManager} bound to the currently active
+ * transaction on the given adapter instance. Repositories and services
+ * call this to stay inside the surrounding `@Transactional` scope without
+ * having to thread the EntityManager through their arguments.
+ *
+ * Resolution order:
+ * 1. If a transaction is active on `typeorm:${adapterInstance}`, return
+ *    its EntityManager — every write goes through the transaction.
+ * 2. Otherwise, if `fallback` is provided, return `fallback.manager` —
+ *    writes execute autocommit.
+ * 3. Otherwise throw {@link IllegalTransactionStateError}. Passing no
+ *    fallback is a deliberate assertion that the caller MUST be inside
+ *    a transaction.
+ *
+ * @param adapterInstance - Adapter instance name. Defaults to `'default'`.
+ * @param fallback - DataSource used when no transaction is active.
+ */
+function getCurrentEntityManager(adapterInstance = 'default', fallback) {
+    const active = core_1.TransactionContext.getActiveTransaction(typeOrmContextKey(adapterInstance));
+    if (active !== undefined) {
+        return active.handle.entityManager;
+    }
+    if (fallback !== undefined) {
+        return fallback.manager;
+    }
+    throw new core_1.IllegalTransactionStateError(`No active transaction for 'typeorm:${adapterInstance}' and no fallback DataSource ` +
+        `provided. Either wrap the call with @Transactional() or pass a DataSource as fallback.`);
+}
+/**
+ * Predicate: is there an active TypeORM transaction on this adapter
+ * instance? Useful to guard side effects that must only fire inside a
+ * transaction.
+ */
+function isInTransaction(adapterInstance = 'default') {
+    return core_1.TransactionContext.getActiveTransaction(typeOrmContextKey(adapterInstance)) !== undefined;
+}
+//# sourceMappingURL=get-entity-manager.js.map

package/dist/helpers/get-entity-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-entity-manager.js","sourceRoot":"","sources":["../../src/helpers/get-entity-manager.ts"],"names":[],"mappings":";;AAiCA,0DAkBC;AAOD,0CAEC;AA5DD,qDAA8F;AAK9F;;;;;GAKG;AACH,SAAS,iBAAiB,CAAC,eAAuB;IAChD,OAAO,WAAW,eAAe,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,uBAAuB,CACrC,eAAe,GAAG,SAAS,EAC3B,QAAqB;IAErB,MAAM,MAAM,GAAG,yBAAkB,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC,CAAC;IAE3F,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAQ,MAAM,CAAC,MAAmC,CAAC,aAAa,CAAC;IACnE,CAAC;IAED,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;QAC3B,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC1B,CAAC;IAED,MAAM,IAAI,mCAA4B,CACpC,sCAAsC,eAAe,+BAA+B;QAClF,wFAAwF,CAC3F,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,SAAgB,eAAe,CAAC,eAAe,GAAG,SAAS;IACzD,OAAO,yBAAkB,CAAC,oBAAoB,CAAC,iBAAiB,CAAC,eAAe,CAAC,CAAC,KAAK,SAAS,CAAC;AACnG,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types/typeorm-transaction-handle';
+export * from './adapter/typeorm.adapter';
+export * from './helpers/get-entity-manager';
+export * from './module/typeorm-transactional.module';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/typeorm-transaction-handle"), exports);
+__exportStar(require("./adapter/typeorm.adapter"), exports);
+__exportStar(require("./helpers/get-entity-manager"), exports);
+__exportStar(require("./module/typeorm-transactional.module"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,qEAAmD;AACnD,4DAA0C;AAC1C,+DAA6C;AAC7C,wEAAsD"}