@nestjs-transactional/typeorm 1.0.0-alpha.3 → 1.0.0

package/README.md

@@ -1,76 +1,41 @@
 # @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)
+[![npm version](https://img.shields.io/npm/v/%40nestjs-transactional%2Ftypeorm?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
+TypeORM adapter for
+[`@nestjs-transactional/core`](https://www.npmjs.com/package/@nestjs-transactional/core).
 
-```bash
-pnpm add @nestjs-transactional/typeorm @nestjs-transactional/core typeorm @nestjs/typeorm reflect-metadata
+Two things come with it. The adapter itself, which maps `@Transactional()`
+onto TypeORM's transactions and savepoints — and **transparent
+transactional repositories**: your existing `@InjectRepository(Order)`
+instances start honouring the active transaction on their own, with no
+change to the code that uses them.
+
+```ts
+@Injectable()
+export class OrderService {
+  constructor(@InjectRepository(Order) private readonly orders: Repository<Order>) {}
+
+  @Transactional()
+  async place(dto: PlaceOrderDto) {
+    // Runs in the transaction. Rolls back if anything below throws.
+    // Outside a @Transactional method, the same call autocommits.
+    return this.orders.save(dto);
+  }
+}
 ```
 
-## Compatibility
+No `getCurrentEntityManager()`, no passing an `EntityManager` down
+through service layers, no separate "transactional" repository type.
 
-| Peer                                | Supported range            |
-| ----------------------------------- | -------------------------- |
-| Node.js                             | `>=22.13.0`                |
-| `typeorm`                           | `^0.3.0 \|\| ^1.0.0`       |
-| `@nestjs/typeorm`                   | `^10.0.0 \|\| ^11.0.0`     |
-| `@nestjs/common` / `@nestjs/core`   | `^10.0.0 \|\| ^11.0.0`     |
-| `reflect-metadata`                  | `^0.1.13 \|\| ^0.2.0`      |
-| `rxjs`                              | `^7.0.0`                   |
-
-The TypeORM range covers both stable `0.3.x` and stable `1.x`
-releases. CI runs the full unit and integration matrix
-(testcontainers Postgres) against both TypeORM majors, so the
-adapter is exercised end-to-end on every supported peer. TypeORM
-nightly / beta builds are not in the declared range; install them
-explicitly via `pnpm.overrides` if you need to pin to one.
+## Install
 
-## Quick start
+```bash
+pnpm add @nestjs-transactional/typeorm @nestjs-transactional/core typeorm @nestjs/typeorm reflect-metadata
+```
 
-Minimal single-DataSource setup:
+## Quick start
 
 ```ts
 import { Module } from '@nestjs/common';
@@ -80,13 +45,8 @@ import { TypeOrmTransactionalModule } from '@nestjs-transactional/typeorm';
 
 @Module({
   imports: [
-    TypeOrmModule.forRoot({
-      type: 'postgres',
-      url: process.env.DATABASE_URL,
-      entities: [User],
-      synchronize: false,
-    }),
-    TypeOrmModule.forFeature([User]),
+    TypeOrmModule.forRoot({ type: 'postgres', entities: [Order] }),
+    TypeOrmModule.forFeature([Order]),
 
     TransactionalModule.forRoot({ isGlobal: true }),
     TypeOrmTransactionalModule.forRoot(),
@@ -95,285 +55,153 @@ import { TypeOrmTransactionalModule } from '@nestjs-transactional/typeorm';
 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.
+`TransactionalModule.forRoot({ isGlobal: true })` has to be there, with
+`isGlobal` — that is how this module sees the core registry from its own
+DI scope. The `DataSource` is found through `@nestjs/typeorm`'s
+`getDataSourceToken(name)`, the same convention
+`@InjectRepository(E, dataSource)` uses, so nothing else needs wiring.
 
-## Transparent transactional behaviour
+## What becomes transparent
 
-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:
+These all dispatch through the active transaction:
 
-```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';
+- `@InjectRepository(Entity)` — the common case.
+- `@InjectEntityManager() em.getRepository(E)`.
+- `@InjectDataSource() ds.getRepository(E)` and `ds.manager`.
+- Custom repositories built with `Repository.extend(...)`.
+- `TreeRepository` and `MongoRepository`, which inherit from `Repository`.
 
-@Injectable()
-export class OrderService {
-  constructor(
-    @InjectRepository(Order)
-    private readonly orderRepo: Repository<Order>,
-  ) {}
+Two patterns are **not** covered, and need an escape hatch:
 
-  @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. **`em.save(Entity, ...)` called directly** on an injected
+   `EntityManager`. The patch covers `em.getRepository(E).save(...)`,
+   not the manager's own data methods — patching all ~14 of them would
+   require per-method recursion guards, which was judged not worth the
+   surface area.
+2. **`BaseEntity` static methods** (`User.save(...)`).
+   `BaseEntity.useDataSource(...)` captures a `DataSource` reference
+   that bypasses the patch. The library `typeorm-transactional` has the
+   same limitation.
 
-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:
+For both, either use a repository or reach for 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],
-    );
-  }
+@Transactional()
+async runRawSql() {
+  // Pass the DataSource as fallback so this also works outside a
+  // transaction, where it returns ds.manager.
+  const em = getCurrentEntityManager('default', this.ds);
+  await em.query('UPDATE accounts SET balance = balance - $1', [100]);
 }
 ```
 
-## Multi-DataSource
+## Dialect-dependent behaviour
 
-```ts
-@Module({
-  imports: [
-    TypeOrmModule.forRoot({ name: 'default', /* ... */ }),
-    TypeOrmModule.forRoot({ name: 'billing',  /* ... */ }),
+Two options behave differently per database, and both fail loudly or
+harmlessly rather than surprisingly:
 
-    TransactionalModule.forRoot({ isGlobal: true }),
-    TypeOrmTransactionalModule.forRoot({ isDefault: true }),       // 'default'
-    TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }), // 'billing'
-  ],
-})
-export class AppModule {}
-```
+- **`readOnly`** is enforced on `postgres`, `cockroachdb` and
+  `aurora-postgres`, where the adapter issues `SET TRANSACTION READ ONLY`
+  as the transaction's first statement and the database refuses a write.
+  On other dialects it is a silent no-op. MySQL is not merely
+  unimplemented but unimplementable: `SET TRANSACTION` there applies to
+  the *next* transaction and errors inside a started one. Worth knowing
+  if you develop on SQLite and deploy to Postgres — the constraint
+  appears in production for the first time.
+  ([DD-027](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/dd/027-readonly-and-timeout-semantics.md))
+- **`PropagationMode.NESTED`** needs savepoints. The adapter checks
+  TypeORM's own `driver.transactionSupport` flag and throws
+  `IllegalTransactionStateError` naming the driver and the alternatives,
+  instead of running your "nested" transaction as part of the outer one.
+
+## Multiple dataSources
 
-Target a specific dataSource in a transactional method:
+One `forRoot` call per dataSource:
 
 ```ts
-import { Transactional } from '@nestjs-transactional/core';
+TypeOrmTransactionalModule.forRoot({ isDefault: true }),        // 'default'
+TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }),  // 'billing'
+```
 
-@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(/* ... */);
-  }
+```ts
+@Transactional({ dataSource: 'billing' })
+async chargeCard() {
+  return this.invoiceRepo.save(/* ... */); // repo bound to 'billing'
 }
 ```
 
-**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`.
+A repository bound to dataSource A, used inside a
+`@Transactional({ dataSource: 'B' })` method, autocommits: its patched
+manager looks for an active transaction on A, finds none, and falls back
+to its original manager. **Distributed transactions across dataSources
+are not supported** — that is deliberate, and cross-dataSource atomicity
+is what the outbox is for.
 
 ## 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 {}
+TypeOrmTransactionalModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (cfg: ConfigService) => ({
+    dataSource: cfg.get('DATA_SOURCE_NAME', 'default'),
+    isDefault: true,
+  }),
+});
 ```
 
-`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.
+Registration is deferred to `OnModuleInit` so the dataSource resolves
+correctly even when paired with `TypeOrmModule.forRootAsync`. Per-dataSource
+adapter tokens are not registered on this path, because NestJS needs
+provider tokens at module-definition time; use sync `forRoot({ dataSource })`
+if you inject adapters by token.
 
-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).
+## Compatibility
 
-## Testing
+| Peer | Supported range |
+| --- | --- |
+| Node.js | `>=22.13.0` |
+| `typeorm` | `^0.3.0 \|\| ^1.0.0` |
+| `@nestjs/typeorm` | `^10.0.0 \|\| ^11.0.0` |
+| `@nestjs/common` / `@nestjs/core` | `^10.0.0 \|\| ^11.0.0` |
+| `reflect-metadata` | `^0.1.13 \|\| ^0.2.0` |
+| `rxjs` | `^7.0.0` |
 
-### Unit tests — in-memory SQLite
+Both stable TypeORM lines are supported. CI runs the full unit and
+integration matrix — including savepoints and isolation against a real
+Postgres — at three points of that range: `0.3.31`, `1.0.0` and `1.1.0`.
 
-For fast unit tests that don't need a real database, use TypeORM's
-`sqljs` driver:
+## Testing
 
-```ts
-import { DataSource } from 'typeorm';
-import { TypeOrmTransactionAdapter } from '@nestjs-transactional/typeorm';
+For unit tests, TypeORM's in-memory `sqljs` driver is enough:
 
-const ds = new DataSource({
-  type: 'sqljs',
-  synchronize: true,
-  entities: [YourEntity],
-});
+```ts
+const ds = new DataSource({ type: 'sqljs', synchronize: true, entities: [Order] });
 await ds.initialize();
-
 const adapter = new TypeOrmTransactionAdapter(ds, 'default');
 ```
 
-### Integration tests — testcontainers-node + real Postgres
+Note that `readOnly` is not enforced on `sqljs`, so a read-only
+violation your tests miss can still surface on Postgres. For tests that
+need real dialect behaviour, run Postgres through
+[testcontainers](https://node.testcontainers.org/); the
+[`testing-patterns`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/testing-patterns)
+example shows both layers.
 
-Bundled helper for real Postgres integration:
+## Documentation
 
-```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);
-});
+- [Getting started and full docs](https://github.com/igorgolovanov/nestjs-transactional#readme)
+- [`readOnly` and `timeout` semantics (DD-027)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/dd/027-readonly-and-timeout-semantics.md)
+- [Multi-adapter architecture (ADR-018)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/adr/018-multi-adapter-architecture.md)
+- [Known limitations](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/known-limitations.md)
+- Runnable examples:
+  [`basic-transactional`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/basic-transactional),
+  [`multi-datasource-basic`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/multi-datasource-basic),
+  [`read-write-separation`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/read-write-separation),
+  [`e-commerce-orders`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/e-commerce-orders)
 
-// 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
-```
+## License
 
-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.
+MIT

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

@@ -1,4 +1,4 @@
-import type { TransactionAdapter, TransactionOptions } from '@nestjs-transactional/core';
+import { type TransactionAdapter, type TransactionOptions } from '@nestjs-transactional/core';
 import type { DataSource } from 'typeorm';
 import type { TypeOrmTransactionHandle } from '../types/typeorm-transaction-handle';
 /**
@@ -10,6 +10,12 @@ import type { TypeOrmTransactionHandle } from '../types/typeorm-transaction-hand
  * 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.
+ *
+ * `PropagationMode.NESTED` needs savepoints, so `runInSavepoint` first
+ * checks the driver's own capability flag and rejects with
+ * `IllegalTransactionStateError` on drivers that cannot do them (SQL
+ * Server, SAP HANA, MongoDB, Spanner, Cordova) instead of emitting SQL
+ * they will refuse.
  */
 export declare class TypeOrmTransactionAdapter implements TransactionAdapter<TypeOrmTransactionHandle> {
     private readonly dataSource;
@@ -35,5 +41,23 @@ export declare class TypeOrmTransactionAdapter implements TransactionAdapter<Typ
     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>;
+    /**
+     * Fail fast when the configured driver cannot do savepoints, rather
+     * than emitting `SAVEPOINT` SQL it will reject with an opaque
+     * driver-level error that says nothing about `NESTED` propagation.
+     *
+     * TypeORM reports the capability itself — `driver.transactionSupport`
+     * is `'nested'` for the savepoint-capable drivers (Postgres, MySQL,
+     * Oracle, SQLite, CockroachDB, ...), `'simple'` for SQL Server and
+     * SAP HANA, and `'none'` for MongoDB, Spanner and Cordova. Reading the
+     * flag beats maintaining our own dialect allowlist, which would rot
+     * with every driver TypeORM adds.
+     *
+     * Deliberately permissive when the flag is missing: a TypeORM version
+     * that renames or drops it must not turn every `NESTED` call into a
+     * hard failure, since absence of the signal is not evidence of absent
+     * support.
+     */
+    private assertSavepointsSupported;
 }
 //# sourceMappingURL=typeorm.adapter.d.ts.map

package/dist/adapter/typeorm.adapter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeOrmTransactionAdapter = void 0;
 const node_crypto_1 = require("node:crypto");
+const core_1 = require("@nestjs-transactional/core");
 /**
  * TypeORM implementation of {@link TransactionAdapter}. Delegates begin /
  * commit / rollback to `DataSource.transaction` and emits raw `SAVEPOINT`
@@ -11,6 +12,12 @@ const node_crypto_1 = require("node:crypto");
  * 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.
+ *
+ * `PropagationMode.NESTED` needs savepoints, so `runInSavepoint` first
+ * checks the driver's own capability flag and rejects with
+ * `IllegalTransactionStateError` on drivers that cannot do them (SQL
+ * Server, SAP HANA, MongoDB, Spanner, Cordova) instead of emitting SQL
+ * they will refuse.
  */
 class TypeOrmTransactionAdapter {
     dataSource;
@@ -37,6 +44,9 @@ class TypeOrmTransactionAdapter {
     async runInTransaction(options, fn) {
         const isolation = mapIsolation(options.isolation);
         const runner = async (entityManager) => {
+            if (options.readOnly === true) {
+                await applyReadOnly(entityManager, this.dataSource.options.type);
+            }
             const handle = {
                 id: (0, node_crypto_1.randomUUID)(),
                 adapterName: this.name,
@@ -50,6 +60,7 @@ class TypeOrmTransactionAdapter {
         return this.dataSource.transaction(runner);
     }
     async runInSavepoint(parent, fn) {
+        this.assertSavepointsSupported();
         const savepointName = `sp_${(0, node_crypto_1.randomUUID)().replace(/-/g, '_').substring(0, 30)}`;
         await parent.entityManager.query(`SAVEPOINT ${savepointName}`);
         try {
@@ -62,8 +73,74 @@ class TypeOrmTransactionAdapter {
             throw err;
         }
     }
+    /**
+     * Fail fast when the configured driver cannot do savepoints, rather
+     * than emitting `SAVEPOINT` SQL it will reject with an opaque
+     * driver-level error that says nothing about `NESTED` propagation.
+     *
+     * TypeORM reports the capability itself — `driver.transactionSupport`
+     * is `'nested'` for the savepoint-capable drivers (Postgres, MySQL,
+     * Oracle, SQLite, CockroachDB, ...), `'simple'` for SQL Server and
+     * SAP HANA, and `'none'` for MongoDB, Spanner and Cordova. Reading the
+     * flag beats maintaining our own dialect allowlist, which would rot
+     * with every driver TypeORM adds.
+     *
+     * Deliberately permissive when the flag is missing: a TypeORM version
+     * that renames or drops it must not turn every `NESTED` call into a
+     * hard failure, since absence of the signal is not evidence of absent
+     * support.
+     */
+    assertSavepointsSupported() {
+        const support = this.dataSource.driver
+            ?.transactionSupport;
+        if (support !== undefined && support !== 'nested') {
+            throw new core_1.IllegalTransactionStateError(`PropagationMode.NESTED needs savepoints, which the '${this.dataSource.options.type}' ` +
+                `driver does not support (TypeORM reports transactionSupport: '${support}'). ` +
+                "Use PropagationMode.REQUIRED to join the caller's transaction, or " +
+                'REQUIRES_NEW for an independent one.');
+        }
+    }
 }
 exports.TypeOrmTransactionAdapter = TypeOrmTransactionAdapter;
+/**
+ * Dialects where `SET TRANSACTION READ ONLY` is valid after `BEGIN`,
+ * provided it precedes the transaction's first query.
+ *
+ * An explicit allowlist, unlike the savepoint check above: TypeORM
+ * publishes a capability flag for nested transactions
+ * (`driver.transactionSupport`) but none for transaction access mode, so
+ * there is nothing to read. **Review this list when a driver is added.**
+ *
+ * MySQL and MariaDB are absent on purpose rather than by omission —
+ * `SET TRANSACTION` there applies to the *next* transaction and raises
+ * `ERROR 1568` inside a started one, so read-only would have to be set
+ * at `START TRANSACTION` time, which TypeORM does not expose. See
+ * DD-027.
+ */
+const READ_ONLY_DIALECTS = new Set([
+    'postgres',
+    'cockroachdb',
+    'aurora-postgres',
+]);
+/**
+ * Ask the database to reject writes for the remainder of this
+ * transaction, on the dialects that can do it.
+ *
+ * A silent no-op elsewhere, deliberately: `CqrsTransactionalModule`
+ * defaults every query handler to `readOnly: true`, so throwing here
+ * would break consumers on MySQL or SQLite over an option they never
+ * set. `readOnly` is a hint in Spring too — honoured where possible
+ * (DD-027).
+ *
+ * Must run before any user statement; Postgres rejects the statement
+ * once the transaction has executed its first query.
+ */
+async function applyReadOnly(entityManager, dialect) {
+    if (!READ_ONLY_DIALECTS.has(dialect)) {
+        return;
+    }
+    await entityManager.query('SET TRANSACTION READ ONLY');
+}
 /**
  * Map the core's underscore-style {@link IsolationLevel} to TypeORM's
  * space-separated string. Returns `undefined` when no level is set so the

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

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

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

@@ -2,7 +2,7 @@ import { type DynamicModule, type InjectionToken, type ModuleMetadata } from '@n
 /**
  * Options accepted by {@link TypeOrmTransactionalModule.forRoot}.
  *
- * Phase 14.20 reshape: this module now resolves the actual TypeORM
+ * Reshaped so 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
@@ -41,7 +41,7 @@ export interface TypeOrmTransactionalOptions {
  * populates as a side effect.
  *
  * Mirrors the documented limitation on
- * `TransactionalModule.forRootAsync` (Phase 14.10).
+ * `TransactionalModule.forRootAsync`.
  */
 export interface TypeOrmTransactionalAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
     readonly useFactory: (...args: never[]) => Promise<TypeOrmTransactionalOptions> | TypeOrmTransactionalOptions;
@@ -50,7 +50,7 @@ export interface TypeOrmTransactionalAsyncOptions extends Pick<ModuleMetadata, '
 /**
  * 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).
+ * the transparent transactional patching machinery.
  * Once registered:
  *
  * - Every `Repository` reachable via `@InjectRepository`,

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

@@ -46,7 +46,7 @@ const ASYNC_OPTIONS_TOKEN = (id) => Symbol(`TYPEORM_TRANSACTIONAL_ASYNC_OPTIONS[
 /**
  * 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).
+ * the transparent transactional patching machinery.
  * Once registered:
  *
  * - Every `Repository` reachable via `@InjectRepository`,
@@ -190,7 +190,7 @@ let TypeOrmTransactionalModule = class TypeOrmTransactionalModule {
         // (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).
+        // `TypeOrmModule.forRootAsync` (Convention #22).
         //
         // The robust pattern is `OnModuleInit`: by the time the hook
         // runs, every provider in the module tree has been instantiated

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

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

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

@@ -8,7 +8,7 @@
  *
  * This wrap matters specifically for the
  * `@InjectEntityManager() em.getRepository(Entity).save(...)` user
- * pattern (Phase 14.20 Q1 Option A coverage proof): the injected
+ * pattern (coverage proof in the integration tests): 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`
@@ -22,7 +22,7 @@
  *
  * `@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
+ *. Use `getCurrentEntityManager()` as the escape
  * hatch.
  */
 export declare function applyEntityManagerPatches(): void;

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

@@ -35,7 +35,7 @@ let originalGetRepository;
  *
  * This wrap matters specifically for the
  * `@InjectEntityManager() em.getRepository(Entity).save(...)` user
- * pattern (Phase 14.20 Q1 Option A coverage proof): the injected
+ * pattern (coverage proof in the integration tests): 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`
@@ -49,7 +49,7 @@ let originalGetRepository;
  *
  * `@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
+ *. Use `getCurrentEntityManager()` as the escape
  * hatch.
  */
 function applyEntityManagerPatches() {

package/dist/patching/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Phase 14.20 transparent transactional repositories — patching
+ * 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
@@ -7,7 +7,7 @@
  *
  * @internal
  */
-export { applyRepositoryPatches, areRepositoryPatchesApplied, } from './repository-patches';
+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';

package/dist/patching/index.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * Phase 14.20 transparent transactional repositories — patching
+ * 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

package/dist/patching/index.js.map

@@ -1 +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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/patching/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAmCH,0CAGC;AAwBD,0DAEC;AA9DD,qEAAqE;AACrE,yDAA0D;AAC1D,6DAA8D;AAE9D,2DAA2F;AAAlF,4HAAA,sBAAsB,OAAA;AAAE,iIAAA,2BAA2B,OAAA;AAC5D,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/symbols.d.ts

@@ -1,6 +1,6 @@
 /**
  * Hidden property keys used by the transparent transactional patching
- * machinery (Phase 14.20).
+ * machinery.
  *
  * `Symbol.for(...)` is used (not module-local `Symbol(...)`) so the same
  * key resolves identically across realms and across multiple copies of

package/dist/patching/symbols.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * Hidden property keys used by the transparent transactional patching
- * machinery (Phase 14.20).
+ * machinery.
  *
  * `Symbol.for(...)` is used (not module-local `Symbol(...)`) so the same
  * key resolves identically across realms and across multiple copies of

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@nestjs-transactional/typeorm",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0",
   "description": "TypeORM adapter for @nestjs-transactional/core — EntityManager propagation, savepoints, multi-datasource",
   "license": "MIT",
+  "type": "commonjs",
+  "sideEffects": [
+    "./dist/module/typeorm-transactional.module.js"
+  ],
   "author": "Igor Golovanov",
   "repository": {
     "type": "git",
-    "url": "https://github.com/igorgolovanov/nestjs-transactional.git",
+    "url": "git+https://github.com/igorgolovanov/nestjs-transactional.git",
     "directory": "packages/typeorm"
   },
   "bugs": {
@@ -41,7 +45,6 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "alpha",
     "provenance": true
   },
   "peerDependencies": {
@@ -51,7 +54,7 @@
     "reflect-metadata": "^0.1.13 || ^0.2.0",
     "rxjs": "^7.0.0",
     "typeorm": "^0.3.0 || ^1.0.0",
-    "@nestjs-transactional/core": "^1.0.0-alpha.3"
+    "@nestjs-transactional/core": "^1.0.0"
   },
   "devDependencies": {
     "@nestjs/common": "^11.0.0",
@@ -64,8 +67,8 @@
     "rxjs": "^7.8.1",
     "sql.js": "^1.11.0",
     "testcontainers": "^10.13.0",
-    "typeorm": "^0.3.0 || ^1.0.0",
-    "@nestjs-transactional/core": "1.0.0-alpha.3"
+    "typeorm": "^1.1.0",
+    "@nestjs-transactional/core": "1.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
@@ -75,6 +78,9 @@
     "test:cov": "jest --coverage",
     "test:integration": "jest --config jest.integration.config.js",
     "type-check": "tsc --noEmit",
-    "lint": "eslint \"src/**/*.ts\""
+    "lint": "eslint \"src/**/*.ts\"",
+    "api:check": "api-extractor run",
+    "api:update": "api-extractor run --local",
+    "publish:check": "publint && attw --pack ."
   }
 }