@lad-tech/nsc-toolkit 0.5.2

package/src/Method.ts

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

package/src/Root.ts

@@ -0,0 +1,69 @@
+import { Baggage, CacheService } from './interfaces';
+import * as opentelemetry from '@opentelemetry/api';
+import { NatsConnection } from 'nats';
+import { Logs } from '@lad-tech/toolbelt';
+
+export class Root {
+  protected SERVICE_SUBJECT_FOR_GET_HTTP_SETTINGS = 'get_http_settings';
+  protected CACHE_SERVICE_KEY = 'CACHE';
+  protected
+  protected logger: Logs.Logger;
+
+  constructor(protected brocker: NatsConnection, cache?: CacheService) {
+    this.logger = new Logs.Logger();
+  }
+
+  protected castToNumber(value?: string) {
+    const result = +value!;
+    if (isNaN(result)) {
+      throw new Error(`Невозможно привести значение ${value} к числу`);
+    }
+    return result;
+  }
+
+  protected getSettingFromEnv(name: string, required = true) {
+    const value = process.env[name];
+    if (!value && required) {
+      throw new Error(`Не установлена обязательная настройка: ${name}`);
+    }
+    return value;
+  }
+
+  /**
+   * Make opentelemetry context from baggagge
+   */
+  protected getContext(baggage?: Baggage) {
+    if (baggage) {
+      return opentelemetry.trace.setSpanContext(opentelemetry.context.active(), baggage);
+    }
+  }
+
+  protected getExpired(expired?: number, ownTimeout?: number) {
+    try {
+      if (!expired) {
+        const timeout = ownTimeout || this.castToNumber(this.getSettingFromEnv('DEFAULT_REPONSE_TIMEOUT'));
+        return Date.now() + timeout * 1000;
+      }
+      return expired;
+    } catch (error) {
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  protected buildErrorMessage(error: string | Error, code?: number) {
+    let message = '';
+    if (error instanceof Error) {
+      message = error.message;
+    } else {
+      message = error;
+    }
+    return {
+      payload: null,
+      error: {
+        message,
+        code,
+      },
+    };
+  }
+}

package/src/Service.ts

@@ -0,0 +1,419 @@
+import { Root } from './Root';
+import { JSONCodec, Subscription } from 'nats';
+import { Message, Emitter, Method, ServiceOptions, Baggage, ExternalBaggage, ClientService } from './interfaces';
+import { BasicTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
+import { Resource } from '@opentelemetry/resources';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { Tracer, Context, Span, trace } from '@opentelemetry/api';
+import { InstanceContainer, ServiceContainer } from './injector';
+import { JaegerExporter } from '@opentelemetry/exporter-jaeger';
+import { IncomingHttpHeaders, ServerResponse } from 'http';
+import { Readable, Transform, pipeline } from 'stream';
+import { Logs } from '@lad-tech/toolbelt';
+import * as http from 'http';
+import * as os from 'os';
+
+export class Service<E extends Emitter = {}> extends Root {
+  public emitter = {} as E;
+  private serviceName: string;
+  private httpServer?: http.Server;
+  protected httpPort?: number;
+  protected ipAddress?: string;
+  private subscriptions: Subscription[] = [];
+  private httpMethods = new Map<string, Method>();
+  private rootSpans = new Map<string, Span>();
+
+  constructor(private options: ServiceOptions<E>) {
+    super(options.brokerConnection, options.cache?.service);
+
+    this.serviceName = options.name;
+    this.logger.setLocation(this.serviceName);
+    if (options.events.length) {
+      this.emitter = options.events.reduce((result, action) => {
+        result[action] = ((params: unknown) => {
+          this.brocker.publish(`${options.name}.${String(action)}`, this.buildMessage(params));
+        }) as E[keyof E];
+        return result;
+      }, this.emitter);
+    }
+    this.createTracer();
+  }
+
+  /**
+   * Create global Tracer
+   */
+  private createTracer() {
+    const provider = new BasicTracerProvider({
+      resource: new Resource({
+        [SemanticResourceAttributes.SERVICE_NAME]: this.options.name,
+      }),
+    });
+    const exporter = new JaegerExporter({
+      endpoint: this.getSettingFromEnv('OTEL_AGENT', false),
+    });
+    provider.addSpanProcessor(new SimpleSpanProcessor(exporter));
+    provider.register();
+  }
+
+  /**
+   * Wrapper for async methods. Create span
+   */
+  private async perform(
+    func: (...args: unknown[]) => Promise<unknown>,
+    funcContext: unknown,
+    arg: unknown[],
+    tracer: Tracer,
+    context?: Context,
+  ) {
+    const span = tracer.startSpan(func.name, undefined, context);
+    const query = func.apply(funcContext, arg);
+    query
+      .then(() => span.end())
+      .catch(error => {
+        span.setAttribute('error', true);
+        span.setAttribute('error.kind', error);
+        span.end();
+        throw error;
+      });
+    return query;
+  }
+
+  /**
+   * Creating an object to inject into Method (business logic)
+   */
+  private createObjectWithDependencies(action: string, tracer: Tracer, baggage?: Baggage) {
+    const services = ServiceContainer.get(action);
+    const dependences: Record<string, unknown> = {};
+    if (services?.size) {
+      services.forEach((Dependence, key) => {
+        dependences[key] = new Dependence(this.brocker, baggage, this.options.cache);
+      });
+    }
+    const perform = this.perform;
+    const context = this.getContext(baggage);
+    const instances = InstanceContainer.get(action);
+    if (instances?.size) {
+      instances.forEach((instance, key) => {
+        const trap = {
+          get(target: any, propKey: string, receiver: any) {
+            const method = Reflect.get(target, propKey, receiver);
+            if (typeof method === 'function') {
+              return function (...args: unknown[]) {
+                return perform(method, instance, args, tracer, context);
+              };
+            } else {
+              return method;
+            }
+          },
+        };
+        dependences[key] = new Proxy(instance, trap);
+      });
+    }
+
+    dependences['logger'] = new Logs.Logger({ location: `${this.serviceName}.${action}`, metadata: baggage });
+    return dependences;
+  }
+
+  /**
+   * Create Method (business logic) context
+   */
+  private createMethodContext(Method: Method, dependencies: Record<string, unknown>) {
+    const context = new Method();
+    for (const key in dependencies) {
+      context[key] = dependencies[key];
+    }
+    context['emitter'] = this.emitter;
+    return context;
+  }
+
+  /**
+   * Create Baggage from span. Expired one-on-one business logic call
+   */
+  private getNextBaggage(span: Span, baggage?: Baggage) {
+    const { traceId, spanId, traceFlags } = span.spanContext();
+    return { traceId, spanId, traceFlags, expired: baggage?.expired };
+  }
+
+  /**
+   * If there is no baggage. For example, in HTTP Gateway
+   */
+  public getRootBaggage(subject: string, headers?: ExternalBaggage, ownTimeout?: number) {
+    const baggage = headers ? this.getBaggageFromHTTPHeader(headers) : undefined;
+    const tracer = trace.getTracer('');
+    const context = this.getContext(baggage);
+    const span = tracer.startSpan(subject, undefined, context);
+    const newBaggage = this.getNextBaggage(span, baggage);
+    this.rootSpans.set(newBaggage.traceId, span);
+    return {
+      ...newBaggage,
+      expired: this.getExpired(undefined, ownTimeout),
+    };
+  }
+
+  /**
+   * End root baggage
+   */
+  public endRootSpan(traceId: string, error?: Error) {
+    const span = this.rootSpans.get(traceId);
+    if (span) {
+      if (error) {
+        span.setAttribute('error', true);
+        span.setAttribute('error.kind', error.message);
+      }
+      span.end();
+      this.rootSpans.delete(traceId);
+    }
+  }
+
+  public buildService<C extends ClientService>(Client: C, baggage?: Baggage) {
+    return new Client(this.brocker, baggage, this.options.cache) as InstanceType<C>;
+  }
+
+  /**
+   * Create service Method for send HTTP settings
+   */
+  private async runServiceMethodForHttp() {
+    const subject = `${this.serviceName}.${this.SERVICE_SUBJECT_FOR_GET_HTTP_SETTINGS}`;
+    const subscription = this.brocker.subscribe(subject, { queue: this.serviceName });
+    this.subscriptions.push(subscription);
+    for await (const message of subscription) {
+      message.respond(this.buildMessage(this.getHttpSettings()));
+    }
+  }
+
+  private makeHttpSingleResponse(response: ServerResponse, data: Message) {
+    const responseData = JSON.stringify(data);
+    response
+      .writeHead(200, {
+        'Content-Length': Buffer.byteLength(responseData),
+        'Content-Type': 'application/json',
+      })
+      .write(responseData);
+    response.end();
+  }
+
+  /**
+   * Create transform stream for convert object to string in stream pipeline
+   */
+  private getStringifyTransform() {
+    return new Transform({
+      objectMode: true,
+      transform(chunk, encoding, push) {
+        try {
+          if (chunk instanceof Buffer) {
+            push(null, chunk);
+          }
+          const result = JSON.stringify(chunk);
+          push(null, result);
+        } catch (error) {
+          push(error);
+        }
+      },
+    });
+  }
+
+  private makeHttpStreamReponse(response: ServerResponse, data: Message<Readable>) {
+    data.payload.on('error', error => {
+      this.logger.error(error);
+    });
+    response.writeHead(200, {
+      'Content-Type': 'application/octet-stream',
+    });
+    pipeline(data.payload, this.getStringifyTransform(), response, () => {});
+  }
+
+  /**
+   *  Up HTTP server and start listen http routes
+   */
+  private async buildHTTPHandlers() {
+    await this.upHTTPServer();
+    this.runServiceMethodForHttp();
+    this.httpServer!.on('request', async (request, response) => {
+      try {
+        if (request.method !== 'POST' || !request.url) {
+          throw new Error('Wrong http request');
+        }
+        const parsedUrl = request.url.split('/');
+        parsedUrl.shift();
+        const [serviceName, action, ...other] = parsedUrl;
+        const wrongServiceName = this.serviceName !== serviceName;
+        const Method = this.httpMethods.get(action);
+        if (other.length || wrongServiceName || !Method) {
+          throw new Error('Wrong url or service name or action');
+        }
+        const baggage = this.getBaggageFromHTTPHeader(request.headers as IncomingHttpHeaders & ExternalBaggage);
+
+        if (Method.settings.options?.useStream?.request) {
+          const result = await this.handled(request, Method, baggage);
+          if (Method.settings.options.useStream.response && result.payload instanceof Readable) {
+            this.makeHttpStreamReponse(response, result as Message<Readable>);
+            return;
+          }
+          this.makeHttpSingleResponse(response, result);
+          return;
+        }
+        const requestDataRaw: Buffer[] = [];
+        for await (const data of request) {
+          requestDataRaw.push(data);
+        }
+        const requestData = Buffer.concat(requestDataRaw).toString();
+        const result = await this.handled(JSON.parse(requestData), Method, baggage);
+        if (Method.settings.options?.useStream?.response && result.payload instanceof Readable) {
+          this.makeHttpStreamReponse(response, result as Message<Readable>);
+          return;
+        }
+        this.makeHttpSingleResponse(response, result);
+      } catch (error: unknown) {
+        this.logger.error(error);
+        if (error instanceof Error) {
+          this.makeHttpSingleResponse(response, this.buildErrorMessage(error));
+          return;
+        }
+        this.makeHttpSingleResponse(response, this.buildErrorMessage('System unknown error'));
+      }
+    });
+  }
+
+  /**
+   * Run business logic for request
+   */
+  private async handled(payload: unknown, Method: Method, baggage?: Baggage): Promise<Message> {
+    const subject = `${this.serviceName}.${Method.settings.action}`;
+    const tracer = trace.getTracer('');
+
+    const context = this.getContext(baggage);
+    const span = tracer.startSpan(subject, undefined, context);
+
+    try {
+      const requestedDependencies = this.createObjectWithDependencies(
+        Method.settings.action,
+        tracer,
+        this.getNextBaggage(span, baggage),
+      );
+      const context = this.createMethodContext(Method, requestedDependencies);
+      const result = {
+        payload: await context.handler.call(context, payload),
+      };
+      span.end();
+      return result;
+    } catch (error) {
+      this.logger.error(error);
+      span.setAttribute('error', true);
+      span.setAttribute('error.kind', error);
+      span.end();
+      return this.buildErrorMessage(error);
+    }
+  }
+
+  /**
+   * Start service. Subscribe for subject and up http server
+   */
+  public async start() {
+    const { methods } = this.options;
+    try {
+      methods.forEach(async Method => {
+        if (Method.settings.options?.useStream) {
+          this.httpMethods.set(Method.settings.action, Method);
+          return;
+        }
+
+        const subject = `${this.serviceName}.${Method.settings.action}`;
+
+        const subscription = this.brocker.subscribe(subject, { queue: this.serviceName });
+        this.subscriptions.push(subscription);
+        for await (const message of subscription) {
+          const { payload, baggage } = JSONCodec<Message<unknown>>().decode(message.data);
+          try {
+            const result = await this.handled(payload, Method, baggage);
+            message.respond(this.buildMessage(result));
+          } catch (error) {
+            message.respond(this.buildMessage({ error: error.message }));
+          }
+        }
+      });
+      if (this.httpMethods.size > 0) {
+        await this.buildHTTPHandlers();
+      }
+      this.logger.info('Service successfully started!');
+    } catch (error) {
+      if (error instanceof Error) {
+        this.logger.error(error.name, error.message);
+      } else {
+        this.logger.error('An error occurred while starting the service', error);
+      }
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Build message for broker
+   */
+  private buildMessage(message: unknown) {
+    return Buffer.from(JSON.stringify(message));
+  }
+
+  private async upHTTPServer() {
+    this.httpServer = http.createServer();
+    this.ipAddress = this.getMyIpV4();
+    this.httpPort = await new Promise((resolve, reject) => {
+      this.httpServer = this.httpServer!.listen(0, () => {
+        const address = this.httpServer!.address();
+
+        if (!address) {
+          reject(new Error('Failed to get the port number: server is not listening'));
+          return;
+        }
+
+        if (typeof address === 'string') {
+          reject(new Error('Listening on a unix socket is not supported'));
+          return;
+        }
+
+        resolve(address.port);
+      });
+    });
+    return this.httpServer!;
+  }
+
+  private getMyIpV4() {
+    const networkInterfaces = os.networkInterfaces();
+    const myIpV4Address = Object.keys(networkInterfaces).reduce((ip, key) => {
+      if (ip) {
+        return ip;
+      }
+      const networkInterface = networkInterfaces[key];
+      const externalIpV4Interface = networkInterface?.find(item => !item.internal && item.family === 'IPv4');
+      if (externalIpV4Interface) {
+        return externalIpV4Interface.address;
+      }
+      return ip;
+    }, '');
+    if (!myIpV4Address) {
+      throw new Error('Failed to get service ip address');
+    }
+    return myIpV4Address;
+  }
+
+  private getHttpSettings() {
+    return {
+      ip: this.ipAddress,
+      port: this.httpPort,
+    };
+  }
+
+  private getBaggageFromHTTPHeader(headers: ExternalBaggage) {
+    const expired = headers['nsc-expired'] ? +headers['nsc-expired'] : undefined;
+    const traceId = headers['nsc-trace-id'];
+    const spanId = headers['nsc-span-id'];
+    const traceFlags = headers['nsc-trace-flags'] ? +headers['nsc-trace-flags'] : undefined;
+    if (traceId && spanId && traceFlags) {
+      return {
+        traceId,
+        spanId,
+        traceFlags,
+        expired,
+      };
+    }
+    return undefined;
+  }
+}

package/src/index.ts

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

package/src/injector.ts

@@ -0,0 +1,43 @@
+import 'reflect-metadata';
+import { Method, ClientService } from './interfaces';
+
+export type Instance = Record<string, (props: unknown) => Promise<unknown>>;
+export type Dependence = ClientService<unknown>;
+export type DependenceStorage = Map<string, Dependence>;
+export type InstanceStorage = Map<string, Instance>;
+
+const serviceMetaKey = Symbol('services');
+const instanceMetaKey = Symbol('instance');
+
+export const ServiceContainer: Map<string, DependenceStorage> = new Map();
+export const InstanceContainer: Map<string, InstanceStorage> = new Map();
+
+export function related<T extends Method>(target: T) {
+  const dependencies: DependenceStorage = Reflect.getMetadata(serviceMetaKey, target.prototype);
+  const instances: InstanceStorage = Reflect.getMetadata(instanceMetaKey, target.prototype);
+  ServiceContainer.set(target.settings.action, dependencies);
+  InstanceContainer.set(target.settings.action, instances);
+}
+
+function setMetaData(item: Dependence | Instance, itemName: string, metaKey: symbol, target: any) {
+  let storage: Map<string, unknown>;
+  if (Reflect.hasMetadata(metaKey, target)) {
+    storage = Reflect.getMetadata(metaKey, target);
+  } else {
+    storage = new Map();
+    Reflect.defineMetadata(metaKey, storage, target);
+  }
+  storage.set(itemName, item);
+}
+
+export function service(dependence: Dependence) {
+  return function (target: any, dependenceName: string): void {
+    setMetaData(dependence, dependenceName, serviceMetaKey, target);
+  };
+}
+
+export function instance(instance: Instance) {
+  return function (target: any, instanceName: string): void {
+    setMetaData(instance, instanceName, instanceMetaKey, target);
+  };
+}

package/src/interfaces.ts

@@ -0,0 +1,89 @@
+// COMMON
+
+import type { NatsConnection } from 'nats';
+import type { Client } from './Client';
+
+export interface MethodOptions {
+  useStream?: {
+    request?: boolean;
+    response?: boolean;
+  };
+  cache?: number; // in minuts
+  timeout?: number; // in seconds
+  runTimeValidation?: {
+    request?: boolean;
+    response?: boolean;
+  };
+}
+
+export interface MethodSettings {
+  action: string;
+  options?: MethodOptions;
+  request?: Record<string, unknown>;
+  response?: Record<string, unknown>;
+}
+
+export interface Method {
+  settings: MethodSettings;
+  new (): { handler: (params: unknown) => Promise<unknown> };
+}
+
+export type ClientService<C = Client> = new (
+  natsConnection: NatsConnection,
+  baggage?: Baggage,
+  cache?: CacheSettings,
+) => C;
+
+export type Baggage = {
+  traceId: string;
+  spanId: string;
+  traceFlags: number;
+  expired?: number;
+};
+
+export type ExternalBaggage = {
+  'nsc-expired'?: number;
+  'nsc-trace-id'?: string;
+  'nsc-span-id'?: string;
+  'nsc-trace-flags'?: number;
+};
+
+export interface Message<M = any> {
+  payload: M;
+  baggage?: Baggage;
+  error?: {
+    message: string;
+    code?: number;
+  };
+}
+
+export type Emitter = Record<string, (params: unknown) => void>;
+
+export interface CacheSettings {
+  service: CacheService;
+  timeout: number;
+}
+
+export interface ServiceOptions<E extends Emitter> {
+  name: string;
+  brokerConnection: NatsConnection;
+  methods: Method[];
+  events: keyof E extends [] ? [] : [keyof E];
+  cache?: CacheSettings;
+}
+
+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 HttpSettings {
+  ip?: string;
+  port?: number;
+}
+
+export interface CacheService {
+  set: (key: string, value: string, expired?: number) => Promise<void>;
+  get: (key: string) => Promise<string | undefined>;
+  delete: (key: string) => Promise<void>;
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "sourceMap": true,
+    "strictNullChecks": true,
+    "module": "commonjs",
+    "target": "es2019",
+    "allowJs": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "lib": ["es2019"],
+    "outDir": "./dist",
+    "declarationDir": "./dist/types/"
+  },
+  "include": ["."],
+  "exclude": ["node_modules","./examples"]
+}