@nestjs-transactional/core 1.0.0-alpha.5 → 2.0.0

package/README.md

@@ -1,265 +1,218 @@
 # @nestjs-transactional/core
 
-[![npm version](https://img.shields.io/npm/v/%40nestjs-transactional%2Fcore/alpha?style=flat-square&label=npm)](https://www.npmjs.com/package/@nestjs-transactional/core)
+[![npm version](https://img.shields.io/npm/v/%40nestjs-transactional%2Fcore?style=flat-square&label=npm)](https://www.npmjs.com/package/@nestjs-transactional/core)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/LICENSE)
 
-Core primitives for declarative Spring-style transaction management
-in NestJS.
-
-## Overview
-
-The adapter-agnostic foundation of the `@nestjs-transactional` family:
-
-- `TransactionContext` — `AsyncLocalStorage`-backed carrier that
-  propagates the active transaction across `await` boundaries.
-- `TransactionManager` — runtime with the full Spring propagation
-  semantics (`REQUIRED`, `REQUIRES_NEW`, `NESTED`, `SUPPORTS`,
-  `NOT_SUPPORTED`, `NEVER`, `MANDATORY`) plus `rollbackFor` /
-  `noRollbackFor` rules and before / after commit / rollback hooks.
-- `@Transactional()`, `@ReadOnly()`, `@TransactionalOn(instance)`
-  decorators — metadata-only; runtime wrapping is performed by the
-  three coordinated mechanisms documented in
-  [ADR-005](../../docs/adr/005-method-wrapping-strategy.md).
-- `TransactionalInterceptor` — wires `@Transactional` on controllers,
-  resolvers, gateways, and microservice handlers via `APP_INTERCEPTOR`.
-- `TransactionalModule.forRoot` / `forRootAsync` — module wiring,
-  one call per dataSource (multi-`forRoot` pattern, see
-  [ADR-019](../../docs/adr/019-outbox-multi-forroot-pattern.md)).
-- `TransactionAdapter<THandle>` SPI — the port for ORM-specific
-  adapters.
-- `InMemoryTransactionAdapter` (via the `@nestjs-transactional/core/testing`
-  subpath) — drop-in adapter for unit tests.
-
-This package does not depend on any concrete ORM. Install
-`@nestjs-transactional/typeorm` for TypeORM integration, or implement
-your own adapter against the `TransactionAdapter` interface.
-
-## Installation
+Declarative transactions for NestJS, with Spring's semantics.
+
+Put `@Transactional()` on a method and everything it touches runs in
+one transaction — across `await` boundaries, without threading a
+manager through your call stack. All seven Spring propagation modes are
+implemented, including `NESTED` via savepoints.
+
+This package is ORM-agnostic and does nothing on its own: it needs an
+adapter. Most applications install
+[`@nestjs-transactional/typeorm`](https://www.npmjs.com/package/@nestjs-transactional/typeorm)
+alongside it, which also makes injected repositories transaction-aware
+automatically. For event delivery that survives a crash, add
+[`@nestjs-transactional/outbox`](https://www.npmjs.com/package/@nestjs-transactional/outbox);
+for `@nestjs/cqrs` handlers,
+[`@nestjs-transactional/cqrs`](https://www.npmjs.com/package/@nestjs-transactional/cqrs).
+
+## Install
 
 ```bash
-pnpm add @nestjs-transactional/core reflect-metadata
+pnpm add @nestjs-transactional/core @nestjs-transactional/typeorm reflect-metadata
 ```
 
-Load `reflect-metadata` once at the application entry point (same as
-for NestJS itself).
+Load `reflect-metadata` once at your entry point, as NestJS itself
+requires.
 
-## Quick start
+## Module format
+
+This package ships **ESM only**, matching NestJS 12, which is ESM-only
+across its own packages. There is no CommonJS build.
+
+A CommonJS application still works: Node loads ESM from `require()`
+since 22.12.0, which is why `engines.node` is `>=22.13.0`. What does not
+follow Node here is tooling with its own module loader — Jest above all,
+which needs `NODE_OPTIONS=--experimental-vm-modules` and a few config
+settings. The 19 example applications in the repository all run their
+suites that way and can be copied from.
+
+Reasoning and measurements: [ADR-022](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/adr/022-esm-only-packaging.md).
 
-In typical use this package is imported via an integration package
-(like `@nestjs-transactional/typeorm`) which registers the adapter
-into the `AdapterRegistry` automatically. The minimal application
-shape is:
+## Quick start
 
 ```ts
 import { Module } from '@nestjs/common';
 import { TransactionalModule } from '@nestjs-transactional/core';
 import { TypeOrmTransactionalModule } from '@nestjs-transactional/typeorm';
-// ...your TypeORM config
 
 @Module({
   imports: [
-    TypeOrmModule.forRoot({ /* ... */ }),
+    TypeOrmModule.forRoot({
+      /* ... */
+    }),
 
-    // Infrastructure-only forRoot — registers TransactionManager,
-    // AdapterRegistry, and the interceptor. No `adapter` here; the
-    // integration package below registers it.
+    // Infrastructure only: TransactionManager, AdapterRegistry, the
+    // interceptor. `isGlobal` matters — the adapter package below
+    // needs to see the registry from its own DI scope.
     TransactionalModule.forRoot({ isGlobal: true }),
 
-    // Integration package registers `TypeOrmTransactionAdapter`
-    // for the default dataSource.
+    // Registers the TypeORM adapter for the default dataSource.
     TypeOrmTransactionalModule.forRoot(),
   ],
 })
 export class AppModule {}
 ```
 
-`@Transactional()` on any controller handler, query handler, or
-service method is then wrapped in a transaction automatically:
+That is the whole setup. Now any method — a controller handler, a
+service method, a CQRS handler — becomes transactional by decoration:
 
 ```ts
-import { Controller, Get, Param } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { Transactional } from '@nestjs-transactional/core';
 
-@Controller('orders')
-export class OrdersController {
-  constructor(private readonly orders: OrdersService) {}
-
-  @Get(':id')
+@Injectable()
+export class OrdersService {
   @Transactional()
-  async findOne(@Param('id') id: string) {
-    return this.orders.findById(id);
+  async placeOrder(dto: PlaceOrderDto): Promise<Order> {
+    const order = await this.orders.save(dto);
+    await this.stock.reserve(order); // same transaction
+    return order; // commits here; a throw rolls both back
   }
 }
 ```
 
-### Direct adapter registration (custom backends)
-
-When implementing a new `TransactionAdapter` (Prisma, Mongoose, ...),
-pass it to `forRoot` directly:
-
-```ts
-import { TransactionalModule, type TransactionAdapter } from '@nestjs-transactional/core';
+## Propagation
 
-const myAdapter: TransactionAdapter = /* ... */;
+`@Transactional({ propagation })` decides what happens when a
+transactional method is called from inside another one. The default,
+`REQUIRED`, joins the caller — which is what you want almost always.
 
-@Module({
-  imports: [
-    TransactionalModule.forRoot({
-      isGlobal: true,
-      adapter: myAdapter,
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-For multi-dataSource setups, call `forRoot` once per dataSource —
-each call registers exactly one adapter under its dataSource name.
-
-## Decorator options
+| Mode | Caller has a transaction | Caller has none |
+| --- | --- | --- |
+| `REQUIRED` *(default)* | join it | start one |
+| `REQUIRES_NEW` | suspend it, run independently, resume | start one |
+| `NESTED` | run in a savepoint | start one |
+| `SUPPORTS` | join it | run without a transaction |
+| `NOT_SUPPORTED` | suspend it, run without one, resume | run without one |
+| `NEVER` | throw `IllegalTransactionStateError` | run without one |
+| `MANDATORY` | join it | throw `IllegalTransactionStateError` |
+
+`REQUIRES_NEW` is how you make a side effect survive the caller's
+rollback — an audit row that must persist even when the operation
+fails. `NESTED` gives you a partial rollback inside one transaction;
+it needs a driver with savepoint support, and the TypeORM adapter
+raises a clear error rather than silently degrading if the driver has
+none.
+
+## Options
 
 ```ts
-import {
-  Transactional,
-  ReadOnly,
-  TransactionalOn,
-  PropagationMode,
-} from '@nestjs-transactional/core';
-
 class ReportsService {
-  // Explicit propagation + isolation.
   @Transactional({
     propagation: PropagationMode.REQUIRES_NEW,
     isolation: 'SERIALIZABLE',
-    timeout: 10_000,
   })
-  async rebuildReport() { /* ... */ }
+  async rebuild() {}
+
+  // Roll back on anything except ValidationError.
+  @Transactional({ noRollbackFor: [ValidationError] })
+  async processBatch() {}
 
   // Shorthand for { readOnly: true }.
   @ReadOnly()
-  async exportCsv() { /* ... */ }
+  async exportCsv() {}
 
-  // Rollback rules — commit on `ValidationError`, roll back on others.
-  @Transactional({ noRollbackFor: [ValidationError] })
-  async processBatch() { /* ... */ }
-
-  // Target a specific dataSource in multi-DataSource setups.
+  // Target one dataSource in a multi-dataSource application.
   @TransactionalOn('billing')
-  async chargeCard() { /* ... */ }
+  async chargeCard() {}
 }
 ```
 
-Propagation semantics:
-
-| Mode | Active outer transaction | No outer transaction |
-| --- | --- | --- |
-| `REQUIRED` (default) | join | start new |
-| `REQUIRES_NEW` | suspend + start new, then resume | start new |
-| `NESTED` | run inside a savepoint | start new |
-| `SUPPORTS` | join | run without transaction |
-| `NOT_SUPPORTED` | suspend + run without transaction, then resume | run without transaction |
-| `NEVER` | throw `IllegalTransactionStateError` | run without transaction |
-| `MANDATORY` | join | throw `IllegalTransactionStateError` |
-
-## Async module configuration
-
-```ts
-import { TransactionalModule } from '@nestjs-transactional/core';
-
-@Module({
-  imports: [
-    TransactionalModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: (config: ConfigService) => ({
-        adapter: buildAdapterFromConfig(config),
-      }),
-    }),
-  ],
-})
-export class AppModule {}
-```
+Two options carry caveats worth knowing before you rely on them:
 
-`isGlobal` and `registerInterceptor` remain static top-level flags —
-they must be known at module definition time. The async factory
-returns the per-call configuration (`adapter` and any other
-runtime-resolved options).
+- **`readOnly`** is enforced by the database only on Postgres-family
+  dialects, where the adapter issues `SET TRANSACTION READ ONLY`.
+  Elsewhere it documents intent and nothing rejects a write. Spring
+  treats it as a hint too. See
+  [DD-027](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/dd/027-readonly-and-timeout-semantics.md).
+- **`timeout`** is accepted by the type but **not implemented** by the
+  TypeORM adapter. It is deliberately not approximated: Postgres'
+  `statement_timeout` bounds each statement rather than the
+  transaction, so `timeout: 5000` on a method issuing four queries
+  would allow twenty seconds. It stays in the surface for adapters
+  whose driver exposes a real transaction budget.
 
-## Lifecycle hooks
+## Commit and rollback hooks
 
-Register hooks from inside a transactional method — they fire on the
-current transaction:
+Register from inside a transactional method; the hook binds to the
+transaction currently running.
 
 ```ts
-import { TransactionManager } from '@nestjs-transactional/core';
-
-export class OrdersService {
-  constructor(private readonly manager: TransactionManager) {}
-
-  @Transactional()
-  async placeOrder(payload: PlaceOrderDto) {
-    const order = await this.orders.insert(payload);
+@Transactional()
+async placeOrder(dto: PlaceOrderDto) {
+  const order = await this.orders.save(dto);
 
-    this.manager.registerAfterCommit(async () => {
-      // Fires only after the adapter commits. Never on rollback.
-      await this.analytics.trackOrderPlaced(order.id);
-    });
+  // Runs only after the commit succeeds — never on rollback.
+  this.manager.registerAfterCommit(() => this.analytics.track(order.id));
 
-    this.manager.registerAfterRollback(async (error) => {
-      // Receives the error that caused the rollback.
-      await this.metrics.recordFailedOrder(order.id, error);
-    });
+  // Receives the error that caused the rollback.
+  this.manager.registerAfterRollback((error) => this.metrics.failed(error));
 
-    return order;
-  }
+  return order;
 }
 ```
 
-Hook errors are caught and logged via NestJS `Logger` — they do not
-affect the transaction outcome or prevent sibling hooks from running.
+A throwing hook is logged and swallowed: it changes neither the
+transaction's outcome nor its sibling hooks. For event handlers with
+these semantics as first-class decorators, see the `cqrs` package.
 
 ## Testing
 
-`InMemoryTransactionAdapter` from the `/testing` subpath gives
-adapter-level observability without a real database:
+`InMemoryTransactionAdapter` from the `/testing` subpath records
+commits, rollbacks and savepoints without a database:
 
 ```ts
 import { InMemoryTransactionAdapter } from '@nestjs-transactional/core/testing';
-import { TransactionalModule } from '@nestjs-transactional/core';
 
 const adapter = new InMemoryTransactionAdapter();
 
-const moduleRef = await Test.createTestingModule({
-  imports: [
-    TransactionalModule.forRoot({ isGlobal: true, adapter }),
-  ],
+await Test.createTestingModule({
+  imports: [TransactionalModule.forRoot({ isGlobal: true, adapter })],
 }).compile();
 
-// After exercising the code under test:
 expect(adapter.committedTransactions).toHaveLength(1);
 expect(adapter.rolledBackTransactions).toHaveLength(0);
-expect(adapter.savepointsReleased).toHaveLength(0);
 ```
 
-`adapter.reset()` clears all observation arrays between tests when
-you keep a single adapter instance across cases. For multi-DS test
-setups, pass distinct dataSource names to the constructor:
+`adapter.reset()` clears the arrays between cases. Pass a dataSource
+name to the constructor for multi-dataSource tests.
+
+## Custom adapters
+
+To support another ORM, implement `TransactionAdapter<THandle>` and
+hand it to `forRoot` directly:
 
 ```ts
-const billing = new InMemoryTransactionAdapter('billing');
-const inventory = new InMemoryTransactionAdapter('inventory');
+TransactionalModule.forRoot({ isGlobal: true, adapter: myAdapter });
 ```
 
-## Worked examples
+One `forRoot` call registers one adapter. Multi-dataSource
+applications call it once per dataSource.
 
-- [`basic-transactional`](../../examples/basic-transactional) —
-  `@Transactional()` on a plain service.
-- [`testing-patterns`](../../examples/testing-patterns) —
-  `InMemoryTransactionAdapter` from `core/testing` plus the outbox /
-  integration test layers.
+## Documentation
 
-Full catalogue: [examples/README.md](../../examples/README.md).
+- [Getting started and full docs](https://github.com/igorgolovanov/nestjs-transactional#readme)
+- [Architecture: core design](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/architecture/core-design.md)
+- [How methods get wrapped (ADR-005)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/docs/adr/005-method-wrapping-strategy.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),
+  [`testing-patterns`](https://github.com/igorgolovanov/nestjs-transactional/tree/main/examples/testing-patterns)
 
-## Status
+## License
 
-Alpha. Public API may change between 0.x releases.
+MIT

package/dist/bootstrap/transactional-methods.bootstrap.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata';
 import { type OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
-import { TransactionManager } from '../manager/transaction.manager';
+import { TransactionManager } from '../manager/transaction.manager.js';
 /**
  * `OnApplicationBootstrap` service that wraps every `@Transactional()`
  * method on a plain `@Injectable()` provider with
@@ -10,7 +10,7 @@ import { TransactionManager } from '../manager/transaction.manager';
  * This is the second of the three coordinated wrapping mechanisms
  * described in ADR-005:
  *
- * 1. {@link import('../interceptor/transactional.interceptor').TransactionalInterceptor}
+ * 1. {@link import('../interceptor/transactional.interceptor.js').TransactionalInterceptor}
  *    — for controller / resolver / gateway request-boundary handlers.
  * 2. This class — for regular `@Injectable` services.
  * 3. `CqrsHandlerWrapper` (in `@nestjs-transactional/cqrs`) — for CQRS

package/dist/bootstrap/transactional-methods.bootstrap.js

@@ -1,4 +1,3 @@
-"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);
@@ -9,14 +8,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 var TransactionalMethodsBootstrap_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionalMethodsBootstrap = void 0;
-require("reflect-metadata");
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const transactional_decorator_1 = require("../decorators/transactional.decorator");
-const markers_1 = require("../internal/markers");
-const transaction_manager_1 = require("../manager/transaction.manager");
+import 'reflect-metadata';
+import { Injectable, Logger } from '@nestjs/common';
+import { DiscoveryService, MetadataScanner } from '@nestjs/core';
+import { TRANSACTIONAL_METADATA, getTransactionalMetadata, } from '../decorators/transactional.decorator.js';
+import { WRAPPED_MARKER } from '../internal/markers.js';
+import { TransactionManager } from '../manager/transaction.manager.js';
 /**
  * Metadata keys set by `@nestjs/cqrs`'s handler decorators. Mirrored here
  * so the bootstrap skips CQRS handler classes — they are wrapped by
@@ -37,7 +34,7 @@ const CQRS_HANDLER_KEYS = [
  * This is the second of the three coordinated wrapping mechanisms
  * described in ADR-005:
  *
- * 1. {@link import('../interceptor/transactional.interceptor').TransactionalInterceptor}
+ * 1. {@link import('../interceptor/transactional.interceptor.js').TransactionalInterceptor}
  *    — for controller / resolver / gateway request-boundary handlers.
  * 2. This class — for regular `@Injectable` services.
  * 3. `CqrsHandlerWrapper` (in `@nestjs-transactional/cqrs`) — for CQRS
@@ -60,7 +57,7 @@ let TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = class Tran
     discovery;
     metadataScanner;
     manager;
-    logger = new common_1.Logger(TransactionalMethodsBootstrap_1.name);
+    logger = new Logger(TransactionalMethodsBootstrap_1.name);
     constructor(discovery, metadataScanner, manager) {
         this.discovery = discovery;
         this.metadataScanner = metadataScanner;
@@ -81,7 +78,7 @@ let TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = class Tran
             const prototype = Object.getPrototypeOf(instance);
             if (prototype === null)
                 continue;
-            const classMetadata = (0, transactional_decorator_1.getTransactionalMetadata)(metatype);
+            const classMetadata = getTransactionalMetadata(metatype);
             const methodNames = this.metadataScanner.getAllMethodNames(prototype);
             const methods = prototype;
             const host = instance;
@@ -89,13 +86,13 @@ let TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = class Tran
                 const protoMethod = methods[methodName];
                 if (typeof protoMethod !== 'function')
                     continue;
-                const metadata = (0, transactional_decorator_1.getTransactionalMetadata)(protoMethod) ?? classMetadata;
+                const metadata = getTransactionalMetadata(protoMethod) ?? classMetadata;
                 if (metadata === undefined)
                     continue;
                 const currentMethod = host[methodName];
                 if (typeof currentMethod !== 'function')
                     continue;
-                if (Reflect.getMetadata(markers_1.WRAPPED_MARKER, currentMethod) === true)
+                if (Reflect.getMetadata(WRAPPED_MARKER, currentMethod) === true)
                     continue;
                 if (this.wrapMethod(host, methodName, currentMethod, instance, metadata)) {
                     wrappedCount++;
@@ -111,19 +108,19 @@ let TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = class Tran
         const boundOriginal = currentMethod.bind(instance);
         const manager = this.manager;
         const wrapped = (...args) => manager.run(metadata, () => Promise.resolve(boundOriginal(...args)));
-        Reflect.defineMetadata(markers_1.WRAPPED_MARKER, true, wrapped);
-        Reflect.defineMetadata(transactional_decorator_1.TRANSACTIONAL_METADATA, metadata, wrapped);
+        Reflect.defineMetadata(WRAPPED_MARKER, true, wrapped);
+        Reflect.defineMetadata(TRANSACTIONAL_METADATA, metadata, wrapped);
         host[methodName] = wrapped;
         this.logger.debug(`Wrapped ${instance.constructor.name}.${methodName} ` +
             `(propagation=${metadata.propagation ?? 'REQUIRED'})`);
         return true;
     }
 };
-exports.TransactionalMethodsBootstrap = TransactionalMethodsBootstrap;
-exports.TransactionalMethodsBootstrap = TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.DiscoveryService,
-        core_1.MetadataScanner,
-        transaction_manager_1.TransactionManager])
+TransactionalMethodsBootstrap = TransactionalMethodsBootstrap_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [DiscoveryService,
+        MetadataScanner,
+        TransactionManager])
 ], TransactionalMethodsBootstrap);
+export { TransactionalMethodsBootstrap };
 //# sourceMappingURL=transactional-methods.bootstrap.js.map

package/dist/bootstrap/transactional-methods.bootstrap.js.map

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

package/dist/context/transaction-context-view.d.ts

@@ -1,4 +1,4 @@
-import { type ActiveTransaction } from './transaction.context';
+import { type ActiveTransaction } from './transaction.context.js';
 /**
  * Per-dataSource read-only view over {@link TransactionContext}'s active
  * transaction Map (DD-022). Bound to a single dataSource name at

package/dist/context/transaction-context-view.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionContextView = void 0;
-const transaction_context_1 = require("./transaction.context");
+import { TransactionContext } from './transaction.context.js';
 /**
  * Per-dataSource read-only view over {@link TransactionContext}'s active
  * transaction Map (DD-022). Bound to a single dataSource name at
@@ -18,7 +15,7 @@ const transaction_context_1 = require("./transaction.context");
  * `getTransactionContextToken(dataSource)`. Inject via
  * `@InjectTransactionContext(dataSource?)`.
  */
-class TransactionContextView {
+export class TransactionContextView {
     dataSource;
     /**
      * @param dataSource - Public dataSource name this view is bound to.
@@ -33,7 +30,7 @@ class TransactionContextView {
      * `TransactionContext.getActiveTransactionByDataSource(this.dataSource)`.
      */
     getActiveTransaction() {
-        return transaction_context_1.TransactionContext.getActiveTransactionByDataSource(this.dataSource);
+        return TransactionContext.getActiveTransactionByDataSource(this.dataSource);
     }
     /**
      * Predicate convenience over {@link getActiveTransaction}. Useful for
@@ -44,5 +41,4 @@ class TransactionContextView {
         return this.getActiveTransaction() !== undefined;
     }
 }
-exports.TransactionContextView = TransactionContextView;
 //# sourceMappingURL=transaction-context-view.js.map

package/dist/context/transaction-context-view.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction-context-view.js","sourceRoot":"","sources":["../../src/context/transaction-context-view.ts"],"names":[],"mappings":";;;AAAA,+DAG+B;AAE/B;;;;;;;;;;;;;;;GAeG;AACH,MAAa,sBAAsB;IAKZ;IAJrB;;;OAGG;IACH,YAAqB,UAAkB;QAAlB,eAAU,GAAV,UAAU,CAAQ;IAAG,CAAC;IAE3C;;;;OAIG;IACH,oBAAoB;QAClB,OAAO,wCAAkB,CAAC,gCAAgC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,oBAAoB,EAAE,KAAK,SAAS,CAAC;IACnD,CAAC;CACF;AAxBD,wDAwBC"}
+{"version":3,"file":"transaction-context-view.js","sourceRoot":"","sources":["../../src/context/transaction-context-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEtF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,sBAAsB;IAKZ;IAJrB;;;OAGG;IACH,YAAqB,UAAkB;QAAlB,eAAU,GAAV,UAAU,CAAQ;IAAG,CAAC;IAE3C;;;;OAIG;IACH,oBAAoB;QAClB,OAAO,kBAAkB,CAAC,gCAAgC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,oBAAoB,EAAE,KAAK,SAAS,CAAC;IACnD,CAAC;CACF"}

package/dist/context/transaction.context.d.ts

@@ -1,5 +1,5 @@
-import type { TransactionHandle } from '../types/transaction-handle';
-import type { TransactionOptions } from '../types/transaction-options';
+import type { TransactionHandle } from '../types/transaction-handle.js';
+import type { TransactionOptions } from '../types/transaction-options.js';
 /**
  * A single transaction currently live on the async context. Adapters register
  * one of these under their `adapterInstanceName` when they begin a transaction
@@ -55,7 +55,7 @@ export interface TransactionContextStore {
  *
  * **Public dataSource-name access**:
  * {@link getActiveTransactionByDataSource} provides dataSource-name
- * lookup for Phase 14.2+ multi-adapter consumers — it scans the Map
+ * lookup for multi-adapter consumers — it scans the Map
  * for the entry whose `adapterInstanceName === dataSource`. Both
  * access patterns coexist; future cleanup is possible once
  * cross-package consumers migrate to the dataSource-name lookup and

package/dist/context/transaction.context.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionContext = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-const errors_1 = require("../types/errors");
-const als = new node_async_hooks_1.AsyncLocalStorage();
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { IllegalTransactionStateError } from '../types/errors.js';
+const als = new AsyncLocalStorage();
 /**
  * Thin façade over `AsyncLocalStorage` that carries the active
  * {@link TransactionContextStore} across async boundaries. This is the
@@ -19,13 +16,13 @@ const als = new node_async_hooks_1.AsyncLocalStorage();
  *
  * **Public dataSource-name access**:
  * {@link getActiveTransactionByDataSource} provides dataSource-name
- * lookup for Phase 14.2+ multi-adapter consumers — it scans the Map
+ * lookup for multi-adapter consumers — it scans the Map
  * for the entry whose `adapterInstanceName === dataSource`. Both
  * access patterns coexist; future cleanup is possible once
  * cross-package consumers migrate to the dataSource-name lookup and
  * no backwards-compatibility constraints remain.
  */
-class TransactionContext {
+export class TransactionContext {
     /**
      * Run `fn` inside a transaction context scope.
      *
@@ -95,7 +92,7 @@ class TransactionContext {
     static setActiveTransaction(adapterInstanceName, tx) {
         const store = als.getStore();
         if (store === undefined) {
-            throw new errors_1.IllegalTransactionStateError('Cannot set active transaction outside of TransactionContext.run()');
+            throw new IllegalTransactionStateError('Cannot set active transaction outside of TransactionContext.run()');
         }
         store.activeTransactions.set(adapterInstanceName, tx);
     }
@@ -108,5 +105,4 @@ class TransactionContext {
         als.getStore()?.activeTransactions.delete(adapterInstanceName);
     }
 }
-exports.TransactionContext = TransactionContext;
 //# sourceMappingURL=transaction.context.js.map