@nestjs-transactional/outbox-typeorm 1.0.0-alpha.0

package/dist/migrations/1700000000000-create-event-publication.d.ts

@@ -0,0 +1,18 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+/**
+ * Initial schema for the Event Publication Registry. Creates both the
+ * hot queue (`event_publication`) and the archive table
+ * (`event_publication_archive`), along with the indexes needed by the
+ * worker, operator queries, and the cleanup routines.
+ *
+ * The timestamp `1700000000000` is a placeholder chosen so this
+ * migration sorts before any application-owned migrations a user might
+ * add in their project. Teams integrating the package can copy the
+ * file into their own migrations directory and rename it to match
+ * their migration timestamp convention.
+ */
+export declare class CreateEventPublication1700000000000 implements MigrationInterface {
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}
+//# sourceMappingURL=1700000000000-create-event-publication.d.ts.map

package/dist/migrations/1700000000000-create-event-publication.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateEventPublication1700000000000 = void 0;
+const event_publication_schema_1 = require("../schema/event-publication-schema");
+/**
+ * Initial schema for the Event Publication Registry. Creates both the
+ * hot queue (`event_publication`) and the archive table
+ * (`event_publication_archive`), along with the indexes needed by the
+ * worker, operator queries, and the cleanup routines.
+ *
+ * The timestamp `1700000000000` is a placeholder chosen so this
+ * migration sorts before any application-owned migrations a user might
+ * add in their project. Teams integrating the package can copy the
+ * file into their own migrations directory and rename it to match
+ * their migration timestamp convention.
+ */
+class CreateEventPublication1700000000000 {
+    async up(queryRunner) {
+        await (0, event_publication_schema_1.applyEventPublicationSchema)(queryRunner);
+    }
+    async down(queryRunner) {
+        await (0, event_publication_schema_1.revertEventPublicationSchema)(queryRunner);
+    }
+}
+exports.CreateEventPublication1700000000000 = CreateEventPublication1700000000000;
+//# sourceMappingURL=1700000000000-create-event-publication.js.map

package/dist/migrations/1700000000000-create-event-publication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1700000000000-create-event-publication.js","sourceRoot":"","sources":["../../src/migrations/1700000000000-create-event-publication.ts"],"names":[],"mappings":";;;AAEA,iFAG4C;AAE5C;;;;;;;;;;;GAWG;AACH,MAAa,mCAAmC;IAC9C,KAAK,CAAC,EAAE,CAAC,WAAwB;QAC/B,MAAM,IAAA,sDAA2B,EAAC,WAAW,CAAC,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,WAAwB;QACjC,MAAM,IAAA,uDAA4B,EAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AARD,kFAQC"}

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

@@ -0,0 +1,272 @@
+import { type DynamicModule, type InjectionToken, type ModuleMetadata, type Provider } from '@nestjs/common';
+import { type SchemaInitializationOptions } from '../schema/schema-initialization-options';
+/**
+ * Options accepted by {@link OutboxTypeOrmModule.forRoot} (Phase 14.21).
+ *
+ * The dataSource identifier is now a *string name only*. The actual
+ * `DataSource` instance is resolved from DI under
+ * `getDataSourceToken(name)` — the same convention `@nestjs/typeorm`
+ * uses for `@InjectRepository(E, dataSource)`. Mirrors the Phase 14.20
+ * shape of `TypeOrmTransactionalModule.forRoot`.
+ */
+export interface OutboxTypeOrmOptions {
+    /**
+     * Identifier of the dataSource the repository binds to. Aligns with
+     * `TypeOrmTransactionalModule.forRoot({ dataSource })` and the
+     * `@Transactional({ dataSource })` decorator option. Defaults to
+     * `'default'`.
+     *
+     * Multi-dataSource deployments call `forRoot` once per dataSource;
+     * each call registers its own `TypeOrmEventPublicationRepository`
+     * instance under {@link getTypeOrmRepositoryProviderToken} so the
+     * outbox-side per-DS tokens (Phase 14.3) can resolve them via the
+     * provider returned by {@link typeOrmEventPublicationRepositoryProvider}.
+     */
+    readonly dataSource?: string;
+    /**
+     * Development-only auto-schema-creation config. Defaults to
+     * `{ enabled: false }`. When enabled, {@link SchemaInitializer} will
+     * create `event_publication` and `event_publication_archive` on
+     * application bootstrap if they are missing. Production deployments
+     * should apply the shipped TypeORM migration instead.
+     */
+    readonly schemaInitialization?: SchemaInitializationOptions;
+    /**
+     * Register as a `@Global()` module so exports are visible to
+     * `OutboxModule` and the rest of the application without an explicit
+     * import chain. Defaults to `true` — the typical deployment imports
+     * `OutboxTypeOrmModule.forRoot` once in the root module and
+     * expects the repository to be globally resolvable.
+     */
+    readonly isGlobal?: boolean;
+}
+/**
+ * Asynchronous flavour of {@link OutboxTypeOrmOptions}. Mirrors the
+ * shape of `TypeOrmTransactionalModule.forRootAsync` (Phase 14.20).
+ *
+ * **dataSource name limitation**: the `dataSource` field on this
+ * interface is *statically declared* (not async-resolved). NestJS
+ * provider tokens must be declared at module-build time, and
+ * per-DS tokens like `getTypeOrmRepositoryProviderToken(name)`
+ * require the name synchronously. The async factory resolves only
+ * the remaining config (`schemaInitialization`, `isGlobal`). If
+ * fully-async dataSource-name resolution is required, pre-resolve
+ * the name in your own bootstrap code and call sync `forRoot`
+ * with the result.
+ */
+export interface OutboxTypeOrmAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Statically-known dataSource name (see {@link OutboxTypeOrmAsyncOptions}
+     * JSDoc for the rationale). Defaults to `'default'`.
+     */
+    readonly dataSource?: string;
+    /**
+     * Async factory resolving the *remaining* options (excluding
+     * `dataSource` which must be static).
+     */
+    readonly useFactory: (...args: never[]) => Promise<Omit<OutboxTypeOrmOptions, 'dataSource'>> | Omit<OutboxTypeOrmOptions, 'dataSource'>;
+    readonly inject?: readonly InjectionToken[];
+}
+/**
+ * Private per-dataSource token under which {@link OutboxTypeOrmModule}
+ * registers the `TypeOrmEventPublicationRepository` instance for a
+ * given dataSource. Internal — consumed only by
+ * {@link typeOrmEventPublicationRepositoryProvider} via `useExisting`,
+ * which the user feeds into `OutboxModule.forRoot({ repository })` (one
+ * `forRoot` call per dataSource — ADR-019 multi-forRoot pattern).
+ */
+export declare function getTypeOrmRepositoryProviderToken(dataSourceName: string): string;
+/**
+ * NestJS module that wires the TypeORM persistence backend for the
+ * Event Publication Registry (Phase 14.21 reshape, mirrors Phase
+ * 14.20's `TypeOrmTransactionalModule.forRoot`). Multi-dataSource
+ * setups call {@link forRoot} once per dataSource — each call
+ * registers an independent {@link TypeOrmEventPublicationRepository}
+ * instance under a private per-dataSource token. The
+ * {@link typeOrmEventPublicationRepositoryProvider} factory returns
+ * a `Provider` that aliases the outbox-side per-DS repository token
+ * to that private token.
+ *
+ * The actual `DataSource` is resolved via `@nestjs/typeorm`'s
+ * `getDataSourceToken(name)` — `TypeOrmModule.forRoot(...)` registers
+ * it globally, so this module just looks it up in DI.
+ *
+ * Single-dataSource wiring:
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ ... }),
+ *
+ *     TransactionalModule.forRoot({ isGlobal: true }),
+ *     TypeOrmTransactionalModule.forRoot(),
+ *
+ *     OutboxModule.forRoot({
+ *       repository: typeOrmEventPublicationRepositoryProvider(),
+ *     }),
+ *     OutboxTypeOrmModule.forRoot(),
+ *     OutboxModule.forFeature([OrderPlacedEvent]),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Multi-dataSource wiring:
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ ... }),
+ *     TypeOrmModule.forRoot({ name: 'billing', ... }),
+ *
+ *     TransactionalModule.forRoot({ isGlobal: true }),
+ *     TypeOrmTransactionalModule.forRoot(),
+ *     TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }),
+ *
+ *     OutboxModule.forRoot({
+ *       repository: typeOrmEventPublicationRepositoryProvider(),
+ *     }),
+ *     OutboxModule.forRoot({
+ *       dataSource: 'billing',
+ *       repository: typeOrmEventPublicationRepositoryProvider('billing'),
+ *     }),
+ *
+ *     OutboxTypeOrmModule.forRoot(),
+ *     OutboxTypeOrmModule.forRoot({ dataSource: 'billing' }),
+ *
+ *     OutboxModule.forFeature([DefaultEvent], { dataSource: 'default' }),
+ *     OutboxModule.forFeature([BillingEvent], { dataSource: 'billing' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+export declare class OutboxTypeOrmModule {
+    /**
+     * @internal
+     * Counter for `forRootAsync`-only token uniqueness. Mirrors the
+     * pattern used in `TypeOrmTransactionalModule.forRootAsync`
+     * (Phase 14.20) — every async call gets a unique provider symbol
+     * so consecutive calls don't collide.
+     */
+    private static asyncCounter;
+    /**
+     * Test-only — reset the async-counter so tests building multiple
+     * modules sequentially don't accumulate symbol IDs in a single
+     * Jest worker. Production code should never call this.
+     *
+     * @internal
+     */
+    static resetForTesting(): void;
+    /**
+     * Synchronous registration. Each call binds one DataSource (by
+     * name) to the outbox-typeorm infrastructure: registers the
+     * repository under the private per-DS token, registers the
+     * per-DS `SchemaInitializer`, and resolves the actual `DataSource`
+     * via `@nestjs/typeorm`'s `getDataSourceToken(name)`.
+     *
+     * @example Default DataSource
+     * ```ts
+     * OutboxTypeOrmModule.forRoot()
+     * ```
+     *
+     * @example Named DataSource
+     * ```ts
+     * OutboxTypeOrmModule.forRoot({ dataSource: 'billing' })
+     * ```
+     */
+    static forRoot(options?: OutboxTypeOrmOptions): DynamicModule;
+    /**
+     * Asynchronous registration. The `dataSource` name is statically
+     * declared (see {@link OutboxTypeOrmAsyncOptions} for the
+     * rationale); the `useFactory` resolves the remaining options
+     * (`schemaInitialization`, `isGlobal`) through a NestJS-style
+     * async factory.
+     *
+     * @example
+     * ```ts
+     * OutboxTypeOrmModule.forRootAsync({
+     *   dataSource: 'billing',
+     *   imports: [ConfigModule],
+     *   inject: [ConfigService],
+     *   useFactory: (cfg: ConfigService) => ({
+     *     schemaInitialization: { enabled: cfg.get('NODE_ENV') !== 'production' },
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options: OutboxTypeOrmAsyncOptions): DynamicModule;
+}
+/**
+ * Factory returning a `Provider` that aliases the outbox-side per-DS
+ * repository token (`getEventPublicationRepositoryToken(dataSourceName)`)
+ * to the `TypeOrmEventPublicationRepository` instance registered by
+ * {@link OutboxTypeOrmModule.forRoot} for the same dataSource.
+ *
+ * **Why this bridge function exists** (frequently-asked question, full
+ * explanation):
+ *
+ * `OutboxModule.forRoot` ALWAYS registers something under the per-DS
+ * `getEventPublicationRepositoryToken(dataSourceName)` token — when no
+ * `repository` option is passed, it defaults to
+ * `InMemoryEventPublicationRepository`. `OutboxTypeOrmModule.forRoot`
+ * cannot register under THE SAME token directly because both modules
+ * are `@Global()` and a duplicate `@Global()` provider for the same
+ * token causes NestJS DI conflicts.
+ *
+ * The bridge function side-steps the conflict by registering an
+ * `useExisting` alias provider in `OutboxModule`'s scope:
+ * `OutboxModule.forRoot({ repository: typeOrmEventPublicationRepositoryProvider() })`
+ * tells `OutboxModule` "for this dataSource's repository, alias to the
+ * private token under which `OutboxTypeOrmModule.forRoot` registered
+ * its `TypeOrmEventPublicationRepository` instance". `OutboxModule`'s
+ * `reBindProvider` machinery overwrites the placeholder `provide`
+ * field with the per-DS expected token; the `useExisting` clause
+ * carries the actual aliasing.
+ *
+ * Net flow at runtime:
+ *
+ * ```
+ * @InjectEventPublicationRepository → getEventPublicationRepositoryToken('billing')
+ *   → useExisting → getTypeOrmRepositoryProviderToken('billing')   // private
+ *   → TypeOrmEventPublicationRepository instance
+ * ```
+ *
+ * Phase 14.21 considered removing this bridge function (delete it,
+ * have `OutboxTypeOrmModule.forRoot` register directly under the
+ * official outbox-side token), but the change would require
+ * `OutboxModule.forRoot` to drop its in-memory default — which would
+ * break 14+ outbox unit tests that rely on `OutboxModule.forRoot({})`
+ * defaulting to in-memory. The bridge function is small and
+ * well-documented; keeping it preserves the architectural separation
+ * (outbox-core does not import outbox-typeorm) and saves the test
+ * migration burden.
+ *
+ * Usage — pass to `OutboxModule.forRoot({ repository })`. Multi-DS
+ * setups call `forRoot` once per dataSource (ADR-019 multi-forRoot
+ * pattern) with the corresponding alias-provider call:
+ *
+ * ```ts
+ * // Single-DS
+ * OutboxModule.forRoot({
+ *   repository: typeOrmEventPublicationRepositoryProvider(),
+ * })
+ *
+ * // Multi-DS — one forRoot per dataSource
+ * OutboxModule.forRoot({
+ *   repository: typeOrmEventPublicationRepositoryProvider(),
+ * })
+ * OutboxModule.forRoot({
+ *   dataSource: 'billing',
+ *   repository: typeOrmEventPublicationRepositoryProvider('billing'),
+ * })
+ * ```
+ *
+ * The returned provider's `provide` field is a placeholder
+ * (`EVENT_PUBLICATION_REPOSITORY`) — outbox's `reBindProvider`
+ * overwrites it with the per-DS token. The substantive part is the
+ * `useExisting` clause, which resolves to the private per-DS token
+ * registered by `forRoot`.
+ */
+export declare function typeOrmEventPublicationRepositoryProvider(dataSourceName?: string): Provider;
+//# sourceMappingURL=outbox-typeorm.module.d.ts.map

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

@@ -0,0 +1,335 @@
+"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 OutboxTypeOrmModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboxTypeOrmModule = void 0;
+exports.getTypeOrmRepositoryProviderToken = getTypeOrmRepositoryProviderToken;
+exports.typeOrmEventPublicationRepositoryProvider = typeOrmEventPublicationRepositoryProvider;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const outbox_1 = require("@nestjs-transactional/outbox");
+const typeorm_event_publication_repository_1 = require("../repository/typeorm-event-publication.repository");
+const schema_initialization_options_1 = require("../schema/schema-initialization-options");
+const schema_initializer_1 = require("../schema/schema-initializer");
+/**
+ * Private per-dataSource token under which {@link OutboxTypeOrmModule}
+ * registers the `TypeOrmEventPublicationRepository` instance for a
+ * given dataSource. Internal — consumed only by
+ * {@link typeOrmEventPublicationRepositoryProvider} via `useExisting`,
+ * which the user feeds into `OutboxModule.forRoot({ repository })` (one
+ * `forRoot` call per dataSource — ADR-019 multi-forRoot pattern).
+ */
+function getTypeOrmRepositoryProviderToken(dataSourceName) {
+    return `OUTBOX_TYPEORM_REPOSITORY_${dataSourceName}`;
+}
+/**
+ * Internal per-dataSource token for the {@link SchemaInitializer}
+ * instance bound to a given dataSource. Each `forRoot` call
+ * instantiates its own initializer (NestJS lifecycle invokes
+ * `onApplicationBootstrap` on every registered instance) so the
+ * `event_publication` schema is created in each configured dataSource
+ * independently.
+ */
+function getOutboxTypeOrmSchemaInitializerToken(dataSourceName) {
+    return `OUTBOX_TYPEORM_SCHEMA_INITIALIZER_${dataSourceName}`;
+}
+/**
+ * Internal per-dataSource token carrying the resolved
+ * {@link SchemaInitializationOptions} the matching
+ * {@link SchemaInitializer} reads on bootstrap. Distinct from the
+ * package-level `SCHEMA_INITIALIZATION_OPTIONS` symbol exported by
+ * `../schema/schema-initialization-options` — that symbol stays
+ * exported for users who wire `SchemaInitializer` manually outside
+ * `OutboxTypeOrmModule.forRoot`.
+ */
+function getOutboxTypeOrmSchemaOptionsToken(dataSourceName) {
+    return `OUTBOX_TYPEORM_SCHEMA_OPTIONS_${dataSourceName}`;
+}
+const ASYNC_OPTIONS_TOKEN = (id) => Symbol(`OUTBOX_TYPEORM_ASYNC_OPTIONS[${id}]`);
+/**
+ * NestJS module that wires the TypeORM persistence backend for the
+ * Event Publication Registry (Phase 14.21 reshape, mirrors Phase
+ * 14.20's `TypeOrmTransactionalModule.forRoot`). Multi-dataSource
+ * setups call {@link forRoot} once per dataSource — each call
+ * registers an independent {@link TypeOrmEventPublicationRepository}
+ * instance under a private per-dataSource token. The
+ * {@link typeOrmEventPublicationRepositoryProvider} factory returns
+ * a `Provider` that aliases the outbox-side per-DS repository token
+ * to that private token.
+ *
+ * The actual `DataSource` is resolved via `@nestjs/typeorm`'s
+ * `getDataSourceToken(name)` — `TypeOrmModule.forRoot(...)` registers
+ * it globally, so this module just looks it up in DI.
+ *
+ * Single-dataSource wiring:
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ ... }),
+ *
+ *     TransactionalModule.forRoot({ isGlobal: true }),
+ *     TypeOrmTransactionalModule.forRoot(),
+ *
+ *     OutboxModule.forRoot({
+ *       repository: typeOrmEventPublicationRepositoryProvider(),
+ *     }),
+ *     OutboxTypeOrmModule.forRoot(),
+ *     OutboxModule.forFeature([OrderPlacedEvent]),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * Multi-dataSource wiring:
+ *
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     TypeOrmModule.forRoot({ ... }),
+ *     TypeOrmModule.forRoot({ name: 'billing', ... }),
+ *
+ *     TransactionalModule.forRoot({ isGlobal: true }),
+ *     TypeOrmTransactionalModule.forRoot(),
+ *     TypeOrmTransactionalModule.forRoot({ dataSource: 'billing' }),
+ *
+ *     OutboxModule.forRoot({
+ *       repository: typeOrmEventPublicationRepositoryProvider(),
+ *     }),
+ *     OutboxModule.forRoot({
+ *       dataSource: 'billing',
+ *       repository: typeOrmEventPublicationRepositoryProvider('billing'),
+ *     }),
+ *
+ *     OutboxTypeOrmModule.forRoot(),
+ *     OutboxTypeOrmModule.forRoot({ dataSource: 'billing' }),
+ *
+ *     OutboxModule.forFeature([DefaultEvent], { dataSource: 'default' }),
+ *     OutboxModule.forFeature([BillingEvent], { dataSource: 'billing' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+let OutboxTypeOrmModule = class OutboxTypeOrmModule {
+    static { OutboxTypeOrmModule_1 = this; }
+    /**
+     * @internal
+     * Counter for `forRootAsync`-only token uniqueness. Mirrors the
+     * pattern used in `TypeOrmTransactionalModule.forRootAsync`
+     * (Phase 14.20) — every async call gets a unique provider symbol
+     * so consecutive calls don't collide.
+     */
+    static asyncCounter = 0;
+    /**
+     * Test-only — reset the async-counter so tests building multiple
+     * modules sequentially don't accumulate symbol IDs in a single
+     * Jest worker. Production code should never call this.
+     *
+     * @internal
+     */
+    static resetForTesting() {
+        this.asyncCounter = 0;
+    }
+    /**
+     * Synchronous registration. Each call binds one DataSource (by
+     * name) to the outbox-typeorm infrastructure: registers the
+     * repository under the private per-DS token, registers the
+     * per-DS `SchemaInitializer`, and resolves the actual `DataSource`
+     * via `@nestjs/typeorm`'s `getDataSourceToken(name)`.
+     *
+     * @example Default DataSource
+     * ```ts
+     * OutboxTypeOrmModule.forRoot()
+     * ```
+     *
+     * @example Named DataSource
+     * ```ts
+     * OutboxTypeOrmModule.forRoot({ dataSource: 'billing' })
+     * ```
+     */
+    static forRoot(options = {}) {
+        const dataSourceName = options.dataSource ?? 'default';
+        const providers = buildPerDataSourceProviders(dataSourceName, {
+            schemaInitializationProvider: {
+                provide: getOutboxTypeOrmSchemaOptionsToken(dataSourceName),
+                useValue: options.schemaInitialization ?? schema_initialization_options_1.DEFAULT_SCHEMA_INITIALIZATION_OPTIONS,
+            },
+        });
+        return {
+            module: OutboxTypeOrmModule_1,
+            global: options.isGlobal ?? true,
+            providers,
+            exports: buildPerDataSourceExports(dataSourceName),
+        };
+    }
+    /**
+     * Asynchronous registration. The `dataSource` name is statically
+     * declared (see {@link OutboxTypeOrmAsyncOptions} for the
+     * rationale); the `useFactory` resolves the remaining options
+     * (`schemaInitialization`, `isGlobal`) through a NestJS-style
+     * async factory.
+     *
+     * @example
+     * ```ts
+     * OutboxTypeOrmModule.forRootAsync({
+     *   dataSource: 'billing',
+     *   imports: [ConfigModule],
+     *   inject: [ConfigService],
+     *   useFactory: (cfg: ConfigService) => ({
+     *     schemaInitialization: { enabled: cfg.get('NODE_ENV') !== 'production' },
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options) {
+        const dataSourceName = options.dataSource ?? 'default';
+        const id = this.asyncCounter++;
+        const asyncOptionsToken = ASYNC_OPTIONS_TOKEN(id);
+        const asyncOptionsProvider = {
+            provide: asyncOptionsToken,
+            useFactory: options.useFactory,
+            inject: options.inject ? [...options.inject] : undefined,
+        };
+        const schemaOptionsProvider = {
+            provide: getOutboxTypeOrmSchemaOptionsToken(dataSourceName),
+            useFactory: (resolved) => resolved.schemaInitialization ?? schema_initialization_options_1.DEFAULT_SCHEMA_INITIALIZATION_OPTIONS,
+            inject: [asyncOptionsToken],
+        };
+        const providers = [
+            asyncOptionsProvider,
+            ...buildPerDataSourceProviders(dataSourceName, {
+                schemaInitializationProvider: schemaOptionsProvider,
+            }),
+        ];
+        return {
+            module: OutboxTypeOrmModule_1,
+            global: true,
+            imports: options.imports ?? [],
+            providers,
+            exports: buildPerDataSourceExports(dataSourceName),
+        };
+    }
+};
+exports.OutboxTypeOrmModule = OutboxTypeOrmModule;
+exports.OutboxTypeOrmModule = OutboxTypeOrmModule = OutboxTypeOrmModule_1 = __decorate([
+    (0, common_1.Module)({})
+], OutboxTypeOrmModule);
+/**
+ * Common per-dataSource provider construction shared between
+ * `forRoot` (sync schema-options provider) and `forRootAsync`
+ * (async-resolved schema-options provider). The repository and
+ * SchemaInitializer providers are shape-identical between the two
+ * paths; only the schema-options provider's mechanics differ
+ * (sync `useValue` vs async `useFactory`), which is why it's
+ * passed in.
+ */
+function buildPerDataSourceProviders(dataSourceName, args) {
+    const dataSourceToken = (0, typeorm_1.getDataSourceToken)(dataSourceName);
+    const repositoryToken = getTypeOrmRepositoryProviderToken(dataSourceName);
+    const schemaInitializerToken = getOutboxTypeOrmSchemaInitializerToken(dataSourceName);
+    const schemaOptionsToken = getOutboxTypeOrmSchemaOptionsToken(dataSourceName);
+    return [
+        {
+            provide: repositoryToken,
+            useFactory: (ds) => new typeorm_event_publication_repository_1.TypeOrmEventPublicationRepository(ds, dataSourceName),
+            inject: [dataSourceToken],
+        },
+        args.schemaInitializationProvider,
+        {
+            provide: schemaInitializerToken,
+            useFactory: (ds, opts) => new schema_initializer_1.SchemaInitializer(ds, opts),
+            inject: [dataSourceToken, schemaOptionsToken],
+        },
+    ];
+}
+function buildPerDataSourceExports(dataSourceName) {
+    return [
+        getTypeOrmRepositoryProviderToken(dataSourceName),
+        getOutboxTypeOrmSchemaInitializerToken(dataSourceName),
+        getOutboxTypeOrmSchemaOptionsToken(dataSourceName),
+    ];
+}
+/**
+ * Factory returning a `Provider` that aliases the outbox-side per-DS
+ * repository token (`getEventPublicationRepositoryToken(dataSourceName)`)
+ * to the `TypeOrmEventPublicationRepository` instance registered by
+ * {@link OutboxTypeOrmModule.forRoot} for the same dataSource.
+ *
+ * **Why this bridge function exists** (frequently-asked question, full
+ * explanation):
+ *
+ * `OutboxModule.forRoot` ALWAYS registers something under the per-DS
+ * `getEventPublicationRepositoryToken(dataSourceName)` token — when no
+ * `repository` option is passed, it defaults to
+ * `InMemoryEventPublicationRepository`. `OutboxTypeOrmModule.forRoot`
+ * cannot register under THE SAME token directly because both modules
+ * are `@Global()` and a duplicate `@Global()` provider for the same
+ * token causes NestJS DI conflicts.
+ *
+ * The bridge function side-steps the conflict by registering an
+ * `useExisting` alias provider in `OutboxModule`'s scope:
+ * `OutboxModule.forRoot({ repository: typeOrmEventPublicationRepositoryProvider() })`
+ * tells `OutboxModule` "for this dataSource's repository, alias to the
+ * private token under which `OutboxTypeOrmModule.forRoot` registered
+ * its `TypeOrmEventPublicationRepository` instance". `OutboxModule`'s
+ * `reBindProvider` machinery overwrites the placeholder `provide`
+ * field with the per-DS expected token; the `useExisting` clause
+ * carries the actual aliasing.
+ *
+ * Net flow at runtime:
+ *
+ * ```
+ * @InjectEventPublicationRepository → getEventPublicationRepositoryToken('billing')
+ *   → useExisting → getTypeOrmRepositoryProviderToken('billing')   // private
+ *   → TypeOrmEventPublicationRepository instance
+ * ```
+ *
+ * Phase 14.21 considered removing this bridge function (delete it,
+ * have `OutboxTypeOrmModule.forRoot` register directly under the
+ * official outbox-side token), but the change would require
+ * `OutboxModule.forRoot` to drop its in-memory default — which would
+ * break 14+ outbox unit tests that rely on `OutboxModule.forRoot({})`
+ * defaulting to in-memory. The bridge function is small and
+ * well-documented; keeping it preserves the architectural separation
+ * (outbox-core does not import outbox-typeorm) and saves the test
+ * migration burden.
+ *
+ * Usage — pass to `OutboxModule.forRoot({ repository })`. Multi-DS
+ * setups call `forRoot` once per dataSource (ADR-019 multi-forRoot
+ * pattern) with the corresponding alias-provider call:
+ *
+ * ```ts
+ * // Single-DS
+ * OutboxModule.forRoot({
+ *   repository: typeOrmEventPublicationRepositoryProvider(),
+ * })
+ *
+ * // Multi-DS — one forRoot per dataSource
+ * OutboxModule.forRoot({
+ *   repository: typeOrmEventPublicationRepositoryProvider(),
+ * })
+ * OutboxModule.forRoot({
+ *   dataSource: 'billing',
+ *   repository: typeOrmEventPublicationRepositoryProvider('billing'),
+ * })
+ * ```
+ *
+ * The returned provider's `provide` field is a placeholder
+ * (`EVENT_PUBLICATION_REPOSITORY`) — outbox's `reBindProvider`
+ * overwrites it with the per-DS token. The substantive part is the
+ * `useExisting` clause, which resolves to the private per-DS token
+ * registered by `forRoot`.
+ */
+function typeOrmEventPublicationRepositoryProvider(dataSourceName = 'default') {
+    return {
+        provide: outbox_1.EVENT_PUBLICATION_REPOSITORY,
+        useExisting: getTypeOrmRepositoryProviderToken(dataSourceName),
+    };
+}
+//# sourceMappingURL=outbox-typeorm.module.js.map

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

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