@lad-tech/nsc-toolkit 1.21.0 → 1.22.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-# [1.21.0](https://github.com/lad-tech/nsc-toolkit/compare/v1.20.1...v1.21.0) (2024-08-14)
+## [1.22.1](https://github.com/lad-tech/nsc-toolkit/compare/v1.22.0...v1.22.1) (2024-08-15)
 
 
-### Features
+### Bug Fixes
 
-* Add new requestId field into baggage ([#113](https://github.com/lad-tech/nsc-toolkit/issues/113)) ([02c222d](https://github.com/lad-tech/nsc-toolkit/commit/02c222d13b7325211edc6049cad8301440b64b47))
+* Add required version nats driver and update nats driver ([#115](https://github.com/lad-tech/nsc-toolkit/issues/115)) ([1815d3a](https://github.com/lad-tech/nsc-toolkit/commit/1815d3a77d354aa8c0b97fe33503365f638b9641))

package/dist/Client.js

@@ -36,12 +36,29 @@ class Client extends Root_1.Root {
                 message.ack = event.ack.bind(event);
                 message.nak = event.nak.bind(event);
             }
-            listener.emit(`${eventName}`, message);
+            listener.emit(eventName, message);
+        }
+    }
+    async startBatchWatch(fetcher, listener, eventName) {
+        while (true) {
+            const batch = [];
+            const events = fetcher.fetch();
+            for await (const event of events) {
+                let data;
+                try {
+                    data = (0, nats_1.JSONCodec)().decode(event.data);
+                }
+                catch (error) {
+                    data = (0, nats_1.StringCodec)().decode(event.data);
+                }
+                const message = { data };
+                message.ack = event.ack.bind(event);
+                message.nak = event.nak.bind(event);
+                batch.push(message);
+            }
+            listener.emit(eventName, batch);
         }
     }
-    /**
-     * Make listener for service events. Auto subscribe and unsubscribe to subject
-     */
     getListener(serviceNameFrom, options) {
         if (!this.events) {
             throw new Error('The service does not generate events');
@@ -73,7 +90,12 @@ class Client extends Root_1.Root {
                                 subscription = this.broker.subscribe(`${this.serviceName}.${eventName}`, queue);
                             }
                             this.subscriptions.set(eventName, subscription);
-                            this.startWatch(subscription, listener, String(eventName));
+                            if (StreamManager_1.StreamManager.isStreamFetcher(subscription) && StreamManager_1.StreamManager.isPullConsumerOptions(options)) {
+                                this.startBatchWatch(subscription, listener, String(eventName));
+                            }
+                            else {
+                                this.startWatch(subscription, listener, String(eventName));
+                            }
                             return method.call(target, eventName, handler);
                         }
                         catch (error) {
@@ -182,7 +204,8 @@ class Client extends Root_1.Root {
             return (0, nats_1.JSONCodec)().decode(result.data);
         }
         catch (error) {
-            return this.buildErrorMessage(error);
+            const errorMessage = new Error(`${error === null || error === void 0 ? void 0 : error.message}. Subject: ${subject} `);
+            return this.buildErrorMessage(errorMessage);
         }
     }
     async makeHttpRequest(subject, message, options, timeout) {
@@ -219,11 +242,13 @@ class Client extends Root_1.Root {
                     resolve(JSON.parse(responseDataString));
                 }
                 catch (error) {
-                    resolve(this.buildErrorMessage(error));
+                    const errorMessage = new Error(`${error === null || error === void 0 ? void 0 : error.message}. Subject: ${subject} `);
+                    resolve(this.buildErrorMessage(errorMessage));
                 }
             });
             request.on('error', error => {
-                resolve(this.buildErrorMessage(error));
+                const errorMessage = new Error(`${error === null || error === void 0 ? void 0 : error.message}. Subject: ${subject} `);
+                resolve(this.buildErrorMessage(errorMessage));
             });
             if (this.isStream(message.payload)) {
                 message.payload.pipe(request);

package/dist/StreamFetcher.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamFetcher = void 0;
+class StreamFetcher {
+    constructor(jsClient, streamName, consumerName, options) {
+        this.jsClient = jsClient;
+        this.streamName = streamName;
+        this.consumerName = consumerName;
+        this.options = options;
+    }
+    fetch(noWait, size, expires) {
+        return this.jsClient.fetch(this.streamName, this.consumerName, {
+            batch: size !== null && size !== void 0 ? size : this.options.batchSize,
+            expires: expires !== null && expires !== void 0 ? expires : this.options.batchTimeout,
+            no_wait: noWait !== null && noWait !== void 0 ? noWait : this.options.noWait,
+        });
+    }
+}
+exports.StreamFetcher = StreamFetcher;
+//# sourceMappingURL=StreamFetcher.js.map

package/dist/StreamManager.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamManager = void 0;
 const nats_1 = require("nats");
 const Root_1 = require("./Root");
+const StreamFetcher_1 = require("./StreamFetcher");
+const types_1 = require("nats/lib/jetstream/types");
 class StreamManager extends Root_1.Root {
     constructor(param) {
         super(param.broker, param.outputFormatter);
@@ -21,6 +23,12 @@ class StreamManager extends Root_1.Root {
             rollUps: true,
         };
     }
+    static isPullConsumerOptions(setting) {
+        return !!(setting === null || setting === void 0 ? void 0 : setting.batch);
+    }
+    static isStreamFetcher(consumer) {
+        return !!(consumer === null || consumer === void 0 ? void 0 : consumer.fetch);
+    }
     async createStreams() {
         if (!this.jsm) {
             this.jsm = await this.param.broker.jetstreamManager();
@@ -55,14 +63,29 @@ class StreamManager extends Root_1.Root {
     async createConsumer(serviceNameFrom, eventName, setting) {
         const consumerName = this.capitalizeFirstLetter(serviceNameFrom) + this.capitalizeFirstLetter(eventName);
         const prefix = this.param.options.prefix;
-        const subjeсt = `${this.param.serviceName}.${prefix}.${eventName}`;
+        const subject = `${this.param.serviceName}.${prefix}.${eventName}`;
+        if (!this.jsm) {
+            this.jsm = await this.param.broker.jetstreamManager();
+        }
         const options = (0, nats_1.consumerOpts)();
+        const isPullConsumer = StreamManager.isPullConsumerOptions(setting);
         options
             .durable(consumerName)
             .manualAck()
             .ackExplicit()
-            .maxAckPending((setting === null || setting === void 0 ? void 0 : setting.maxPending) || 10)
-            .deliverTo((0, nats_1.createInbox)());
+            .filterSubject(subject)
+            .maxAckPending((setting === null || setting === void 0 ? void 0 : setting.maxPending) || 10);
+        if (!isPullConsumer) {
+            options.deliverTo((0, nats_1.createInbox)());
+        }
+        if (isPullConsumer) {
+            if (setting.maxPullRequestExpires) {
+                options.maxPullRequestExpires(setting.maxPullRequestExpires);
+            }
+            if (setting.maxPullRequestBatch) {
+                options.maxPullBatch(setting.maxPullRequestBatch);
+            }
+        }
         if (setting === null || setting === void 0 ? void 0 : setting.maxAckWaiting) {
             options.ackWait(setting.maxAckWaiting);
         }
@@ -77,7 +100,19 @@ class StreamManager extends Root_1.Root {
                 options.deliverAll();
             }
         }
-        return this.broker.jetstream().subscribe(subjeсt, options);
+        const streamName = await this.jsm.streams.find(subject);
+        if (!streamName) {
+            throw new Error(`Error creating consumer ${consumerName}. Stream for subject ${subject} not found`);
+        }
+        if ((0, types_1.isConsumerOptsBuilder)(options)) {
+            await this.jsm.consumers.add(streamName, options.config);
+        }
+        return isPullConsumer
+            ? new StreamFetcher_1.StreamFetcher(this.broker.jetstream(), streamName, consumerName, {
+                batchSize: setting.maxPullRequestBatch,
+                batchTimeout: setting.maxPullRequestExpires,
+            })
+            : this.broker.jetstream().subscribe(subject, options);
     }
     getStreamName(eventName) {
         const serviceName = this.capitalizeFirstLetter(this.param.serviceName);

package/dist/Union/Broker.js

@@ -13,6 +13,18 @@ class UnionBroker {
         this.DEFAULT_TIMEOUT = 60000; // 1 Minut
         this.emitter = new node_stream_1.EventEmitter();
     }
+    publishMessage(msg) {
+        throw new Error('Method not implemented.');
+    }
+    respondMessage(msg) {
+        throw new Error('Method not implemented.');
+    }
+    requestMany(subject, payload, opts) {
+        throw new Error('Method not implemented.');
+    }
+    reconnect() {
+        throw new Error('Method not implemented.');
+    }
     closed() {
         return Promise.resolve();
     }

package/dist/Union/JetStreamClient.js

@@ -6,6 +6,12 @@ class JetStreamClientBlank {
     constructor(emitter) {
         this.emitter = emitter;
     }
+    jetstreamManager(checkAPI) {
+        throw new Error('Method not implemented.');
+    }
+    getOptions() {
+        throw new Error('Method not implemented.');
+    }
     publish(subj, data, options) {
         throw new Error('Method publish not implemented.');
     }

package/dist/Union/JetStreamManager.js

@@ -6,6 +6,12 @@ class JetStreamManagerBlank {
     constructor() {
         this.streams = new StreamApi_1.StreamApiBlank();
     }
+    getOptions() {
+        throw new Error('Method not implemented.');
+    }
+    jetstream() {
+        throw new Error('Method not implemented.');
+    }
     getAccountInfo() {
         throw new Error('Method getAccountInfo not implemented.');
     }

package/dist/Union/StreamApi.js

@@ -2,6 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamApiBlank = void 0;
 class StreamApiBlank {
+    listKvs() {
+        throw new Error('Method not implemented.');
+    }
+    listObjectStores() {
+        throw new Error('Method not implemented.');
+    }
+    names(subject) {
+        throw new Error('Method not implemented.');
+    }
+    get(name) {
+        throw new Error('Method not implemented.');
+    }
     info(stream, opts) {
         return Promise.resolve({});
     }

package/dist/types/Client.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { Readable } from 'node:stream';
-import { ClientParam, Emitter, GetListenerOptions, Listener, MethodSettings } from './interfaces';
+import { ClientParam, Emitter, GetBatchListenerOptions, GetListenerOptions, Listener, ListenerBatch, MethodSettings } from './interfaces';
 import { Root } from './Root';
 type RequestData = Record<string, unknown> | Readable;
 export declare class Client<E extends Emitter = Emitter> extends Root {
@@ -13,10 +13,12 @@ export declare class Client<E extends Emitter = Emitter> extends Root {
     private REQUEST_HTTP_SETTINGS_TIMEOUT;
     constructor({ broker, events, loggerOutputFormatter, serviceName, baggage, cache, Ref }: ClientParam<E>);
     private startWatch;
+    private startBatchWatch;
     /**
      * Make listener for service events. Auto subscribe and unsubscribe to subject
      */
     getListener<A extends keyof E>(serviceNameFrom: string, options?: GetListenerOptions): Listener<E>;
+    getListener<A extends keyof E>(serviceNameFrom: string, options?: GetBatchListenerOptions): ListenerBatch<E>;
     private createCacheKey;
     private validate;
     protected request<R = any, P extends RequestData = RequestData>(subject: string, data: P, { options, request, response }: MethodSettings): Promise<R>;

package/dist/types/StreamFetcher.d.ts

@@ -0,0 +1,15 @@
+import { JetStreamClient, JsMsg, QueuedIterator } from 'nats';
+interface BatcherOptions {
+    batchSize?: number;
+    batchTimeout?: number;
+    noWait?: boolean;
+}
+export declare class StreamFetcher {
+    private jsClient;
+    private streamName;
+    private consumerName;
+    private options;
+    constructor(jsClient: JetStreamClient, streamName: string, consumerName: string, options: BatcherOptions);
+    fetch(noWait?: boolean, size?: number, expires?: number): QueuedIterator<JsMsg>;
+}
+export {};

package/dist/types/StreamManager.d.ts

@@ -1,6 +1,7 @@
-import { StreamManagerParam, GetListenerOptions } from '.';
-import { JetStreamSubscription } from 'nats';
+import { StreamManagerParam, GetListenerOptions, GetBatchListenerOptions } from '.';
+import { JetStreamSubscription, Subscription } from 'nats';
 import { Root } from './Root';
+import { StreamFetcher } from './StreamFetcher';
 export declare class StreamManager extends Root {
     private param;
     private readonly STAR_WILDCARD;
@@ -10,8 +11,11 @@ export declare class StreamManager extends Root {
     private readonly defaultStreamOption;
     private jsm?;
     constructor(param: StreamManagerParam);
+    static isPullConsumerOptions(setting?: GetListenerOptions | GetBatchListenerOptions): setting is GetBatchListenerOptions;
+    static isStreamFetcher(consumer?: JetStreamSubscription | StreamFetcher | Subscription): consumer is StreamFetcher;
     createStreams(): Promise<void>;
     createConsumer(serviceNameFrom: string, eventName: string, setting?: GetListenerOptions): Promise<JetStreamSubscription>;
+    createConsumer(serviceNameFrom: string, eventName: string, setting?: GetBatchListenerOptions): Promise<StreamFetcher>;
     private getStreamName;
     private isNotFoundStreamError;
     private buildPrefixForStreamName;

package/dist/types/Union/Broker.d.ts

@@ -1,9 +1,14 @@
-import { JetStreamClient, JetStreamManager, JetStreamOptions, Msg, NatsConnection, PublishOptions, RequestOptions, ServerInfo, Stats, Status, Subscription, SubscriptionOptions } from 'nats';
+import { JetStreamClient, JetStreamManager, JetStreamOptions, Msg, NatsConnection, Payload, PublishOptions, RequestManyOptions, RequestOptions, ServerInfo, ServicesAPI, Stats, Status, Subscription, SubscriptionOptions } from 'nats';
 interface Union {
     isUnion?: boolean;
 }
 export type Broker = NatsConnection & Union;
 export declare class UnionBroker implements Broker {
+    publishMessage(msg: Msg): void;
+    respondMessage(msg: Msg): boolean;
+    requestMany(subject: string, payload?: Payload | undefined, opts?: Partial<RequestManyOptions> | undefined): Promise<AsyncIterable<Msg>>;
+    services: ServicesAPI;
+    reconnect(): Promise<void>;
     info?: ServerInfo;
     isUnion: boolean;
     private DEFAULT_TIMEOUT;

package/dist/types/Union/JetStreamClient.d.ts

@@ -1,12 +1,15 @@
 /// <reference types="node" />
-import { ConsumerOpts, ConsumerOptsBuilder, JetStreamClient, JetStreamPublishOptions, JetStreamPullSubscription, JetStreamSubscription, JsMsg, PubAck, PullOptions } from 'nats';
-import { QueuedIterator } from 'nats/lib/nats-base-client/queued_iterator';
-import { Views } from 'nats/lib/nats-base-client/types';
+import { ConsumerOpts, ConsumerOptsBuilder, Consumers, JetStreamClient, JetStreamManager, JetStreamOptions, JetStreamPublishOptions, JetStreamPullSubscription, JetStreamSubscription, JsMsg, PubAck, PullOptions, QueuedIterator, Streams, Views } from 'nats';
 import { EventEmitter } from 'stream';
 export declare class JetStreamClientBlank implements JetStreamClient {
     private emitter;
     views: Views;
     constructor(emitter: EventEmitter);
+    apiPrefix: string;
+    consumers: Consumers;
+    streams: Streams;
+    jetstreamManager(checkAPI?: boolean | undefined): Promise<JetStreamManager>;
+    getOptions(): JetStreamOptions;
     publish(subj: string, data?: Uint8Array, options?: Partial<JetStreamPublishOptions>): Promise<PubAck>;
     pull(stream: string, durable: string, expires?: number): Promise<JsMsg>;
     fetch(stream: string, durable: string, opts?: Partial<PullOptions>): QueuedIterator<JsMsg>;

package/dist/types/Union/JetStreamManager.d.ts

@@ -1,7 +1,8 @@
-import { JetStreamAccountStats, JetStreamManager } from 'nats';
-import { ConsumerAPI, Advisory } from 'nats/lib/nats-base-client/types';
+import { Advisory, ConsumerAPI, JetStreamAccountStats, JetStreamClient, JetStreamManager, JetStreamOptions } from 'nats';
 import { StreamApiBlank } from './StreamApi';
 export declare class JetStreamManagerBlank implements JetStreamManager {
+    getOptions(): JetStreamOptions;
+    jetstream(): JetStreamClient;
     consumers: ConsumerAPI;
     streams: StreamApiBlank;
     getAccountInfo(): Promise<JetStreamAccountStats>;

package/dist/types/Union/StreamApi.d.ts

@@ -1,5 +1,9 @@
-import { Lister, MsgRequest, PurgeOpts, PurgeResponse, StoredMsg, StreamAPI, StreamConfig, StreamInfo, StreamInfoRequestOptions, StreamUpdateConfig } from 'nats/lib/nats-base-client/types';
+import { StreamAPI, StreamInfoRequestOptions, StreamInfo, StreamConfig, StreamUpdateConfig, PurgeOpts, PurgeResponse, Lister, MsgRequest, StoredMsg, KvStatus, ObjectStoreStatus, Stream } from 'nats';
 export declare class StreamApiBlank implements StreamAPI {
+    listKvs(): Lister<KvStatus>;
+    listObjectStores(): Lister<ObjectStoreStatus>;
+    names(subject?: string | undefined): Lister<string>;
+    get(name: string): Promise<Stream>;
     info(stream: string, opts?: Partial<StreamInfoRequestOptions>): Promise<StreamInfo>;
     add(cfg: Partial<StreamConfig>): Promise<StreamInfo>;
     update(name: string, cfg: Partial<StreamUpdateConfig>): Promise<StreamInfo>;

package/dist/types/Union/Subscription.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
-import { Msg, NatsError, Subscription } from 'nats';
-import { Closed, ConsumerInfoable, Destroyable } from 'nats/lib/nats-base-client/types';
+import { Closed, ConsumerInfoable, Destroyable, Msg, NatsError, Subscription } from 'nats';
 import { PassThrough } from 'node:stream';
 export declare class UnionSubscription extends PassThrough implements Subscription, Destroyable, Closed, ConsumerInfoable {
     closed: Promise<void>;

package/dist/types/interfaces.d.ts

@@ -71,6 +71,11 @@ export interface GetListenerOptions {
     maxPending?: number;
     maxAckWaiting?: number;
 }
+export interface GetBatchListenerOptions extends GetListenerOptions {
+    batch: true;
+    maxPullRequestBatch?: number;
+    maxPullRequestExpires?: number;
+}
 export interface StreamManagerParam {
     serviceName: string;
     options: StreamOptions;
@@ -129,6 +134,10 @@ export interface Listener<E extends Emitter> {
     on<A extends keyof E>(action: A, handler: E[A]): void;
     off<A extends keyof E>(action: A, handler: E[A]): void;
 }
+export interface ListenerBatch<E extends Emitter> {
+    on<A extends keyof E>(action: A, handler: (params: Array<Parameters<E[A]>[0]>) => void): void;
+    off<A extends keyof E>(action: A, handler: (params: Array<Parameters<E[A]>[0]>) => void): void;
+}
 export interface HttpSettings {
     ip?: string;
     port?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lad-tech/nsc-toolkit",
-  "version": "1.21.0",
+  "version": "1.22.1",
   "description": "Toolkit for create microservices around NATS",
   "main": "dist/index.js",
   "types": "./dist/types/index.d.ts",
@@ -41,9 +41,12 @@
     "@opentelemetry/sdk-trace-base": "^1.3.1",
     "@opentelemetry/semantic-conventions": "^1.3.1",
     "ajv": "^8.11.0",
-    "nats": "^2.6.1",
+    "nats": "^2.28.2",
     "reflect-metadata": "^0.1.13"
   },
+  "peerDependencies": {
+    "nats": "^2.15.0"
+  },
   "jest": {
     "preset": "ts-jest",
     "testEnvironment": "node",