@lad-tech/nsc-toolkit 1.21.0 → 1.22.0

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.0](https://github.com/lad-tech/nsc-toolkit/compare/v1.21.0...v1.22.0) (2024-08-14)
 
 
 ### Features
 
-* 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 support pull consumer ([#110](https://github.com/lad-tech/nsc-toolkit/issues/110)) ([ed77ad7](https://github.com/lad-tech/nsc-toolkit/commit/ed77ad7fa0542c0e8d0b56e71b430a14672bafae))

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 jsconsumeropts_1 = require("nats/lib/nats-base-client/jsconsumeropts");
+const StreamFetcher_1 = require("./StreamFetcher");
 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, jsconsumeropts_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/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,16 @@
+import { JetStreamClient, JsMsg } from 'nats';
+import { QueuedIterator } from 'nats/lib/nats-base-client/queued_iterator';
+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/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.0",
   "description": "Toolkit for create microservices around NATS",
   "main": "dist/index.js",
   "types": "./dist/types/index.d.ts",