@lakutata/nats 2.3.0 → 3.0.0-beta.0

package/dist/esm/entrypoints/NatsServiceEntrypoint.js

@@ -0,0 +1,123 @@
+import { Application } from '@lakutata/core';
+import { ServiceContext } from '@lakutata/entrypoint';
+import { ServiceChannel, ServiceResponseCodec } from '@lakutata/entrypoint/channel';
+import { ServiceEventCodec } from '../lib/ServiceEventCodec.js';
+/**
+ * Create a service adapter of an entrypoint served over NATS: the requests sent to the application's id (by the
+ * {@link ServiceProxy} components of the other applications, or any NATS client) are dispatched to the controllers'
+ * service actions, through the {@link NATS} component registered under `natsComponentName`.
+ *
+ * A request's payload is the message matched against the `@ServiceAction` patterns: the action's pattern and its input
+ * in one object. It is answered with a service response `{success, error, payload}` (see `ServiceResponseCodec`):
+ * `payload` is the action's result, or `error` the properties of the error when the action failed (no matching action,
+ * validation, access denied…). A request whose payload cannot be decoded, or whose response cannot be sent, is answered
+ * with such an error too, so the requester does not wait for its timeout. A published message (without reply subject)
+ * runs the action without answer.
+ *
+ * The instances of the service share the requests through a queue group: each request is handled by one of them. Large
+ * requests and responses go through the NATS component's bulk channel. `Entrypoint.broadcast()` publishes its events
+ * under the entrypoint's subject, to the proxies of the service (it counts them 0: NATS does not tell how many receive
+ * them); `Entrypoint.notify()` does not reach it (NATS has no client ids). When the entrypoint stops, the subscription is drained: no request is received any more
+ * (the callers get no responder and retry), the requests in progress are answered.
+ * @param natsComponentName The name of the NATS component, as registered in the components; the entrypoint fails to
+ * start when it is not registered.
+ * @param options The subject, the queue group, the adapter name and its middlewares.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {Application, DTO} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {ServiceAction} from 'lakutata/decorator/ctrl'
+ * import {Expect} from 'lakutata/decorator/dto'
+ * import {buildNatsClientOptions, natsServiceEntrypoint} from '@lakutata/nats'
+ *
+ * class GetOrderDTO extends DTO {
+ *     @Expect(DTO.Number().integer().required())
+ *     public id!: number
+ * }
+ *
+ * class OrderController extends Controller {
+ *     //Invoked by orderService.invoke({cmd: 'order.get', id: 1}) in the other applications
+ *     @ServiceAction({cmd: 'order.get'}, GetOrderDTO)
+ *     public async get(input: GetOrderDTO): Promise<{ id: number, total: number }> {
+ *         return {id: input.id, total: 42}
+ *     }
+ * }
+ *
+ * Application.run({
+ *     //The subject of the requests: the serviceId of the proxies
+ *     id: 'order.service',
+ *     name: 'OrderService',
+ *     components: {
+ *         nats: buildNatsClientOptions({servers: 'nats://127.0.0.1:4222'}),
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [OrderController],
+ *             service: natsServiceEntrypoint('nats')
+ *         })
+ *     },
+ *     bootstrap: ['entrypoint']
+ * })
+ * ```
+ */
+export function natsServiceEntrypoint(natsComponentName, options = {}) {
+    let subscription;
+    let nats;
+    let subject;
+    return {
+        channel: 'service',
+        definition: ServiceChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: async (runtime) => {
+            nats = await runtime.module.getObject(natsComponentName);
+            subject = options.subject ?? Application.appId;
+            subscription = nats.subscribe(subject, async (payload) => {
+                try {
+                    return ServiceResponseCodec.encode(await runtime.dispatch(new ServiceContext({ data: payload })), false);
+                }
+                catch (e) {
+                    return ServiceResponseCodec.encodeError(e);
+                }
+            }, {
+                queue: options.queue ?? `${subject}.serviceQueue`,
+                //The failures outside of the dispatch (a payload which cannot be decoded, a response which cannot be encoded)
+                //are answered too, so the requester does not wait for its timeout
+                errorResponse: (error) => ServiceResponseCodec.encodeError(error)
+            });
+        },
+        //The events published under the subject of the entrypoint, to the proxies of its service (their serviceId); NATS
+        //does not tell how many receive them: counted 0. NATS has no client ids: notify() pushes to none
+        broadcast: (event, args) => {
+            if (nats && subject)
+                nats.publish(ServiceEventCodec.formatSubject(subject, event), ServiceEventCodec.encode(args));
+            return 0;
+        },
+        stop: async () => {
+            //No request is received any more, the requests in progress are awaited by the entrypoint
+            try {
+                await subscription?.drain();
+            }
+            catch {
+                //The connection is already closed
+            }
+        }
+    };
+}
+/**
+ * The former name of {@link natsServiceEntrypoint}, kept for the applications written for 2.x; it behaves the same.
+ * @param natsComponentName The name of the NATS component, as registered in the components.
+ * @param options The subject, the queue group, the adapter name and its middlewares.
+ * @returns The adapter, to give to the `service` option of `buildEntrypoints`.
+ * @example
+ * ```typescript
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {setupNatsServiceEntrypoint} from '@lakutata/nats'
+ *
+ * class OrderController extends Controller {
+ * }
+ *
+ * //The same as natsServiceEntrypoint('nats')
+ * export const entrypoint = buildEntrypoints({controllers: [OrderController], service: setupNatsServiceEntrypoint('nats')})
+ * ```
+ */
+export const setupNatsServiceEntrypoint = natsServiceEntrypoint;

package/dist/esm/exceptions/NatsBadRequestException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` (and so `ServiceProxy.invoke()`) when the request fails with an error of the NATS client
+ * whose code is `400` (a bad request). The client reports such codes for some JetStream operations, not for the core
+ * requests the component sends, so it is rarely seen. Its `errno` is `E_NATS_BAD_REQUEST`, its `statusCode` 400.
+ */
+export class NatsBadRequestException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_BAD_REQUEST';
+        this.message = 'Bad Request';
+        this.statusCode = 400;
+    }
+}

package/dist/esm/exceptions/NatsBulkException.js

@@ -0,0 +1,22 @@
+import { Exception } from '@lakutata/core';
+/**
+ * A failure of the bulk channel, which relays the large payloads through a JetStream object store; its message tells
+ * the cause:
+ * - `bulk channel is not enabled`: `putBulk()` or `getBulk()` called, or a reference received, while the channel is
+ *   disabled (the `bulk` option is `false`, or the channel failed to start);
+ * - `bulk put failed: …` / `bulk get failed: …`: the object store rejected the write or the read;
+ * - `bulk object not found: <id>`: the referenced object is gone (its time to live passed) or is in another bucket
+ *   (the peers do not share their `bulkBucket`).
+ *
+ * `NATS.request()` and `ServiceProxy.invoke()` throw it when the large request cannot be stored or the large response
+ * cannot be read; `ServiceProxy.invoke()` never retries it, since the service may have processed the request. On the
+ * service side, the failure is answered to the requester, which receives a `ServiceInvokeException` whose `errno` is
+ * `E_NATS_BULK`. Its `errno` is `E_NATS_BULK`, its `statusCode` 502.
+ */
+export class NatsBulkException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_BULK';
+        this.statusCode = 502;
+    }
+}

package/dist/esm/exceptions/NatsForbiddenException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` (and so `ServiceProxy.invoke()`) when the request fails with an error of the NATS client
+ * whose code is `403` (a forbidden request). The client reports such codes for some JetStream operations, not for the
+ * core requests the component sends, so it is rarely seen. Its `errno` is `E_NATS_FORBIDDEN`, its `statusCode` 403.
+ */
+export class NatsForbiddenException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_FORBIDDEN';
+        this.message = 'Forbidden';
+        this.statusCode = 403;
+    }
+}

package/dist/esm/exceptions/NatsInternalServerException.js

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` (and so `ServiceProxy.invoke()`) when the request fails with an error of the NATS client
+ * whose code is `500` (an internal error of the server). The client reports such codes for some JetStream operations,
+ * not for the core requests the component sends, so it is rarely seen. Its `errno` is `E_NATS_INTERNAL_SERVER`, its
+ * `statusCode` 500.
+ */
+export class NatsInternalServerException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_INTERNAL_SERVER';
+        this.message = 'Internal Server Error';
+        this.statusCode = 500;
+    }
+}

package/dist/esm/exceptions/NatsNoRespondersAvailableException.js

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` when no subscription receives the request: nobody listens on the subject (the service is
+ * not running, or is stopping). It is thrown at once, without waiting for the timeout, and the request was not
+ * processed: `ServiceProxy.invoke()` retries it (`maxRetries` times) before throwing it. Its `errno` is
+ * `E_NATS_NO_RESPONDERS_AVAILABLE`, its `statusCode` 503.
+ */
+export class NatsNoRespondersAvailableException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_NO_RESPONDERS_AVAILABLE';
+        this.message = 'No Responders Available';
+        this.statusCode = 503;
+    }
+}

package/dist/esm/exceptions/NatsNotFoundException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` (and so `ServiceProxy.invoke()`) when the request fails with an error of the NATS client
+ * whose code is `404` (a subject not found). The client reports such codes for some JetStream operations, not for the
+ * core requests the component sends, so it is rarely seen. Its `errno` is `E_NATS_NOT_FOUND`, its `statusCode` 404.
+ */
+export class NatsNotFoundException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_NOT_FOUND';
+        this.message = 'Subject Not Found';
+        this.statusCode = 404;
+    }
+}

package/dist/esm/exceptions/NatsRequestTimeoutException.js

@@ -0,0 +1,14 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `NATS.request()` (and so `ServiceProxy.invoke()`) when no response arrives within the request's timeout.
+ * The request may have been received and processed, its response lost or late: it is never retried. Its `errno` is
+ * `E_NATS_REQUEST_TIMEOUT`, its `statusCode` 408.
+ */
+export class NatsRequestTimeoutException extends Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_REQUEST_TIMEOUT';
+        this.message = 'Request Timeout';
+        this.statusCode = 408;
+    }
+}

package/dist/esm/exports/Nats.js

@@ -0,0 +1,15 @@
+export { natsServiceEntrypoint, setupNatsServiceEntrypoint } from '../entrypoints/NatsServiceEntrypoint.js';
+export { ServiceProxy, buildServiceProxy } from '../providers/ServiceProxy.js';
+export { RetentionPolicy } from 'nats';
+export { NATS, buildNatsClientOptions } from '../components/NATS.js';
+export { jsonCodec } from '../codecs/JSONCodec.js';
+export { messagePackCodec } from '../codecs/MessagePackCodec.js';
+export { StringCodec } from 'nats';
+export { NatsBadRequestException } from '../exceptions/NatsBadRequestException.js';
+export { NatsForbiddenException } from '../exceptions/NatsForbiddenException.js';
+export { NatsInternalServerException } from '../exceptions/NatsInternalServerException.js';
+export { NatsNoRespondersAvailableException } from '../exceptions/NatsNoRespondersAvailableException.js';
+export { NatsNotFoundException } from '../exceptions/NatsNotFoundException.js';
+export { NatsRequestTimeoutException } from '../exceptions/NatsRequestTimeoutException.js';
+export { ServiceInvokeException } from '@lakutata/entrypoint';
+export { NatsBulkException } from '../exceptions/NatsBulkException.js';

package/dist/esm/interfaces/NatsClientOptions.js

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

package/dist/esm/lib/ServiceEventCodec.js

@@ -0,0 +1,21 @@
+import { md5 } from '@lakutata/utils';
+import * as querystring from 'node:querystring';
+export class ServiceEventCodec {
+    static hashEventName(serviceId, eventName) {
+        return md5(querystring.encode({
+            serviceId: serviceId,
+            eventName: eventName
+        })).toString('hex');
+    }
+    static encode(args) {
+        return {
+            args: args
+        };
+    }
+    static decode(eventData) {
+        return eventData.args;
+    }
+    static formatSubject(serviceId, eventName) {
+        return `framework.internal.service.event.${this.hashEventName(serviceId, eventName)}`;
+    }
+}

package/dist/esm/providers/ServiceProxy.js

@@ -0,0 +1,270 @@
+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);
+};
+import { Application, DTO, Provider } from '@lakutata/core';
+import { Configurable, Inject, Singleton } from '@lakutata/core/decorator/di';
+import { delay } from '@lakutata/utils';
+import { ServiceResponseCodec } from '@lakutata/entrypoint/channel';
+import { NatsNoRespondersAvailableException } from '../exceptions/NatsNoRespondersAvailableException.js';
+/**
+ * Build the provider options of a {@link ServiceProxy}, to register it in the `providers` of an application under the
+ * name of your choice (as in 2.x); declare one per remote service. The options are validated when the proxy is created,
+ * not here.
+ * @param options The NATS component to use, the id of the remote service, and the retries of the requests nobody
+ * received.
+ * @returns The provider options (`{class: ServiceProxy, ...options}`).
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildNatsClientOptions, buildServiceProxy, type ServiceProxy} from '@lakutata/nats'
+ *
+ * Application
+ *     .run({
+ *         id: 'shop.app',
+ *         name: 'Shop',
+ *         components: {
+ *             nats: buildNatsClientOptions({servers: 'nats://127.0.0.1:4222'})
+ *         },
+ *         providers: {
+ *             //The actions and the events of the application whose id is "order.service"
+ *             orderService: buildServiceProxy({natsComponentName: 'nats', serviceId: 'order.service', maxRetries: 5})
+ *         }
+ *     })
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const orderService: ServiceProxy = await app.getObject('orderService')
+ *         console.log(await orderService.invoke({cmd: 'order.get', id: 1}))
+ *     })
+ * ```
+ */
+export const buildServiceProxy = (options) => {
+    return {
+        class: ServiceProxy,
+        natsComponentName: options.natsComponentName,
+        serviceId: options.serviceId,
+        maxRetries: options.maxRetries,
+        retryDelay: options.retryDelay
+    };
+};
+/**
+ * The proxy of a remote service served by {@link natsServiceEntrypoint}: it invokes the service's actions and listens to
+ * its events, over a {@link NATS} component. Register it in the `providers` of an application with
+ * {@link buildServiceProxy} (as in 2.x), one per remote service, and get it with `getObject()` or `@Inject`; it is a
+ * singleton provider, shared by the scopes. It resolves its NATS component when it is created (which fails when that
+ * component is not registered).
+ *
+ * An invocation is a NATS request to the service id, answered by one instance of the service (its queue group): the
+ * action's result is returned, the action's failure thrown as a `ServiceInvokeException` carrying the remote error's
+ * properties (`errno`, `statusCode`, `message`…). A request nobody received is sent again (`maxRetries`, `retryDelay`);
+ * a timeout is never retried, since the action may have run. Large requests and responses go through the bulk channel
+ * of the NATS component (see {@link NATS}).
+ *
+ * The event listeners registered through the proxy are removed when it is destroyed.
+ * @example
+ * ```typescript
+ * import {Application, Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {buildNatsClientOptions, buildServiceProxy, ServiceInvokeException, type ServiceProxy} from '@lakutata/nats'
+ *
+ * type Order = {id: number, total: number}
+ *
+ * class Billing extends Component {
+ *     @Inject('orderService')
+ *     protected readonly orderService: ServiceProxy
+ *
+ *     public async total(id: number): Promise<number | undefined> {
+ *         try {
+ *             //The action of the order service matching {cmd: 'order.get'}, its input {id}; 30 seconds at most
+ *             const order: Order = await this.orderService.invoke({cmd: 'order.get', id: id}, 30000)
+ *             return order.total
+ *         } catch (error) {
+ *             //The action failed: the remote error's errno and statusCode are copied
+ *             if (error instanceof ServiceInvokeException && error.statusCode === 404) return undefined
+ *             //NatsNoRespondersAvailableException (not running, after the retries), NatsRequestTimeoutException…
+ *             throw error
+ *         }
+ *     }
+ * }
+ *
+ * Application
+ *     .run({
+ *         id: 'billing.app',
+ *         name: 'Billing',
+ *         components: {
+ *             nats: buildNatsClientOptions({servers: 'nats://127.0.0.1:4222'}),
+ *             billing: {class: Billing}
+ *         },
+ *         providers: {
+ *             orderService: buildServiceProxy({natsComponentName: 'nats', serviceId: 'order.service'})
+ *         }
+ *     })
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const orderService: ServiceProxy = await app.getObject('orderService')
+ *         //The events emitted by the order service with NATS.emitServiceEvent('orderPaid', id, total)
+ *         orderService.on('orderPaid', (id: number, total: number): void => console.log(`Order ${id} paid: ${total}`))
+ *         const billing: Billing = await app.getObject('billing')
+ *         console.log(await billing.total(1))
+ *     })
+ * ```
+ */
+let ServiceProxy = class ServiceProxy extends Provider {
+    constructor() {
+        super(...arguments);
+        /**
+         * The event listeners registered through this proxy, by event name, removed when it is destroyed.
+         */
+        this.eventListeners = new Map();
+    }
+    /**
+     * Resolve the NATS component.
+     * @throws {Error} When no component is registered under `natsComponentName`.
+     */
+    async init() {
+        this.nats = await this.app.getObject(this.natsComponentName);
+    }
+    /**
+     * Remove the event listeners registered through this proxy.
+     */
+    async destroy() {
+        this.eventListeners.forEach((listeners, eventName) => listeners.forEach((wrapper) => this.nats.offServiceEvent(this.serviceId, eventName, wrapper)));
+        this.eventListeners.clear();
+    }
+    /**
+     * Record an event listener registered through this proxy, to remove it when the proxy is destroyed.
+     * @param eventName The event name.
+     * @param listener The listener.
+     */
+    keepListener(eventName, listener) {
+        const listeners = this.eventListeners.get(eventName) ?? new Map();
+        this.eventListeners.set(eventName, listeners);
+        //Added once
+        if (listeners.has(listener))
+            return undefined;
+        //A wrapper of this proxy: the NATS component shared by the proxies keeps their listeners apart, the same function
+        //added by two proxies included
+        const wrapper = (...args) => listener(...args);
+        listeners.set(listener, wrapper);
+        return wrapper;
+    }
+    /**
+     * Invoke an action of the remote service and return its result.
+     * @param input The message: the action's pattern (as declared by its `@ServiceAction`) and its input, in one object
+     * (`{cmd: 'order.get', id: 1}`). It is encoded with the NATS component's codec (plain JSON data).
+     * @param timeout The time to wait for the response of each attempt, in milliseconds. A missing service fails at once
+     * (no responder), so it only bounds a request received and processed too slowly; `0` waits 600000 (10 minutes).
+     * @returns The action's result (the data of a `StatusResult`).
+     * @throws {ServiceInvokeException} When the action fails, or no action matches: its message is the remote error's, its
+     * `errno`, `statusCode` and other properties are copied from it, its `service` is the service id.
+     * @throws {NatsNoRespondersAvailableException} When nobody received the request, after `maxRetries` retries.
+     * @throws {NatsRequestTimeoutException} When no response arrives in time (never retried: the action may have run).
+     * @throws {NatsBulkException} When a large request cannot be stored, or a large response cannot be read.
+     * @throws {Error} The NATS client error `MAX_PAYLOAD_EXCEEDED` when a request too large is not relayed (see
+     * {@link NATS.request}), `CONNECTION_CLOSED` once the connection is closed.
+     */
+    async invoke(input, timeout = 10 * 60 * 1000) {
+        //Only a request nobody received is retried: no instance processed it, so the retry is its first processing.
+        //A timeout (the request may be processed and its response lost) and a failure of the service (processed) are thrown,
+        //a non-idempotent action is never run twice
+        for (let attempt = 0;; attempt++) {
+            try {
+                const response = await this.nats.request(this.serviceId, input, timeout);
+                return ServiceResponseCodec.decode(response, this.serviceId);
+            }
+            catch (e) {
+                if (e instanceof NatsNoRespondersAvailableException && attempt < this.maxRetries) {
+                    await delay(this.retryDelay);
+                    continue;
+                }
+                throw e;
+            }
+        }
+    }
+    /**
+     * Listen to an event of the remote service, emitted by its NATS component with `emitServiceEvent()`. A listener
+     * registered again for the same event on the same NATS component is ignored.
+     * @param eventName The event name.
+     * @param listener The listener, receiving the event's arguments.
+     * @param onlySingleClientReceived Whether each event goes to one of the listeners registered with `true` for it, across
+     * all the applications (a queue group, such as the instances of one service), instead of to each of them.
+     * @returns The proxy, for chaining.
+     */
+    on(eventName, listener, onlySingleClientReceived = false) {
+        const wrapper = this.keepListener(eventName, listener);
+        if (wrapper)
+            this.nats.onServiceEvent(this.serviceId, eventName, wrapper, onlySingleClientReceived);
+        return this;
+    }
+    /**
+     * Listen to the next occurrence of an event of the remote service only.
+     * @param eventName The event name.
+     * @param listener The listener, receiving the event's arguments.
+     * @returns The proxy, for chaining.
+     */
+    once(eventName, listener) {
+        if (!this.keepListener(eventName, listener))
+            return this;
+        //The function registered is the one kept: off() removes it
+        const registered = (...args) => {
+            this.eventListeners.get(eventName)?.delete(listener);
+            return listener(...args);
+        };
+        this.eventListeners.get(eventName).set(listener, registered);
+        this.nats.onceServiceEvent(this.serviceId, eventName, registered);
+        return this;
+    }
+    /**
+     * Stop listening to an event of the remote service.
+     * @param eventName The event name.
+     * @param listener The listener to remove; without it, every listener of the event added through this proxy (the
+     * listeners added through the other proxies or `NATS.onServiceEvent()` are kept).
+     * @returns The proxy, for chaining.
+     */
+    off(eventName, listener) {
+        //This proxy's listeners only: the other proxies of the NATS component keep theirs
+        const listeners = this.eventListeners.get(eventName);
+        if (!listeners)
+            return this;
+        for (const [registered, wrapper] of [...listeners]) {
+            if (listener && registered !== listener)
+                continue;
+            this.nats.offServiceEvent(this.serviceId, eventName, wrapper);
+            listeners.delete(registered);
+        }
+        if (!listeners.size)
+            this.eventListeners.delete(eventName);
+        return this;
+    }
+};
+__decorate([
+    Inject(Application),
+    __metadata("design:type", Application
+    /**
+     * The name of the NATS component the proxy uses.
+     */
+    )
+], ServiceProxy.prototype, "app", void 0);
+__decorate([
+    Configurable(DTO.String().required()),
+    __metadata("design:type", String)
+], ServiceProxy.prototype, "natsComponentName", void 0);
+__decorate([
+    Configurable(DTO.String().required()),
+    __metadata("design:type", String)
+], ServiceProxy.prototype, "serviceId", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().optional().default(3)),
+    __metadata("design:type", Number)
+], ServiceProxy.prototype, "maxRetries", void 0);
+__decorate([
+    Configurable(DTO.Number().integer().optional().default(100)),
+    __metadata("design:type", Number)
+], ServiceProxy.prototype, "retryDelay", void 0);
+ServiceProxy = __decorate([
+    Singleton()
+], ServiceProxy);
+export { ServiceProxy };

package/dist/esm/types/SubscribeOptions.js

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

package/dist/types/codecs/JSONCodec.d.ts

@@ -0,0 +1,32 @@
+import { Codec } from 'nats';
+/**
+ * Create the JSON codec of the NATS messages, for the `codec` option of {@link buildNatsClientOptions}. A value is sent
+ * as the UTF-8 JSON text of a one-element array (`{id: 1}` is sent as `[{"id":1}]`), so that every value, `null` and
+ * the strings included, has a JSON form; the peers written in other languages wrap and unwrap that array.
+ *
+ * The values go through `JSON.stringify()`: a `Date` arrives as its ISO string, a `Buffer` as
+ * `{type: 'Buffer', data: [...]}`, a class instance as a plain object, `undefined` as `null` (and is dropped from the
+ * objects), `NaN` and `Infinity` as `null`; a `bigint` or a circular value fails the encoding with a `TypeError`.
+ * Decoding bytes which are not such JSON throws a `SyntaxError`. Both sides of a subject must use the same codec.
+ * @returns The codec.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildNatsClientOptions, jsonCodec} from '@lakutata/nats'
+ *
+ * Application.run({
+ *     id: 'json.app',
+ *     name: 'JSON',
+ *     components: {
+ *         //Readable messages, for peers which do not speak MessagePack
+ *         nats: buildNatsClientOptions({servers: 'nats://127.0.0.1:4222', codec: jsonCodec()})
+ *     }
+ * })
+ *
+ * const codec = jsonCodec()
+ * const bytes: Uint8Array = codec.encode({id: 1, at: new Date(0)})
+ * console.log(Buffer.from(bytes).toString()) //[{"id":1,"at":"1970-01-01T00:00:00.000Z"}]
+ * console.log(codec.decode(bytes)) //{id: 1, at: '1970-01-01T00:00:00.000Z'}
+ * ```
+ */
+export declare function jsonCodec(): Codec<any>;

package/dist/types/codecs/MessagePackCodec.d.ts

@@ -0,0 +1,22 @@
+import { Codec } from 'nats';
+/**
+ * Create the MessagePack codec of the NATS messages, the default `codec` of the {@link NATS} component. A value is sent
+ * as the MessagePack encoding of a one-element array holding it, smaller and faster to decode than JSON.
+ *
+ * The value is first normalized through JSON (`JSON.parse(JSON.stringify(value))`), so that the peers written in other
+ * languages receive plain JSON data: a `Date` arrives as its ISO string, a `Buffer` as `{type: 'Buffer', data: [...]}`
+ * (the binary data is not kept as binary), a class instance as a plain object, `undefined` as `null` (and is dropped
+ * from the objects); a `bigint` or a circular value fails the encoding with a `TypeError`. Decoding bytes which are not
+ * MessagePack throws. Both sides of a subject must use the same codec.
+ * @returns The codec.
+ * @example
+ * ```typescript
+ * import {messagePackCodec} from '@lakutata/nats'
+ *
+ * const codec = messagePackCodec()
+ * const bytes: Uint8Array = codec.encode({id: 1, tags: ['a', 'b']})
+ * console.log(codec.decode(bytes)) //{id: 1, tags: ['a', 'b']}
+ * console.log(codec.decode(codec.encode(undefined))) //null
+ * ```
+ */
+export declare function messagePackCodec(): Codec<any>;