@jdevel/tnest 0.0.2 → 0.0.4

package/README.md

@@ -30,11 +30,11 @@ npm install @nestjs/common @nestjs/microservices reflect-metadata rxjs
 
 Contracts describe the messages exchanged between services. There are three kinds:
 
-| Type | Purpose | Has response? |
-|------|---------|---------------|
-| `Command` | Write operation (request/response) | Yes |
-| `Query` | Read operation (request/response) | Yes |
-| `Event` | Notification (fire-and-forget) | No |
+| Type      | Purpose                            | Has response? |
+| --------- | ---------------------------------- | ------------- |
+| `Command` | Write operation (request/response) | Yes           |
+| `Query`   | Read operation (request/response)  | Yes           |
+| `Event`   | Notification (fire-and-forget)     | No            |
 
 ```ts
 // contracts/user.contracts.ts
@@ -63,9 +63,9 @@ export type UserContracts = typeof userContracts;
 You can also define contracts with explicit interfaces if you prefer:
 
 ```ts
-import type { Command, Event, Query } from '@jdevel/tnest';
+import type { Command, Event, Query, ContractRegistry } from '@jdevel/tnest';
 
-export interface UserContracts {
+export interface UserContracts extends ContractRegistry {
   'user.create': Command<'user.create', CreateUserDto, User>;
   'user.created': Event<'user.created', { userId: string; email: string }>;
   'user.get': Query<'user.get', { id: string }, User>;
@@ -74,6 +74,10 @@ export interface UserContracts {
 
 ### 2. Register the module
 
+#### Static configuration with `forRoot`
+
+Use `forRoot` when your transport configuration is known at compile time:
+
 ```ts
 // app.module.ts
 import { Module } from '@nestjs/common';
@@ -91,6 +95,13 @@ import { TnestModule } from '@jdevel/tnest';
             options: { host: 'localhost', port: 3001 },
           },
         },
+        {
+          name: 'NOTIFICATION_SERVICE',
+          options: {
+            transport: Transport.REDIS,
+            options: { host: 'localhost', port: 6379 },
+          },
+        },
       ],
     }),
   ],
@@ -98,6 +109,107 @@ import { TnestModule } from '@jdevel/tnest';
 export class AppModule {}
 ```
 
+#### Async configuration with `forRootAsync`
+
+Use `forRootAsync` when transport configuration comes from `ConfigService`, environment variables, or another async source.
+
+**With `useFactory`:**
+
+```ts
+import { Module } from '@nestjs/common';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { Transport } from '@nestjs/microservices';
+import { TnestModule } from '@jdevel/tnest';
+
+@Module({
+  imports: [
+    TnestModule.forRootAsync({
+      imports: [ConfigModule],
+      // Declare client names upfront so they can be injected before the factory resolves
+      clientNames: ['USER_SERVICE', 'NOTIFICATION_SERVICE'],
+      useFactory: (config: ConfigService) => ({
+        clients: [
+          {
+            name: 'USER_SERVICE',
+            options: {
+              transport: Transport.TCP,
+              options: {
+                host: config.get('USER_SERVICE_HOST'),
+                port: config.get<number>('USER_SERVICE_PORT'),
+              },
+            },
+          },
+          {
+            name: 'NOTIFICATION_SERVICE',
+            options: {
+              transport: Transport.REDIS,
+              options: {
+                host: config.get('REDIS_HOST'),
+                port: config.get<number>('REDIS_PORT'),
+              },
+            },
+          },
+        ],
+      }),
+      inject: [ConfigService],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+**With `useClass`:**
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+import { TnestModule, type TnestOptionsFactory, type TnestModuleOptions } from '@jdevel/tnest';
+
+@Injectable()
+class TnestConfigService implements TnestOptionsFactory {
+  createTnestOptions(): TnestModuleOptions {
+    return {
+      clients: [
+        {
+          name: 'USER_SERVICE',
+          options: {
+            transport: Transport.TCP,
+            options: { host: 'localhost', port: 3001 },
+          },
+        },
+      ],
+    };
+  }
+}
+
+@Module({
+  imports: [
+    TnestModule.forRootAsync({
+      clientNames: ['USER_SERVICE'],
+      useClass: TnestConfigService,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+**With `useExisting`:**
+
+```ts
+@Module({
+  imports: [
+    TnestModule.forRootAsync({
+      clientNames: ['USER_SERVICE'],
+      useExisting: TnestConfigService, // reuse an already-registered provider
+      imports: [ConfigModule],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+> **Note:** The `clientNames` array tells the module which client tokens to register upfront. Each name must match a `name` in the `clients` array returned by the factory. Without `clientNames`, async clients won't be injectable by token.
+
 ### 3. Send messages (producer)
 
 ```ts
@@ -120,10 +232,10 @@ export class OrderService {
   }
 
   async createOrder(userId: string) {
-    const user = await firstValueFrom(
-      this.users.send('user.get', { id: userId }),
-    );
+    // send() for commands and queries — type-safe pattern, payload, and response
+    const user = await firstValueFrom(this.users.send('user.get', { id: userId }));
 
+    // emit() for events — type-safe pattern and payload, no response
     this.users.emit('user.created', {
       userId: user.id,
       email: user.email,
@@ -147,8 +259,28 @@ this.users.send('user.created', { userId: '1', email: 'a@b.com' });
 //               ~~~~~~~~~~~~~~ ERROR: 'user.created' is an event, use emit()
 ```
 
+When using the second type parameter on handler decorators, the compiler also catches handler signature mismatches:
+
+```ts
+@TypedMessagePattern<UserContracts, 'user.create'>('user.create')
+async create(payload: { wrong: number }) {
+  //                   ~~~~~~~~~~~~~~~~ ERROR: expects { email: string; name: string }
+  return { id: '1' };
+}
+
+@TypedMessagePattern<UserContracts, 'user.get'>('user.get')
+async get(payload: { id: string }): Promise<{ wrong: boolean }> {
+  //                                         ~~~~~~~~~~~~~~~~~ ERROR: must return User
+  return { wrong: true };
+}
+```
+
+> **Note:** Omitting the second type parameter preserves the existing behavior — the decorator validates the pattern string but does not constrain the method signature.
+
 ### 4. Handle messages (consumer)
 
+#### Using decorators
+
 ```ts
 // user.controller.ts
 import { Controller } from '@nestjs/common';
@@ -157,25 +289,56 @@ import type { UserContracts } from './contracts/user.contracts';
 
 @Controller()
 export class UserController {
-  @TypedMessagePattern<UserContracts>('user.create')
+  // Pass the pattern as a second type parameter to enforce the method signature.
+  // The compiler will error if the payload or return type doesn't match the contract.
+  @TypedMessagePattern<UserContracts, 'user.create'>('user.create')
   async create(payload: { email: string; name: string }) {
     return { id: crypto.randomUUID(), ...payload };
   }
 
-  @TypedMessagePattern<UserContracts>('user.get')
+  @TypedMessagePattern<UserContracts, 'user.get'>('user.get')
   async get(payload: { id: string }) {
     return { id: payload.id, email: 'user@example.com', name: 'Example' };
   }
 
-  @TypedEventPattern<UserContracts>('user.created')
+  @TypedEventPattern<UserContracts, 'user.created'>('user.created')
   async handleCreated(payload: { userId: string; email: string }) {
     console.log(`User created: ${payload.userId}`);
   }
 }
 ```
 
+#### Using handler type helpers
+
+If you prefer explicit typing without decorators, use `TypedMessageHandler` and `TypedEventHandler`:
+
+```ts
+import type { TypedMessageHandler, TypedEventHandler } from '@jdevel/tnest';
+import { MessagePattern, EventPattern } from '@nestjs/microservices';
+import type { UserContracts } from './contracts/user.contracts';
+
+@Controller()
+export class UserController {
+  @MessagePattern('user.create')
+  create: TypedMessageHandler<UserContracts, 'user.create'> = async (payload) => {
+    // payload is typed as { email: string; name: string }
+    // return type is enforced as User | Promise<User> | Observable<User>
+    return { id: crypto.randomUUID(), ...payload };
+  };
+
+  @EventPattern('user.created')
+  handleCreated: TypedEventHandler<UserContracts, 'user.created'> = async (payload) => {
+    // payload is typed as { userId: string; email: string }
+    // return type is enforced as void | Promise<void>
+    console.log(`User created: ${payload.userId}`);
+  };
+}
+```
+
 ## Testing
 
+### MockTypedClient
+
 `MockTypedClient` records every message and returns configurable canned responses:
 
 ```ts
@@ -185,66 +348,45 @@ import type { UserContracts } from './contracts/user.contracts';
 
 const mock = new MockTypedClient<UserContracts>();
 
+// Set up canned responses
 mock.setResponse('user.get', {
   id: '42',
   email: 'test@example.com',
   name: 'Test User',
 });
 
+// Use the mock exactly like a real TypedClient
 const user = await firstValueFrom(mock.send('user.get', { id: '42' }));
 // user.id === '42'
 
-expect(mock.messages).toEqual([
-  { type: 'send', pattern: 'user.get', payload: { id: '42' } },
-]);
+// Assert on recorded messages
+expect(mock.messages).toEqual([{ type: 'send', pattern: 'user.get', payload: { id: '42' } }]);
+
+// Reset between tests
+mock.reset();
 ```
 
+### TestContractModule
+
 For integration tests, `TestContractModule` swaps real clients for mocks:
 
 ```ts
 import { Test } from '@nestjs/testing';
-import { MockTypedClient, TestContractModule } from '@jdevel/tnest';
+import { MockTypedClient, TestContractModule, getClientToken } from '@jdevel/tnest';
 import type { UserContracts } from './contracts/user.contracts';
 
-const mock = new MockTypedClient<UserContracts>();
+const mockUserClient = new MockTypedClient<UserContracts>();
 
 const module = await Test.createTestingModule({
-  imports: [
-    TestContractModule.register([
-      { name: 'USER_SERVICE', mock },
-    ]),
-  ],
+  imports: [TestContractModule.register([{ name: 'USER_SERVICE', mock: mockUserClient }])],
   providers: [OrderService],
 }).compile();
-```
-
-## Async Module Configuration
 
-Use `forRootAsync` when transport config comes from `ConfigService` or another async source:
+const service = module.get(OrderService);
 
-```ts
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { TnestModule } from '@jdevel/tnest';
-import { Transport } from '@nestjs/microservices';
-
-TnestModule.forRootAsync({
-  imports: [ConfigModule],
-  useFactory: (config: ConfigService) => ({
-    clients: [
-      {
-        name: 'USER_SERVICE',
-        options: {
-          transport: Transport.TCP,
-          options: {
-            host: config.get('USER_SERVICE_HOST'),
-            port: config.get('USER_SERVICE_PORT'),
-          },
-        },
-      },
-    ],
-  }),
-  inject: [ConfigService],
-});
+// The mock is also retrievable by token
+const client = module.get(getClientToken('USER_SERVICE'));
+// client === mockUserClient
 ```
 
 ## Runtime Validation (Optional)
@@ -261,17 +403,18 @@ import {
 } from '@jdevel/tnest';
 
 @Injectable()
-class MyValidator implements ContractValidator {
+class ZodValidator implements ContractValidator {
   validate(payload: unknown): void {
     // your validation logic (zod, class-validator, joi, etc.)
+    // throw an error if validation fails
   }
 }
 
 // Register in module providers
-{ provide: CONTRACT_VALIDATOR, useClass: MyValidator }
+{ provide: CONTRACT_VALIDATOR, useClass: ZodValidator }
 
-// Apply to handlers
-@TypedMessagePattern<UserContracts>('user.create')
+// Apply to handlers — validation runs before the handler method
+@TypedMessagePattern<UserContracts, 'user.create'>('user.create')
 @ValidateContract()
 async create(payload: CreateUserDto) {
   // payload has been validated at runtime
@@ -283,6 +426,7 @@ async create(payload: CreateUserDto) {
 Provide custom payload serialization (protobuf, msgpack, etc.) by implementing `PayloadSerializer` and `PayloadDeserializer`:
 
 ```ts
+import { Injectable } from '@nestjs/common';
 import {
   PAYLOAD_SERIALIZER,
   PAYLOAD_DESERIALIZER,
@@ -292,8 +436,12 @@ import {
 
 @Injectable()
 class MsgpackSerializer implements PayloadSerializer, PayloadDeserializer {
-  serialize(payload: unknown) { return msgpack.encode(payload); }
-  deserialize(data: unknown) { return msgpack.decode(data as Buffer); }
+  serialize(payload: unknown) {
+    return msgpack.encode(payload);
+  }
+  deserialize(data: unknown) {
+    return msgpack.decode(data as Buffer);
+  }
 }
 
 // Register in module providers
@@ -301,12 +449,15 @@ class MsgpackSerializer implements PayloadSerializer, PayloadDeserializer {
 { provide: PAYLOAD_DESERIALIZER, useClass: MsgpackSerializer }
 ```
 
+A `DefaultPayloadSerializer` (pass-through) is included and used when no custom serializer is registered.
+
 ## Utility Types
 
 Extract type information from your contract registry:
 
 ```ts
 import type {
+  PatternOf,
   PayloadOf,
   ResponseOf,
   CommandPatterns,
@@ -316,42 +467,65 @@ import type {
   CommandsOf,
   EventsOf,
   QueriesOf,
+  ValidateRegistry,
 } from '@jdevel/tnest';
 
-type Payload = PayloadOf<UserContracts['user.create']>;   // CreateUserDto
-type Response = ResponseOf<UserContracts['user.create']>;  // User
-type Cmds = CommandPatterns<UserContracts>;                 // 'user.create'
-type Evts = EventPatterns<UserContracts>;                  // 'user.created'
-type Qrys = QueryPatterns<UserContracts>;                  // 'user.get'
-type Sendable = SendablePatterns<UserContracts>;            // 'user.create' | 'user.get'
+// Extract parts of a single contract
+type CreatePayload = PayloadOf<UserContracts['user.create']>; // CreateUserDto
+type CreateResponse = ResponseOf<UserContracts['user.create']>; // User
+type CreatePattern = PatternOf<UserContracts['user.create']>; // 'user.create'
+
+// Pattern string unions by contract kind
+type Cmds = CommandPatterns<UserContracts>; // 'user.create'
+type Evts = EventPatterns<UserContracts>; // 'user.created'
+type Qrys = QueryPatterns<UserContracts>; // 'user.get'
+type Sendable = SendablePatterns<UserContracts>; // 'user.create' | 'user.get'
+
+// Filter a registry to contracts of a specific kind
+type OnlyCommands = CommandsOf<UserContracts>; // { 'user.create': Command<...> }
+type OnlyEvents = EventsOf<UserContracts>; // { 'user.created': Event<...> }
+type OnlyQueries = QueriesOf<UserContracts>; // { 'user.get': Query<...> }
+
+// Validate that a registry's keys match its pattern type parameters
+type Validated = ValidateRegistry<UserContracts>;
+// Produces an error type if any key doesn't match its contract's pattern
 ```
 
 ## API Reference
 
-| Export | Kind | Description |
-|--------|------|-------------|
-| `TnestModule` | Module | Dynamic module with `forRoot` / `forRootAsync` |
-| `TypedClient` | Class | Type-safe wrapper around `ClientProxy` |
-| `TypedClientFactory` | Service | Creates `TypedClient` instances |
-| `TypedMessagePattern` | Decorator | Typed `@MessagePattern` for commands/queries |
-| `TypedEventPattern` | Decorator | Typed `@EventPattern` for events |
-| `MockTypedClient` | Class | Test double that records messages |
-| `TestContractModule` | Module | Registers mock clients for testing |
-| `ValidateContract` | Decorator | Opt-in runtime payload validation |
-| `getClientToken` | Function | Returns injection token for a named client |
-| `defineRegistry` | Function | Builder helper for defining contract registries |
-| `command` / `event` / `query` | Functions | Builder helpers for individual contracts |
-| `Command` / `Event` / `Query` | Type | Contract type interfaces |
-| `ContractRegistry` | Type | Base type for a registry of contracts |
-| `PayloadOf` / `ResponseOf` / `PatternOf` | Type | Extract parts of a contract |
-| `CommandsOf` / `EventsOf` / `QueriesOf` | Type | Filter registry by contract kind |
-| `CommandPatterns` / `EventPatterns` / `QueryPatterns` | Type | Pattern string unions by kind |
-| `SendablePatterns` | Type | Union of command + query patterns |
-| `ContractValidator` | Interface | Implement for runtime validation |
-| `PayloadSerializer` / `PayloadDeserializer` | Interface | Implement for custom serialization |
-| `CONTRACT_VALIDATOR` | Token | Injection token for validator |
-| `PAYLOAD_SERIALIZER` / `PAYLOAD_DESERIALIZER` | Token | Injection tokens for serialization |
+| Export                                                | Kind      | Description                                         |
+| ----------------------------------------------------- | --------- | --------------------------------------------------- |
+| `TnestModule`                                         | Module    | Dynamic module with `forRoot` / `forRootAsync`      |
+| `TypedClient`                                         | Class     | Type-safe wrapper around `ClientProxy`              |
+| `TypedClientFactory`                                  | Service   | Creates `TypedClient` instances                     |
+| `TypedMessagePattern`                                 | Decorator | Typed `@MessagePattern` for commands/queries        |
+| `TypedEventPattern`                                   | Decorator | Typed `@EventPattern` for events                    |
+| `ValidateContract`                                    | Decorator | Opt-in runtime payload validation                   |
+| `MockTypedClient`                                     | Class     | Test double that records messages                   |
+| `TestContractModule`                                  | Module    | Registers mock clients for testing                  |
+| `getClientToken`                                      | Function  | Returns injection token for a named client          |
+| `defineRegistry`                                      | Function  | Builder helper for defining contract registries     |
+| `command` / `event` / `query`                         | Functions | Builder helpers for individual contracts            |
+| `Command` / `Event` / `Query`                         | Type      | Contract type interfaces                            |
+| `ContractRegistry`                                    | Type      | Base type for a registry of contracts               |
+| `ValidateRegistry`                                    | Type      | Validates registry keys match contract patterns     |
+| `PayloadOf` / `ResponseOf` / `PatternOf`              | Type      | Extract parts of a contract                         |
+| `CommandsOf` / `EventsOf` / `QueriesOf`               | Type      | Filter registry by contract kind                    |
+| `CommandPatterns` / `EventPatterns` / `QueryPatterns` | Type      | Pattern string unions by kind                       |
+| `SendablePatterns`                                    | Type      | Union of command + query patterns                   |
+| `TypedMessageHandler`                                 | Type      | Function signature for command/query handlers       |
+| `TypedEventHandler`                                   | Type      | Function signature for event handlers               |
+| `TnestModuleOptions`                                  | Interface | Configuration for `forRoot`                         |
+| `TnestModuleAsyncOptions`                             | Interface | Configuration for `forRootAsync`                    |
+| `TnestOptionsFactory`                                 | Interface | Implement for `useClass`/`useExisting` async config |
+| `TnestClientDefinition`                               | Interface | Client name + transport options pair                |
+| `ContractValidator`                                   | Interface | Implement for runtime validation                    |
+| `PayloadSerializer` / `PayloadDeserializer`           | Interface | Implement for custom serialization                  |
+| `DefaultPayloadSerializer`                            | Class     | Pass-through serializer (default)                   |
+| `CONTRACT_VALIDATOR`                                  | Token     | Injection token for validator                       |
+| `PAYLOAD_SERIALIZER` / `PAYLOAD_DESERIALIZER`         | Token     | Injection tokens for serialization                  |
+| `TNEST_OPTIONS`                                       | Token     | Injection token for module options                  |
 
 ## License
 
-MIT
+MIT

package/dist/__tests__/constants.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/constants.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+describe('TNEST_OPTIONS', () => {
+    it('is a Symbol', () => {
+        expect(typeof constants_1.TNEST_OPTIONS).toBe('symbol');
+    });
+});
+describe('getClientToken()', () => {
+    it('returns a string prefixed with TNEST_CLIENT_PREFIX', () => {
+        const token = (0, constants_1.getClientToken)('USER_SERVICE');
+        expect(token).toBe(`${constants_1.TNEST_CLIENT_PREFIX}USER_SERVICE`);
+    });
+    it('returns deterministic tokens for the same name', () => {
+        expect((0, constants_1.getClientToken)('SVC')).toBe((0, constants_1.getClientToken)('SVC'));
+    });
+    it('returns different tokens for different names', () => {
+        expect((0, constants_1.getClientToken)('A')).not.toBe((0, constants_1.getClientToken)('B'));
+    });
+});
+//# sourceMappingURL=constants.spec.js.map

package/dist/__tests__/constants.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.spec.js","sourceRoot":"","sources":["../../src/__tests__/constants.spec.ts"],"names":[],"mappings":";;AAAA,4CAAkF;AAElF,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE;QACrB,MAAM,CAAC,OAAO,yBAAa,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,EAAE,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC5D,MAAM,KAAK,GAAG,IAAA,0BAAc,EAAC,cAAc,CAAC,CAAC;QAC7C,MAAM,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,+BAAmB,cAAc,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gDAAgD,EAAE,GAAG,EAAE;QACxD,MAAM,CAAC,IAAA,0BAAc,EAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,IAAA,0BAAc,EAAC,KAAK,CAAC,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACtD,MAAM,CAAC,IAAA,0BAAc,EAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,IAAA,0BAAc,EAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/__tests__/tnest-module.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tnest-module.spec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@nestjs/testing");
+const tnest_module_1 = require("../tnest.module");
+const client_1 = require("../client");
+const constants_1 = require("../constants");
+describe('TnestModule', () => {
+    describe('forRoot()', () => {
+        it('provides TypedClientFactory', async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [tnest_module_1.TnestModule.forRoot()],
+            }).compile();
+            const factory = module.get(client_1.TypedClientFactory);
+            expect(factory).toBeInstanceOf(client_1.TypedClientFactory);
+        });
+        it('provides TNEST_OPTIONS', async () => {
+            const options = { clients: [] };
+            const module = await testing_1.Test.createTestingModule({
+                imports: [tnest_module_1.TnestModule.forRoot(options)],
+            }).compile();
+            const resolved = module.get(constants_1.TNEST_OPTIONS);
+            expect(resolved).toBe(options);
+        });
+        it('registers named client tokens from client definitions', async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [
+                    tnest_module_1.TnestModule.forRoot({
+                        clients: [{ name: 'USER_SERVICE', options: { transport: 0 } }],
+                    }),
+                ],
+            }).compile();
+            const token = (0, constants_1.getClientToken)('USER_SERVICE');
+            const client = module.get(token);
+            expect(client).toBeDefined();
+        });
+    });
+    describe('forRootAsync()', () => {
+        it('provides TypedClientFactory', async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [
+                    tnest_module_1.TnestModule.forRootAsync({
+                        useFactory: () => ({ clients: [] }),
+                    }),
+                ],
+            }).compile();
+            const factory = module.get(client_1.TypedClientFactory);
+            expect(factory).toBeInstanceOf(client_1.TypedClientFactory);
+        });
+        it('resolves TNEST_OPTIONS from factory', async () => {
+            const options = { clients: [] };
+            const module = await testing_1.Test.createTestingModule({
+                imports: [
+                    tnest_module_1.TnestModule.forRootAsync({
+                        useFactory: () => options,
+                    }),
+                ],
+            }).compile();
+            const resolved = module.get(constants_1.TNEST_OPTIONS);
+            expect(resolved).toBe(options);
+        });
+        it('registers named client tokens when clientNames are provided', async () => {
+            const module = await testing_1.Test.createTestingModule({
+                imports: [
+                    tnest_module_1.TnestModule.forRootAsync({
+                        clientNames: ['USER_SERVICE'],
+                        useFactory: () => ({
+                            clients: [{ name: 'USER_SERVICE', options: { transport: 0 } }],
+                        }),
+                    }),
+                ],
+            }).compile();
+            const token = (0, constants_1.getClientToken)('USER_SERVICE');
+            const client = module.get(token);
+            expect(client).toBeDefined();
+        });
+        it('throws when clientName is not found in resolved options', async () => {
+            await expect(testing_1.Test.createTestingModule({
+                imports: [
+                    tnest_module_1.TnestModule.forRootAsync({
+                        clientNames: ['MISSING_SERVICE'],
+                        useFactory: () => ({ clients: [] }),
+                    }),
+                ],
+            }).compile()).rejects.toThrow(/client "MISSING_SERVICE" was declared in clientNames but not found/);
+        });
+    });
+});
+//# sourceMappingURL=tnest-module.spec.js.map

package/dist/__tests__/tnest-module.spec.js.map

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

package/dist/client/__tests__/typed-client-factory.spec.d.ts

@@ -0,0 +1 @@
+export {};