@squiz/optimization-utils 1.0.0

package/src/event/EventHandler.ts

@@ -0,0 +1,57 @@
+import { injectable } from 'inversify';
+import { DomainEvent } from './DomainEvent';
+
+@injectable()
+export abstract class EventHandler<TEvent extends DomainEvent = DomainEvent> {
+  abstract execute(event: TEvent): Promise<void>;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Constructor = new (...args: Array<any>) => any;
+type EventConstructor = Constructor;
+type EventHandlerConstructor = Constructor;
+type EventHandlerMetadata = Array<{
+  eventHandler: EventHandlerConstructor;
+  event: EventConstructor;
+}>;
+
+const EVENT_HANDLER_SYMBOL = Symbol();
+
+export function getEventHandlerMetadata(): EventHandlerMetadata {
+  return Reflect.getMetadata(EVENT_HANDLER_SYMBOL, Object) ?? [];
+}
+
+function setEventHandlerMetadata({
+  event,
+  eventHandler,
+}: {
+  eventHandler: EventHandlerConstructor;
+  event: EventConstructor;
+}): void {
+  const metadata = getEventHandlerMetadata();
+  const handlerExists = metadata.find(
+    (m) => m.eventHandler.name === eventHandler.name,
+  );
+
+  if (handlerExists) {
+    throw new Error(
+      `The EventHandler has been used two times: ${eventHandler.name}. The EventHandler has to have uniq name`,
+    );
+  }
+
+  const newMetadata: EventHandlerMetadata = [
+    ...getEventHandlerMetadata(),
+    { eventHandler, event },
+  ];
+
+  Reflect.defineMetadata(EVENT_HANDLER_SYMBOL, newMetadata, Object);
+}
+
+export function AsEventHandler(event: EventConstructor): ClassDecorator {
+  return (target) => {
+    setEventHandlerMetadata({
+      event,
+      eventHandler: target as unknown as EventHandlerConstructor,
+    });
+  };
+}

package/src/event/__tests__/DynamoDBEventMapper.spec.ts

@@ -0,0 +1,113 @@
+import {
+  EventDynamoDBModel,
+  eventToDynamoDB,
+  toEventFromPlain,
+  toEventFromDynamoDb,
+} from '../DynamoDBEventMapper';
+import { faker } from '@faker-js/faker';
+import { marshall } from '@aws-sdk/util-dynamodb';
+import { TenantIdValue } from '../../valueObject/TenantId';
+import { AsDomainEvent, DomainEvent } from '../DomainEvent';
+
+type ExampleEventDetail = {
+  experimentId: string;
+  tenantId: TenantIdValue;
+};
+
+@AsDomainEvent()
+class ExampleEvent implements DomainEvent<{}> {
+  readonly detail!: ExampleEventDetail;
+  readonly eventId!: string;
+  readonly name!: string;
+  readonly time!: Date;
+  readonly version!: string;
+
+  constructor(data: Omit<ExampleEvent, 'name'>) {
+    this.detail = data.detail;
+    this.eventId = data.eventId;
+    this.name = ExampleEvent.name;
+    this.time = data.time;
+    this.version = data.version;
+  }
+}
+
+const createPlainExampleEvent: () => {
+  eventId: string;
+  name: string;
+  detail: ExampleEventDetail;
+  time: string;
+  version: string;
+} = () => {
+  return {
+    detail: {
+      experimentId: faker.string.uuid(),
+      tenantId: faker.string.uuid(),
+    },
+    eventId: faker.string.uuid(),
+    time: faker.date.past().toISOString(),
+    version: faker.number.int().toString(),
+    name: ExampleEvent.name,
+    ttl: faker.date.past().getTime() / 1000,
+  };
+};
+
+describe('toEventEntityFromDynamoDb', () => {
+  it('should map dynamo item to event instance', () => {
+    const event = createPlainExampleEvent();
+
+    const result = toEventFromDynamoDb<ExampleEvent>(marshall(event));
+
+    expect(result).toEqual(
+      new ExampleEvent({
+        detail: event.detail,
+        eventId: event.eventId,
+        time: new Date(event.time),
+        version: event.version,
+      }),
+    );
+  });
+});
+
+describe('toEventFromPlain', () => {
+  const event = createPlainExampleEvent();
+
+  it('should map the plain object to event instance', () => {
+    const result = toEventFromPlain<ExampleEvent>(event);
+
+    expect(result).toEqual(
+      new ExampleEvent({
+        detail: event.detail,
+        eventId: event.eventId,
+        time: new Date(event.time),
+        version: event.version,
+      }),
+    );
+  });
+});
+
+describe('toDynamoDB', () => {
+  it('should map event entity to dynamo item', () => {
+    const event = new ExampleEvent({
+      detail: {
+        experimentId: faker.string.uuid(),
+        tenantId: faker.string.uuid(),
+      },
+      eventId: faker.string.uuid(),
+      time: new Date('2020-01-01T00:00:00.000Z'),
+      version: faker.number.int().toString(),
+    });
+
+    const result = eventToDynamoDB(event);
+
+    expect(result).toEqual(
+      marshall({
+        detail: event.detail,
+        eventId: event.eventId,
+        time: event.time.toISOString(),
+        version: event.version,
+        name: 'ExampleEvent',
+        ttl: new Date('2020-01-31T00:00:00.000Z').getTime() / 1000,
+      } as EventDynamoDBModel),
+    );
+  });
+});

package/src/exception/DomainException.ts

@@ -0,0 +1,34 @@
+export abstract class DomainException extends Error {
+  protected constructor(message: string) {
+    super(message);
+
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class ValidationException extends DomainException {
+  constructor(
+    readonly message = 'Validation failed',
+    readonly details?: unknown,
+  ) {
+    super(message);
+  }
+}
+
+export class UnprocessableEntityException extends DomainException {
+  constructor(
+    readonly message = 'Unprocessable entity',
+    readonly details?: unknown,
+  ) {
+    super(message);
+  }
+}
+
+export class NotFoundException extends DomainException {
+  constructor(
+    readonly message = 'Not found',
+    readonly details?: unknown,
+  ) {
+    super(message);
+  }
+}

package/src/httpClient/FetchHttpClient.ts

@@ -0,0 +1,92 @@
+import { inject, injectable } from 'inversify';
+import { Logger } from '../logger/Logger';
+import { createLog } from '../logger/LoggerMessage';
+import fetch from 'node-fetch-commonjs';
+import {
+  HttpClient,
+  HttpRequestOptions,
+  HttpResponse,
+} from '../httpClient/HttpClient';
+import { captureHTTPsGlobal } from 'aws-xray-sdk';
+import http from 'http';
+import https from 'https';
+
+captureHTTPsGlobal(https, true);
+captureHTTPsGlobal(http, true);
+
+@injectable()
+export class FetchHttpClient implements HttpClient {
+  constructor(
+    @inject(Logger)
+    private readonly logger: Logger,
+  ) {}
+
+  async sendRequest({
+    headers = {},
+    url,
+    method,
+    body,
+    handleHttpErrorStatusCodes,
+  }: HttpRequestOptions): Promise<HttpResponse> {
+    const logMessage = createLog()
+      .attachMetadata({ url: url.toString() })
+      .attachMetadata({ method })
+      .create(this);
+    const applicationJsonHeader = 'application/json';
+    const isApplicationJson = headers['Content-Type'] === applicationJsonHeader;
+    const requestBody = body && isApplicationJson ? JSON.stringify(body) : body;
+
+    this.logger.debug(...logMessage('started sending http request'));
+    const response = await fetch(url, {
+      headers,
+      method,
+      ...(body && { body: requestBody }),
+    });
+
+    this.logger.debug(...logMessage('finished sending http request'));
+
+    const responseContentType = response.headers.get('Content-Type');
+    const isJsonResponse = responseContentType?.includes(applicationJsonHeader);
+
+    this.logger.debug(
+      ...logMessage(
+        `the response ` +
+          `${isJsonResponse ? 'contains' : 'does not contain'} ` +
+          `the application/json header`,
+      ),
+    );
+    this.logger.debug(...logMessage('available headers in the next log:'));
+    this.logger.debug(...logMessage(response.headers));
+    const responseBodyRawText = await response.text();
+    const responseBody =
+      isJsonResponse && responseBodyRawText
+        ? JSON.parse(responseBodyRawText)
+        : responseBodyRawText;
+    const httpResponse = new HttpResponse({
+      statusCode: response.status,
+      body: responseBody,
+    });
+
+    const shouldBeHandled = handleHttpErrorStatusCodes?.includes(
+      response.status,
+    );
+
+    if (shouldBeHandled) {
+      this.logger.debug(...logMessage('handled NotFound as an empty response'));
+      return httpResponse;
+    }
+
+    if (!response.ok) {
+      this.logger.error(
+        ...logMessage(`http response status: ${response.status}`),
+      );
+      this.logger.debug(...logMessage(`http response body in the next log`));
+      this.logger.debug(...logMessage({ responseBodyRawText }));
+      throw new Error(`Error occurs calling: ${method} ${url}`, {
+        cause: responseBody,
+      });
+    }
+
+    return httpResponse;
+  }
+}

package/src/httpClient/HttpClient.ts

@@ -0,0 +1,46 @@
+import { injectable } from 'inversify';
+import { captureHTTPsGlobal } from 'aws-xray-sdk';
+import { ClassFields } from './../typesUtils/utilities';
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+captureHTTPsGlobal(require('https'));
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+captureHTTPsGlobal(require('http'));
+
+export type HttpRequestOptions = {
+  url: URL | string;
+  method: HttpMethod;
+  body?: string | Record<string, string> | Array<unknown>;
+  headers?: Record<string, string>;
+  handleHttpErrorStatusCodes?: Array<number>;
+};
+
+export enum HttpMethod {
+  GET = 'GET',
+  POST = 'POST',
+  DELETE = 'DELETE',
+  PUT = 'PUT',
+  PATCH = 'PATCH',
+}
+
+export class HttpResponse {
+  readonly statusCode: number;
+  readonly body: unknown;
+
+  constructor(opts: ClassFields<HttpResponse>) {
+    this.statusCode = opts.statusCode;
+    this.body = opts.body;
+  }
+
+  hasHttpStatus(statusCode: number): boolean {
+    return this.statusCode === statusCode;
+  }
+
+  isNotFound(): boolean {
+    return this.hasHttpStatus(404);
+  }
+}
+
+@injectable()
+export abstract class HttpClient {
+  abstract sendRequest(opts: HttpRequestOptions): Promise<HttpResponse>;
+}

package/src/httpClient/HttpRequestBuilder.ts

@@ -0,0 +1,120 @@
+import { injectable } from 'inversify';
+import { HttpClient, HttpRequestOptions, HttpResponse } from './HttpClient';
+
+@injectable()
+export class HttpRequestBuilderFactory {
+  constructor(private readonly httpClient: HttpClient) {}
+
+  create(): Pick<HttpRequestBuilder, 'url'> {
+    return new HttpRequestBuilder({}, this.httpClient);
+  }
+}
+
+export class HttpRequestBuilder {
+  constructor(
+    private opts: Partial<HttpRequestOptions>,
+    private readonly httpClient: HttpClient,
+  ) {}
+
+  url(url: HttpRequestOptions['url']): Pick<HttpRequestBuilder, 'method'> {
+    return this.setOptions({
+      ...this.opts,
+      url,
+    });
+  }
+
+  method(method: HttpRequestOptions['method']): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      method,
+    });
+  }
+
+  headers(headers: HttpRequestOptions['headers']): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        ...headers,
+      },
+    });
+  }
+
+  body(body?: HttpRequestOptions['body']): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      body,
+    });
+  }
+
+  authorizationByBearer(token: string): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        Authorization: `Bearer ${token}`,
+      },
+    });
+  }
+
+  authorizationByXApiKey(apiKey: string): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        'x-api-key': apiKey,
+      },
+    });
+  }
+
+  applicationJson(): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      headers: {
+        ...this.opts.headers,
+        'Content-Type': 'application/json',
+      },
+    });
+  }
+
+  handleNotFound(): HttpRequestBuilder {
+    return this.handleErrorStatusCode(404);
+  }
+
+  handleErrorStatusCode(errorStatusCode: number): HttpRequestBuilder {
+    return this.setOptions({
+      ...this.opts,
+      handleHttpErrorStatusCodes: [
+        ...new Set([
+          ...(this.opts.handleHttpErrorStatusCodes ?? []),
+          errorStatusCode,
+        ]),
+      ],
+    });
+  }
+
+  private setOptions(opts: Partial<HttpRequestOptions>): HttpRequestBuilder {
+    this.opts = opts;
+    return this;
+  }
+
+  sendRequest(): Promise<HttpResponse> {
+    if (!this.opts.url) {
+      throw new Error('The url is not defined');
+    }
+
+    if (!this.opts.method) {
+      throw new Error('The method is not defined');
+    }
+
+    // this is only for typescript information, without extra variable typescript thinks that
+    // the url and method are undefined
+    const options: HttpRequestOptions = {
+      url: this.opts.url,
+      method: this.opts.method,
+      ...this.opts,
+    };
+
+    return this.httpClient.sendRequest(options);
+  }
+}

package/src/httpClient/__tests__/FetchHttpClient.spec.ts

@@ -0,0 +1,146 @@
+import {
+  HttpClient,
+  HttpMethod,
+  HttpRequestOptions,
+  HttpResponse,
+} from '../HttpClient';
+import { Container } from 'inversify';
+import { FetchHttpClient } from '../FetchHttpClient';
+import fetch from 'node-fetch-commonjs';
+import { faker } from '@faker-js/faker';
+import Mock = jest.Mock;
+import { Logger } from '../../logger/Logger';
+import {
+  createLoggerMock,
+  createResponse,
+  FetchMock,
+} from '../../testing/mock';
+
+jest.mock('node-fetch-commonjs');
+
+describe('FetchHttpClient', () => {
+  let httpClient: HttpClient;
+  let mockFetch: FetchMock;
+  let params: HttpRequestOptions;
+
+  beforeEach(() => {
+    const container = new Container();
+
+    container.bind(Logger).toConstantValue(createLoggerMock());
+    container.bind(HttpClient).to(FetchHttpClient);
+    mockFetch = fetch as Mock;
+    mockFetch.mockReset();
+    httpClient = container.get(HttpClient);
+
+    params = {
+      url: faker.internet.url(),
+      body: faker.word.words(),
+      headers: {
+        'example-header': faker.word.words(),
+      },
+      method: faker.helpers.arrayElement(Object.values(HttpMethod)),
+    };
+  });
+
+  describe('passing params to fetch', () => {
+    it('should call the fetch with passed parameters', async () => {
+      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
+
+      await httpClient.sendRequest(params);
+
+      expect(mockFetch).toHaveBeenCalledWith(params.url, {
+        body: params.body,
+        method: params.method,
+        headers: params.headers,
+      });
+    });
+
+    it('should parse request body to JSON if passed Content-Type: application/json', async () => {
+      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
+      const body = { example: faker.word.words() };
+
+      await httpClient.sendRequest({
+        ...params,
+        body,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      expect(mockFetch).toHaveBeenCalledWith(params.url, {
+        body: JSON.stringify(body),
+        method: params.method,
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+    });
+  });
+
+  describe('handling response', () => {
+    it('should return a JSON if the response contains Content-Type: application/json in the response', async () => {
+      const expectedResponse = JSON.stringify({ example: faker.word.words() });
+
+      mockFetch.mockResolvedValueOnce(
+        createResponse(200, expectedResponse, {
+          'Content-Type': 'application/json',
+        }),
+      );
+
+      const response = await httpClient.sendRequest(params);
+
+      expect(response).toEqual(
+        new HttpResponse({
+          statusCode: 200,
+          body: expectedResponse,
+        }),
+      );
+    });
+
+    it('should return text if the response do not contain the Content-Type: application/json in the response', async () => {
+      mockFetch.mockResolvedValueOnce(createResponse(200, {}));
+
+      const response = await httpClient.sendRequest(params);
+
+      expect(response).toEqual({
+        statusCode: 200,
+        body: expect.any(String),
+      });
+    });
+
+    it('should throw exception if the response is not OK', async () => {
+      mockFetch.mockResolvedValueOnce(
+        createResponse(faker.number.int({ min: 400 }), {}),
+      );
+
+      await expect(() => httpClient.sendRequest(params)).rejects.toThrow();
+    });
+  });
+
+  describe('handleHttpErrorStatusCodes', () => {
+    it('should throw exception if the handleHttpErrorStatusCodes does not contain the status code to handle', async () => {
+      mockFetch.mockResolvedValueOnce(createResponse(404, {}));
+
+      await expect(() =>
+        httpClient.sendRequest({
+          ...params,
+          handleHttpErrorStatusCodes: [401],
+        }),
+      ).rejects.toThrow();
+    });
+
+    it('should return response if the handleHttpErrorStatusCodes contains the status code to handle', async () => {
+      mockFetch.mockResolvedValueOnce(createResponse(404, {}));
+
+      const response = await httpClient.sendRequest({
+        ...params,
+        handleHttpErrorStatusCodes: [404],
+      });
+
+      expect(response).toEqual({
+        statusCode: 404,
+        body: expect.anything(),
+      });
+    });
+  });
+});

package/src/httpClient/__tests__/HttpClient.spec.ts

@@ -0,0 +1,52 @@
+import { HttpResponse } from '../HttpClient';
+import { faker } from '@faker-js/faker';
+
+describe('HttpResponse', () => {
+  describe('hasHttpStatus', () => {
+    it('should return true if the statusCode is as expected', () => {
+      const httpResponse = new HttpResponse({
+        statusCode: 200,
+        body: undefined,
+      });
+
+      const result = httpResponse.hasHttpStatus(200);
+
+      expect(result).toBeTruthy();
+    });
+
+    it('should return false if the statusCode is not as expected', () => {
+      const httpResponse = new HttpResponse({
+        statusCode: 200,
+        body: undefined,
+      });
+
+      const result = httpResponse.hasHttpStatus(faker.number.int({ min: 201 }));
+
+      expect(result).toBeFalsy();
+    });
+  });
+
+  describe('isNotFound', () => {
+    it('should return true if the statusCode is 404', () => {
+      const httpResponse = new HttpResponse({
+        statusCode: 404,
+        body: undefined,
+      });
+
+      const result = httpResponse.isNotFound();
+
+      expect(result).toBeTruthy();
+    });
+
+    it('should return false if the statusCode is different than 404', () => {
+      const httpResponse = new HttpResponse({
+        statusCode: 200,
+        body: undefined,
+      });
+
+      const result = httpResponse.isNotFound();
+
+      expect(result).toBeFalsy();
+    });
+  });
+});