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

package/LICENSE

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

package/README.md

@@ -0,0 +1,311 @@
+# @nestjs-transactional/outbox-microservices
+
+[![npm version](https://img.shields.io/npm/v/%40nestjs-transactional%2Foutbox-microservices/alpha?style=flat-square&label=npm)](https://www.npmjs.com/package/@nestjs-transactional/outbox-microservices)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue?style=flat-square)](https://github.com/igorgolovanov/nestjs-transactional/blob/main/LICENSE)
+
+> Spring Modulith `@Externalized` parity for NestJS — durable,
+> retryable delivery of outbox events to external message brokers via
+> the `@nestjs/microservices` `ClientProxy` abstraction.
+
+`MicroservicesEventExternalizer` plugs into `@nestjs-transactional/outbox`
+as the concrete `EventExternalizer` implementation and reuses the
+existing `ClientsModule` registration in your application — one
+package covers every transport `@nestjs/microservices` already
+supports (Kafka, RabbitMQ, NATS, JMS, gRPC, custom).
+
+## Architectural foundation
+
+- [ADR-015 — event externalization architecture](../../docs/adr/015-event-externalization-architecture.md)
+  explains the design (single-package strategy, structural-port SPI,
+  reuse of `ClientsModule`, atomicity / ordering rules).
+- [ADR-016 — externalization reliability semantics with `@nestjs/microservices`](../../docs/adr/016-externalization-reliability-semantics.md)
+  documents the silent-success limitation that scopes what this
+  package can guarantee out of the box, and the three production
+  mitigation strategies.
+- [`docs/architecture/event-externalization.md`](../../docs/architecture/event-externalization.md)
+  has diagrams, the end-to-end sequence, the failure-mode table, and
+  the Spring Modulith mapping.
+
+### Spring Modulith mapping (at a glance)
+
+This package is the NestJS analogue of Spring Modulith's
+`@Externalized` plus its four broker-specific artefacts
+(`spring-modulith-events-kafka`, `-amqp`, `-jms`, `-messaging`)
+collapsed into one. `@Externalized` (in `outbox`) lifts directly
+from Spring's annotation; the broker setup moves from a Spring
+auto-configuration to the user's own `ClientsModule.register()`.
+Function-based `routingKey` and `headers` callbacks replace SpEL
+expressions; bring your own type system. Full table in the
+architecture doc above.
+
+## Status
+
+Alpha. Public API may change between 0.x releases. Headers /
+`routingKey` are accepted on `@Externalized` but not yet applied to
+the wire payload — see *Limitations* below. End-to-end coverage
+lives in the externalization examples (`externalization-kafka`,
+`externalization-multi-broker`, `externalization-multi-datasource`,
+`externalization-with-fallback`) and the
+[`e-commerce-orders`](../../examples/e-commerce-orders) flagship —
+see [Worked examples](#worked-examples).
+
+## Important: reliability semantics (read before production use)
+
+**Read this before adopting the package in production.** The
+`@nestjs/microservices` `ClientProxy.emit()` API this package depends
+on (per [DD-017](../../docs/dd/017-reuse-clients-module.md)) does NOT propagate broker-side
+delivery failures in a way the externalizer can observe. In
+fire-and-forget mode the Observable returned by `emit()` completes
+when the proxy considers the dispatch *handed off to the transport*,
+not when the broker has *durably acknowledged* the message.
+
+Concretely, this means:
+
+- A `ClientKafka` configured against an unreachable broker can resolve
+  `emit()` successfully, the externalizer reports success, and the
+  outbox publication is finalised as `COMPLETED` — even though no
+  message ever reached a broker.
+- The same applies to RabbitMQ in default fire-and-forget mode and to
+  any other transport `@nestjs/microservices` supports.
+- Silent broker failures bypass the outbox retry / staleness /
+  resubmit machinery: there is nothing to retry, because as far as
+  this layer is concerned delivery succeeded.
+
+The outbox still gives you crash-consistent **enqueueing** of events
+and at-least-once **local listener** delivery. What it does NOT give
+you, in this version, is at-least-once **broker-side** delivery
+through `ClientProxy`.
+
+[ADR-016](../../docs/adr/016-externalization-reliability-semantics.md)
+documents the finding in full and lays out the future path
+(broker-aware externalizers using native producers under the same
+`EVENT_EXTERNALIZER` SPI).
+[ADR-015](../../docs/adr/015-event-externalization-architecture.md)
+records why this trade-off is acceptable for the v1 scope —
+[`docs/architecture/event-externalization.md`](../../docs/architecture/event-externalization.md)
+has the full sequence diagram and the failure-mode table.
+
+### Mitigation strategies for production
+
+1. **Configure the underlying `ClientProxy` for stronger
+   acknowledgment.** Kafka: `producer.acks: 'all'` plus
+   `producer.idempotent: true`. RabbitMQ: confirm-channel via
+   `amqp-connection-manager`. NATS: JetStream with explicit ack. The
+   package reuses whatever proxy you registered (DD-017) — it does
+   not interfere with this configuration.
+
+2. **Combine with consumer-side acknowledgment / inbox patterns.**
+   Track processed message ids on the receiving system and surface
+   gaps to operators. The outbox publication's listener id plus the
+   domain event id is enough to deduplicate.
+
+3. **Wait for the broker-aware externalizer iteration** when neither
+   of the above is feasible. The
+   [`EVENT_EXTERNALIZER` SPI](../outbox/src/externalization/event-externalizer.ts)
+   is stable; native adapters will plug into the same place without
+   client-side changes.
+
+## Installation
+
+```bash
+pnpm add @nestjs-transactional/outbox-microservices @nestjs-transactional/outbox @nestjs/microservices
+```
+
+`@nestjs-transactional/core`, `@nestjs/common`, `@nestjs/core`,
+`reflect-metadata`, and `rxjs` are peer dependencies (already present
+in any NestJS application).
+
+## Prerequisites
+
+This package does NOT register `ClientProxy` instances — that is your
+job (DD-017). Configure them through the standard
+`@nestjs/microservices` `ClientsModule`:
+
+```typescript
+import { ClientsModule, Transport } from '@nestjs/microservices';
+
+@Module({
+  imports: [
+    ClientsModule.register([
+      {
+        name: 'KAFKA_CLIENT',
+        transport: Transport.KAFKA,
+        options: {
+          client: { brokers: ['localhost:9092'] },
+        },
+      },
+    ]),
+  ],
+})
+export class AppModule {}
+```
+
+`OutboxMicroservicesModule.forRoot({ defaultClient: 'KAFKA_CLIENT' })`
+then resolves the same proxy via `ModuleRef.get(token, { strict: false })`
+when an outbox publication is ready to be externalized — no parallel
+connection pool, no second mental model.
+
+## Basic example
+
+```typescript
+import { Module } from '@nestjs/common';
+import { ClientsModule, Transport } from '@nestjs/microservices';
+import { TransactionalModule } from '@nestjs-transactional/core';
+import { Externalized, OutboxModule } from '@nestjs-transactional/outbox';
+import { OutboxMicroservicesModule } from '@nestjs-transactional/outbox-microservices';
+
+@Externalized<OrderPlacedEvent>({
+  target: 'orders.placed',
+  routingKey: (e) => e.tenantId, // see Limitations — logged, not yet applied
+})
+export class OrderPlacedEvent {
+  constructor(
+    readonly orderId: string,
+    readonly tenantId: string,
+  ) {}
+}
+
+@Module({
+  imports: [
+    TransactionalModule.forRoot({ isGlobal: true }),
+    ClientsModule.register([
+      {
+        name: 'KAFKA_CLIENT',
+        transport: Transport.KAFKA,
+        options: { client: { brokers: ['localhost:9092'] } },
+      },
+    ]),
+    OutboxModule.forRoot({}),
+    OutboxModule.forFeature([OrderPlacedEvent]),
+    OutboxMicroservicesModule.forRoot({
+      defaultClient: 'KAFKA_CLIENT',
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+When an `OrderPlacedEvent` flows through the outbox the local
+listeners run first; once they succeed the externalizer calls
+`KAFKA_CLIENT.emit('orders.placed', event)`. Failures (broker down,
+client misconfigured, ...) mark the publication `FAILED` and surface
+through `FailedEventPublications.resubmit()` — single-unit atomicity
+per [DD-019](../../docs/dd/019-hybrid-delivery-atomicity.md).
+
+## Multiple clients
+
+Register every transport you need under distinct tokens, then point
+each event at its broker via the `client` option on `@Externalized`:
+
+```typescript
+ClientsModule.register([
+  { name: 'KAFKA_CLIENT', transport: Transport.KAFKA, options: { ... } },
+  { name: 'AMQP_CLIENT',  transport: Transport.RMQ,   options: { ... } },
+]),
+
+@Externalized({ target: 'orders.placed', client: 'KAFKA_CLIENT' })
+class OrderPlacedEvent { /* ... */ }
+
+@Externalized({ target: 'audit', client: 'AMQP_CLIENT' })
+class AuditableEvent { /* ... */ }
+```
+
+A `defaultClient` configured on the module is used when an event
+omits the per-event `client`. Set neither and the externalizer
+rejects the publication with a clear `ExternalizationError` — the row
+is recorded as `FAILED` and the operator can fix the configuration
+and resubmit.
+
+## Multi-dataSource setups
+
+This package needs no special configuration when the application
+runs with multiple `OutboxModule.forRoot()` calls (one per
+dataSource — ADR-019 multi-forRoot pattern). A single
+`MicroservicesEventExternalizer` instance covers every dataSource;
+per-DS processors all dispatch through it. Per-broker routing is
+already handled by the per-event `client` parameter shown in
+[*Multiple clients*](#multiple-clients) above — `@Externalized` is
+dataSource-agnostic by design (an event class that lives in the
+`'billing'` dataSource via `OutboxModule.forFeature([Event], { dataSource: 'billing' })`
+still uses the same `client:` token resolution as a default-DS
+event). See [`@nestjs-transactional/outbox` README](../outbox/README.md)
+for the multi-`forRoot` pattern.
+
+The module is registered as `@Global()` so the bound
+`EVENT_EXTERNALIZER` is visible to `OutboxModule`'s sibling-imported
+per-DS processors without an explicit import chain.
+
+## Async configuration
+
+For `defaultClient` that must be resolved from a `ConfigService`:
+
+```typescript
+OutboxMicroservicesModule.forRootAsync({
+  imports: [ConfigModule],
+  inject: [ConfigService],
+  useFactory: (config: ConfigService) => ({
+    defaultClient: config.getOrThrow<string>('outbox.defaultClient'),
+  }),
+}),
+```
+
+## Bootstrap validation
+
+By default the module resolves `defaultClient` once at
+`OnApplicationBootstrap` and throws a descriptive error if the token
+is unbound — the misconfiguration surfaces before the first event is
+processed. Disable with `validateOnBootstrap: false` when the
+`ClientProxy` registration is wired by an asynchronous factory that
+finishes after the outbox bootstrap (the lookup is then deferred to
+the first `externalize()` call).
+
+## Limitations
+
+- **Headers and `routingKey` are accepted but not applied** to the
+  wire payload yet. The `@nestjs/microservices` `ClientProxy.emit`
+  API has no unified headers / routing-key parameter — handling is
+  transport-specific (Kafka headers, AMQP properties, NATS subject
+  suffixes, ...). For now the externalizer logs resolved values at
+  debug level for visibility; the broker-aware message-construction
+  iteration ships in a later release. Wrap the event in a
+  transport-specific envelope inside your own code if you need them
+  before then.
+- **Real-broker integration tests** (Postgres + Kafka / RabbitMQ via
+  testcontainers) are not bundled with this package — the unit and
+  module specs use a mock `ClientProxy` and cover the SPI contract
+  end-to-end without a live broker. The
+  [`externalization-with-fallback`](../../examples/externalization-with-fallback/)
+  example demonstrates a real-broker setup via docker-compose with
+  the ADR-016 silent-success limitation observable end-to-end.
+
+## Testing
+
+The package's own tests use a mock `ClientProxy` directly. To exercise
+the externalizer in your application's tests, register a stub provider
+under your client's token before the module imports:
+
+```typescript
+const moduleRef = await Test.createTestingModule({
+  imports: [
+    /* ... ClientsModule.register([{ name: 'KAFKA_CLIENT', ... }]) */
+    OutboxMicroservicesModule.forRoot({ defaultClient: 'KAFKA_CLIENT' }),
+  ],
+})
+  .overrideProvider('KAFKA_CLIENT')
+  .useValue({ emit: jest.fn(() => of(undefined)) })
+  .compile();
+```
+
+## Worked examples
+
+- [`externalization-kafka`](../../examples/externalization-kafka) — single DataSource + single Kafka broker, the canonical baseline.
+- [`externalization-multi-broker`](../../examples/externalization-multi-broker) — Kafka + RabbitMQ + Redis pub/sub routed per event via `@Externalized({ client })`.
+- [`externalization-multi-datasource`](../../examples/externalization-multi-datasource) — two physical Postgres × two `ClientProxy` registrations on a single broker.
+- [`externalization-with-fallback`](../../examples/externalization-with-fallback) — ADR-016 silent-success demo + the three production mitigation patterns + `FailedEventPublications.resubmit` recovery flow.
+- [`e-commerce-orders`](../../examples/e-commerce-orders) — flagship application; externalization is the terminal step of the order saga.
+
+Full catalogue: [examples/README.md](../../examples/README.md).
+
+## License
+
+MIT — see [LICENSE](../../LICENSE).

package/dist/externalizer/microservices-event-externalizer.d.ts

@@ -0,0 +1,37 @@
+import { type OnApplicationBootstrap } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { type EventExternalizer, type ExternalizationMetadata } from '@nestjs-transactional/outbox';
+import { type OutboxMicroservicesOptions } from '../types/options';
+/**
+ * {@link EventExternalizer} implementation backed by `@nestjs/microservices`
+ * `ClientProxy`. Routes externalized events to whichever transport
+ * the configured `ClientProxy` was registered with — Kafka, RabbitMQ,
+ * NATS, JMS, gRPC, or any custom transport.
+ *
+ * Per DD-017 this externalizer does NOT register clients itself;
+ * users register them via standard `ClientsModule.register()` /
+ * `ClientsModule.registerAsync()` and pass the token through
+ * `OutboxMicroservicesModule.forRoot({ defaultClient })`. Per-event
+ * overrides via `@Externalized({ client })` resolve through the same
+ * `ModuleRef.get(token, { strict: false })` lookup.
+ *
+ * **Headers / routingKey limitation (Phase 11.3):** the
+ * `@nestjs/microservices` `ClientProxy.emit` API has no unified
+ * headers / routing-key parameter — handling is transport-specific
+ * (Kafka headers, AMQP properties, NATS subject suffixes, ...). For
+ * the first version we log resolved headers and routing keys at debug
+ * level for visibility but do not apply them to the wire payload —
+ * users that need them can wrap the event in a transport-specific
+ * envelope inside their own code or wait for the broker-aware message
+ * construction iteration.
+ */
+export declare class MicroservicesEventExternalizer implements EventExternalizer, OnApplicationBootstrap {
+    private readonly moduleRef;
+    private readonly options;
+    private readonly logger;
+    constructor(moduleRef: ModuleRef, options: OutboxMicroservicesOptions);
+    onApplicationBootstrap(): void;
+    externalize(event: unknown, metadata: ExternalizationMetadata): Promise<void>;
+    private resolveClient;
+}
+//# sourceMappingURL=microservices-event-externalizer.d.ts.map

package/dist/externalizer/microservices-event-externalizer.js

@@ -0,0 +1,133 @@
+"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 MicroservicesEventExternalizer_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicroservicesEventExternalizer = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const outbox_1 = require("@nestjs-transactional/outbox");
+const rxjs_1 = require("rxjs");
+const options_1 = require("../types/options");
+/**
+ * {@link EventExternalizer} implementation backed by `@nestjs/microservices`
+ * `ClientProxy`. Routes externalized events to whichever transport
+ * the configured `ClientProxy` was registered with — Kafka, RabbitMQ,
+ * NATS, JMS, gRPC, or any custom transport.
+ *
+ * Per DD-017 this externalizer does NOT register clients itself;
+ * users register them via standard `ClientsModule.register()` /
+ * `ClientsModule.registerAsync()` and pass the token through
+ * `OutboxMicroservicesModule.forRoot({ defaultClient })`. Per-event
+ * overrides via `@Externalized({ client })` resolve through the same
+ * `ModuleRef.get(token, { strict: false })` lookup.
+ *
+ * **Headers / routingKey limitation (Phase 11.3):** the
+ * `@nestjs/microservices` `ClientProxy.emit` API has no unified
+ * headers / routing-key parameter — handling is transport-specific
+ * (Kafka headers, AMQP properties, NATS subject suffixes, ...). For
+ * the first version we log resolved headers and routing keys at debug
+ * level for visibility but do not apply them to the wire payload —
+ * users that need them can wrap the event in a transport-specific
+ * envelope inside their own code or wait for the broker-aware message
+ * construction iteration.
+ */
+let MicroservicesEventExternalizer = MicroservicesEventExternalizer_1 = class MicroservicesEventExternalizer {
+    moduleRef;
+    options;
+    logger = new common_1.Logger(MicroservicesEventExternalizer_1.name);
+    constructor(moduleRef, options) {
+        this.moduleRef = moduleRef;
+        this.options = options;
+    }
+    onApplicationBootstrap() {
+        if (this.options.validateOnBootstrap === false) {
+            this.logger.log('Bootstrap validation disabled — defaultClient will be resolved on first externalize() call');
+            return;
+        }
+        if (this.options.defaultClient === undefined) {
+            this.logger.log('No defaultClient configured — every @Externalized event must specify its own client');
+            return;
+        }
+        try {
+            this.resolveClient(this.options.defaultClient);
+            this.logger.log(`Externalization configured with default client: ${formatToken(this.options.defaultClient)}`);
+        }
+        catch (err) {
+            const cause = err instanceof Error ? err.message : String(err);
+            throw new Error(`OutboxMicroservicesModule: defaultClient '${formatToken(this.options.defaultClient)}' ` +
+                `is not registered in the DI container. Register the ClientProxy via ` +
+                `ClientsModule.register() / ClientsModule.registerAsync(), or pass ` +
+                `validateOnBootstrap: false to defer resolution to the first event. ` +
+                `Original error: ${cause}`);
+        }
+    }
+    async externalize(event, metadata) {
+        const clientToken = metadata.client ?? this.options.defaultClient;
+        if (clientToken === undefined) {
+            throw new outbox_1.ExternalizationError(`No ClientProxy specified for event ${metadata.eventType}. ` +
+                `Set defaultClient on OutboxMicroservicesModule.forRoot() or pass ` +
+                `'client' in the @Externalized() decorator options.`, metadata.eventType, metadata.target);
+        }
+        let client;
+        try {
+            client = this.resolveClient(clientToken);
+        }
+        catch (err) {
+            const cause = err instanceof Error ? err : undefined;
+            const causeMessage = err instanceof Error ? err.message : String(err);
+            throw new outbox_1.ExternalizationError(`ClientProxy '${formatToken(clientToken)}' not found in the DI container. ` +
+                `Ensure it is registered via ClientsModule.register() / registerAsync(). ` +
+                `Original error: ${causeMessage}`, metadata.eventType, metadata.target, cause);
+        }
+        if (metadata.headers !== undefined || metadata.routingKey !== undefined) {
+            // Phase 11.3 limitation — ClientProxy.emit has no unified
+            // headers / routing-key parameter. Logged for visibility; the
+            // broker-aware message construction iteration will route them
+            // through transport-specific envelopes.
+            this.logger.debug(`${metadata.eventType}: headers/routingKey are not applied to the wire payload in this version (Phase 11.3 limitation): ${JSON.stringify({ headers: metadata.headers, routingKey: metadata.routingKey })}`);
+        }
+        try {
+            await (0, rxjs_1.firstValueFrom)(client.emit(metadata.target, event));
+            this.logger.debug(`Externalized ${metadata.eventType} → ${metadata.target} (client: ${formatToken(clientToken)})`);
+        }
+        catch (err) {
+            const cause = err instanceof Error ? err : undefined;
+            const causeMessage = err instanceof Error ? err.message : String(err);
+            throw new outbox_1.ExternalizationError(`Failed to publish ${metadata.eventType} to ${metadata.target}: ${causeMessage}`, metadata.eventType, metadata.target, cause);
+        }
+    }
+    resolveClient(token) {
+        const proxy = this.moduleRef.get(token, { strict: false });
+        if (proxy === null || proxy === undefined) {
+            throw new Error('Resolved provider is null/undefined');
+        }
+        return proxy;
+    }
+};
+exports.MicroservicesEventExternalizer = MicroservicesEventExternalizer;
+exports.MicroservicesEventExternalizer = MicroservicesEventExternalizer = MicroservicesEventExternalizer_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(options_1.OUTBOX_MICROSERVICES_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.ModuleRef, Object])
+], MicroservicesEventExternalizer);
+function formatToken(token) {
+    if (typeof token === 'symbol') {
+        return token.toString();
+    }
+    if (typeof token === 'function') {
+        return token.name || '<anonymous function token>';
+    }
+    return String(token);
+}
+//# sourceMappingURL=microservices-event-externalizer.js.map

package/dist/externalizer/microservices-event-externalizer.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { MicroservicesEventExternalizer } from './externalizer/microservices-event-externalizer';
+export { OutboxMicroservicesModule, type OutboxMicroservicesAsyncOptions, } from './module/outbox-microservices.module';
+export { OUTBOX_MICROSERVICES_OPTIONS, type OutboxMicroservicesOptions, } from './types/options';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTBOX_MICROSERVICES_OPTIONS = exports.OutboxMicroservicesModule = exports.MicroservicesEventExternalizer = void 0;
+var microservices_event_externalizer_1 = require("./externalizer/microservices-event-externalizer");
+Object.defineProperty(exports, "MicroservicesEventExternalizer", { enumerable: true, get: function () { return microservices_event_externalizer_1.MicroservicesEventExternalizer; } });
+var outbox_microservices_module_1 = require("./module/outbox-microservices.module");
+Object.defineProperty(exports, "OutboxMicroservicesModule", { enumerable: true, get: function () { return outbox_microservices_module_1.OutboxMicroservicesModule; } });
+var options_1 = require("./types/options");
+Object.defineProperty(exports, "OUTBOX_MICROSERVICES_OPTIONS", { enumerable: true, get: function () { return options_1.OUTBOX_MICROSERVICES_OPTIONS; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,oGAAiG;AAAxF,kJAAA,8BAA8B,OAAA;AACvC,oFAG8C;AAF5C,wIAAA,yBAAyB,OAAA;AAG3B,2CAGyB;AAFvB,uHAAA,4BAA4B,OAAA"}

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

@@ -0,0 +1,60 @@
+import { type DynamicModule, type InjectionToken, type ModuleMetadata } from '@nestjs/common';
+import { type OutboxMicroservicesOptions } from '../types/options';
+/**
+ * Async-options shape for {@link OutboxMicroservicesModule.forRootAsync}.
+ * `imports` follows NestJS convention so the factory can pull values
+ * from a `ConfigModule` (or similar) without leaking the module
+ * reference into the factory signature.
+ */
+export interface OutboxMicroservicesAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    readonly useFactory: (...args: never[]) => Promise<OutboxMicroservicesOptions> | OutboxMicroservicesOptions;
+    readonly inject?: readonly InjectionToken[];
+}
+/**
+ * NestJS module that wires the
+ * {@link MicroservicesEventExternalizer} as the
+ * `EventExternalizer` for `outbox`. Reuses the user's existing
+ * `@nestjs/microservices` `ClientsModule` registration (DD-017) — the
+ * package does NOT register clients itself.
+ *
+ * Typical wiring:
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     ClientsModule.register([
+ *       { name: 'KAFKA_CLIENT', transport: Transport.KAFKA, options: { ... } },
+ *     ]),
+ *     OutboxModule.forRoot({}),
+ *     OutboxModule.forFeature([OrderPlacedEvent]),
+ *     OutboxMicroservicesModule.forRoot({ defaultClient: 'KAFKA_CLIENT' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * The module binds {@link EVENT_EXTERNALIZER} via `useExisting` so
+ * `OutboxModule`'s `EventPublicationProcessor` picks the externalizer
+ * up through its `@Optional()` injection (DD-018). Both the SPI
+ * binding and the concrete class are exported so consumers can inject
+ * either.
+ *
+ * **Multi-dataSource setups**: a single externalizer covers every
+ * dataSource. Per-broker routing — when different events should land
+ * on different transports — happens via the per-event
+ * `@Externalized({ client })` parameter (Phase 11.3), not via a
+ * dataSource-keyed externalizer Map. See `outbox` README for the
+ * multi-`OutboxModule.forRoot()` pattern (ADR-019); each per-DS
+ * processor injects this same externalizer via `EVENT_EXTERNALIZER`.
+ *
+ * The module is registered as `@Global()` (since Phase 14.6) so the
+ * `EVENT_EXTERNALIZER` binding is visible to `OutboxModule`'s
+ * sibling-imported per-DS processors without an explicit import
+ * chain. Pre-Phase-14.6 the module was non-global, which silently
+ * broke the documented usage pattern in multi-module trees — fixed
+ * in Phase 14.6 verification work.
+ */
+export declare class OutboxMicroservicesModule {
+    static forRoot(options?: OutboxMicroservicesOptions): DynamicModule;
+    static forRootAsync(options: OutboxMicroservicesAsyncOptions): DynamicModule;
+}
+//# sourceMappingURL=outbox-microservices.module.d.ts.map

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

@@ -0,0 +1,95 @@
+"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 OutboxMicroservicesModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboxMicroservicesModule = void 0;
+const common_1 = require("@nestjs/common");
+const outbox_1 = require("@nestjs-transactional/outbox");
+const microservices_event_externalizer_1 = require("../externalizer/microservices-event-externalizer");
+const options_1 = require("../types/options");
+/**
+ * NestJS module that wires the
+ * {@link MicroservicesEventExternalizer} as the
+ * `EventExternalizer` for `outbox`. Reuses the user's existing
+ * `@nestjs/microservices` `ClientsModule` registration (DD-017) — the
+ * package does NOT register clients itself.
+ *
+ * Typical wiring:
+ * ```ts
+ * @Module({
+ *   imports: [
+ *     ClientsModule.register([
+ *       { name: 'KAFKA_CLIENT', transport: Transport.KAFKA, options: { ... } },
+ *     ]),
+ *     OutboxModule.forRoot({}),
+ *     OutboxModule.forFeature([OrderPlacedEvent]),
+ *     OutboxMicroservicesModule.forRoot({ defaultClient: 'KAFKA_CLIENT' }),
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * The module binds {@link EVENT_EXTERNALIZER} via `useExisting` so
+ * `OutboxModule`'s `EventPublicationProcessor` picks the externalizer
+ * up through its `@Optional()` injection (DD-018). Both the SPI
+ * binding and the concrete class are exported so consumers can inject
+ * either.
+ *
+ * **Multi-dataSource setups**: a single externalizer covers every
+ * dataSource. Per-broker routing — when different events should land
+ * on different transports — happens via the per-event
+ * `@Externalized({ client })` parameter (Phase 11.3), not via a
+ * dataSource-keyed externalizer Map. See `outbox` README for the
+ * multi-`OutboxModule.forRoot()` pattern (ADR-019); each per-DS
+ * processor injects this same externalizer via `EVENT_EXTERNALIZER`.
+ *
+ * The module is registered as `@Global()` (since Phase 14.6) so the
+ * `EVENT_EXTERNALIZER` binding is visible to `OutboxModule`'s
+ * sibling-imported per-DS processors without an explicit import
+ * chain. Pre-Phase-14.6 the module was non-global, which silently
+ * broke the documented usage pattern in multi-module trees — fixed
+ * in Phase 14.6 verification work.
+ */
+let OutboxMicroservicesModule = OutboxMicroservicesModule_1 = class OutboxMicroservicesModule {
+    static forRoot(options = {}) {
+        const providers = [
+            { provide: options_1.OUTBOX_MICROSERVICES_OPTIONS, useValue: options },
+            microservices_event_externalizer_1.MicroservicesEventExternalizer,
+            { provide: outbox_1.EVENT_EXTERNALIZER, useExisting: microservices_event_externalizer_1.MicroservicesEventExternalizer },
+        ];
+        return {
+            module: OutboxMicroservicesModule_1,
+            global: true,
+            providers,
+            exports: [outbox_1.EVENT_EXTERNALIZER, microservices_event_externalizer_1.MicroservicesEventExternalizer],
+        };
+    }
+    static forRootAsync(options) {
+        const providers = [
+            {
+                provide: options_1.OUTBOX_MICROSERVICES_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject ? [...options.inject] : undefined,
+            },
+            microservices_event_externalizer_1.MicroservicesEventExternalizer,
+            { provide: outbox_1.EVENT_EXTERNALIZER, useExisting: microservices_event_externalizer_1.MicroservicesEventExternalizer },
+        ];
+        return {
+            module: OutboxMicroservicesModule_1,
+            global: true,
+            imports: options.imports ?? [],
+            providers,
+            exports: [outbox_1.EVENT_EXTERNALIZER, microservices_event_externalizer_1.MicroservicesEventExternalizer],
+        };
+    }
+};
+exports.OutboxMicroservicesModule = OutboxMicroservicesModule;
+exports.OutboxMicroservicesModule = OutboxMicroservicesModule = OutboxMicroservicesModule_1 = __decorate([
+    (0, common_1.Module)({})
+], OutboxMicroservicesModule);
+//# sourceMappingURL=outbox-microservices.module.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outbox-microservices.module.js","sourceRoot":"","sources":["../../src/module/outbox-microservices.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAMwB;AACxB,yDAAkE;AAElE,uGAAkG;AAClG,8CAG0B;AAe1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEI,IAAM,yBAAyB,iCAA/B,MAAM,yBAAyB;IACpC,MAAM,CAAC,OAAO,CAAC,UAAsC,EAAE;QACrD,MAAM,SAAS,GAAe;YAC5B,EAAE,OAAO,EAAE,sCAA4B,EAAE,QAAQ,EAAE,OAAO,EAAE;YAC5D,iEAA8B;YAC9B,EAAE,OAAO,EAAE,2BAAkB,EAAE,WAAW,EAAE,iEAA8B,EAAE;SAC7E,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,2BAAyB;YACjC,MAAM,EAAE,IAAI;YACZ,SAAS;YACT,OAAO,EAAE,CAAC,2BAAkB,EAAE,iEAA8B,CAAC;SAC9D,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,YAAY,CAAC,OAAwC;QAC1D,MAAM,SAAS,GAAe;YAC5B;gBACE,OAAO,EAAE,sCAA4B;gBACrC,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS;aACzD;YACD,iEAA8B;YAC9B,EAAE,OAAO,EAAE,2BAAkB,EAAE,WAAW,EAAE,iEAA8B,EAAE;SAC7E,CAAC;QAEF,OAAO;YACL,MAAM,EAAE,2BAAyB;YACjC,MAAM,EAAE,IAAI;YACZ,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;YAC9B,SAAS;YACT,OAAO,EAAE,CAAC,2BAAkB,EAAE,iEAA8B,CAAC;SAC9D,CAAC;IACJ,CAAC;CACF,CAAA;AAnCY,8DAAyB;oCAAzB,yBAAyB;IADrC,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,yBAAyB,CAmCrC"}

package/dist/types/options.d.ts

@@ -0,0 +1,40 @@
+import { type InjectionToken } from '@nestjs/common';
+/**
+ * Configuration accepted by
+ * {@link OutboxMicroservicesModule.forRoot} (and the resolved factory
+ * result of `forRootAsync`). Per DD-017 the package does NOT register
+ * `ClientProxy` instances itself — register them via the standard
+ * `ClientsModule.register()` / `ClientsModule.registerAsync()` from
+ * `@nestjs/microservices` and pass the token here.
+ */
+export interface OutboxMicroservicesOptions {
+    /**
+     * DI token of the default `ClientProxy` used when an `@Externalized`
+     * mapping does not specify its own `client` override. Resolved via
+     * `ModuleRef.get(token, { strict: false })` so the proxy can live in
+     * any module (including a globally-imported `ClientsModule`).
+     *
+     * If omitted, every `@Externalized` event must carry a `client` of
+     * its own — otherwise the externalizer rejects the publication and
+     * the row is recorded as `FAILED` (DD-019).
+     */
+    readonly defaultClient?: InjectionToken;
+    /**
+     * When `true` (default), the externalizer's `OnApplicationBootstrap`
+     * hook resolves `defaultClient` immediately and fails the bootstrap
+     * if the binding is missing — surfacing a misconfiguration before
+     * the first event is processed. Set `false` to defer resolution
+     * until the first call to `externalize()` (useful when the
+     * `ClientProxy` registration is itself wired by an asynchronous
+     * factory that has not finished by the time bootstrap runs).
+     */
+    readonly validateOnBootstrap?: boolean;
+}
+/**
+ * DI token for the resolved {@link OutboxMicroservicesOptions} object.
+ * Internal — consumers configure the module via
+ * `OutboxMicroservicesModule.forRoot()` rather than injecting the
+ * token directly.
+ */
+export declare const OUTBOX_MICROSERVICES_OPTIONS: unique symbol;
+//# sourceMappingURL=options.d.ts.map

package/dist/types/options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OUTBOX_MICROSERVICES_OPTIONS = void 0;
+/**
+ * DI token for the resolved {@link OutboxMicroservicesOptions} object.
+ * Internal — consumers configure the module via
+ * `OutboxMicroservicesModule.forRoot()` rather than injecting the
+ * token directly.
+ */
+exports.OUTBOX_MICROSERVICES_OPTIONS = Symbol('OUTBOX_MICROSERVICES_OPTIONS');
+//# sourceMappingURL=options.js.map

package/dist/types/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/types/options.ts"],"names":[],"mappings":";;;AAmCA;;;;;GAKG;AACU,QAAA,4BAA4B,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@nestjs-transactional/outbox-microservices",
+  "version": "1.0.0-alpha.0",
+  "description": "Event externalization for @nestjs-transactional/outbox via @nestjs/microservices ClientProxy — Spring Modulith @Externalized parity",
+  "license": "MIT",
+  "author": "Igor Golovanov",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/igorgolovanov/nestjs-transactional.git",
+    "directory": "packages/outbox-microservices"
+  },
+  "bugs": {
+    "url": "https://github.com/igorgolovanov/nestjs-transactional/issues"
+  },
+  "homepage": "https://github.com/igorgolovanov/nestjs-transactional/tree/main/packages/outbox-microservices#readme",
+  "keywords": [
+    "nestjs",
+    "microservices",
+    "outbox",
+    "event-publication-registry",
+    "event-externalization",
+    "spring-modulith",
+    "kafka",
+    "rabbitmq",
+    "nats"
+  ],
+  "engines": {
+    "node": ">=22.11.0"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.js.map",
+    "!dist/**/*.spec.*"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^10.0.0 || ^11.0.0",
+    "@nestjs/core": "^10.0.0 || ^11.0.0",
+    "@nestjs/microservices": "^10.0.0 || ^11.0.0",
+    "reflect-metadata": "^0.1.13 || ^0.2.0",
+    "rxjs": "^7.0.0",
+    "@nestjs-transactional/outbox": "^1.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/microservices": "^11.0.0",
+    "@nestjs/testing": "^11.0.0",
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.5.4",
+    "@nestjs-transactional/core": "1.0.0-alpha.0",
+    "@nestjs-transactional/outbox": "1.0.0-alpha.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rimraf dist *.tsbuildinfo coverage",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"src/**/*.ts\""
+  }
+}