@lad-tech/nsc-toolkit 1.28.0 → 1.28.2

package/dist/interfaces.js

@@ -1,16 +0,0 @@
-"use strict";
-// COMMON
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TagKey = exports.DependencyType = void 0;
-exports.DependencyType = {
-    SERVICE: 'service',
-    ADAPTER: 'adapter',
-    CONSTANT: 'constant', // Just an object
-};
-exports.TagKey = {
-    LOCATION: 'location',
-    TYPE: 'type',
-    NAME: 'name',
-    TARGET: 'target',
-};
-//# sourceMappingURL=interfaces.js.map

package/dist/types/Client.d.ts

@@ -1,32 +0,0 @@
-/// <reference types="node" />
-import { Readable } from 'node:stream';
-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 {
-    private serviceName;
-    private baggage?;
-    private cache?;
-    private events?;
-    private Ref?;
-    private subscriptions;
-    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>;
-    private getHTTPSettingsFromRemoteService;
-    private isStream;
-    private makeBrokerRequest;
-    private makeHttpRequest;
-    private isJsMessage;
-    private getBaggageFromNATSHeader;
-}
-export {};

package/dist/types/Container.d.ts

@@ -1,54 +0,0 @@
-import { ClientService, DependencyType, InitializableService, Tag } from '.';
-type Constant = Record<string, any>;
-type Service<R extends Constant = Constant> = ClientService<R>;
-export type Adapter<R extends Constant = Constant> = new (...args: any[]) => R;
-export type Singlton = {
-    singlton: true;
-    tag?: Tag;
-};
-export type NeedInit = {
-    init: true;
-    tag?: Tag;
-};
-export type AdapterOptions = Singlton | NeedInit;
-type Dependency = Service | Adapter | Constant;
-type ContainerValue = {
-    type: DependencyType;
-    value: Dependency;
-    options?: AdapterOptions;
-};
-declare class Container {
-    private readonly container;
-    private readonly singltons;
-    private buildDependency;
-    private inject;
-    private isServiceDependency;
-    private isAdapterDependency;
-    private isConstantDependency;
-    bind<R extends Record<string, any>>(key: symbol, type: typeof DependencyType.SERVICE, value: ClientService<R>): void;
-    bind<R extends Record<string, any>>(key: symbol, type: typeof DependencyType.ADAPTER, value: Adapter<R>, options?: Singlton): void;
-    bind<R extends Record<string, any>>(key: symbol, type: typeof DependencyType.ADAPTER, value: Adapter<R & InitializableService>, options?: NeedInit): void;
-    bind<R extends Record<string, any>>(key: symbol, type: typeof DependencyType.CONSTANT, value: R): void;
-    symbol(key: symbol): {
-        to: {
-            Adapter: <R extends Record<string, any>>(value: Adapter<R> | Adapter<R & import("./interfaces").GracefulShutdownAdditionalService & {
-                init: () => Promise<any>;
-            }>, options?: AdapterOptions) => void;
-            Singlton: <R_1 extends Record<string, any>>(value: Adapter<R_1>) => void;
-            Constant: <R_2 extends Record<string, any>>(value: R_2) => void;
-            Initializable: <R_3 extends Record<string, any>>(value: Adapter<R_3 & import("./interfaces").GracefulShutdownAdditionalService & {
-                init: () => Promise<any>;
-            }>) => void;
-            Service: <R_4 extends Record<string, any>>(value: ClientService<R_4>) => void;
-        };
-    };
-    unbind(key: symbol): Promise<void>;
-    get(key: symbol): {
-        dependency: ContainerValue;
-        constructor: unknown[];
-    };
-    getInstance<R = Constant>(key: symbol): R;
-    initDependencies(): Promise<InitializableService[]>;
-}
-export declare const container: Container;
-export {};

package/dist/types/Meter.d.ts

@@ -1,11 +0,0 @@
-import { Baggage, EventMeter, Tag } from './interfaces';
-import { Root } from './Root';
-export declare class Meter extends Root implements EventMeter {
-    private name;
-    private baggage?;
-    private span?;
-    constructor(name: string, baggage?: Baggage | undefined);
-    start(): void;
-    end(error?: Error): void;
-    measure<T extends (...args: any[]) => any>(func: T, arg: Parameters<T>, context: unknown, tag?: Tag): ReturnType<T>;
-}

package/dist/types/Method.d.ts

@@ -1,6 +0,0 @@
-import { Logs } from '@lad-tech/toolbelt';
-import { Emitter } from './interfaces';
-export declare class BaseMethod<E extends Emitter = Record<string, () => void>> {
-    protected logger: Logs.Logger;
-    protected emitter: E;
-}

package/dist/types/Root.d.ts

@@ -1,29 +0,0 @@
-import { Logs } from '@lad-tech/toolbelt';
-import * as opentelemetry from '@opentelemetry/api';
-import type { NatsConnection } from 'nats';
-import { type Baggage, type ExternalBaggage, type Tag } from './interfaces';
-import { Broker } from './Union';
-export declare class Root {
-    protected readonly SERVICE_SUBJECT_FOR_GET_HTTP_SETTINGS = "get_http_settings";
-    protected readonly CACHE_SERVICE_KEY = "CACHE";
-    protected readonly SUBJECT_DELIMITER = ".";
-    protected logger: Logs.Logger;
-    broker: Broker;
-    constructor(broker?: NatsConnection, outputFormatter?: Logs.OutputFormatter);
-    protected castToNumber(value?: string): number;
-    protected getSettingFromEnv(name: string, required?: boolean): string | undefined;
-    /**
-     * Make opentelemetry context from baggagge
-     */
-    protected getContext(baggage?: Baggage): opentelemetry.Context | undefined;
-    protected getExpired(expired?: number, ownTimeout?: number): number;
-    protected buildErrorMessage(error: string | Error | Record<any, any>, code?: number): {
-        payload: null;
-        error: {
-            message: string;
-            code: number | undefined;
-        };
-    };
-    protected convertBaggaggeToExternalHeader(baggage?: Partial<Baggage>): ExternalBaggage;
-    protected applyTag(span: opentelemetry.Span, tag?: Tag): void;
-}

package/dist/types/Service.d.ts

@@ -1,140 +0,0 @@
-import { Root } from './Root';
-import { Emitter, ServiceOptions, Baggage, ExternalBaggage, ClientService } from '.';
-export declare class Service<E extends Emitter = Emitter> extends Root {
-    private options;
-    emitter: E;
-    private serviceName;
-    private httpServer?;
-    private httpProbServer?;
-    protected httpPort?: number;
-    protected ipAddress?: string;
-    private subscriptions;
-    private httpMethods;
-    private rootSpans;
-    /**
-     * Unique identifier NATS header for a message that will be used by the server apply
-     * de-duplication within the configured Duplicate Window
-     */
-    private readonly UNIQ_ID_HEADER;
-    /**
-     * Nats-Rollup header indicating all prior messages should be purged
-     */
-    private readonly ROLLUP_HEADER;
-    /**
-     * Roll-up only same subject message in the stream
-     */
-    private readonly ROLLUP_STRATEGY;
-    private readonly BASE_EVENT_SUFFIX;
-    constructor(options: ServiceOptions<E>);
-    /**
-     * Create global Tracer
-     */
-    private createTracer;
-    private finishSpan;
-    /**
-     * Wrapper for async methods. Create span
-     */
-    private perform;
-    /**
-     * Build trap for object with async methods
-     */
-    private getTrap;
-    /**
-     * Creating an object to inject into Method (business logic)
-     */
-    private createObjectWithDependencies;
-    /**
-     * Create Method (business logic) context
-     */
-    private createMethodContext;
-    /**
-     * 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
-     */
-    getRootBaggage(subject: string, headers?: ExternalBaggage, ownTimeout?: number): {
-        expired: number;
-        traceId: string;
-        spanId: string;
-        traceFlags: number;
-        requestId: string | undefined;
-    };
-    /**
-     * End root baggage
-     */
-    endRootSpan(traceId: string, error?: Error): void;
-    buildService<C extends ClientService>(Client: C, baggage?: Baggage): InstanceType<C>;
-    /**
-     * Create service Method for send HTTP settings
-     */
-    private runServiceMethodForHttp;
-    private makeHttpSingleResponse;
-    /**
-     * Create transform stream for convert object to string in stream pipeline
-     */
-    private getStringifyTransform;
-    private makeHttpStreamResponse;
-    /**
-     *  Up HTTP server and start listen http routes
-     */
-    private buildHTTPHandlers;
-    /**
-     * Run business logic for request
-     */
-    private handled;
-    /**
-     * Wrap emitter for luggage baggagge
-     */
-    private getWrappedEmitter;
-    /**
-     * Make error object if error instance of Error object for logger
-     */
-    private createErrorMessageForLogger;
-    /**
-     * Start service. Subscribe for subject and up http server
-     */
-    start(): Promise<void>;
-    /**
-     * Correct finish all connections
-     */
-    private cleanupAndExit;
-    stop(): Promise<void>;
-    /**
-     * Handler for OS Signal
-     */
-    private handleSignal;
-    /**
-     * Handler for Force OS Signal
-     */
-    private handleFatalError;
-    /**
-     * Register listeners for Graceful Shutdown
-     */
-    private registerGracefulShutdown;
-    /**
-     * Up Probe Route for container orchestration service
-     */
-    private upProbeRoutes;
-    /**
-     * Type guard for NATS debug event
-     */
-    private isNATSDebugEvent;
-    /**
-     * Logs events from the broker
-     */
-    private watchBrokerEvents;
-    /**
-     * Build message for broker
-     */
-    private buildMessage;
-    private upHTTPServer;
-    private getMyIpV4;
-    private getHttpSettings;
-    private getBaggageFromExternalHeader;
-}

package/dist/types/StreamBatchMsgFetcher.d.ts

@@ -1,13 +0,0 @@
-import { Consumer, ConsumerMessages } from 'nats';
-interface BatcherOptions {
-    batchSize?: number;
-    batchTimeout?: number;
-    noWait?: boolean;
-}
-export declare class StreamBatchMsgFetcher {
-    private consumer;
-    private options;
-    constructor(consumer: Consumer, options: BatcherOptions);
-    fetch(size?: number, expires?: number): Promise<ConsumerMessages>;
-}
-export {};

package/dist/types/StreamManager.d.ts

@@ -1,26 +0,0 @@
-import { StreamManagerParam, GetListenerOptions, GetBatchListenerOptions } from '.';
-import { Subscription } from 'nats';
-import { Root } from './Root';
-import { StreamBatchMsgFetcher } from './StreamBatchMsgFetcher';
-import { StreamSingleMsgFetcher } from './StreamSingleMsgFetcher';
-export declare class StreamManager extends Root {
-    private param;
-    private readonly STAR_WILDCARD;
-    private readonly GREATER_WILDCARD;
-    private readonly TWO_WEEKS_IN_SECOND;
-    private readonly ONE_DAY_IN_SECOND;
-    private readonly CONSUMER_NOT_FOUND;
-    private readonly defaultStreamOption;
-    private jsm?;
-    constructor(param: StreamManagerParam);
-    static isPullConsumerOptions(setting?: GetListenerOptions | GetBatchListenerOptions): setting is GetBatchListenerOptions;
-    static isStreamFetcher(consumer?: StreamSingleMsgFetcher | StreamBatchMsgFetcher | Subscription): consumer is StreamBatchMsgFetcher;
-    createStreams(): Promise<void>;
-    createConsumer(serviceNameFrom: string, eventName: string, setting?: GetListenerOptions): Promise<StreamSingleMsgFetcher>;
-    createConsumer(serviceNameFrom: string, eventName: string, setting?: GetBatchListenerOptions): Promise<StreamBatchMsgFetcher>;
-    private getStreamName;
-    private isNotFoundStreamError;
-    private buildPrefixForStreamName;
-    private capitalizeFirstLetter;
-    private convertSecondsToNanoseconds;
-}

package/dist/types/StreamOptions/BufferToJsonTransform.d.ts

@@ -1,14 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Logs } from '@lad-tech/toolbelt';
-import { Transform, TransformCallback, TransformOptions } from 'stream';
-export declare class BufferToJsonTransform<T = any> extends Transform {
-    private head;
-    private static errors;
-    private logger?;
-    constructor(options: TransformOptions & {
-        logger?: Logs.Logger;
-    });
-    _transform(tail: Buffer, _: BufferEncoding, cb: TransformCallback): Promise<void>;
-}

package/dist/types/StreamOptions/JsonToBufferTransform.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Transform, TransformCallback } from 'stream';
-export declare class JsonToBufferTransform<T> extends Transform {
-    _transform(chunk: T, encoding: BufferEncoding, cb: TransformCallback): void;
-}

package/dist/types/StreamOptions/index.d.ts

@@ -1,2 +0,0 @@
-export * from './JsonToBufferTransform';
-export * from './BufferToJsonTransform';

package/dist/types/StreamSingleMsgFetcher.d.ts

@@ -1,16 +0,0 @@
-import { Consumer } from 'nats';
-export declare class StreamSingleMsgFetcher {
-    private consumer;
-    private done;
-    constructor(consumer: Consumer);
-    [Symbol.asyncIterator](): {
-        next: () => Promise<{
-            value: import("nats").JsMsg;
-            done: boolean;
-        } | {
-            done: boolean;
-            value?: undefined;
-        }>;
-    };
-    unsubscribe(): void;
-}

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

@@ -1,32 +0,0 @@
-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;
-    private emitter;
-    closed(): Promise<void | Error>;
-    close(): Promise<void>;
-    publish(subject: string, data?: Uint8Array, options?: PublishOptions): void;
-    subscribe(subject: string, opts?: SubscriptionOptions): Subscription;
-    request(subject: string, data?: Uint8Array, opts?: RequestOptions): Promise<Msg>;
-    flush(): Promise<void>;
-    drain(): Promise<void>;
-    isClosed(): boolean;
-    isDraining(): boolean;
-    getServer(): string;
-    status(): AsyncIterable<Status>;
-    stats(): Stats;
-    jetstreamManager(opts?: JetStreamOptions): Promise<JetStreamManager>;
-    jetstream(opts?: JetStreamOptions): JetStreamClient;
-    rtt(): Promise<number>;
-}
-export {};

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

@@ -1,16 +0,0 @@
-import { ConsumerAPI, ConsumerConfig, ConsumerInfo, ConsumerUpdateConfig, Lister } from 'nats';
-export declare class ConsumerApiBlank implements ConsumerAPI {
-    info(stream: string, consumer: string): Promise<ConsumerInfo>;
-    add(stream: string, cfg: Partial<ConsumerConfig>): Promise<ConsumerInfo>;
-    update(stream: string, durable: string, cfg: Partial<ConsumerUpdateConfig>): Promise<ConsumerInfo>;
-    delete(stream: string, consumer: string): Promise<boolean>;
-    list(stream: string): Lister<ConsumerInfo>;
-    pause(stream: string, name: string, until?: Date | undefined): Promise<{
-        paused: boolean;
-        pause_until?: string | undefined;
-    }>;
-    resume(stream: string, name: string): Promise<{
-        paused: boolean;
-        pause_until?: string | undefined;
-    }>;
-}

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

@@ -1,18 +0,0 @@
-/// <reference types="node" />
-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>;
-    pullSubscribe(subject: string, opts: ConsumerOptsBuilder | Partial<ConsumerOpts>): Promise<JetStreamPullSubscription>;
-    subscribe(subject: string, opts: ConsumerOptsBuilder | Partial<ConsumerOpts>): Promise<JetStreamSubscription>;
-}

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

@@ -1,12 +0,0 @@
-import { Advisory, JetStreamAccountStats, JetStreamClient, JetStreamManager, JetStreamOptions } from 'nats';
-import { StreamApiBlank } from './StreamApi';
-import { ConsumerApiBlank } from './ConsumerApi';
-export declare class JetStreamManagerBlank implements JetStreamManager {
-    getOptions(): JetStreamOptions;
-    jetstream(): JetStreamClient;
-    consumers: ConsumerApiBlank;
-    streams: StreamApiBlank;
-    getAccountInfo(): Promise<JetStreamAccountStats>;
-    advisories(): AsyncIterable<Advisory>;
-}
-export declare const jetStreamManagerBlank: JetStreamManagerBlank;

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

@@ -1,16 +0,0 @@
-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>;
-    purge(stream: string, opts?: PurgeOpts): Promise<PurgeResponse>;
-    delete(stream: string): Promise<boolean>;
-    list(): Lister<StreamInfo>;
-    deleteMessage(stream: string, seq: number, erase?: boolean): Promise<boolean>;
-    getMessage(stream: string, query: MsgRequest): Promise<StoredMsg>;
-    find(subject: string): Promise<string>;
-}

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

@@ -1,19 +0,0 @@
-/// <reference types="node" />
-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: any;
-    unsubscribe(max?: number): void;
-    drain(): Promise<void>;
-    isDraining(): boolean;
-    isClosed(): boolean;
-    callback(err: NatsError | null, msg: Msg): void;
-    getSubject(): string;
-    getReceived(): number;
-    getProcessed(): number;
-    getPending(): number;
-    getID(): number;
-    getMax(): number | undefined;
-    destroy(error?: Error | undefined): any;
-    consumerInfo(): Promise<any>;
-}

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

@@ -1 +0,0 @@
-export * from './Broker';

package/dist/types/index.d.ts

@@ -1,7 +0,0 @@
-export * from './Service';
-export * from './Client';
-export * from './Method';
-export * from './injector';
-export * from './Container';
-export * from './interfaces';
-export * from './StreamOptions';

package/dist/types/injector.d.ts

@@ -1,14 +0,0 @@
-import 'reflect-metadata';
-import { Method, ClientService } from './interfaces';
-export type Instance = Record<string, (props: any) => Promise<unknown>>;
-export type Dependency = ClientService<unknown>;
-export type DependenceStorage = Map<string, Dependency>;
-export type InstanceStorage = Map<string, Instance>;
-export declare const dependencyStorageMetaKey: unique symbol;
-export declare const ServiceContainer: Map<string, DependenceStorage>;
-export declare const InstanceContainer: Map<string, InstanceStorage>;
-export declare const ConstructorDependencyKey = "constructor";
-export declare function related<T extends Method>(target: T): void;
-export declare function service(dependence: Dependency): (target: any, dependenceName: string) => void;
-export declare function instance(instance: Instance): (target: any, instanceName: string) => void;
-export declare function inject(key: symbol): (target: any, property: string | symbol | undefined, index?: number) => void;