@lad-tech/nsc-toolkit 0.5.2

package/examples/HttpGate/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "gate",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "fastify": "^4.3.0"
+  }
+}

package/examples/LogicService/index.ts

@@ -0,0 +1,16 @@
+import { Client } from '../../src/Client';
+import { NatsConnection } from 'nats';
+import { WeirdSumRequest, WeirdSumResponse } from './interfaces';
+import { Baggage, CacheSettings } from '../../src/interfaces';
+import { name, methods } from './service.json';
+export * from './interfaces';
+
+export default class ServiceMathClient extends Client {
+  constructor(nats: NatsConnection, baggage?: Baggage, cacheSettings?: CacheSettings) {
+    super(nats, name, baggage, cacheSettings);
+  }
+
+  public async weirdSum(payload: WeirdSumRequest) {
+    return this.request<WeirdSumResponse>(`${name}.${methods.WeirdSum.action}`, payload, methods.WeirdSum);
+  }
+}

package/examples/LogicService/interfaces.ts

@@ -0,0 +1,10 @@
+// SERVICE
+
+export type WeirdSumRequest = {
+  a: number;
+  b: number;
+};
+
+export type WeirdSumResponse = {
+  result: number;
+};

package/examples/LogicService/methods/WeirdSum.ts

@@ -0,0 +1,20 @@
+import { WeirdSumRequest, WeirdSumResponse } from '../interfaces';
+import { related, service } from '../../../src/injector';
+import { methods } from '../service.json';
+
+import Math from '../../MathService';
+import { BaseMethod } from '../../../src/Method';
+
+@related
+export class WeirdSum extends BaseMethod {
+  static settings = methods.WeirdSum;
+  @service(Math) private math: Math;
+
+  public async handler(request: WeirdSumRequest): Promise<WeirdSumResponse> {
+    const sum = await this.math.sum(request);
+    const fibonacci = await this.math.fibonacci({ length: sum.result });
+    this.logger.info('Some info');
+    const result = await this.math.sumStream(fibonacci);
+    return result;
+  }
+}

package/examples/LogicService/service.json

@@ -0,0 +1,31 @@
+{
+  "name": "Logic",
+  "description": "busines logic BFF",
+  "methods": {
+    "WeirdSum": {
+      "action": "weirdsum",
+      "description": "Weird sum logic. Gets two numbers and adds them. The result is a length Fibonacci sequence. Add the sequence and get the result",
+      "options": {
+        "cache": 5,
+        "runTimeValidation": {
+          "request": true
+        }
+      },
+      "request": {
+        "type": "object",
+        "properties": {
+          "a": { "type": "number" },
+          "b": {"type": "number" }
+        },
+        "required": ["a", "b"]
+      },
+      "response": {
+        "type": "object",
+        "properties": {
+          "result": { "type": "number" }
+        },
+        "required": ["result"]
+      }
+    }
+  }
+}

package/examples/LogicService/service.ts

@@ -0,0 +1,15 @@
+import { Service } from '../../src/Service';
+import { name } from './service.json';
+import { connect } from 'nats';
+
+import { WeirdSum } from './methods/WeirdSum';
+
+(async () => {
+  const brokerConnection = await connect({ servers: ['localhost:4222'] });
+  new Service({
+    name,
+    brokerConnection,
+    methods: [WeirdSum],
+    events: [],
+  }).start();
+})();

package/examples/MathService/Untitled-1.json

@@ -0,0 +1,62 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "methods": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "action": { "type": "string" },
+          "description": { "type": "string" },
+          "options": { "$ref": "#/$defs/options" },
+          "request": { "type": "object" },
+          "response": { "type": "object" }
+        },
+        "required": [ "action", "description", "options" ]
+      }
+    },
+    "events": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string" },
+          "description": { "type": "string" },
+          "message": { "type": "object" }
+        },
+        "required": [ "action", "description", "options", "message" ]
+      }
+    }
+  },
+  "required": [ "name", "description", "methods" ],
+
+  "$defs": {
+    "options": {
+      "type": "object",
+      "properties": {
+        "useStream": {
+          "type": "object",
+          "properties": {
+            "request": { "type": "boolean" },
+            "response": { "type": "boolean" }
+          }
+        },
+        "cache": { "type": "number" },
+        "runTimeValidation": {
+          "type": "object",
+          "properties": {
+            "request": { "type": "boolean" },
+            "response": { "type": "boolean" }
+          }
+        }
+      }
+    }
+  }
+}

package/examples/MathService/index.ts

@@ -0,0 +1,22 @@
+import { Client } from '../../src/Client';
+import { NatsConnection } from 'nats';
+import { SumRequest, SumResponse, EmitterMath, SumStreamResponse, FibonacciRequest } from './interfaces';
+import { Baggage, CacheSettings } from '../../src/interfaces';
+import { name, methods } from './service.json';
+import { Readable } from 'stream';
+export * from './interfaces';
+
+export default class ServiceMathClient extends Client<EmitterMath> {
+  constructor(nats: NatsConnection, baggage?: Baggage, cacheSettings?: CacheSettings) {
+    super(nats, name, baggage, cacheSettings);
+  }
+  public async sum(payload: SumRequest) {
+    return this.request<SumResponse>(`${name}.${methods.Sum.action}`, payload, methods.Sum);
+  }
+  public async sumStream(payload: Readable) {
+    return this.request<SumStreamResponse>(`${name}.${methods.SumStream.action}`, payload, methods.SumStream);
+  }
+  public async fibonacci(payload: FibonacciRequest) {
+    return this.request<Readable>(`${name}.${methods.Fibonacci.action}`, payload, methods.Fibonacci);
+  }
+}

package/examples/MathService/interfaces.ts

@@ -0,0 +1,26 @@
+// SERVICE
+
+interface ElapsedEvent {
+  elapsed: number;
+}
+
+export type EmitterMath = {
+  elapsed: (params: ElapsedEvent) => void;
+};
+
+export type SumRequest = {
+  a: number;
+  b: number;
+};
+
+export interface SumResponse {
+  result: number;
+}
+
+export type FibonacciRequest = {
+  length: number;
+};
+
+export type SumStreamResponse = {
+  result: number;
+};

package/examples/MathService/methods/Fibonacci.ts

@@ -0,0 +1,29 @@
+import { FibonacciRequest } from '../interfaces';
+import { related } from '../../../src/injector';
+import { methods } from '../service.json';
+import { Readable } from 'stream';
+import { setTimeout } from 'timers/promises';
+import { BaseMethod } from '../../../src/Method';
+import { Method } from '../../../src/interfaces';
+
+@related
+export class Fibonacci extends BaseMethod {
+  static settings = methods.Fibonacci;
+  private firstNumber = 0;
+  private secondNumber = 1;
+  public async handler(request: FibonacciRequest): Promise<Readable> {
+    const { length } = request;
+    return Readable.from(this.getFibonacciSequence(length));
+  }
+  private async *getFibonacciSequence(length: number) {
+    let limit = length;
+    do {
+      await setTimeout(100);
+      const nextNumber = this.firstNumber + this.secondNumber;
+      this.firstNumber = this.secondNumber;
+      this.secondNumber = nextNumber;
+      yield nextNumber;
+      limit--;
+    } while (limit > 0);
+  }
+}

package/examples/MathService/methods/Sum.ts

@@ -0,0 +1,16 @@
+import { SumRequest, SumResponse } from '../interfaces';
+import { related } from '../../../src/injector';
+import { methods } from '../service.json';
+import { BaseMethod } from '../../../src/Method';
+
+@related
+export class Sum extends BaseMethod {
+  static settings = methods.Sum;
+  public async handler(request: SumRequest): Promise<SumResponse> {
+    const { a, b } = request;
+    return { result: this.sum(a, b) };
+  }
+  private sum(a: number, b: number) {
+    return a + b;
+  }
+}

package/examples/MathService/methods/SumStream.ts

@@ -0,0 +1,18 @@
+import { SumStreamResponse } from '../interfaces';
+import { related } from '../../../src/injector';
+import { methods } from '../service.json';
+import { Readable } from 'stream';
+import { BaseMethod } from '../../../src/Method';
+
+@related
+export class SumStream extends BaseMethod {
+  static settings = methods.SumStream;
+  private result = 0;
+  public async handler(request: Readable): Promise<SumStreamResponse> {
+    for await (const chunk of request) {
+      const sequenceNumber = +Buffer.from(chunk).toString();
+      this.result += sequenceNumber;
+    }
+    return { result: this.result };
+  }
+}

package/examples/MathService/service.json

@@ -0,0 +1,64 @@
+{
+  "name": "Math",
+  "description": "Mathematics service",
+  "methods": {
+    "Sum": {
+      "action": "sum",
+      "description": "Addition of two numbers",
+      "options": {},
+      "request": {
+        "type": "object",
+        "properties": {
+          "a": { "type": "number" },
+          "b": {"type": "number" }
+        },
+        "required": ["a", "b"]
+      },
+      "response": {
+        "type": "object",
+        "properties": {
+          "result": { "type": "number" }
+        },
+        "required": ["result"]
+      }
+    },
+    "Fibonacci": {
+      "action": "fibonacci",
+      "description": "Return Fibonacci sequence given length",
+      "options": {
+        "useStream": {
+          "response": true
+        }
+      },
+      "request": {
+        "type": "object",
+        "properties": {
+          "length": { "type": "number" }
+        },
+        "required": ["length"]
+      },
+      "response": {
+        "type": "number"
+      }
+    },
+    "SumStream": {
+      "action": "sumstream",
+      "description": "Adding all the numbers of the stream",
+      "options": {
+        "useStream": {
+          "request": true
+        }
+      },
+      "request": {
+        "type": "number"
+      },
+      "response": {
+        "type": "object",
+        "properties": {
+          "result": { "type": "number" }
+        },
+        "required": ["result"]
+      }
+    }
+  }
+}

package/examples/MathService/service.ts

@@ -0,0 +1,18 @@
+import { Service } from '../../src/Service';
+import { EmitterMath } from './interfaces';
+import { name } from './service.json';
+import { connect } from 'nats';
+
+import { Sum } from './methods/Sum';
+import { SumStream } from './methods/SumStream';
+import { Fibonacci } from './methods/Fibonacci';
+
+(async () => {
+  const brokerConnection = await connect({ servers: ['localhost:4222'] });
+  new Service<EmitterMath>({
+    name,
+    brokerConnection,
+    methods: [Sum, SumStream, Fibonacci],
+    events: ['elapsed'],
+  }).start();
+})();

package/examples/SimpleCache.ts

@@ -0,0 +1,21 @@
+export class SimpleCache {
+  private map = new Map<string, string>();
+
+  public async get(key: string) {
+    return this.map.get(key);
+  }
+
+  public async delete(key: string) {
+    this.map.delete(key);
+    return;
+  }
+
+  public async set(key: string, data: string, expired?: number) {
+    this.map.set(key, data);
+    if (expired) {
+      setTimeout(() => {
+        this.map.delete(key);
+      }, expired * 60 * 1000);
+    }
+  }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@lad-tech/nsc-toolkit",
+  "version": "0.5.2",
+  "description": "Toolkit for create microservices around NATS",
+  "main": "dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "scripts": {
+    "build": "rm -rf ./dist && tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "DevHive crew",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^17.0.42",
+    "@typescript-eslint/eslint-plugin": "^5.43.0",
+    "eslint": "^7.32.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-jest": "^26.1.3",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "prettier": "^2.6.1",
+    "prettier-eslint": "^13.0.0",
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.3"
+  },
+  "dependencies": {
+    "@lad-tech/toolbelt": "^1.1.1",
+    "@opentelemetry/api": "^1.1.0",
+    "@opentelemetry/exporter-jaeger": "^1.3.1",
+    "@opentelemetry/resources": "^1.3.1",
+    "@opentelemetry/sdk-trace-base": "^1.3.1",
+    "@opentelemetry/semantic-conventions": "^1.3.1",
+    "ajv": "^8.11.0",
+    "nats": "^2.6.1",
+    "reflect-metadata": "^0.1.13"
+  }
+
+}

package/src/Client.ts

@@ -0,0 +1,237 @@
+import { Root } from './Root';
+import { NatsConnection, Subscription, JSONCodec } from 'nats';
+import {
+  Baggage,
+  Message,
+  Emitter,
+  Listener,
+  HttpSettings,
+  ExternalBaggage,
+  CacheSettings,
+  MethodOptions,
+  MethodSettings,
+} from './interfaces';
+import * as opentelemetry from '@opentelemetry/api';
+import { EventEmitter, Readable } from 'stream';
+import * as http from 'http';
+import { createHash } from 'crypto';
+import { setTimeout } from 'timers/promises';
+import Ajv from 'ajv';
+
+export class Client<E extends Emitter = {}> extends Root {
+  private subscriptions = new Map<keyof E, Subscription>();
+  private REQUEST_HTTP_SETTINGS_TIMEOUT = 1000; // ms
+
+  constructor(
+    natsConnection: NatsConnection,
+    private serviceName: string,
+    private baggage?: Baggage,
+    private cache?: CacheSettings,
+  ) {
+    super(natsConnection);
+    this.logger.setLocation(serviceName);
+  }
+
+  /**
+   * Make listener for service events. Auto subscribe and unsubscribe to subject
+   */
+  public getListener<A extends keyof E>(eventNames: Array<A>, queue?: string): Listener<E> {
+    const listener = new EventEmitter();
+    eventNames.forEach(async eventName => {
+      const subscription = this.brocker.subscribe(`${this.serviceName}.${eventName as string}`, { queue });
+      this.subscriptions.set(eventName, subscription);
+      for await (const event of subscription) {
+        const data = JSONCodec<unknown>().decode(event.data);
+        listener.emit(`${eventName as string}`, data);
+      }
+    });
+    return new Proxy(listener, {
+      get: (target, prop, receiver) => {
+        const method = Reflect.get(target, prop, receiver);
+        if (prop === 'off') {
+          return (eventName: A, listener: (params: unknown) => void) => {
+            this.logger.info('Unsubscribe', eventName);
+            const subscription = this.subscriptions.get(eventName);
+            subscription?.unsubscribe();
+            this.subscriptions.delete(eventName);
+            return method.call(target, eventName, listener);
+          };
+        }
+        return method;
+      },
+    }) as Listener<E>;
+  }
+
+  private createCacheKey(subject: string, data: Record<string, unknown>) {
+    const dataHash = createHash('sha1').update(JSON.stringify(data)).digest('hex');
+    return `${this.CACHE_SERVICE_KEY}:${subject}:${dataHash}`;
+  }
+
+  private validate(data: any, schema: Record<string, unknown>) {
+    const requestValidator = new Ajv().compile(schema);
+    const valid = requestValidator(data);
+    if (!valid) {
+      throw new Error(JSON.stringify(requestValidator.errors));
+    }
+  }
+
+  protected async request<R = any>(
+    subject: string,
+    data: Record<string, unknown> | Readable,
+    { options, request, response }: MethodSettings,
+  ): Promise<R> {
+    const tracer = opentelemetry.trace.getTracer('');
+    const span = tracer.startSpan(subject, undefined, this.getContext(this.baggage));
+    try {
+      if (options?.runTimeValidation?.request && request) {
+        this.validate(data, request);
+      }
+
+      const { spanId, traceId, traceFlags } = span.spanContext();
+      const expired = this.getExpired(this.baggage?.expired, options?.timeout);
+      const message: Message = { payload: data, baggage: { expired, traceId, spanId, traceFlags } };
+      const timeout = expired - Date.now();
+
+      if (timeout <= 0) {
+        throw new Error('Timeout request service ' + subject);
+      }
+
+      let key = '';
+
+      if (options?.cache && !this.isStream(data) && this.cache) {
+        try {
+          key = this.createCacheKey(subject, data);
+          const result = await Promise.race<any>([this.cache.service.get(key), setTimeout(this.cache.timeout, null)]);
+          if (result) {
+            return JSON.parse(result);
+          }
+        } catch (error) {
+          this.logger.warn('get cache: ', error);
+        }
+      }
+
+      const result = options?.useStream
+        ? await this.makeHttpRequest(subject, message, options, timeout)
+        : await this.makeBrokerRequest(subject, message, timeout);
+
+      if (result.error) {
+        throw new Error(result.error.message);
+      }
+
+      if (options?.runTimeValidation?.response && response) {
+        this.validate(result.payload, response);
+      }
+
+      if (options?.cache && !this.isStream(result.payload) && this.cache) {
+        this.cache.service.set(key, JSON.stringify(result.payload), options.cache);
+      }
+
+      return result.payload;
+    } catch (error) {
+      span.setAttribute('error', true);
+      span.setAttribute('error.kind', error);
+      this.logger.error(error);
+      throw error;
+    } finally {
+      span.end();
+    }
+  }
+
+  private async getHTTPSettingsFromRemoteService() {
+    const subject = `${this.serviceName}.${this.SERVICE_SUBJECT_FOR_GET_HTTP_SETTINGS}`;
+    const result = await this.brocker.request(subject, Buffer.from(JSON.stringify('')), {
+      timeout: this.REQUEST_HTTP_SETTINGS_TIMEOUT,
+    });
+    const { ip, port } = JSONCodec<HttpSettings>().decode(result.data);
+    if (!ip || !port) {
+      throw new Error(`Remote service ${this.serviceName} did not return http settings`);
+    }
+    return { ip, port };
+  }
+
+  private isStream(data: unknown | Readable): data is Readable {
+    return data instanceof Readable;
+  }
+
+  private async makeBrokerRequest(subject: string, message: Message, timeout: number) {
+    try {
+      const result = await this.brocker.request(subject, Buffer.from(JSON.stringify(message)), { timeout });
+      return JSONCodec<Message<any>>().decode(result.data);
+    } catch (error) {
+      return this.buildErrorMessage(error);
+    }
+  }
+
+  private async makeHttpRequest(
+    subject: string,
+    message: Message | Message<Readable>,
+    options: MethodOptions,
+    timeout: number,
+  ): Promise<Message<any>> {
+    return new Promise(async resolve => {
+      const { ip, port } = await this.getHTTPSettingsFromRemoteService();
+      const serviceActionPath = subject.split('.');
+      const headersFromBaggage = this.convertBaggaggeToExternalHeader(message.baggage);
+
+      const headers = {
+        'Content-Type': this.isStream(message.payload) ? 'application/octet-stream' : 'application/json',
+        ...headersFromBaggage,
+      };
+      if (!this.isStream(message.payload)) {
+        headers['Content-Length'] = Buffer.byteLength(JSON.stringify(message.payload));
+      }
+      const request = http.request(
+        {
+          host: ip,
+          port,
+          path: `/${serviceActionPath.join('/')}`,
+          method: 'POST',
+          headers,
+          timeout,
+        },
+        async response => {
+          if (options?.useStream?.response) {
+            resolve({ payload: response });
+            return;
+          }
+
+          const data: Buffer[] = [];
+          for await (const chunk of response) {
+            data.push(chunk);
+          }
+
+          const responseDataString = Buffer.concat(data).toString();
+          try {
+            resolve(JSON.parse(responseDataString));
+          } catch (error) {
+            resolve(this.buildErrorMessage(error));
+          }
+        },
+      );
+
+      request.on('error', error => {
+        resolve(this.buildErrorMessage(error));
+      });
+
+      if (this.isStream(message.payload)) {
+        message.payload.pipe(request);
+        return;
+      }
+
+      request.write(JSON.stringify(message.payload));
+      request.end();
+    });
+  }
+
+  private convertBaggaggeToExternalHeader(baggage?: Baggage): ExternalBaggage {
+    if (!baggage) {
+      return {};
+    }
+    return {
+      'nsc-expired': baggage.expired,
+      'nsc-trace-id': baggage.traceId,
+      'nsc-span-id': baggage.spanId,
+      'nsc-trace-flags': baggage.traceFlags,
+    };
+  }
+}