@nest-yalc-2/api-strategy 1.3.3

package/src/__tests__/nest-http-call.strategy.spec.ts

@@ -0,0 +1,164 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { HttpService } from '@nestjs/axios';
+import { AxiosInstance } from 'axios';
+import {
+  NestHttpCallStrategy,
+  NestHttpCallStrategyProvider,
+} from '../strategies/nest-http-call.strategy.js';
+import { YalcGlobalClsService } from '../../../app/src/cls.module.js';
+
+describe('NestHttpCallStrategy', () => {
+  let httpService: HttpService;
+  let clsService: DeepMocked<YalcGlobalClsService>;
+
+  beforeEach(() => {
+    const axiosRef = createMock<AxiosInstance>();
+    httpService = createMock<HttpService>({
+      axiosRef,
+    });
+
+    clsService = createMock<YalcGlobalClsService>();
+  });
+
+  it('should be defined', () => {
+    expect(NestHttpCallStrategy).toBeDefined();
+  });
+
+  it('should be instantiable', () => {
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    expect(instance).toBeDefined();
+  });
+
+  it('should be able to execute the call method', async () => {
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+    expect(result).toBeDefined();
+  });
+
+  it('should be able to execute the get method', async () => {
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    const result = await instance.get('http://localhost:3000');
+    expect(result).toBeDefined();
+  });
+
+  it('should be able to execute the post method', async () => {
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    const result = await instance.post('http://localhost:3000', {});
+    expect(result).toBeDefined();
+  });
+
+  it('should create a provider', () => {
+    const provider = NestHttpCallStrategyProvider('test');
+    expect(provider).toBeDefined();
+  });
+
+  it('should create a provider and execute the useFactory method', () => {
+    const provider = NestHttpCallStrategyProvider('test');
+    expect(provider.useFactory(httpService, clsService)).toBeDefined();
+  });
+
+  it('should be able to execute the call method and return a json', async () => {
+    const axiosRef = createMock<AxiosInstance>({
+      request: (config: any) => ({ data: '{}' }),
+    });
+    httpService = createMock<HttpService>({
+      axiosRef,
+    });
+
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+    expect(result).toBeDefined();
+  });
+
+  it('should be able to execute the call method with parameters', async () => {
+    const instance = new NestHttpCallStrategy(httpService, clsService);
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+      parameters: {
+        test1: { test: 'test' },
+      },
+    });
+    expect(result).toBeDefined();
+  });
+
+  it('should add internal request token header when provided', async () => {
+    const requestSpy = jest.fn().mockResolvedValue({ data: '{}' });
+    const axiosRef = createMock<AxiosInstance>({
+      request: requestSpy as any,
+    });
+    httpService = createMock<HttpService>({
+      axiosRef,
+    });
+
+    const instance = new NestHttpCallStrategy(
+      httpService,
+      clsService,
+      'http://localhost:3000',
+      {
+        internalRequestHeader: 'x-internal-token',
+        internalRequestToken: 'test-token-123',
+      },
+    );
+
+    await instance.call('/test', {
+      method: 'GET',
+    });
+
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-internal-token': 'test-token-123',
+        }),
+      }),
+    );
+  });
+
+  it('should not override existing internal request token header', async () => {
+    const requestSpy = jest.fn().mockResolvedValue({ data: '{}' });
+    const axiosRef = createMock<AxiosInstance>({
+      request: requestSpy as any,
+    });
+    httpService = createMock<HttpService>({
+      axiosRef,
+    });
+
+    const instance = new NestHttpCallStrategy(
+      httpService,
+      clsService,
+      'http://localhost:3000',
+      {
+        internalRequestHeader: 'x-internal-token',
+        internalRequestToken: 'test-token-123',
+      },
+    );
+
+    await instance.call('/test', {
+      method: 'GET',
+      headers: {
+        'x-internal-token': 'user-provided-token',
+      },
+    });
+
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-internal-token': 'user-provided-token',
+        }),
+      }),
+    );
+  });
+});

package/src/__tests__/nest-local-call.strategy.spec.ts

@@ -0,0 +1,263 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock, DeepMocked, PartialFuncReturn } from '@golevelup/ts-jest';
+import { HttpAdapterHost } from '@nestjs/core';
+import { FastifyAdapter } from '@nestjs/platform-fastify';
+import { InjectOptions } from 'fastify';
+import {
+  NestLocalCallStrategy,
+  NestLocalCallStrategyProvider,
+} from '../strategies/nest-local-call.strategy.js';
+import { YalcGlobalClsService } from '../../../app/src/cls.module.js';
+
+describe('NestLocalCallStrategy', () => {
+  let adapterHost: HttpAdapterHost;
+  let clsService: DeepMocked<YalcGlobalClsService>;
+
+  beforeEach(() => {
+    adapterHost = createMock<HttpAdapterHost>({
+      httpAdapter: {
+        getInstance: () =>
+          createMock<FastifyAdapter>({
+            inject: (
+              _opts: string | InjectOptions,
+            ): PartialFuncReturn<Promise<any>> =>
+              ({
+                body: '{}',
+                json: () => ({}),
+              } as any),
+          }),
+      },
+    });
+
+    clsService = createMock<YalcGlobalClsService>();
+  });
+
+  it('should be defined', () => {
+    expect(NestLocalCallStrategy).toBeDefined();
+  });
+
+  it('should be instantiable', () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    expect(instance).toBeDefined();
+  });
+
+  it('should be able to execute the call method', async () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+    expect(result).toBeDefined();
+  });
+
+  it('should be able to execute the get method', async () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    const result = await instance.get('http://localhost:3000');
+    expect(result).toBeDefined();
+  });
+
+  it('should be able to execute the post method', async () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    const result = await instance.post('http://localhost:3000', {});
+    expect(result).toBeDefined();
+  });
+
+  it('should create a provider', () => {
+    const provider = NestLocalCallStrategyProvider('test');
+    expect(provider).toBeDefined();
+  });
+
+  it('should create a provider and execute the useFactory method', () => {
+    const provider = NestLocalCallStrategyProvider('test');
+    expect(provider.useFactory(adapterHost, clsService)).toBeDefined();
+  });
+
+  it('should be able to execute the call method with parameters', async () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+      parameters: {
+        test1: { test: 'test' },
+      },
+    });
+    expect(result).toBeDefined();
+  });
+
+  it('should skip parsing json if json parse throws an error', async () => {
+    adapterHost = createMock<HttpAdapterHost>({
+      httpAdapter: {
+        getInstance: () =>
+          createMock<FastifyAdapter>({
+            inject: (
+              _opts: string | InjectOptions,
+            ): PartialFuncReturn<Promise<any>> =>
+              ({
+                body: '{',
+                json: () => {
+                  throw new Error('test');
+                },
+              } as any),
+          }),
+      },
+    });
+
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    expect(instance).toBeDefined();
+
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+
+    expect(result.data).toEqual('{');
+  });
+
+  it('should skip parsing json if shouldSkipJsonParse is true', async () => {
+    const instance = new NestLocalCallStrategy(
+      adapterHost,
+      clsService,
+      // @ts-expect-error isnt needed for test
+      {},
+      '',
+      {
+        shouldSkipJsonParse: (body) => true,
+      },
+    );
+    expect(instance).toBeDefined();
+
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+
+    expect(result.data).toEqual('{}');
+  });
+
+  it('should parse json if shouldSkipJsonParse is false', async () => {
+    const instance = new NestLocalCallStrategy(
+      adapterHost,
+      clsService,
+      // @ts-expect-error isnt needed for test
+      {},
+      '',
+      {
+        shouldSkipJsonParse: (body) => false,
+      },
+    );
+    expect(instance).toBeDefined();
+
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+
+    expect(result.data).toMatchObject({});
+  });
+
+  it('should parse json if shouldSkipJsonParse is undefined', async () => {
+    const instance = new NestLocalCallStrategy(adapterHost, clsService);
+    expect(instance).toBeDefined();
+
+    const result = await instance.call('http://localhost:3000', {
+      method: 'GET',
+    });
+
+    expect(result.data).toMatchObject({});
+  });
+
+  it('should add internal request token header when provided', async () => {
+    const injectSpy = jest.fn().mockResolvedValue({
+      body: '{}',
+      json: () => ({}),
+    });
+    adapterHost = createMock<HttpAdapterHost>({
+      httpAdapter: {
+        getInstance: () =>
+          createMock<FastifyAdapter>({
+            inject: injectSpy as any,
+          }),
+      },
+    });
+
+    const configService = {
+      values: {
+        internalRequestToken: 'test-token-123',
+      },
+    };
+
+    const instance = new NestLocalCallStrategy(
+      adapterHost,
+      clsService,
+      // @ts-expect-error minimal config for test
+      configService,
+      '',
+      {
+        internalRequestHeader: 'x-internal-token',
+      },
+    );
+
+    await instance.call('/test', {
+      method: 'GET',
+    });
+
+    expect(injectSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-internal-token': 'test-token-123',
+        }),
+      }),
+    );
+  });
+
+  it('should not override existing internal request token header', async () => {
+    const injectSpy = jest.fn().mockResolvedValue({
+      body: '{}',
+      json: () => ({}),
+    });
+    adapterHost = createMock<HttpAdapterHost>({
+      httpAdapter: {
+        getInstance: () =>
+          createMock<FastifyAdapter>({
+            inject: injectSpy as any,
+          }),
+      },
+    });
+
+    const configService = {
+      values: {
+        internalRequestToken: 'test-token-123',
+      },
+    };
+
+    const instance = new NestLocalCallStrategy(
+      adapterHost,
+      clsService,
+      // @ts-expect-error minimal config for test
+      configService,
+      '',
+      {
+        internalRequestHeader: 'x-internal-token',
+      },
+    );
+
+    await instance.call('/test', {
+      method: 'GET',
+      headers: {
+        'x-internal-token': 'user-provided-token',
+      },
+    });
+
+    expect(injectSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          'x-internal-token': 'user-provided-token',
+        }),
+      }),
+    );
+  });
+});

package/src/__tests__/nest-local-event.strategy.spec.ts

@@ -0,0 +1,55 @@
+import {
+  expect,
+  jest,
+  describe,
+  it,
+  beforeEach,
+  beforeAll,
+  afterAll,
+  afterEach,
+} from '@jest/globals';
+import { createMock } from '@golevelup/ts-jest';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import {
+  NestLocalEventStrategy,
+  NestLocalEventStrategyProvider,
+} from '../strategies/nest-local-event.strategy.js';
+
+describe('NestLocalEventStrategy', () => {
+  let eventEmitter: EventEmitter2;
+
+  beforeEach(() => {
+    eventEmitter = createMock<EventEmitter2>();
+  });
+
+  it('should be defined', () => {
+    expect(NestLocalEventStrategy).toBeDefined();
+  });
+
+  it('should be instantiable', () => {
+    const instance = new NestLocalEventStrategy(eventEmitter);
+    expect(instance).toBeDefined();
+  });
+
+  it('should call method emit', () => {
+    const instance = new NestLocalEventStrategy(eventEmitter);
+    instance.emit('test', {});
+    expect(eventEmitter.emit).toHaveBeenCalled();
+  });
+
+  it('should call method emit Async', () => {
+    const instance = new NestLocalEventStrategy(eventEmitter);
+    instance.emitAsync('test', {});
+    expect(eventEmitter.emitAsync).toHaveBeenCalled();
+  });
+
+  it('should create a provider', () => {
+    const provider = NestLocalEventStrategyProvider('test');
+    expect(provider).toBeDefined();
+  });
+
+  it('should create a provider and execute the useFactory method', () => {
+    const provider = NestLocalEventStrategyProvider('test');
+    expect(provider.useFactory(eventEmitter)).toBeDefined();
+  });
+});

package/src/__tests__/rabbitmq-event.strategy.spec.ts

@@ -0,0 +1,220 @@
+import { jest, beforeEach, describe, expect, it } from "@jest/globals";
+import { createMock } from "@golevelup/ts-jest";
+import { EventEmitter2 } from "@nestjs/event-emitter";
+import amqp from "amqplib";
+import { RabbitMqEventStrategy, RabbitMqEventStrategyProvider } from "../strategies/rabbitmq-event.strategy.js";
+
+const publish = jest.fn(() => true);
+const assertExchange = jest.fn();
+const channelClose = jest.fn();
+const connectionClose = jest.fn();
+const createChannel = jest.fn();
+const connect = jest.spyOn(amqp, 'connect' as never) as unknown as jest.Mock;
+
+describe("RabbitMqEventStrategy", () => {
+  let eventEmitter: EventEmitter2;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    eventEmitter = createMock<EventEmitter2>({
+      emit: jest.fn(() => true),
+      emitAsync: jest.fn(() => Promise.resolve([])),
+    });
+
+    publish.mockReturnValue(true);
+    assertExchange.mockResolvedValue(undefined as never);
+    channelClose.mockResolvedValue(undefined as never);
+    connectionClose.mockResolvedValue(undefined as never);
+    createChannel.mockResolvedValue({
+      assertExchange,
+      publish,
+      close: channelClose,
+    } as never);
+    connect.mockResolvedValue({
+      createChannel,
+      close: connectionClose,
+    } as never);
+  });
+
+  it("publishes to RabbitMQ asynchronously", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+
+    const result = await strategy.emitAsync("task.created", { id: "task-1" });
+
+    expect(result).toBe(true);
+    expect(eventEmitter.emitAsync).not.toHaveBeenCalled();
+    expect(connect).toHaveBeenCalledWith("amqp://localhost");
+    expect(assertExchange).toHaveBeenCalledWith("test.events", "topic", {
+      durable: true,
+    });
+    expect(publish).toHaveBeenCalledWith(
+      "test.events",
+      "task.created",
+      Buffer.from(JSON.stringify({ id: "task-1" })),
+      {
+        contentType: "application/json",
+        persistent: true,
+      }
+    );
+  });
+
+  it("uses custom broker options and buffer serialization", async () => {
+    const body = Buffer.from("encoded");
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+      exchangeType: "fanout",
+      durable: false,
+      persistent: false,
+      contentType: "application/custom",
+      publishOptions: {
+        expiration: "1000",
+      },
+      serialize: () => body,
+    });
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+
+    expect(assertExchange).toHaveBeenCalledWith("test.events", "fanout", {
+      durable: false,
+    });
+    expect(publish).toHaveBeenCalledWith("test.events", "task.created", body, {
+      contentType: "application/custom",
+      persistent: false,
+      expiration: "1000",
+    });
+  });
+
+  it("reuses the open RabbitMQ channel", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+    await strategy.emitAsync("task.updated", { id: "task-1" });
+
+    expect(connect).toHaveBeenCalledTimes(1);
+    expect(createChannel).toHaveBeenCalledTimes(1);
+    expect(publish).toHaveBeenCalledTimes(2);
+  });
+
+  it("publishes in the background for sync emit", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+
+    const result = strategy.emit("task.created", { id: "task-1" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(result).toBe(true);
+    expect(eventEmitter.emit).not.toHaveBeenCalled();
+    expect(publish).toHaveBeenCalled();
+  });
+
+  it("does not fail sync emit when background publishing fails", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+    connect.mockRejectedValueOnce(new Error("publish failed") as never);
+
+    const result = strategy.emit("task.created", { id: "task-1" });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(result).toBe(true);
+    expect(connect).toHaveBeenCalled();
+  });
+
+  it("closes RabbitMQ resources on module destroy", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+    await strategy.onModuleDestroy();
+
+    expect(channelClose).toHaveBeenCalled();
+    expect(connectionClose).toHaveBeenCalled();
+  });
+
+  it("ignores closing errors on module destroy", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+    channelClose.mockRejectedValue(new Error("already closing") as never);
+    connectionClose.mockRejectedValue(new Error("connection closing") as never);
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+
+    await expect(strategy.onModuleDestroy()).resolves.toBeUndefined();
+  });
+
+  it("ignores synchronous closing errors on module destroy", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+    channelClose.mockImplementationOnce(() => {
+      throw new Error("already closing");
+    });
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+
+    await expect(strategy.onModuleDestroy()).resolves.toBeUndefined();
+  });
+
+  it("throws unexpected close errors on module destroy", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+    channelClose.mockRejectedValue(new Error("boom") as never);
+
+    await strategy.emitAsync("task.created", { id: "task-1" });
+
+    await expect(strategy.onModuleDestroy()).rejects.toThrow("boom");
+  });
+
+  it("does not close RabbitMQ resources before a connection is opened", async () => {
+    const strategy = new RabbitMqEventStrategy({
+      url: "amqp://localhost",
+      exchange: "test.events",
+    });
+
+    await strategy.onModuleDestroy();
+
+    expect(channelClose).not.toHaveBeenCalled();
+    expect(connectionClose).not.toHaveBeenCalled();
+  });
+
+  it("creates a provider", () => {
+    const provider = RabbitMqEventStrategyProvider("test", {
+      options: {
+        url: "amqp://localhost",
+        exchange: "test.events",
+      },
+    });
+
+    expect(provider).toBeDefined();
+    expect(provider.useFactory()).toBeDefined();
+  });
+
+  it("creates a provider with an options factory", () => {
+    const provider = RabbitMqEventStrategyProvider("test", {
+      options: () => ({
+        url: "amqp://localhost",
+        exchange: "test.events",
+      }),
+    });
+
+    expect(provider.useFactory()).toBeDefined();
+  });
+});