@fluojs/microservices 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+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.ko.md

@@ -0,0 +1,182 @@
+# @fluojs/microservices
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo용 트랜스포트 기반 마이크로서비스 패키지입니다. TCP, Redis, NATS, Kafka, RabbitMQ, MQTT, gRPC 같은 여러 프로토콜 위에서 동일한 데코레이터 기반 프로그래밍 모델을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [주요 기능](#주요-기능)
+- [공통 패턴](#공통-패턴)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+pnpm add @fluojs/microservices
+```
+
+선택적 트랜스포트 의존성:
+
+- `@fluojs/microservices`가 직접 로드하는 선택적 peer: `@grpc/grpc-js`, `@grpc/proto-loader`, `ioredis`, `mqtt`
+- 애플리케이션이 transport에 명시적으로 넘겨야 하는 caller-owned broker client: `nats`, `kafkajs`, `amqplib`
+
+## 사용 시점
+
+- 서비스 간 통신을 메시지나 이벤트 중심으로 분리하고 싶을 때
+- TCP, NATS, Kafka 같은 여러 트랜스포트 위에서 같은 핸들러 모델을 유지하고 싶을 때
+- 요청-응답과 이벤트 fan-out을 같은 프레임워크 규약으로 다루고 싶을 때
+- gRPC 스트리밍을 포함한 복수의 마이크로서비스 프로토콜을 fluo DI와 함께 사용하고 싶을 때
+
+## 빠른 시작
+
+```ts
+import { MessagePattern, MicroservicesModule, TcpMicroserviceTransport } from '@fluojs/microservices';
+import { Module } from '@fluojs/core';
+import { fluoFactory } from '@fluojs/runtime';
+
+class MathHandler {
+  @MessagePattern('math.sum')
+  sum(data: { a: number; b: number }) {
+    return data.a + data.b;
+  }
+}
+
+@Module({
+  imports: [
+    MicroservicesModule.forRoot({
+      transport: new TcpMicroserviceTransport({ port: 4000 }),
+    }),
+  ],
+  providers: [MathHandler],
+})
+class AppModule {}
+
+const microservice = await fluoFactory.createMicroservice(AppModule);
+await microservice.listen();
+```
+
+`fluo new`는 NATS, Kafka, RabbitMQ를 숨겨진 내장 구현이 아니라 caller-owned bootstrap contract로 취급합니다. 생성된 스타터는 `src/app.ts`에서 `nats` + `JSONCodec()`, `kafkajs` producer/consumer collaborator, `amqplib` publisher/consumer collaborator를 직접 연결하고, 외부 broker 의존성은 `.env`와 생성된 README에 그대로 드러냅니다. 이 패키지 자체가 해당 런타임을 직접 로드하지 않으므로 `@fluojs/microservices`의 peer dependency로도 선언하지 않습니다.
+
+## 주요 기능
+
+### 다중 트랜스포트 지원
+
+비즈니스 핸들러는 그대로 두고 TCP, Redis Pub/Sub, Redis Streams, NATS, Kafka, RabbitMQ, MQTT, gRPC 같은 트랜스포트만 바꿔 배치할 수 있습니다.
+
+### 패턴 기반 라우팅
+
+`@MessagePattern`은 요청-응답 흐름에, `@EventPattern`은 fire-and-forget 이벤트에 사용합니다. 문자열과 정규식 패턴 모두 지원합니다.
+
+### gRPC 스트리밍
+
+`@ServerStreamPattern`, `@ClientStreamPattern`, `@BidiStreamPattern`으로 unary 외의 스트리밍 패턴도 다룰 수 있습니다.
+
+### 요청 단위 DI scope
+
+마이크로서비스 핸들러도 fluo의 request/transient scope 모델을 그대로 따르므로, 메시지 또는 이벤트 단위로 격리된 상태를 안전하게 사용할 수 있습니다.
+
+### 전달 안전 기본값
+
+- TCP 프레임은 기본적으로 newline-delimited 메시지당 1 MiB로 제한되며, 한도를 넘는 프레임은 요청 버퍼를 무한히 키우는 대신 소켓을 종료합니다.
+- Redis Streams는 요청/이벤트 엔트리를 핸들러 처리가 끝난 뒤에만 ACK합니다. 실패한 이벤트는 조기 ACK로 유실하지 않고 broker 복구/재전달 경로에 남겨 둡니다.
+- Redis Streams는 기본적으로 live request/event stream에 publish-time trimming을 적용하지 않으므로, pending 엔트리가 `xack` 또는 consumer-group 복구 경로가 끝나기 전에 잘리지 않습니다. ACK가 끝난 request/reply 엔트리는 정리되고, 인스턴스별 response stream은 기본적으로 bounded retention(`responseRetentionMaxLen: 1_000`)을 유지한 뒤 `close()` 중 삭제됩니다.
+- Redis Streams는 `close()` 중 인스턴스별 response stream은 항상 삭제하지만, 활성 fleet 전체에서 ownership를 증명할 수 없으면 공유 request consumer group은 보수적으로 유지합니다. lease-capable listener는 coordination metadata만 정리하고, mixed/fallback fleet에서는 살아 있는 다른 listener가 여전히 필요로 할 수 있으므로 공유 request group을 제거하지 않습니다.
+- `messageRetentionMaxLen`과 `eventRetentionMaxLen`은 고급 opt-in 설정으로 남아 있습니다. 이를 켜면 Redis가 ACK 전 pending live-stream 엔트리를 먼저 trim할 수 있으므로 broker-managed recovery 보장을 일부 포기하는 운영 판단이 됩니다.
+- RabbitMQ 요청-응답은 기본적으로 인스턴스별 response queue를 사용합니다. 공유 reply topology를 의도적으로 운영할 때만 `responseQueue`를 명시적으로 지정하세요.
+- transport logger를 통해 이벤트 핸들러 실패를 기록하는 경로(`RedisPubSubMicroserviceTransport`, `RedisStreamsMicroserviceTransport`, `NatsMicroserviceTransport`, `MqttMicroserviceTransport`, gRPC event emit)는 끝까지 logger-driven observability를 유지합니다. transport logger를 주입하지 않으면 fluo는 해당 실패를 raw `console.error` fallback으로 복제하지 않습니다.
+
+## 공통 패턴
+
+### 커스텀 모듈 등록
+
+custom provider/export/non-global 구성이 필요할 때도 raw provider array로 내려가지 말고 `MicroservicesModule.forRoot({ transport, module: { ... } })`를 우선 사용하세요.
+
+```ts
+import { Module } from '@fluojs/core';
+import { MicroservicesModule } from '@fluojs/microservices';
+
+const EXTRA_MICROSERVICE_EXPORT = Symbol('extra-microservice-export');
+
+@Module({
+  imports: [
+    MicroservicesModule.forRoot({
+      transport: customTransport,
+      module: {
+        global: false,
+        providers: [{ provide: EXTRA_MICROSERVICE_EXPORT, useValue: 'custom-module-value' }],
+        additionalExports: [EXTRA_MICROSERVICE_EXPORT],
+      },
+    }),
+  ],
+})
+class FeatureModule {}
+```
+
+Behavioral contract notes:
+
+- 이 모듈 경로는 기본 `MicroservicesModule.forRoot(...)` 호출과 동일한 `MICROSERVICE_OPTIONS`, `MicroserviceLifecycleService`, `MICROSERVICE` wiring을 그대로 설치합니다.
+- `module.providers`는 내장 런타임 wiring 뒤에 추가 provider를 붙이고, `module.additionalExports`는 기본 export 토큰을 교체하지 않고 확장합니다.
+- `module.global`을 사용하면 등록 범위를 로컬로 제한할 수 있습니다.
+
+### provider 배열 헬퍼
+
+`createMicroservicesProviders(...)`는 실제로 low-level provider array 자체가 필요한 호출자에게만 남아 있습니다.
+
+`createMicroservicesProviders(...)`는 커스텀 모듈 조합에 provider 배열이 필요할 때 사용할 수 있습니다.
+
+`createMicroservicesProviders(...)`는 실제로 low-level provider array 자체가 필요한 호출자에게만 남아 있습니다.
+
+```ts
+import { Module } from '@fluojs/core';
+import { createMicroservicesProviders } from '@fluojs/microservices';
+
+@Module({
+  providers: [...createMicroservicesProviders({ transport: customTransport })],
+})
+class ManualMicroserviceProvidersModule {}
+```
+
+## 공개 API 개요
+
+### 루트 배럴 (`@fluojs/microservices`)
+
+- `MicroservicesModule`, `createMicroservicesProviders`: 모듈 등록 진입점입니다.
+- `MicroservicesModule.forRoot(...)`: `module: { global, providers, additionalExports }`와 함께 트랜스포트와 모듈 구성을 설정합니다.
+- `createMicroservicesProviders(...)`: 커스텀 모듈 조합용 provider 배열을 생성합니다.
+- `MessagePattern`, `EventPattern`, `ServerStreamPattern`, `ClientStreamPattern`, `BidiStreamPattern`: 라우팅/스트리밍 데코레이터입니다.
+- `TcpMicroserviceTransport`, `RedisPubSubMicroserviceTransport`, `RedisStreamsMicroserviceTransport`, `NatsMicroserviceTransport`, `KafkaMicroserviceTransport`, `RabbitMqMicroserviceTransport`, `GrpcMicroserviceTransport`, `MqttMicroserviceTransport`: 루트 배럴에서 제공하는 트랜스포트 어댑터입니다.
+- `MicroserviceLifecycleService`, `MICROSERVICE`: 런타임 접근용 서비스와 토큰입니다.
+- `createMicroservicePlatformStatusSnapshot`, `ServerStreamWriter`: 상태 스냅샷/TypeScript 계약 헬퍼입니다.
+
+### 지원되는 트랜스포트 서브패스
+
+- `@fluojs/microservices/tcp`
+- `@fluojs/microservices/redis` (Redis Pub/Sub 트랜스포트)
+- `@fluojs/microservices/nats`
+- `@fluojs/microservices/kafka`
+- `@fluojs/microservices/rabbitmq`
+- `@fluojs/microservices/grpc`
+- `@fluojs/microservices/mqtt`
+
+`RedisStreamsMicroserviceTransport`는 현재 루트 배럴에서만 지원하며, `@fluojs/microservices/redis-streams` 전용 export는 없습니다.
+
+## 관련 패키지
+
+- `@fluojs/core`: 모듈과 DI 메타데이터의 기반 패키지입니다.
+- `@fluojs/runtime`: 마이크로서비스 부트스트랩과 팩토리 API를 제공합니다.
+- `@fluojs/di`: 핸들러와 provider를 resolve하는 DI 엔진입니다.
+
+## 예제 소스
+
+- `packages/microservices/src/module.test.ts`: 모든 트랜스포트 통합 계약을 검증합니다.
+- `packages/microservices/src/public-api.test.ts`: 모듈 등록 override와 `createMicroservicesProviders(...)`를 포함한 루트 배럴 export 계약을 검증합니다.
+- `packages/microservices/src/public-surface.test.ts`: 문서화된 공개 surface를 검증합니다.
+- `packages/microservices/src/public-subpaths.test.ts`: 문서화된 트랜스포트 서브패스 export map 계약을 검증합니다.
+- `examples/microservices-tcp`: 기본 TCP 마이크로서비스 예제입니다.
+- `examples/microservices-kafka`: Kafka 기반 분산 아키텍처 예제입니다.

package/README.md

@@ -0,0 +1,179 @@
+# @fluojs/microservices
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Transport-driven microservices for fluo. Build scalable, message-driven architectures with deep DI integration and support for multiple transport protocols including TCP, Redis, NATS, Kafka, RabbitMQ, and gRPC.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Core Capabilities](#core-capabilities)
+- [Common Patterns](#common-patterns)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+pnpm add @fluojs/microservices
+```
+
+Optional transport-specific dependencies:
+
+- Package-managed optional peers loaded by `@fluojs/microservices`: `@grpc/grpc-js`, `@grpc/proto-loader`, `ioredis`, `mqtt`
+- Caller-owned broker clients passed explicitly to transports: `nats`, `kafkajs`, `amqplib`
+
+## When to Use
+
+- When building a **Distributed System** where services communicate via messages or events.
+- When you need a **Unified Programming Model** across different transport protocols (TCP, NATS, Kafka, etc.).
+- When you require **Request-Response** or **Event-Driven** patterns between isolated services.
+- When integrating with specialized protocols like **gRPC** (including streaming support).
+
+## Quick Start
+
+Define a message handler and bootstrap the microservice using the TCP transport.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { fluoFactory } from '@fluojs/runtime';
+import { MicroservicesModule, MessagePattern, TcpMicroserviceTransport } from '@fluojs/microservices';
+
+class MathHandler {
+  @MessagePattern('math.sum')
+  sum(data: { a: number; b: number }) {
+    return data.a + data.b;
+  }
+}
+
+@Module({
+  imports: [
+    MicroservicesModule.forRoot({
+      transport: new TcpMicroserviceTransport({ port: 4000 })
+    })
+  ],
+  providers: [MathHandler]
+})
+class AppModule {}
+
+const microservice = await fluoFactory.createMicroservice(AppModule);
+await microservice.listen();
+```
+
+`fluo new` treats NATS, Kafka, and RabbitMQ as explicit caller-owned bootstrap contracts rather than hidden built-ins. The generated starters wire `nats` + `JSONCodec()`, `kafkajs` producer/consumer collaborators, and `amqplib` publisher/consumer collaborators in `src/app.ts`, while still making the external broker dependency visible through `.env` and the generated README. Those packages are not loaded from `@fluojs/microservices` itself and therefore are not declared as package peers here.
+
+## Core Capabilities
+
+### Multi-Transport Support
+Write your business logic once and deploy it across various transports. Supports TCP, Redis (Pub/Sub and Streams), NATS, Kafka, RabbitMQ, MQTT, and gRPC.
+
+### Pattern-Based Routing
+Use `@MessagePattern` for request-response flows and `@EventPattern` for fire-and-forget event broadcasting. Patterns support string matching and regular expressions.
+
+### Advanced gRPC Streaming
+First-party support for all gRPC streaming modes: Server-side, Client-side, and Bidirectional streaming using `@ServerStreamPattern`, `@ClientStreamPattern`, and `@BidiStreamPattern`.
+
+### Request-Scoped DI
+Microservice handlers fully support fluo's DI scopes. Request-scoped providers are isolated per message or per event, ensuring safe state management in concurrent processing.
+
+### Delivery Safety Defaults
+- TCP frames are bounded to 1 MiB per newline-delimited message by default; oversized frames close the socket instead of growing the request buffer without limit.
+- Redis Streams acknowledges request/event entries only after handler-side processing finishes. Failed events stay pending for broker-managed recovery instead of being acknowledged early.
+- Redis Streams does not apply publish-time trimming to live request/event streams by default, so pending entries remain recoverable until `xack` or consumer-group recovery completes. Acked request/reply entries are cleaned up, each per-consumer response stream keeps bounded retention by default (`responseRetentionMaxLen: 1_000`), and each response stream is deleted during `close()`.
+- Redis Streams always deletes each per-consumer response stream during `close()`, but it retains the shared request consumer group conservatively once ownership cannot be proven across the active fleet. Lease-capable listeners clean up only their coordination metadata, and mixed or fallback listener fleets keep the shared request group in place so one peer cannot destroy a group that another live listener still needs.
+- `messageRetentionMaxLen` and `eventRetentionMaxLen` remain available as advanced opt-in knobs. Enabling them can trade away broker-managed recovery guarantees because Redis may trim pending live-stream entries before they are acknowledged.
+- RabbitMQ request/reply uses an instance-scoped response queue by default. Pass `responseQueue` explicitly only when you intentionally own and coordinate a shared reply topology.
+- Event-handler failures that flow through the transport logger (`RedisPubSubMicroserviceTransport`, `RedisStreamsMicroserviceTransport`, `NatsMicroserviceTransport`, `MqttMicroserviceTransport`, and gRPC event emits) remain logger-driven. If you do not inject a transport logger, fluo does not mirror those failures through a raw `console.error` fallback.
+
+## Common Patterns
+
+### Custom module registration
+
+Use `MicroservicesModule.forRoot({ transport, module: { ... } })` when you want custom providers, exports, or non-global registration without dropping back to raw provider arrays.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { MicroservicesModule, MicroserviceLifecycleService, MICROSERVICE } from '@fluojs/microservices';
+
+const EXTRA_MICROSERVICE_EXPORT = Symbol('extra-microservice-export');
+
+@Module({
+  imports: [
+    MicroservicesModule.forRoot({
+      transport: customTransport,
+      module: {
+        global: false,
+        providers: [{ provide: EXTRA_MICROSERVICE_EXPORT, useValue: 'custom-module-value' }],
+        additionalExports: [EXTRA_MICROSERVICE_EXPORT],
+      },
+    }),
+  ],
+})
+class FeatureModule {}
+```
+
+Behavioral contract notes:
+
+- The module path still installs the same built-in `MICROSERVICE_OPTIONS`, `MicroserviceLifecycleService`, and `MICROSERVICE` wiring as the default `MicroservicesModule.forRoot(...)` call.
+- `module.providers` appends extra providers after the built-in runtime wiring, while `module.additionalExports` extends the default exported tokens instead of replacing them.
+- `module.global` lets advanced callers keep the registration local.
+
+### Provider-array helper
+
+`createMicroservicesProviders(...)` remains available only for callers that truly need the low-level provider array itself.
+
+Use `createMicroservicesProviders(...)` when you need a provider array for custom module assembly.
+
+`createMicroservicesProviders(...)` remains available only for callers that truly need the low-level provider array itself.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { createMicroservicesProviders } from '@fluojs/microservices';
+
+@Module({
+  providers: [...createMicroservicesProviders({ transport: customTransport })],
+})
+class ManualMicroserviceProvidersModule {}
+```
+
+## Public API Overview
+
+### Root barrel (`@fluojs/microservices`)
+
+- `MicroservicesModule`, `createMicroservicesProviders`: module registration helpers.
+- `MicroservicesModule.forRoot(...)`: Configures a transport plus optional module customization via `module: { global, providers, additionalExports }`.
+- `createMicroservicesProviders(...)`: Builds provider arrays for custom module assembly.
+- `MessagePattern`, `EventPattern`, `ServerStreamPattern`, `ClientStreamPattern`, `BidiStreamPattern`: routing and streaming decorators.
+- `TcpMicroserviceTransport`, `RedisPubSubMicroserviceTransport`, `RedisStreamsMicroserviceTransport`, `NatsMicroserviceTransport`, `KafkaMicroserviceTransport`, `RabbitMqMicroserviceTransport`, `GrpcMicroserviceTransport`, `MqttMicroserviceTransport`: transport adapters exported from the root barrel.
+- `MicroserviceLifecycleService`, `MICROSERVICE`: programmatic runtime access token and service.
+- `createMicroservicePlatformStatusSnapshot`, `ServerStreamWriter`: status and TypeScript contract helpers.
+
+### Supported transport subpaths
+
+- `@fluojs/microservices/tcp`
+- `@fluojs/microservices/redis` (Redis Pub/Sub transport)
+- `@fluojs/microservices/nats`
+- `@fluojs/microservices/kafka`
+- `@fluojs/microservices/rabbitmq`
+- `@fluojs/microservices/grpc`
+- `@fluojs/microservices/mqtt`
+
+`RedisStreamsMicroserviceTransport` is currently supported from the root barrel only; there is no dedicated `@fluojs/microservices/redis-streams` export.
+
+## Related Packages
+
+- `@fluojs/core`: Core DI and module system.
+- `@fluojs/runtime`: Microservice bootstrap and factory.
+- `@fluojs/di`: Underlying dependency injection engine.
+
+## Example Sources
+
+- `packages/microservices/src/module.test.ts`: Integration tests for all transports.
+- `packages/microservices/src/public-api.test.ts`: Root-barrel export coverage, including module registration overrides and `createMicroservicesProviders(...)`.
+- `packages/microservices/src/public-surface.test.ts`: Root-barrel snapshot coverage for the documented public surface.
+- `packages/microservices/src/public-subpaths.test.ts`: Export-map coverage for documented transport subpaths.
+- `examples/microservices-tcp`: Basic TCP microservice example.
+- `examples/microservices-kafka`: Distributed Kafka-based architecture example.

package/dist/decorators.d.ts

@@ -0,0 +1,51 @@
+import type { Pattern } from './types.js';
+type MethodDecoratorLike = (value: Function, context: ClassMethodDecoratorContext) => void;
+/**
+ * Marks a public instance method as the request-response handler for one message pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound transport packets.
+ * @returns A method decorator that stores message-handler metadata for runtime discovery.
+ *
+ * @example
+ * ```ts
+ * import { MessagePattern } from '@fluojs/microservices';
+ *
+ * export class MathHandler {
+ *   @MessagePattern('math.sum')
+ *   sum(data: { a: number; b: number }) {
+ *     return data.a + data.b;
+ *   }
+ * }
+ * ```
+ */
+export declare function MessagePattern(pattern: Pattern): MethodDecoratorLike;
+/**
+ * Marks a public instance method as the fire-and-forget handler for one event pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound event packets.
+ * @returns A method decorator that stores event-handler metadata for runtime discovery.
+ */
+export declare function EventPattern(pattern: Pattern): MethodDecoratorLike;
+/**
+ * Marks a public instance method as the server-streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound server-stream packets.
+ * @returns A method decorator that stores server-stream metadata for runtime discovery.
+ */
+export declare function ServerStreamPattern(pattern: Pattern): MethodDecoratorLike;
+/**
+ * Marks a public instance method as the client-streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound client-stream packets.
+ * @returns A method decorator that stores client-stream metadata for runtime discovery.
+ */
+export declare function ClientStreamPattern(pattern: Pattern): MethodDecoratorLike;
+/**
+ * Marks a public instance method as the bidirectional streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound bidirectional stream packets.
+ * @returns A method decorator that stores bidi-stream metadata for runtime discovery.
+ */
+export declare function BidiStreamPattern(pattern: Pattern): MethodDecoratorLike;
+export {};
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAgC,OAAO,EAAE,MAAM,YAAY,CAAC;AAGxE,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,2BAA2B,KAAK,IAAI,CAAC;AA0D3F;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAEzE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,mBAAmB,CAEvE"}

package/dist/decorators.js

@@ -0,0 +1,106 @@
+import { metadataSymbol } from '@fluojs/core/internal';
+import { microserviceMetadataSymbol } from './metadata.js';
+function getStandardMetadataBag(metadata) {
+  void metadataSymbol;
+  return metadata;
+}
+function defineStandardHandlerMetadata(metadata, propertyKey, handlerMetadata) {
+  const bag = getStandardMetadataBag(metadata);
+  const current = bag[microserviceMetadataSymbol];
+  const map = current ?? new Map();
+  const entries = map.get(propertyKey) ?? [];
+  entries.push(handlerMetadata);
+  map.set(propertyKey, entries);
+  bag[microserviceMetadataSymbol] = map;
+}
+function decoratorDisplayName(kind) {
+  if (kind === 'message') {
+    return 'MessagePattern';
+  }
+  if (kind === 'server-stream') {
+    return 'ServerStreamPattern';
+  }
+  if (kind === 'client-stream') {
+    return 'ClientStreamPattern';
+  }
+  if (kind === 'bidi-stream') {
+    return 'BidiStreamPattern';
+  }
+  return 'EventPattern';
+}
+function createPatternDecorator(kind, pattern) {
+  return (_value, context) => {
+    if (context.private) {
+      throw new Error(`@${decoratorDisplayName(kind)}() cannot be used on private methods.`);
+    }
+    if (context.static) {
+      throw new Error(`@${decoratorDisplayName(kind)}() cannot be used on static methods.`);
+    }
+    defineStandardHandlerMetadata(context.metadata, context.name, {
+      kind,
+      pattern
+    });
+  };
+}
+
+/**
+ * Marks a public instance method as the request-response handler for one message pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound transport packets.
+ * @returns A method decorator that stores message-handler metadata for runtime discovery.
+ *
+ * @example
+ * ```ts
+ * import { MessagePattern } from '@fluojs/microservices';
+ *
+ * export class MathHandler {
+ *   @MessagePattern('math.sum')
+ *   sum(data: { a: number; b: number }) {
+ *     return data.a + data.b;
+ *   }
+ * }
+ * ```
+ */
+export function MessagePattern(pattern) {
+  return createPatternDecorator('message', pattern);
+}
+
+/**
+ * Marks a public instance method as the fire-and-forget handler for one event pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound event packets.
+ * @returns A method decorator that stores event-handler metadata for runtime discovery.
+ */
+export function EventPattern(pattern) {
+  return createPatternDecorator('event', pattern);
+}
+
+/**
+ * Marks a public instance method as the server-streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound server-stream packets.
+ * @returns A method decorator that stores server-stream metadata for runtime discovery.
+ */
+export function ServerStreamPattern(pattern) {
+  return createPatternDecorator('server-stream', pattern);
+}
+
+/**
+ * Marks a public instance method as the client-streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound client-stream packets.
+ * @returns A method decorator that stores client-stream metadata for runtime discovery.
+ */
+export function ClientStreamPattern(pattern) {
+  return createPatternDecorator('client-stream', pattern);
+}
+
+/**
+ * Marks a public instance method as the bidirectional streaming handler for one pattern.
+ *
+ * @param pattern String or `RegExp` pattern matched against inbound bidirectional stream packets.
+ * @returns A method decorator that stores bidi-stream metadata for runtime discovery.
+ */
+export function BidiStreamPattern(pattern) {
+  return createPatternDecorator('bidi-stream', pattern);
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { BidiStreamPattern, ClientStreamPattern, EventPattern, MessagePattern, ServerStreamPattern, } from './decorators.js';
+export { GrpcMicroserviceTransport, type GrpcMicroserviceTransportOptions } from './transports/grpc-transport.js';
+export { KafkaMicroserviceTransport, type KafkaMicroserviceTransportOptions } from './transports/kafka-transport.js';
+export { MicroservicesModule, createMicroservicesProviders } from './module.js';
+export { MicroserviceLifecycleService } from './service.js';
+export { MqttMicroserviceTransport, type MqttMicroserviceTransportOptions } from './transports/mqtt-transport.js';
+export { NatsMicroserviceTransport, type NatsMicroserviceTransportOptions } from './transports/nats-transport.js';
+export { RedisPubSubMicroserviceTransport, type RedisPubSubMicroserviceTransportOptions, } from './transports/redis-transport.js';
+export { RedisStreamsMicroserviceTransport, type RedisStreamClientLike, type RedisStreamsMicroserviceTransportOptions, } from './transports/redis-streams-transport.js';
+export { RabbitMqMicroserviceTransport, type RabbitMqMicroserviceTransportOptions, } from './transports/rabbitmq-transport.js';
+export * from './status.js';
+export { TcpMicroserviceTransport } from './transports/tcp-transport.js';
+export { MICROSERVICE } from './tokens.js';
+export type { Microservice, MicroserviceModuleOptions, MicroserviceModuleRegistrationOptions, MicroserviceTransport, Pattern, ServerStreamWriter, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,EACd,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,yBAAyB,EAAE,KAAK,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAClH,OAAO,EAAE,0BAA0B,EAAE,KAAK,iCAAiC,EAAE,MAAM,iCAAiC,CAAC;AACrH,OAAO,EAAE,mBAAmB,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,yBAAyB,EAAE,KAAK,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAClH,OAAO,EAAE,yBAAyB,EAAE,KAAK,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AAClH,OAAO,EACL,gCAAgC,EAChC,KAAK,uCAAuC,GAC7C,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,iCAAiC,EACjC,KAAK,qBAAqB,EAC1B,KAAK,wCAAwC,GAC9C,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,6BAA6B,EAC7B,KAAK,oCAAoC,GAC1C,MAAM,oCAAoC,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,YAAY,EACZ,yBAAyB,EACzB,qCAAqC,EACrC,qBAAqB,EACrB,OAAO,EACP,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+export { BidiStreamPattern, ClientStreamPattern, EventPattern, MessagePattern, ServerStreamPattern } from './decorators.js';
+export { GrpcMicroserviceTransport } from './transports/grpc-transport.js';
+export { KafkaMicroserviceTransport } from './transports/kafka-transport.js';
+export { MicroservicesModule, createMicroservicesProviders } from './module.js';
+export { MicroserviceLifecycleService } from './service.js';
+export { MqttMicroserviceTransport } from './transports/mqtt-transport.js';
+export { NatsMicroserviceTransport } from './transports/nats-transport.js';
+export { RedisPubSubMicroserviceTransport } from './transports/redis-transport.js';
+export { RedisStreamsMicroserviceTransport } from './transports/redis-streams-transport.js';
+export { RabbitMqMicroserviceTransport } from './transports/rabbitmq-transport.js';
+export * from './status.js';
+export { TcpMicroserviceTransport } from './transports/tcp-transport.js';
+export { MICROSERVICE } from './tokens.js';

package/dist/metadata.d.ts

@@ -0,0 +1,9 @@
+import { type MetadataPropertyKey } from '@fluojs/core';
+import type { HandlerMetadata } from './types.js';
+export declare function defineHandlerMetadata(target: object, propertyKey: MetadataPropertyKey, metadata: HandlerMetadata): void;
+export declare function getHandlerMetadataEntries(target: object): Array<{
+    metadata: HandlerMetadata;
+    propertyKey: MetadataPropertyKey;
+}>;
+export declare const microserviceMetadataSymbol: symbol;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAGxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAuClD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,mBAAmB,EAAE,QAAQ,EAAE,eAAe,GAAG,IAAI,CAKvH;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,GACb,KAAK,CAAC;IAAE,QAAQ,EAAE,eAAe,CAAC;IAAC,WAAW,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAkBxE;AAED,eAAO,MAAM,0BAA0B,QAAkC,CAAC"}

package/dist/metadata.js

@@ -0,0 +1,48 @@
+import { ensureSymbolMetadataPolyfill, metadataSymbol } from '@fluojs/core/internal';
+void ensureSymbolMetadataPolyfill();
+const standardMicroserviceMetadataKey = Symbol.for('fluo.microservices.standard.handler');
+const handlerMetadataStore = new WeakMap();
+function cloneHandlerMetadata(metadata) {
+  return {
+    kind: metadata.kind,
+    pattern: metadata.pattern
+  };
+}
+function getStandardMetadataBag(target) {
+  return target[metadataSymbol];
+}
+function getStandardHandlerMap(target) {
+  const constructor = target.constructor;
+  return constructor ? getStandardMetadataBag(constructor)?.[standardMicroserviceMetadataKey] : undefined;
+}
+function getOrCreateHandlerMap(target) {
+  let map = handlerMetadataStore.get(target);
+  if (!map) {
+    map = new Map();
+    handlerMetadataStore.set(target, map);
+  }
+  return map;
+}
+export function defineHandlerMetadata(target, propertyKey, metadata) {
+  const map = getOrCreateHandlerMap(target);
+  const current = map.get(propertyKey) ?? [];
+  current.push(cloneHandlerMetadata(metadata));
+  map.set(propertyKey, current);
+}
+export function getHandlerMetadataEntries(target) {
+  const stored = handlerMetadataStore.get(target) ?? new Map();
+  const standard = getStandardHandlerMap(target) ?? new Map();
+  const keys = new Set([...stored.keys(), ...standard.keys()]);
+  const entries = [];
+  for (const propertyKey of keys) {
+    const metadataList = [...(stored.get(propertyKey) ?? []), ...(standard.get(propertyKey) ?? [])];
+    for (const metadata of metadataList) {
+      entries.push({
+        metadata: cloneHandlerMetadata(metadata),
+        propertyKey
+      });
+    }
+  }
+  return entries;
+}
+export const microserviceMetadataSymbol = standardMicroserviceMetadataKey;