@lad-tech/nsc-toolkit 0.5.2

package/dist/types/interfaces.d.ts

@@ -0,0 +1,72 @@
+import type { NatsConnection } from 'nats';
+import type { Client } from './Client';
+export interface MethodOptions {
+    useStream?: {
+        request?: boolean;
+        response?: boolean;
+    };
+    cache?: number;
+    timeout?: number;
+    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 declare type ClientService<C = Client> = new (natsConnection: NatsConnection, baggage?: Baggage, cache?: CacheSettings) => C;
+export declare type Baggage = {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+    expired?: number;
+};
+export declare 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 declare 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/examples/HttpGate/index.ts

@@ -0,0 +1,61 @@
+import { connect } from 'nats';
+import LogicService, { WeirdSumRequest } from '../LogicService';
+import { Service } from '../../src/Service';
+import { SimpleCache } from '../SimpleCache';
+import { Logs } from '@lad-tech/toolbelt';
+import Fastify from 'fastify';
+import { Baggage, ExternalBaggage } from '../../src/interfaces';
+
+declare module 'fastify' {
+  interface FastifyRequest {
+    baggage: Baggage;
+  }
+}
+
+const HTTP_SERVICE_PORT = 8000;
+const logger = new Logs.Logger({ location: 'HttpGate' });
+
+const upHttpGate = async (service: Service) => {
+  const fastify = Fastify();
+
+  fastify.decorateRequest('baggage', null);
+
+  fastify.addHook<{ Headers: ExternalBaggage }>('preHandler', (request, reply, done) => {
+    request.baggage = service.getRootBaggage(request.routerPath, request.headers);
+    reply.header('trace-id', request.baggage.traceId);
+    done();
+  });
+
+  fastify.addHook<{ Headers: ExternalBaggage }>('onResponse', (request, reply, done) => {
+    service.endRootSpan(request.baggage.traceId);
+    done();
+  });
+
+  fastify.post<{ Body: WeirdSumRequest }>('/math/weird/sum', async request => {
+    return await service.buildService(LogicService, request.baggage).weirdSum(request.body);
+  });
+
+  await fastify.listen({ port: HTTP_SERVICE_PORT });
+};
+
+const start = async () => {
+  try {
+    const brokerConnection = await connect({ servers: ['localhost:4222'] });
+    const service = new Service({
+      brokerConnection,
+      name: 'HttpGate',
+      methods: [],
+      events: [],
+      cache: { service: new SimpleCache(), timeout: 100 },
+    });
+
+    await service.start();
+    await upHttpGate(service);
+    logger.info('Http server start on port:', HTTP_SERVICE_PORT);
+  } catch (error) {
+    logger.error(error);
+    process.exit(1);
+  }
+};
+
+start();