@nestjs-transactional/core 1.0.0-alpha.0

package/dist/manager/transaction.manager.js

@@ -0,0 +1,412 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var TransactionManager_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManager = void 0;
+const node_crypto_1 = require("node:crypto");
+const common_1 = require("@nestjs/common");
+const transaction_context_1 = require("../context/transaction.context");
+const transaction_observer_1 = require("../observability/transaction-observer");
+const errors_1 = require("../types/errors");
+const propagation_1 = require("../types/propagation");
+const adapter_registry_1 = require("./adapter.registry");
+/**
+ * Runtime that executes a callback inside a transaction, following the
+ * requested {@link PropagationMode}. Exposes registration points for
+ * before/after-commit and after-rollback hooks that the surrounding
+ * transaction fires at the appropriate phase.
+ *
+ * All seven Spring-compatible propagation modes are supported:
+ * `REQUIRED`, `REQUIRES_NEW`, `NESTED`, `SUPPORTS`, `NOT_SUPPORTED`,
+ * `NEVER`, `MANDATORY`. See {@link TransactionManager.run} for the
+ * per-mode behaviour.
+ */
+let TransactionManager = TransactionManager_1 = class TransactionManager {
+    registry;
+    observers;
+    logger = new common_1.Logger(TransactionManager_1.name);
+    constructor(registry, observers = []) {
+        this.registry = registry;
+        this.observers = observers;
+    }
+    /**
+     * Execute `fn` inside a transaction managed by the adapter resolved from
+     * `options` (or defaults from {@link AdapterRegistry}).
+     *
+     * Behaviour by propagation mode:
+     * - `REQUIRED` (default): join the active transaction for this adapter
+     *   instance if one exists; otherwise start a new transaction.
+     * - `REQUIRES_NEW`: always start a new, independent transaction. If an
+     *   outer transaction is active, its {@link ActiveTransaction} entry is
+     *   suspended out of the context Map for the duration of the inner call
+     *   and restored afterwards.
+     * - `NESTED`: if an outer transaction is active, run inside a savepoint
+     *   on that transaction (via {@link TransactionAdapter.runInSavepoint}).
+     *   A savepoint rollback leaves the outer transaction intact. Lifecycle
+     *   hooks registered inside a `NESTED` block attach to the outer
+     *   transaction and fire on the outer commit/rollback. If no outer
+     *   transaction is active, `NESTED` degrades to `REQUIRED`.
+     * - `SUPPORTS`: run `fn` in the outer transaction if present; otherwise
+     *   run `fn` directly with no transaction and no lifecycle hooks.
+     * - `NOT_SUPPORTED`: suspend the outer transaction (remove its entry
+     *   from the context Map) and run `fn` without transactional context.
+     *   Restore on return. Note that the adapter-level connection/query
+     *   runner is NOT actually suspended — this is a context-level opt-out.
+     * - `NEVER`: throw {@link IllegalTransactionStateError} if an outer
+     *   transaction is active; otherwise run `fn` directly.
+     * - `MANDATORY`: throw {@link IllegalTransactionStateError} if no outer
+     *   transaction is active; otherwise join it.
+     *
+     * Both inner and outer transactions share the surrounding
+     * {@link TransactionContext} store — same `correlationId`, same Map —
+     * only the Map slot at `instanceName` is swapped as propagation requires.
+     */
+    async run(options, fn) {
+        // dataSource takes precedence over adapter/adapterInstance (DD-020).
+        // Resolved up front so the rest of run() works in a single shape.
+        const { adapterName, instanceName } = this.resolveAdapterIdentifiers(options);
+        const propagation = options.propagation ?? propagation_1.PropagationMode.REQUIRED;
+        const key = TransactionManager_1.contextKey(adapterName, instanceName);
+        const existing = transaction_context_1.TransactionContext.getActiveTransaction(key);
+        switch (propagation) {
+            case propagation_1.PropagationMode.REQUIRED: {
+                if (existing !== undefined) {
+                    return fn();
+                }
+                const adapter = this.registry.get(adapterName, instanceName);
+                return this.startNew(adapter, adapterName, instanceName, options, fn);
+            }
+            case propagation_1.PropagationMode.REQUIRES_NEW: {
+                const adapter = this.registry.get(adapterName, instanceName);
+                if (existing === undefined) {
+                    return this.startNew(adapter, adapterName, instanceName, options, fn);
+                }
+                transaction_context_1.TransactionContext.removeActiveTransaction(key);
+                try {
+                    return await this.startNew(adapter, adapterName, instanceName, options, fn);
+                }
+                finally {
+                    transaction_context_1.TransactionContext.setActiveTransaction(key, existing);
+                }
+            }
+            case propagation_1.PropagationMode.NESTED: {
+                const adapter = this.registry.get(adapterName, instanceName);
+                if (existing === undefined) {
+                    return this.startNew(adapter, adapterName, instanceName, options, fn);
+                }
+                return this.runNestedSavepoint(adapter, existing, options, fn);
+            }
+            case propagation_1.PropagationMode.SUPPORTS: {
+                return fn();
+            }
+            case propagation_1.PropagationMode.NOT_SUPPORTED: {
+                if (existing === undefined) {
+                    return fn();
+                }
+                transaction_context_1.TransactionContext.removeActiveTransaction(key);
+                try {
+                    return await fn();
+                }
+                finally {
+                    transaction_context_1.TransactionContext.setActiveTransaction(key, existing);
+                }
+            }
+            case propagation_1.PropagationMode.NEVER: {
+                if (existing !== undefined) {
+                    throw new errors_1.IllegalTransactionStateError(`Propagation NEVER cannot be invoked inside an active transaction ` +
+                        `(adapter: '${adapterName}', instance: '${instanceName}')`);
+                }
+                return fn();
+            }
+            case propagation_1.PropagationMode.MANDATORY: {
+                if (existing === undefined) {
+                    throw new errors_1.IllegalTransactionStateError(`Propagation MANDATORY requires an active transaction, but none is ` +
+                        `active (adapter: '${adapterName}', instance: '${instanceName}')`);
+                }
+                return fn();
+            }
+        }
+    }
+    /**
+     * Compose the {@link TransactionContext} key for a given adapter
+     * (type name) + instance pair. Manager and helper packages must agree
+     * on this format so that `@nestjs-transactional/typeorm`'s
+     * `getCurrentEntityManager` can find the transaction registered here.
+     */
+    static contextKey(adapterName, instanceName) {
+        return `${adapterName}:${instanceName}`;
+    }
+    /**
+     * Translate the user-facing options into the internal `(adapterName,
+     * instanceName)` pair used to build the active-transaction Map key.
+     *
+     * Resolution order (DD-020):
+     * 1. `options.dataSource` set: lookup the unique adapter via the
+     *    registry by dataSource name. The dataSource name becomes the
+     *    `instanceName`; the registry hands back the adapter type.
+     * 2. Else: legacy path — `options.adapter` / `options.adapterInstance`
+     *    fall back to the registry's defaults.
+     */
+    resolveAdapterIdentifiers(options) {
+        if (options.dataSource !== undefined) {
+            return {
+                adapterName: this.registry.getAdapterNameByDataSource(options.dataSource),
+                instanceName: options.dataSource,
+            };
+        }
+        return {
+            adapterName: options.adapter ?? this.registry.getDefaultAdapterName(),
+            instanceName: options.adapterInstance ?? this.registry.getDefaultInstanceName(),
+        };
+    }
+    /**
+     * Register a hook to fire after the current transaction commits
+     * successfully. Attaches to the first active transaction on the current
+     * async context — sufficient for single-adapter setups. Hook errors are
+     * swallowed with a warning and do not reject `run()`.
+     *
+     * @throws {IllegalTransactionStateError} If called outside an active transaction.
+     */
+    registerAfterCommit(hook) {
+        this.currentTransaction().afterCommitHooks.push(hook);
+    }
+    /**
+     * Register a hook to fire after the current transaction rolls back. The
+     * hook receives the error that caused the rollback.
+     *
+     * @throws {IllegalTransactionStateError} If called outside an active transaction.
+     */
+    registerAfterRollback(hook) {
+        this.currentTransaction().afterRollbackHooks.push(hook);
+    }
+    /**
+     * Register a hook to fire just before the transaction commits. A throwing
+     * hook triggers the adapter's rollback — the transaction does not commit.
+     *
+     * @throws {IllegalTransactionStateError} If called outside an active transaction.
+     */
+    registerBeforeCommit(hook) {
+        this.currentTransaction().beforeCommitHooks.push(hook);
+    }
+    async startNew(adapter, adapterName, instanceName, options, fn) {
+        const outerStore = transaction_context_1.TransactionContext.getStore();
+        const correlationId = outerStore?.correlationId ?? (0, node_crypto_1.randomUUID)();
+        let activeTx;
+        const startTime = Date.now();
+        const key = TransactionManager_1.contextKey(adapterName, instanceName);
+        const body = async () => {
+            let result;
+            try {
+                result = await adapter.runInTransaction(options, async (handle) => {
+                    activeTx = {
+                        handle,
+                        adapterName,
+                        adapterInstanceName: instanceName,
+                        options,
+                        startedAt: new Date(),
+                        afterCommitHooks: [],
+                        afterRollbackHooks: [],
+                        beforeCommitHooks: [],
+                        correlationId,
+                    };
+                    transaction_context_1.TransactionContext.setActiveTransaction(key, activeTx);
+                    this.notifyStart({
+                        transactionId: handle.id,
+                        adapterName,
+                        adapterInstanceName: instanceName,
+                        correlationId,
+                        options,
+                    });
+                    try {
+                        try {
+                            const innerValue = await fn();
+                            // Before-commit hooks run inside the adapter callback so
+                            // that a throwing hook still triggers the adapter's
+                            // rollback path.
+                            for (const hook of activeTx.beforeCommitHooks) {
+                                await hook();
+                            }
+                            return { ok: true, value: innerValue };
+                        }
+                        catch (err) {
+                            if (this.shouldRollback(err, options)) {
+                                throw err; // let the adapter roll back
+                            }
+                            // Commit despite the error — the manager will re-raise it
+                            // to the caller after the adapter's commit succeeds.
+                            return { ok: false, error: err };
+                        }
+                    }
+                    finally {
+                        transaction_context_1.TransactionContext.removeActiveTransaction(key);
+                    }
+                });
+            }
+            catch (rollbackError) {
+                if (activeTx !== undefined) {
+                    this.notifyRollback({
+                        transactionId: activeTx.handle.id,
+                        adapterName,
+                        adapterInstanceName: instanceName,
+                        correlationId,
+                        options,
+                        durationMs: Date.now() - startTime,
+                        error: rollbackError,
+                        rollbackCount: activeTx.afterRollbackHooks.length,
+                    });
+                    await this.runHooks(activeTx.afterRollbackHooks, rollbackError);
+                }
+                throw rollbackError;
+            }
+            // Adapter has committed. Fire the observer event and afterCommit
+            // hooks regardless of whether we are about to re-raise a business
+            // error — the database state is what the subscribers care about,
+            // and it has been persisted.
+            if (activeTx !== undefined) {
+                this.notifyCommit({
+                    transactionId: activeTx.handle.id,
+                    adapterName,
+                    adapterInstanceName: instanceName,
+                    correlationId,
+                    options,
+                    durationMs: Date.now() - startTime,
+                    commitCount: activeTx.afterCommitHooks.length,
+                });
+                await this.runHooks(activeTx.afterCommitHooks);
+            }
+            if (result.ok) {
+                return result.value;
+            }
+            throw result.error;
+        };
+        if (outerStore === undefined) {
+            return transaction_context_1.TransactionContext.run(correlationId, body);
+        }
+        return body();
+    }
+    notifyStart(ctx) {
+        for (const observer of this.observers) {
+            try {
+                observer.onTransactionStart?.(ctx);
+            }
+            catch (err) {
+                this.logger.warn(`TransactionObserver.onTransactionStart failed: ${String(err)}`, err instanceof Error ? err.stack : undefined);
+            }
+        }
+    }
+    notifyCommit(ctx) {
+        for (const observer of this.observers) {
+            try {
+                observer.onTransactionCommit?.(ctx);
+            }
+            catch (err) {
+                this.logger.warn(`TransactionObserver.onTransactionCommit failed: ${String(err)}`, err instanceof Error ? err.stack : undefined);
+            }
+        }
+    }
+    notifyRollback(ctx) {
+        for (const observer of this.observers) {
+            try {
+                observer.onTransactionRollback?.(ctx);
+            }
+            catch (err) {
+                this.logger.warn(`TransactionObserver.onTransactionRollback failed: ${String(err)}`, err instanceof Error ? err.stack : undefined);
+            }
+        }
+    }
+    /**
+     * Run `fn` inside a savepoint on `parent.handle`. Used by
+     * {@link PropagationMode.NESTED} when there is an active outer transaction.
+     *
+     * The manager intentionally does NOT create a new
+     * {@link ActiveTransaction} for the savepoint — hook registrations inside
+     * `fn` fall through {@link currentTransaction} to the outer transaction,
+     * which is the Spring-style semantic: nested events "promote" to the
+     * enclosing transaction and fire when that transaction commits.
+     *
+     * Rollback semantics follow `shouldRollback`: errors that match the
+     * rollback rules cause the adapter to roll back to the savepoint (the
+     * outer transaction is unaffected); errors that do NOT match lead to a
+     * savepoint release (commit-inside-savepoint) and the error is re-raised
+     * to the caller after the release.
+     */
+    async runNestedSavepoint(adapter, parent, options, fn) {
+        const result = await adapter.runInSavepoint(parent.handle, async () => {
+            try {
+                const value = await fn();
+                return { ok: true, value };
+            }
+            catch (err) {
+                if (this.shouldRollback(err, options)) {
+                    throw err; // adapter rolls back to savepoint
+                }
+                return { ok: false, error: err };
+            }
+        });
+        if (result.ok) {
+            return result.value;
+        }
+        throw result.error;
+    }
+    currentTransaction() {
+        const store = transaction_context_1.TransactionContext.getStore();
+        if (store === undefined) {
+            throw new errors_1.IllegalTransactionStateError('Cannot register a transactional hook outside of TransactionManager.run()');
+        }
+        for (const tx of store.activeTransactions.values()) {
+            return tx;
+        }
+        throw new errors_1.IllegalTransactionStateError('Cannot register a transactional hook: no active transaction on the current context');
+    }
+    /**
+     * Spring-style decision on whether a thrown error should trigger rollback:
+     *
+     * 1. If `noRollbackFor` is set and matches, commit anyway (precedence).
+     * 2. Else if `rollbackFor` is set, roll back only when the error matches
+     *    an entry — a non-match commits (explicit allow-list semantics).
+     * 3. Else (no rules set), any error triggers rollback — the default
+     *    transactional behaviour.
+     */
+    shouldRollback(error, options) {
+        const { noRollbackFor, rollbackFor } = options;
+        if (noRollbackFor !== undefined && noRollbackFor.length > 0) {
+            if (noRollbackFor.some((cls) => error instanceof cls)) {
+                return false;
+            }
+        }
+        if (rollbackFor !== undefined && rollbackFor.length > 0) {
+            return rollbackFor.some((cls) => error instanceof cls);
+        }
+        return true;
+    }
+    async runHooks(hooks, error) {
+        for (const hook of hooks) {
+            try {
+                await hook(error);
+            }
+            catch (hookError) {
+                this.logger.warn(`Transaction lifecycle hook failed: ${String(hookError)}`, hookError instanceof Error ? hookError.stack : undefined);
+            }
+        }
+    }
+};
+exports.TransactionManager = TransactionManager;
+exports.TransactionManager = TransactionManager = TransactionManager_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(adapter_registry_1.ADAPTER_REGISTRY)),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)(transaction_observer_1.TRANSACTION_OBSERVERS)),
+    __metadata("design:paramtypes", [adapter_registry_1.AdapterRegistry, Array])
+], TransactionManager);
+//# sourceMappingURL=transaction.manager.js.map

package/dist/manager/transaction.manager.js.map

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

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

@@ -0,0 +1,242 @@
+import { type DynamicModule, type InjectionToken, type ModuleMetadata } from '@nestjs/common';
+import { type TransactionObserver } from '../observability/transaction-observer';
+import type { TransactionAdapter } from '../types/transaction-adapter';
+/**
+ * Synchronous options for {@link TransactionalModule.forRoot}.
+ *
+ * Multi-dataSource deployments call `forRoot` once per dataSource:
+ *
+ * ```ts
+ * TransactionalModule.forRoot({ adapter: defaultAdapter }),                 // default
+ * TransactionalModule.forRoot({ adapter: billingAdapter }),                 // billing
+ * TransactionalModule.forRoot({ adapter: inventoryAdapter }),               // inventory
+ * ```
+ *
+ * Matches NestJS conventions (`TypeOrmModule`, `MongooseModule`,
+ * `ClientsModule`) and aligns with `OutboxModule.forRoot` from
+ * Phase 14.3.2 (ADR-019). Cross-call coordination of singletons
+ * (`AdapterRegistry`, `TransactionManager`, `APP_INTERCEPTOR`,
+ * `TransactionalMethodsBootstrap`, `TRANSACTION_OBSERVERS`) lives in
+ * static class storage on {@link TransactionalModule}, mirroring
+ * `@nestjs/typeorm`'s `EntitiesMetadataStorage` pattern.
+ *
+ * The `infrastructure-only` shorthand `TransactionalModule.forRoot({})`
+ * (no adapter) is preserved for setups where the adapter is contributed
+ * by an integration package's `forFeature` (e.g.
+ * `TypeOrmTransactionalModule.forFeature` calls `AdapterRegistry.register`
+ * imperatively at module-init time).
+ *
+ * Q5 invariants on multi-call:
+ * - Two calls with the same `adapter.dataSourceName` throw at module-
+ *   definition time.
+ * - Two `forRoot({})` calls (both infrastructure-only) — the second
+ *   throws because infrastructure has already been registered.
+ * - `forRoot({})` then `forRoot({ adapter })` works.
+ * - `forRoot({ adapter A })` then `forRoot({ adapter B })` (different
+ *   dataSource) works.
+ * - `forRoot({ adapter })` then `forRoot({})` throws (infrastructure
+ *   already registered).
+ *
+ * Tests that build multiple modules sequentially MUST call
+ * {@link TransactionalModule.resetForTesting} in `beforeEach`.
+ */
+export interface TransactionalModuleOptions {
+    /**
+     * Adapter instance to register. The adapter's `dataSourceName`
+     * keys this registration; duplicate dataSource names across
+     * `forRoot` calls throw. When omitted, this call only registers
+     * the process-wide infrastructure — adapters are then expected
+     * from an integration package (e.g.
+     * `TypeOrmTransactionalModule.forFeature`).
+     */
+    readonly adapter?: TransactionAdapter;
+    /**
+     * When `true` (default — Phase 14.10), the module is registered as
+     * `@Global()` — its exports are available app-wide without being
+     * re-imported. Honored per call (each `forRoot` builds its own
+     * `DynamicModule` with its own `global` flag). Multi-call setups
+     * effectively require `isGlobal: true` on at least the first call
+     * for `TransactionManager` and `AdapterRegistry` to be visible
+     * across sibling DynamicModules; the default flip aligns the API
+     * with `OutboxModule` (also default-global) and removes a
+     * common-case footgun.
+     */
+    readonly isGlobal?: boolean;
+    /**
+     * When `true` (default), the FIRST `forRoot` call registers
+     * {@link TransactionalInterceptor} as `APP_INTERCEPTOR`. Honored
+     * only on the first call — the value passed to subsequent calls is
+     * ignored (the interceptor is process-wide).
+     */
+    readonly registerInterceptor?: boolean;
+    /**
+     * When `true` (default), the FIRST `forRoot` call registers
+     * {@link TransactionalMethodsBootstrap} — an
+     * `OnApplicationBootstrap` service that wraps every `@Transactional()`
+     * method on plain `@Injectable()` providers with
+     * `TransactionManager.run(...)`. Honored only on the first call;
+     * subsequent calls' value is ignored.
+     */
+    readonly registerMethodsBootstrap?: boolean;
+    /**
+     * Transaction observers registered under {@link TRANSACTION_OBSERVERS}.
+     * Honored only on the FIRST `forRoot` call (Q2 invariant) — passing
+     * `observers` to a subsequent call throws at module-definition time.
+     * Provide your own `TRANSACTION_OBSERVERS` provider via standard DI
+     * if your observers need DI resolution.
+     */
+    readonly observers?: readonly TransactionObserver[];
+}
+/**
+ * Result shape resolved by {@link TransactionalModuleAsyncOptions.useFactory}.
+ *
+ * Per-DS DI tokens (`getTransactionalAdapterToken(ds)`,
+ * `getTransactionContextToken(ds)`,
+ * `getTransactionManagerToken(ds)`) are NOT registered for
+ * `forRootAsync` because the dataSource name is only known after the
+ * async factory runs, while NestJS provider tokens must be declared
+ * statically. If per-DS injection matters, use sync
+ * `forRoot({ adapter })` instead — build the adapter configuration
+ * through your own async logic before reaching the module imports.
+ */
+export interface TransactionalModuleAsyncFactoryResult {
+    readonly adapter?: TransactionAdapter;
+    readonly observers?: readonly TransactionObserver[];
+}
+/**
+ * Asynchronous options for {@link TransactionalModule.forRootAsync}.
+ * Mirrors the multi-call pattern of `forRoot`: each call registers one
+ * dataSource's adapter (resolved asynchronously). See
+ * {@link TransactionalModuleAsyncFactoryResult} for the per-DS-token
+ * limitation.
+ */
+export interface TransactionalModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    readonly isGlobal?: boolean;
+    readonly registerInterceptor?: boolean;
+    readonly registerMethodsBootstrap?: boolean;
+    readonly useFactory: (...args: never[]) => Promise<TransactionalModuleAsyncFactoryResult> | TransactionalModuleAsyncFactoryResult;
+    readonly inject?: readonly InjectionToken[];
+}
+/**
+ * NestJS module that wires the core transactional runtime:
+ * {@link AdapterRegistry}, {@link TransactionManager}, and (by
+ * default) the global {@link TransactionalInterceptor}. ADR-018
+ * shape — multi-dataSource deployments call {@link forRoot} once per
+ * dataSource. Static class storage coordinates singletons across
+ * calls (mirrors Phase 14.3.2 `OutboxModule` per ADR-019).
+ *
+ * The first call registers the process-wide infrastructure; subsequent
+ * calls only contribute per-dataSource providers. Adapter-specific
+ * registration (TypeORM, Prisma, ...) is handled by the integration
+ * package's `forFeature` helper — this module only provides the
+ * adapter-agnostic infrastructure.
+ */
+export declare class TransactionalModule {
+    /**
+     * @internal
+     * Process-wide map of adapter-bearing `forRoot` calls, keyed by
+     * `adapter.dataSourceName`. Used for dedup of duplicate dataSource
+     * registrations at module-definition time. The {@link AdapterRegistry}
+     * itself is populated imperatively by per-DS adapter providers
+     * (factory side effect) — this Map exists for `forRoot`-call-time
+     * coordination only.
+     *
+     * Tests that build multiple modules sequentially MUST call
+     * {@link resetForTesting} between cases.
+     */
+    private static readonly registrations;
+    /**
+     * @internal
+     * `true` once any `forRoot` (or `forRootAsync`) call has run.
+     * First-call-special providers (singletons, interceptor, methods
+     * bootstrap, observers) are only registered when this is `false` at
+     * the start of a call.
+     *
+     * Tracked separately from {@link registrations} because the
+     * shorthand `forRoot({})` (no adapter) still registers
+     * infrastructure but contributes nothing to the Map. Q5 invariant:
+     * a second `forRoot({})` after infrastructure is already registered
+     * throws — the first call already wired everything; the second has
+     * nothing to add.
+     */
+    private static infrastructureRegistered;
+    /**
+     * @internal
+     * Counter for `forRootAsync`-only token uniqueness. Not strictly
+     * needed for `Symbol()` (each call returns a unique symbol
+     * regardless of description), but keeping a numeric id makes
+     * provider names deterministic in error messages.
+     */
+    private static asyncCounter;
+    /**
+     * Test-only — drop every registration so a subsequent `forRoot`
+     * starts from a clean slate. Mirrors the pattern used with
+     * `OutboxModule.resetForTesting` and `EntitiesMetadataStorage` in
+     * `@nestjs/typeorm` test suites.
+     *
+     * Production code should never call this. Calling at runtime after
+     * the module has been initialised does NOT clear the provider tree
+     * NestJS already built — it only affects subsequent `forRoot` calls.
+     *
+     * @internal
+     */
+    static resetForTesting(): void;
+    /**
+     * Synchronous registration. Each call registers one dataSource's
+     * adapter (or, with `adapter` omitted, only the process-wide
+     * infrastructure for an integration package's `forFeature` to write
+     * into).
+     *
+     * @example Single-adapter
+     * ```ts
+     * TransactionalModule.forRoot({ isGlobal: true, adapter })
+     * ```
+     *
+     * @example Multi-adapter (multiple calls)
+     * ```ts
+     * TransactionalModule.forRoot({ isGlobal: true, adapter: defaultAdapter }),
+     * TransactionalModule.forRoot({ adapter: billingAdapter }),
+     * TransactionalModule.forRoot({ adapter: inventoryAdapter }),
+     * ```
+     *
+     * @example Infrastructure-only (TypeORM forFeature handles adapters)
+     * ```ts
+     * TransactionalModule.forRoot({ isGlobal: true }),
+     * TypeOrmTransactionalModule.forFeature({ dataSource }),
+     * ```
+     */
+    static forRoot(options?: TransactionalModuleOptions): DynamicModule;
+    /**
+     * Asynchronous registration. Each call registers one dataSource's
+     * adapter (resolved asynchronously via `useFactory`). Multi-DS
+     * deployments call `forRootAsync` once per dataSource.
+     *
+     * **Per-DS DI token limitation**: per-DS tokens
+     * (`getTransactionalAdapterToken(ds)`, etc.) are NOT registered
+     * for `forRootAsync` calls because the dataSource identifier is
+     * only known after the async factory runs, while NestJS provider
+     * tokens must be declared statically. If per-DS injection matters,
+     * use sync `forRoot({ adapter })` instead — build the adapter
+     * configuration through your own async logic before reaching the
+     * module imports.
+     *
+     * `forRootAsync` still works for `AdapterRegistry`-based access
+     * (`@Transactional({ dataSource })`,
+     * `getCurrentEntityManager(dataSource)`,
+     * `manager.run({ dataSource })`) — those route through the registry,
+     * which is populated by the async factory's side effect via
+     * `AdapterRegistry.register(...)`.
+     *
+     * @example
+     * ```ts
+     * TransactionalModule.forRootAsync({
+     *   inject: [ConfigService],
+     *   useFactory: (config: ConfigService) => ({
+     *     adapter: buildAdapterFromConfig(config),
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options: TransactionalModuleAsyncOptions): DynamicModule;
+}
+//# sourceMappingURL=transactional.module.d.ts.map