@lad-tech/nsc-toolkit 1.20.1 → 1.22.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
-## [1.20.1](https://github.com/lad-tech/nsc-toolkit/compare/v1.20.0...v1.20.1) (2024-07-01)
+# [1.22.0](https://github.com/lad-tech/nsc-toolkit/compare/v1.21.0...v1.22.0) (2024-08-14)
 
 
-### Bug Fixes
+### Features
 
-* Fix param name ([#108](https://github.com/lad-tech/nsc-toolkit/issues/108)) ([3b93529](https://github.com/lad-tech/nsc-toolkit/commit/3b9352967adae3694d3db92e1335c7ec4bfebcde))
+* 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) {
@@ -110,7 +132,7 @@ class Client extends Root_1.Root {
         }
     }
     async request(subject, data, { options, request, response }) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e;
         const tracer = opentelemetry.trace.getTracer('');
         const span = tracer.startSpan(subject, undefined, this.getContext(this.baggage));
         try {
@@ -119,7 +141,8 @@ class Client extends Root_1.Root {
             }
             const { spanId, traceId, traceFlags } = span.spanContext();
             const expired = this.getExpired((_b = this.baggage) === null || _b === void 0 ? void 0 : _b.expired, options === null || options === void 0 ? void 0 : options.timeout);
-            const message = { payload: data, baggage: { expired, traceId, spanId, traceFlags } };
+            const requestId = (_c = this.baggage) === null || _c === void 0 ? void 0 : _c.requestId;
+            const message = { payload: data, baggage: { expired, traceId, spanId, traceFlags, requestId } };
             const timeout = expired - Date.now();
             if (timeout <= 0) {
                 throw new Error('Timeout request service ' + subject);
@@ -141,9 +164,9 @@ class Client extends Root_1.Root {
                 ? await this.makeHttpRequest(subject, message, options, timeout)
                 : await this.makeBrokerRequest(subject, message, timeout);
             if (result.error) {
-                throw new Error((_c = result.error.message) !== null && _c !== void 0 ? _c : result.error);
+                throw new Error((_d = result.error.message) !== null && _d !== void 0 ? _d : result.error);
             }
-            if (((_d = options === null || options === void 0 ? void 0 : options.runTimeValidation) === null || _d === void 0 ? void 0 : _d.response) && response) {
+            if (((_e = options === null || options === void 0 ? void 0 : options.runTimeValidation) === null || _e === void 0 ? void 0 : _e.response) && response) {
                 this.validate(result.payload, response);
             }
             if ((options === null || options === void 0 ? void 0 : options.cache) && !this.isStream(result.payload) && this.cache) {
@@ -181,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) {
@@ -218,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);
@@ -236,12 +262,23 @@ class Client extends Root_1.Root {
         if (!baggage) {
             return {};
         }
-        return {
-            'nsc-expired': baggage.expired,
-            'nsc-trace-id': baggage.traceId,
-            'nsc-span-id': baggage.spanId,
-            'nsc-trace-flags': baggage.traceFlags,
-        };
+        const headers = {};
+        if (baggage.expired) {
+            headers['nsc-expired'] = baggage.expired;
+        }
+        if (baggage.requestId) {
+            headers['x-request-id'] = baggage.requestId;
+        }
+        if (baggage.traceId) {
+            headers['nsc-trace-id'] = baggage.traceId;
+        }
+        if (baggage.spanId) {
+            headers['nsc-span-id'] = baggage.spanId;
+        }
+        if (baggage.traceFlags) {
+            headers['nsc-trace-flags'] = baggage.traceFlags;
+        }
+        return headers;
     }
     isJsMessage(message) {
         return !!message.ack && !!message.nak;

package/dist/Service.js

@@ -192,7 +192,13 @@ class Service extends Root_1.Root {
      */
     getNextBaggage(span, baggage) {
         const { traceId, spanId, traceFlags } = span.spanContext();
-        return { traceId, spanId, traceFlags, expired: baggage === null || baggage === void 0 ? void 0 : baggage.expired };
+        return { traceId, spanId, traceFlags, expired: baggage === null || baggage === void 0 ? void 0 : baggage.expired, requestId: baggage === null || baggage === void 0 ? void 0 : baggage.requestId };
+    }
+    /**
+     * Guard for determine whether baggage contains trace information
+     */
+    isBaggageContainTrace(params) {
+        return !!params && !!(params.traceId && params.spanId && params.traceFlags);
     }
     /**
      * If there is no baggage. For example, in HTTP Gateway
@@ -200,7 +206,7 @@ class Service extends Root_1.Root {
     getRootBaggage(subject, headers, ownTimeout) {
         const baggage = headers ? this.getBaggageFromHTTPHeader(headers) : undefined;
         const tracer = api_1.trace.getTracer('');
-        const context = this.getContext(baggage);
+        const context = this.getContext(this.isBaggageContainTrace(baggage) ? baggage : undefined);
         const span = tracer.startSpan(subject, undefined, context);
         const newBaggage = this.getNextBaggage(span, baggage);
         this.rootSpans.set(newBaggage.traceId, span);
@@ -333,7 +339,7 @@ class Service extends Root_1.Root {
     async handled(payload, Method, baggage) {
         const subject = `${this.serviceName}.${Method.settings.action}`;
         const tracer = api_1.trace.getTracer('');
-        const context = this.getContext(baggage);
+        const context = this.getContext(this.isBaggageContainTrace(baggage) ? baggage : undefined);
         const span = tracer.startSpan(subject, undefined, context);
         const logger = new toolbelt_1.Logs.Logger({
             location: `${this.serviceName}.${Method.settings.action}`,
@@ -579,15 +585,17 @@ class Service extends Root_1.Root {
         const traceId = headers['nsc-trace-id'];
         const spanId = headers['nsc-span-id'];
         const traceFlags = headers['nsc-trace-flags'] ? +headers['nsc-trace-flags'] : undefined;
+        const requestId = headers['x-request-id'] ? String(headers['x-request-id']) : undefined;
         if (traceId && spanId && traceFlags) {
             return {
                 traceId,
                 spanId,
                 traceFlags,
                 expired,
+                requestId,
             };
         }
-        return undefined;
+        return { expired, requestId };
     }
 }
 exports.Service = Service;

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/Service.d.ts

@@ -37,6 +37,10 @@ export declare class Service<E extends Emitter = Emitter> extends Root {
      * Create Baggage from span. Expired one-on-one business logic call
      */
     private getNextBaggage;
+    /**
+     * Guard for determine whether baggage contains trace information
+     */
+    private isBaggageContainTrace;
     /**
      * If there is no baggage. For example, in HTTP Gateway
      */
@@ -45,6 +49,7 @@ export declare class Service<E extends Emitter = Emitter> extends Root {
         traceId: string;
         spanId: string;
         traceFlags: number;
+        requestId: string | undefined;
     };
     /**
      * End root baggage

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

@@ -30,6 +30,7 @@ export type Baggage = {
     traceId: string;
     spanId: string;
     traceFlags: number;
+    requestId?: string;
     expired?: number;
 };
 export type ExternalBaggage = {
@@ -37,6 +38,7 @@ export type ExternalBaggage = {
     'nsc-trace-id'?: string;
     'nsc-span-id'?: string;
     'nsc-trace-flags'?: number;
+    'x-request-id'?: string;
 };
 export interface Message<M = any> {
     payload: M;
@@ -69,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;
@@ -127,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.20.1",
+  "version": "1.22.0",
   "description": "Toolkit for create microservices around NATS",
   "main": "dist/index.js",
   "types": "./dist/types/index.d.ts",