@lakutata/nats 2.3.0 → 3.0.0-beta.1

package/dist/cjs/entrypoints/NatsServiceEntrypoint.d.ts

@@ -0,0 +1,102 @@
+import { ServiceContext, type EntrypointAdapter, type MiddlewareDefinition } from '@lakutata/entrypoint';
+/**
+ * The options of {@link natsServiceEntrypoint}.
+ */
+export type NatsServiceEntrypointOptions = {
+    /**
+     * The adapter name, to tell apart several service adapters of one entrypoint.
+     */
+    name?: string;
+    /**
+     * The subject the requests are received on: the `serviceId` the service proxies use. The events of
+     * `Entrypoint.broadcast()` are published under it; the ones of `NATS.emitServiceEvent()` under the application id.
+     * @default the application id (its `id` option)
+     */
+    subject?: string;
+    /**
+     * The queue group sharing the requests between the instances of the service: each request is handled by one of
+     * them.
+     * @default `{subject}.serviceQueue`
+     */
+    queue?: string;
+    /**
+     * The middlewares of this adapter's actions, run after the entrypoint's global middlewares.
+     */
+    middlewares?: MiddlewareDefinition[];
+};
+/**
+ * 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 declare function natsServiceEntrypoint(natsComponentName: string, options?: NatsServiceEntrypointOptions): EntrypointAdapter<ServiceContext>;
+/**
+ * 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 declare const setupNatsServiceEntrypoint: (natsComponentName: string, options?: NatsServiceEntrypointOptions) => EntrypointAdapter<ServiceContext>;

package/dist/cjs/entrypoints/NatsServiceEntrypoint.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupNatsServiceEntrypoint = void 0;
+exports.natsServiceEntrypoint = natsServiceEntrypoint;
+const core_1 = require("@lakutata/core");
+const entrypoint_1 = require("@lakutata/entrypoint");
+const channel_1 = require("@lakutata/entrypoint/channel");
+const ServiceEventCodec_js_1 = require("../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']
+ * })
+ * ```
+ */
+function natsServiceEntrypoint(natsComponentName, options = {}) {
+    let subscription;
+    let nats;
+    let subject;
+    return {
+        channel: 'service',
+        definition: channel_1.ServiceChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: async (runtime) => {
+            nats = await runtime.module.getObject(natsComponentName);
+            subject = options.subject ?? core_1.Application.appId;
+            subscription = nats.subscribe(subject, async (payload) => {
+                try {
+                    return channel_1.ServiceResponseCodec.encode(await runtime.dispatch(new entrypoint_1.ServiceContext({ data: payload })), false);
+                }
+                catch (e) {
+                    return channel_1.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) => channel_1.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_js_1.ServiceEventCodec.formatSubject(subject, event), ServiceEventCodec_js_1.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')})
+ * ```
+ */
+exports.setupNatsServiceEntrypoint = natsServiceEntrypoint;

package/dist/cjs/exceptions/NatsBadRequestException.d.ts

@@ -0,0 +1,11 @@
+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 declare class NatsBadRequestException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsBadRequestException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsBadRequestException = void 0;
+const core_1 = require("@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.
+ */
+class NatsBadRequestException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_BAD_REQUEST';
+        this.message = 'Bad Request';
+        this.statusCode = 400;
+    }
+}
+exports.NatsBadRequestException = NatsBadRequestException;

package/dist/cjs/exceptions/NatsBulkException.d.ts

@@ -0,0 +1,19 @@
+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 declare class NatsBulkException extends Exception {
+    errno: string | number;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsBulkException.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsBulkException = void 0;
+const core_1 = require("@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.
+ */
+class NatsBulkException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_BULK';
+        this.statusCode = 502;
+    }
+}
+exports.NatsBulkException = NatsBulkException;

package/dist/cjs/exceptions/NatsForbiddenException.d.ts

@@ -0,0 +1,11 @@
+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 declare class NatsForbiddenException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsForbiddenException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsForbiddenException = void 0;
+const core_1 = require("@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.
+ */
+class NatsForbiddenException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_FORBIDDEN';
+        this.message = 'Forbidden';
+        this.statusCode = 403;
+    }
+}
+exports.NatsForbiddenException = NatsForbiddenException;

package/dist/cjs/exceptions/NatsInternalServerException.d.ts

@@ -0,0 +1,12 @@
+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 declare class NatsInternalServerException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsInternalServerException.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsInternalServerException = void 0;
+const core_1 = require("@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.
+ */
+class NatsInternalServerException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_INTERNAL_SERVER';
+        this.message = 'Internal Server Error';
+        this.statusCode = 500;
+    }
+}
+exports.NatsInternalServerException = NatsInternalServerException;

package/dist/cjs/exceptions/NatsNoRespondersAvailableException.d.ts

@@ -0,0 +1,12 @@
+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 declare class NatsNoRespondersAvailableException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsNoRespondersAvailableException.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsNoRespondersAvailableException = void 0;
+const core_1 = require("@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.
+ */
+class NatsNoRespondersAvailableException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_NO_RESPONDERS_AVAILABLE';
+        this.message = 'No Responders Available';
+        this.statusCode = 503;
+    }
+}
+exports.NatsNoRespondersAvailableException = NatsNoRespondersAvailableException;

package/dist/cjs/exceptions/NatsNotFoundException.d.ts

@@ -0,0 +1,11 @@
+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 declare class NatsNotFoundException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsNotFoundException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsNotFoundException = void 0;
+const core_1 = require("@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.
+ */
+class NatsNotFoundException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_NOT_FOUND';
+        this.message = 'Subject Not Found';
+        this.statusCode = 404;
+    }
+}
+exports.NatsNotFoundException = NatsNotFoundException;

package/dist/cjs/exceptions/NatsRequestTimeoutException.d.ts

@@ -0,0 +1,11 @@
+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 declare class NatsRequestTimeoutException extends Exception {
+    errno: string | number;
+    message: string;
+    statusCode: number;
+}

package/dist/cjs/exceptions/NatsRequestTimeoutException.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsRequestTimeoutException = void 0;
+const core_1 = require("@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.
+ */
+class NatsRequestTimeoutException extends core_1.Exception {
+    constructor() {
+        super(...arguments);
+        this.errno = 'E_NATS_REQUEST_TIMEOUT';
+        this.message = 'Request Timeout';
+        this.statusCode = 408;
+    }
+}
+exports.NatsRequestTimeoutException = NatsRequestTimeoutException;

package/dist/cjs/exports/Nats.d.ts

@@ -0,0 +1,18 @@
+export { natsServiceEntrypoint, setupNatsServiceEntrypoint, type NatsServiceEntrypointOptions } from '../entrypoints/NatsServiceEntrypoint.js';
+export { ServiceProxy, buildServiceProxy, type BuildServiceProxyOptions } 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 type { SubscribeOptions } from '../types/SubscribeOptions.js';
+export type { Subscription, Codec } from 'nats';
+export type { NatsClientOptions } from '../interfaces/NatsClientOptions.js';
+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/cjs/exports/Nats.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsBulkException = exports.ServiceInvokeException = exports.NatsRequestTimeoutException = exports.NatsNotFoundException = exports.NatsNoRespondersAvailableException = exports.NatsInternalServerException = exports.NatsForbiddenException = exports.NatsBadRequestException = exports.StringCodec = exports.messagePackCodec = exports.jsonCodec = exports.buildNatsClientOptions = exports.NATS = exports.RetentionPolicy = exports.buildServiceProxy = exports.ServiceProxy = exports.setupNatsServiceEntrypoint = exports.natsServiceEntrypoint = void 0;
+var NatsServiceEntrypoint_js_1 = require("../entrypoints/NatsServiceEntrypoint.js");
+Object.defineProperty(exports, "natsServiceEntrypoint", { enumerable: true, get: function () { return NatsServiceEntrypoint_js_1.natsServiceEntrypoint; } });
+Object.defineProperty(exports, "setupNatsServiceEntrypoint", { enumerable: true, get: function () { return NatsServiceEntrypoint_js_1.setupNatsServiceEntrypoint; } });
+var ServiceProxy_js_1 = require("../providers/ServiceProxy.js");
+Object.defineProperty(exports, "ServiceProxy", { enumerable: true, get: function () { return ServiceProxy_js_1.ServiceProxy; } });
+Object.defineProperty(exports, "buildServiceProxy", { enumerable: true, get: function () { return ServiceProxy_js_1.buildServiceProxy; } });
+var nats_1 = require("nats");
+Object.defineProperty(exports, "RetentionPolicy", { enumerable: true, get: function () { return nats_1.RetentionPolicy; } });
+var NATS_js_1 = require("../components/NATS.js");
+Object.defineProperty(exports, "NATS", { enumerable: true, get: function () { return NATS_js_1.NATS; } });
+Object.defineProperty(exports, "buildNatsClientOptions", { enumerable: true, get: function () { return NATS_js_1.buildNatsClientOptions; } });
+var JSONCodec_js_1 = require("../codecs/JSONCodec.js");
+Object.defineProperty(exports, "jsonCodec", { enumerable: true, get: function () { return JSONCodec_js_1.jsonCodec; } });
+var MessagePackCodec_js_1 = require("../codecs/MessagePackCodec.js");
+Object.defineProperty(exports, "messagePackCodec", { enumerable: true, get: function () { return MessagePackCodec_js_1.messagePackCodec; } });
+var nats_2 = require("nats");
+Object.defineProperty(exports, "StringCodec", { enumerable: true, get: function () { return nats_2.StringCodec; } });
+var NatsBadRequestException_js_1 = require("../exceptions/NatsBadRequestException.js");
+Object.defineProperty(exports, "NatsBadRequestException", { enumerable: true, get: function () { return NatsBadRequestException_js_1.NatsBadRequestException; } });
+var NatsForbiddenException_js_1 = require("../exceptions/NatsForbiddenException.js");
+Object.defineProperty(exports, "NatsForbiddenException", { enumerable: true, get: function () { return NatsForbiddenException_js_1.NatsForbiddenException; } });
+var NatsInternalServerException_js_1 = require("../exceptions/NatsInternalServerException.js");
+Object.defineProperty(exports, "NatsInternalServerException", { enumerable: true, get: function () { return NatsInternalServerException_js_1.NatsInternalServerException; } });
+var NatsNoRespondersAvailableException_js_1 = require("../exceptions/NatsNoRespondersAvailableException.js");
+Object.defineProperty(exports, "NatsNoRespondersAvailableException", { enumerable: true, get: function () { return NatsNoRespondersAvailableException_js_1.NatsNoRespondersAvailableException; } });
+var NatsNotFoundException_js_1 = require("../exceptions/NatsNotFoundException.js");
+Object.defineProperty(exports, "NatsNotFoundException", { enumerable: true, get: function () { return NatsNotFoundException_js_1.NatsNotFoundException; } });
+var NatsRequestTimeoutException_js_1 = require("../exceptions/NatsRequestTimeoutException.js");
+Object.defineProperty(exports, "NatsRequestTimeoutException", { enumerable: true, get: function () { return NatsRequestTimeoutException_js_1.NatsRequestTimeoutException; } });
+var entrypoint_1 = require("@lakutata/entrypoint");
+Object.defineProperty(exports, "ServiceInvokeException", { enumerable: true, get: function () { return entrypoint_1.ServiceInvokeException; } });
+var NatsBulkException_js_1 = require("../exceptions/NatsBulkException.js");
+Object.defineProperty(exports, "NatsBulkException", { enumerable: true, get: function () { return NatsBulkException_js_1.NatsBulkException; } });
+
+//The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)
+if (!Object.prototype.hasOwnProperty.call(exports, 'default')) Object.defineProperty(exports, 'default', {value: exports})

package/dist/cjs/interfaces/NatsClientOptions.d.ts

@@ -0,0 +1,106 @@
+import { Codec } from 'nats';
+/**
+ * The options of the {@link NATS} component, given to {@link buildNatsClientOptions}. They are validated when the
+ * component is created: an invalid value fails it.
+ */
+export interface NatsClientOptions {
+    /**
+     * The NATS server, or the servers of a cluster, to connect to: `host:port` or a URL (`nats://user:pass@host:4222`).
+     * The client connects to one of them (in random order unless `noRandomize`) and moves to another on a disconnect.
+     */
+    servers: string | string[];
+    /**
+     * The codec encoding and decoding every payload: {@link messagePackCodec}, {@link jsonCodec}, or any object with
+     * `encode(value)` and `decode(bytes)`. All the applications exchanging messages on a subject must use the same one.
+     * @default messagePackCodec()
+     */
+    codec?: Codec<unknown>;
+    /**
+     * The time to wait for the connection to a server to be established, in milliseconds.
+     * @default 20000
+     */
+    timeout?: number;
+    /**
+     * The token of the server's token authentication.
+     * @default none
+     */
+    token?: string;
+    /**
+     * The user name of the server's user/password authentication.
+     * @default none
+     */
+    user?: string;
+    /**
+     * The password of the server's user/password authentication, with `user`.
+     * @default none
+     */
+    pass?: string;
+    /**
+     * Whether the client prints the protocol messages it sends and receives (to debug a connection).
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * The number of pings left unanswered after which the connection is considered stale and the client reconnects.
+     * @default 2
+     */
+    maxPingOut?: number;
+    /**
+     * The number of reconnection attempts to each server before giving up, `-1` never giving up. Once given up, the
+     * connection is closed for good: the calls fail with the NATS client error `CONNECTION_CLOSED` until the application
+     * restarts.
+     * @default 10
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * The client name shown by the server's monitoring. It also names the default object store bucket of the bulk
+     * channel (`lkt-bulk-{name}`), and the bulk connection (`{name}-bulk`).
+     * @default none
+     */
+    name?: string;
+    /**
+     * Whether the messages this client publishes are never delivered to its own subscriptions.
+     * @default false
+     */
+    noEcho?: boolean;
+    /**
+     * Whether the servers are tried in the order given, instead of a random order.
+     * @default false
+     */
+    noRandomize?: boolean;
+    /**
+     * The interval between the pings the client sends to check the connection, in milliseconds.
+     * @default 120000
+     */
+    pingInterval?: number;
+    /**
+     * Whether the client reconnects after losing its connection (see `maxReconnectAttempts`). While it reconnects, the
+     * outgoing messages are buffered and the requests wait, failing when their timeout passes.
+     * @default true
+     */
+    reconnect?: boolean;
+    /**
+     * Whether the bulk channel is enabled: the payloads too large for the server's `max_payload` are relayed through a
+     * JetStream object store, using a second connection. It needs JetStream on the server; when the channel cannot
+     * start (no JetStream, bucket rejected…), a warning is printed and the component starts without it.
+     * @default true
+     */
+    bulk?: boolean;
+    /**
+     * The object store bucket of the bulk channel, created when missing. The applications exchanging large payloads
+     * must use the same bucket: a reference to an object of another bucket fails with {@link NatsBulkException}.
+     * @default `lkt-bulk-{name}`, `lkt-bulk-default` without `name`
+     */
+    bulkBucket?: string;
+    /**
+     * The time to live of the objects of the bulk channel, in milliseconds. An object is deleted once read; this removes
+     * the ones never read (a requester gone, a response lost). It applies when the bucket is created.
+     * @default 300000 (5 minutes)
+     */
+    bulkTTL?: number;
+    /**
+     * The number of replicas of the bulk bucket in a JetStream cluster, applied when the bucket is created.
+     * @default none: the server's default (one replica)
+     */
+    bulkReplicas?: number;
+}

package/dist/{lib → cjs/lib}/ServiceEventCodec.d.ts

@@ -7,4 +7,3 @@ export declare class ServiceEventCodec {
     static decode(eventData: ServiceEventData): any[];
     static formatSubject(serviceId: string, eventName: string): string;
 }
-//# sourceMappingURL=ServiceEventCodec.d.ts.map