@jdevel/tnest 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,357 @@
+# @jdevel/tnest
+
+Type-safe communication between NestJS microservices.
+
+Define your message contracts once as TypeScript types, and the compiler enforces them across every producer and consumer — eliminating runtime type mismatches between services.
+
+## Features
+
+- **Compile-time safety** -- mismatched patterns, payloads, or responses are caught before deployment
+- **Transport-agnostic** -- works with any NestJS transport (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC)
+- **NestJS-native** -- standard modules, decorators, and dependency injection
+- **Zero runtime overhead** -- type enforcement happens at compile time; no runtime schema checking unless you opt in
+- **First-class testing** -- `MockTypedClient` and `TestContractModule` included
+
+## Installation
+
+```bash
+npm install @jdevel/tnest
+```
+
+Peer dependencies:
+
+```bash
+npm install @nestjs/common @nestjs/microservices reflect-metadata rxjs
+```
+
+## Quick Start
+
+### 1. Define contracts
+
+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 |
+
+```ts
+// contracts/user.contracts.ts
+import { defineRegistry, command, event, query } from '@jdevel/tnest';
+
+interface CreateUserDto {
+  email: string;
+  name: string;
+}
+
+interface User {
+  id: string;
+  email: string;
+  name: string;
+}
+
+export const userContracts = defineRegistry({
+  'user.create': command<CreateUserDto, User>(),
+  'user.created': event<{ userId: string; email: string }>(),
+  'user.get': query<{ id: string }, User>(),
+});
+
+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';
+
+export interface UserContracts {
+  'user.create': Command<'user.create', CreateUserDto, User>;
+  'user.created': Event<'user.created', { userId: string; email: string }>;
+  'user.get': Query<'user.get', { id: string }, User>;
+}
+```
+
+### 2. Register the module
+
+```ts
+// app.module.ts
+import { Module } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+import { TnestModule } from '@jdevel/tnest';
+
+@Module({
+  imports: [
+    TnestModule.forRoot({
+      clients: [
+        {
+          name: 'USER_SERVICE',
+          options: {
+            transport: Transport.TCP,
+            options: { host: 'localhost', port: 3001 },
+          },
+        },
+      ],
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 3. Send messages (producer)
+
+```ts
+// order.service.ts
+import { Injectable, Inject } from '@nestjs/common';
+import { ClientProxy } from '@nestjs/microservices';
+import { TypedClientFactory, TypedClient, getClientToken } from '@jdevel/tnest';
+import { firstValueFrom } from 'rxjs';
+import type { UserContracts } from './contracts/user.contracts';
+
+@Injectable()
+export class OrderService {
+  private readonly users: TypedClient<UserContracts>;
+
+  constructor(
+    factory: TypedClientFactory,
+    @Inject(getClientToken('USER_SERVICE')) proxy: ClientProxy,
+  ) {
+    this.users = factory.create<UserContracts>(proxy);
+  }
+
+  async createOrder(userId: string) {
+    const user = await firstValueFrom(
+      this.users.send('user.get', { id: userId }),
+    );
+
+    this.users.emit('user.created', {
+      userId: user.id,
+      email: user.email,
+    });
+
+    return { orderId: '123', user };
+  }
+}
+```
+
+The compiler catches contract violations:
+
+```ts
+this.users.send('user.delete', { id: '1' });
+//               ~~~~~~~~~~~~ ERROR: not a valid pattern
+
+this.users.send('user.get', { name: 'test' });
+//                           ~~~~~~~~~~~~~~~~ ERROR: expects { id: string }
+
+this.users.send('user.created', { userId: '1', email: 'a@b.com' });
+//               ~~~~~~~~~~~~~~ ERROR: 'user.created' is an event, use emit()
+```
+
+### 4. Handle messages (consumer)
+
+```ts
+// user.controller.ts
+import { Controller } from '@nestjs/common';
+import { TypedMessagePattern, TypedEventPattern } from '@jdevel/tnest';
+import type { UserContracts } from './contracts/user.contracts';
+
+@Controller()
+export class UserController {
+  @TypedMessagePattern<UserContracts>('user.create')
+  async create(payload: { email: string; name: string }) {
+    return { id: crypto.randomUUID(), ...payload };
+  }
+
+  @TypedMessagePattern<UserContracts>('user.get')
+  async get(payload: { id: string }) {
+    return { id: payload.id, email: 'user@example.com', name: 'Example' };
+  }
+
+  @TypedEventPattern<UserContracts>('user.created')
+  async handleCreated(payload: { userId: string; email: string }) {
+    console.log(`User created: ${payload.userId}`);
+  }
+}
+```
+
+## Testing
+
+`MockTypedClient` records every message and returns configurable canned responses:
+
+```ts
+import { MockTypedClient } from '@jdevel/tnest';
+import { firstValueFrom } from 'rxjs';
+import type { UserContracts } from './contracts/user.contracts';
+
+const mock = new MockTypedClient<UserContracts>();
+
+mock.setResponse('user.get', {
+  id: '42',
+  email: 'test@example.com',
+  name: 'Test User',
+});
+
+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' } },
+]);
+```
+
+For integration tests, `TestContractModule` swaps real clients for mocks:
+
+```ts
+import { Test } from '@nestjs/testing';
+import { MockTypedClient, TestContractModule } from '@jdevel/tnest';
+import type { UserContracts } from './contracts/user.contracts';
+
+const mock = new MockTypedClient<UserContracts>();
+
+const module = await Test.createTestingModule({
+  imports: [
+    TestContractModule.register([
+      { name: 'USER_SERVICE', mock },
+    ]),
+  ],
+  providers: [OrderService],
+}).compile();
+```
+
+## Async Module Configuration
+
+Use `forRootAsync` when transport config comes from `ConfigService` or another async source:
+
+```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],
+});
+```
+
+## Runtime Validation (Optional)
+
+By default, contracts are enforced at compile time only. To add runtime payload validation, implement the `ContractValidator` interface and apply `@ValidateContract()`:
+
+```ts
+import { Injectable } from '@nestjs/common';
+import {
+  CONTRACT_VALIDATOR,
+  ValidateContract,
+  TypedMessagePattern,
+  type ContractValidator,
+} from '@jdevel/tnest';
+
+@Injectable()
+class MyValidator implements ContractValidator {
+  validate(payload: unknown): void {
+    // your validation logic (zod, class-validator, joi, etc.)
+  }
+}
+
+// Register in module providers
+{ provide: CONTRACT_VALIDATOR, useClass: MyValidator }
+
+// Apply to handlers
+@TypedMessagePattern<UserContracts>('user.create')
+@ValidateContract()
+async create(payload: CreateUserDto) {
+  // payload has been validated at runtime
+}
+```
+
+## Custom Serialization (Optional)
+
+Provide custom payload serialization (protobuf, msgpack, etc.) by implementing `PayloadSerializer` and `PayloadDeserializer`:
+
+```ts
+import {
+  PAYLOAD_SERIALIZER,
+  PAYLOAD_DESERIALIZER,
+  type PayloadSerializer,
+  type PayloadDeserializer,
+} from '@jdevel/tnest';
+
+@Injectable()
+class MsgpackSerializer implements PayloadSerializer, PayloadDeserializer {
+  serialize(payload: unknown) { return msgpack.encode(payload); }
+  deserialize(data: unknown) { return msgpack.decode(data as Buffer); }
+}
+
+// Register in module providers
+{ provide: PAYLOAD_SERIALIZER, useClass: MsgpackSerializer }
+{ provide: PAYLOAD_DESERIALIZER, useClass: MsgpackSerializer }
+```
+
+## Utility Types
+
+Extract type information from your contract registry:
+
+```ts
+import type {
+  PayloadOf,
+  ResponseOf,
+  CommandPatterns,
+  EventPatterns,
+  QueryPatterns,
+  SendablePatterns,
+  CommandsOf,
+  EventsOf,
+  QueriesOf,
+} 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'
+```
+
+## 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 |
+
+## License
+
+MIT

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export { TypedClient } from './typed-client';
+export { TypedClientFactory } from './typed-client-factory';

package/dist/client/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedClientFactory = exports.TypedClient = void 0;
+var typed_client_1 = require("./typed-client");
+Object.defineProperty(exports, "TypedClient", { enumerable: true, get: function () { return typed_client_1.TypedClient; } });
+var typed_client_factory_1 = require("./typed-client-factory");
+Object.defineProperty(exports, "TypedClientFactory", { enumerable: true, get: function () { return typed_client_factory_1.TypedClientFactory; } });
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":";;;AAAA,+CAA6C;AAApC,2GAAA,WAAW,OAAA;AACpB,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA"}

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

@@ -0,0 +1,6 @@
+import { ClientProxy, type ClientOptions } from '@nestjs/microservices';
+import type { ContractRegistry } from '../contracts';
+import { TypedClient } from './typed-client';
+export declare class TypedClientFactory {
+    create<TRegistry extends ContractRegistry>(clientOrOptions: ClientProxy | ClientOptions): TypedClient<TRegistry>;
+}

package/dist/client/typed-client-factory.js

@@ -0,0 +1,25 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedClientFactory = void 0;
+const common_1 = require("@nestjs/common");
+const microservices_1 = require("@nestjs/microservices");
+const typed_client_1 = require("./typed-client");
+let TypedClientFactory = class TypedClientFactory {
+    create(clientOrOptions) {
+        const client = clientOrOptions instanceof microservices_1.ClientProxy
+            ? clientOrOptions
+            : microservices_1.ClientProxyFactory.create(clientOrOptions);
+        return new typed_client_1.TypedClient(client);
+    }
+};
+exports.TypedClientFactory = TypedClientFactory;
+exports.TypedClientFactory = TypedClientFactory = __decorate([
+    (0, common_1.Injectable)()
+], TypedClientFactory);
+//# sourceMappingURL=typed-client-factory.js.map

package/dist/client/typed-client-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-client-factory.js","sourceRoot":"","sources":["../../src/client/typed-client-factory.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAA4C;AAC5C,yDAA4F;AAE5F,iDAA6C;AAGtC,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAC7B,MAAM,CACJ,eAA4C;QAE5C,MAAM,MAAM,GACV,eAAe,YAAY,2BAAW;YACpC,CAAC,CAAC,eAAe;YACjB,CAAC,CAAC,kCAAkB,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAEjD,OAAO,IAAI,0BAAW,CAAY,MAAM,CAAC,CAAC;IAC5C,CAAC;CACF,CAAA;AAXY,gDAAkB;6BAAlB,kBAAkB;IAD9B,IAAA,mBAAU,GAAE;GACA,kBAAkB,CAW9B"}

package/dist/client/typed-client.d.ts

@@ -0,0 +1,11 @@
+import { type ClientProxy } from '@nestjs/microservices';
+import type { Observable } from 'rxjs';
+import type { ContractRegistry, EventPatterns, PayloadOf, ResponseOf, SendablePatterns } from '../contracts';
+export declare class TypedClient<TRegistry extends ContractRegistry> {
+    private readonly client;
+    constructor(client: ClientProxy);
+    send<P extends SendablePatterns<TRegistry>>(pattern: P, payload: PayloadOf<TRegistry[P]>): Observable<ResponseOf<TRegistry[P]>>;
+    emit<P extends EventPatterns<TRegistry>>(pattern: P, payload: PayloadOf<TRegistry[P]>): Observable<undefined>;
+    connect(): Promise<void>;
+    close(): void;
+}

package/dist/client/typed-client.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedClient = void 0;
+class TypedClient {
+    constructor(client) {
+        this.client = client;
+    }
+    send(pattern, payload) {
+        return this.client.send(pattern, payload);
+    }
+    emit(pattern, payload) {
+        return this.client.emit(pattern, payload);
+    }
+    connect() {
+        return this.client.connect();
+    }
+    close() {
+        this.client.close();
+    }
+}
+exports.TypedClient = TypedClient;
+//# sourceMappingURL=typed-client.js.map

package/dist/client/typed-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-client.js","sourceRoot":"","sources":["../../src/client/typed-client.ts"],"names":[],"mappings":";;;AAUA,MAAa,WAAW;IACtB,YAA6B,MAAmB;QAAnB,WAAM,GAAN,MAAM,CAAa;IAAG,CAAC;IAEpD,IAAI,CACF,OAAU,EACV,OAAgC;QAEhC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAA2B,OAAO,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAED,IAAI,CACF,OAAU,EACV,OAAgC;QAEhC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IAC/B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;CACF;AAxBD,kCAwBC"}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const TNEST_OPTIONS: unique symbol;
+export declare const TNEST_CLIENT_PREFIX = "TNEST_CLIENT_";
+export declare function getClientToken(name: string): string;

package/dist/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TNEST_CLIENT_PREFIX = exports.TNEST_OPTIONS = void 0;
+exports.getClientToken = getClientToken;
+exports.TNEST_OPTIONS = Symbol('TNEST_OPTIONS');
+exports.TNEST_CLIENT_PREFIX = 'TNEST_CLIENT_';
+function getClientToken(name) {
+    return `${exports.TNEST_CLIENT_PREFIX}${name}`;
+}
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAGA,wCAEC;AALY,QAAA,aAAa,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AACxC,QAAA,mBAAmB,GAAG,eAAe,CAAC;AAEnD,SAAgB,cAAc,CAAC,IAAY;IACzC,OAAO,GAAG,2BAAmB,GAAG,IAAI,EAAE,CAAC;AACzC,CAAC"}

package/dist/contracts/command.d.ts

@@ -0,0 +1,6 @@
+export interface Command<TPattern extends string = string, TPayload = unknown, TResponse = void> {
+    readonly __type: 'command';
+    readonly pattern: TPattern;
+    readonly payload: TPayload;
+    readonly response: TResponse;
+}

package/dist/contracts/command.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=command.js.map

package/dist/contracts/command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.js","sourceRoot":"","sources":["../../src/contracts/command.ts"],"names":[],"mappings":""}

package/dist/contracts/define-helpers.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from './command';
+import type { Event } from './event';
+import type { Query } from './query';
+import type { ContractRegistry } from './utility-types';
+export declare function command<TPayload = void, TResponse = void>(): Command<string, TPayload, TResponse>;
+export declare function event<TPayload = void>(): Event<string, TPayload>;
+export declare function query<TPayload = void, TResponse = unknown>(): Query<string, TPayload, TResponse>;
+type InferRegistry<T extends Record<string, any>> = {
+    [K in keyof T & string]: T[K] extends Command<any, infer P, infer R> ? Command<K, P, R> : T[K] extends Event<any, infer P> ? Event<K, P> : T[K] extends Query<any, infer P, infer R> ? Query<K, P, R> : never;
+};
+export declare function defineRegistry<T extends Record<string, any>>(contracts: T): InferRegistry<T> & ContractRegistry;
+export {};

package/dist/contracts/define-helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = command;
+exports.event = event;
+exports.query = query;
+exports.defineRegistry = defineRegistry;
+function command() {
+    return undefined;
+}
+function event() {
+    return undefined;
+}
+function query() {
+    return undefined;
+}
+function defineRegistry(contracts) {
+    return contracts;
+}
+//# sourceMappingURL=define-helpers.js.map

package/dist/contracts/define-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-helpers.js","sourceRoot":"","sources":["../../src/contracts/define-helpers.ts"],"names":[],"mappings":";;AAKA,0BAEC;AAED,sBAEC;AAED,sBAEC;AAUD,wCAIC;AAxBD,SAAgB,OAAO;IACrB,OAAO,SAAgB,CAAC;AAC1B,CAAC;AAED,SAAgB,KAAK;IACnB,OAAO,SAAgB,CAAC;AAC1B,CAAC;AAED,SAAgB,KAAK;IACnB,OAAO,SAAgB,CAAC;AAC1B,CAAC;AAUD,SAAgB,cAAc,CAC5B,SAAY;IAEZ,OAAO,SAAgB,CAAC;AAC1B,CAAC"}

package/dist/contracts/event.d.ts

@@ -0,0 +1,5 @@
+export interface Event<TPattern extends string = string, TPayload = unknown> {
+    readonly __type: 'event';
+    readonly pattern: TPattern;
+    readonly payload: TPayload;
+}

package/dist/contracts/event.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=event.js.map

package/dist/contracts/event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.js","sourceRoot":"","sources":["../../src/contracts/event.ts"],"names":[],"mappings":""}

package/dist/contracts/index.d.ts

@@ -0,0 +1,6 @@
+export type { Command } from './command';
+export type { Event } from './event';
+export type { Query } from './query';
+export type { ValidateRegistry } from './registry';
+export { command, event, query, defineRegistry } from './define-helpers';
+export type { AnyContract, PatternOf, PayloadOf, ResponseOf, ContractRegistry, CommandsOf, EventsOf, QueriesOf, CommandPatterns, EventPatterns, QueryPatterns, SendablePatterns, } from './utility-types';

package/dist/contracts/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineRegistry = exports.query = exports.event = exports.command = void 0;
+var define_helpers_1 = require("./define-helpers");
+Object.defineProperty(exports, "command", { enumerable: true, get: function () { return define_helpers_1.command; } });
+Object.defineProperty(exports, "event", { enumerable: true, get: function () { return define_helpers_1.event; } });
+Object.defineProperty(exports, "query", { enumerable: true, get: function () { return define_helpers_1.query; } });
+Object.defineProperty(exports, "defineRegistry", { enumerable: true, get: function () { return define_helpers_1.defineRegistry; } });
+//# sourceMappingURL=index.js.map

package/dist/contracts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/contracts/index.ts"],"names":[],"mappings":";;;AAIA,mDAAyE;AAAhE,yGAAA,OAAO,OAAA;AAAE,uGAAA,KAAK,OAAA;AAAE,uGAAA,KAAK,OAAA;AAAE,gHAAA,cAAc,OAAA"}

package/dist/contracts/query.d.ts

@@ -0,0 +1,6 @@
+export interface Query<TPattern extends string = string, TPayload = unknown, TResponse = unknown> {
+    readonly __type: 'query';
+    readonly pattern: TPattern;
+    readonly payload: TPayload;
+    readonly response: TResponse;
+}

package/dist/contracts/query.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=query.js.map

package/dist/contracts/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/contracts/query.ts"],"names":[],"mappings":""}

package/dist/contracts/registry.d.ts

@@ -0,0 +1,8 @@
+import type { ContractRegistry } from './utility-types';
+export type ValidateRegistry<TRegistry extends ContractRegistry> = {
+    [K in keyof TRegistry]: TRegistry[K] extends {
+        pattern: infer P;
+    } ? P extends K ? TRegistry[K] : {
+        error: `Pattern '${P & string}' does not match registry key '${K & string}'`;
+    } : never;
+};

package/dist/contracts/registry.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=registry.js.map

package/dist/contracts/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/contracts/registry.ts"],"names":[],"mappings":""}

package/dist/contracts/utility-types.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from './command';
+import type { Event } from './event';
+import type { Query } from './query';
+export type AnyContract = Command<string, any, any> | Event<string, any> | Query<string, any, any>;
+export type PatternOf<C extends AnyContract> = C['pattern'];
+export type PayloadOf<C extends AnyContract> = C['payload'];
+export type ResponseOf<C extends AnyContract> = C extends Command<any, any, infer R> ? R : C extends Query<any, any, infer R> ? R : C extends Event ? undefined : never;
+export type ContractRegistry = Record<string, AnyContract>;
+export type CommandsOf<TRegistry extends ContractRegistry> = {
+    [K in keyof TRegistry as TRegistry[K] extends Command<any, any, any> ? K : never]: TRegistry[K];
+};
+export type EventsOf<TRegistry extends ContractRegistry> = {
+    [K in keyof TRegistry as TRegistry[K] extends Event<any, any> ? K : never]: TRegistry[K];
+};
+export type QueriesOf<TRegistry extends ContractRegistry> = {
+    [K in keyof TRegistry as TRegistry[K] extends Query<any, any, any> ? K : never]: TRegistry[K];
+};
+export type CommandPatterns<TRegistry extends ContractRegistry> = keyof CommandsOf<TRegistry> & string;
+export type EventPatterns<TRegistry extends ContractRegistry> = keyof EventsOf<TRegistry> & string;
+export type QueryPatterns<TRegistry extends ContractRegistry> = keyof QueriesOf<TRegistry> & string;
+export type SendablePatterns<TRegistry extends ContractRegistry> = CommandPatterns<TRegistry> | QueryPatterns<TRegistry>;

package/dist/contracts/utility-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utility-types.js.map

package/dist/contracts/utility-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.js","sourceRoot":"","sources":["../../src/contracts/utility-types.ts"],"names":[],"mappings":""}

package/dist/handlers/handler-types.d.ts

@@ -0,0 +1,4 @@
+import type { Observable } from 'rxjs';
+import type { ContractRegistry, CommandPatterns, EventPatterns, QueryPatterns, PayloadOf, ResponseOf } from '../contracts';
+export type TypedMessageHandler<TRegistry extends ContractRegistry, P extends CommandPatterns<TRegistry> | QueryPatterns<TRegistry>> = (payload: PayloadOf<TRegistry[P]>) => ResponseOf<TRegistry[P]> | Promise<ResponseOf<TRegistry[P]>> | Observable<ResponseOf<TRegistry[P]>>;
+export type TypedEventHandler<TRegistry extends ContractRegistry, P extends EventPatterns<TRegistry>> = (payload: PayloadOf<TRegistry[P]>) => void | Promise<void>;

package/dist/handlers/handler-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=handler-types.js.map

package/dist/handlers/handler-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-types.js","sourceRoot":"","sources":["../../src/handlers/handler-types.ts"],"names":[],"mappings":""}

package/dist/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export { TypedMessagePattern } from './typed-message-pattern.decorator';
+export { TypedEventPattern } from './typed-event-pattern.decorator';
+export type { TypedMessageHandler, TypedEventHandler } from './handler-types';