@squiz/optimization-utils 2.0.1 → 2.0.3

package/src/date/DateManipulator.ts

@@ -1,29 +0,0 @@
-export type DateManipulator = {
-  addDays(days: number): DateManipulator;
-  addMonths(months: number): DateManipulator;
-  valueOf(): Date;
-};
-
-export function DateManipulator(input: Date): DateManipulator {
-  const addDays = (days: number): DateManipulator => {
-    const copiedDate = new Date(input);
-
-    copiedDate.setDate(copiedDate.getDate() + days);
-
-    return DateManipulator(copiedDate);
-  };
-
-  const addMonths = (months: number): DateManipulator => {
-    const copiedDate = new Date(input);
-
-    copiedDate.setMonth(copiedDate.getMonth() + months);
-
-    return DateManipulator(copiedDate);
-  };
-
-  return {
-    addDays,
-    addMonths,
-    valueOf: () => new Date(input),
-  };
-}

package/src/date/__tests__/DateManipulator.spec.ts

@@ -1,64 +0,0 @@
-import { DateManipulator } from '../DateManipulator';
-
-describe('DateManipulator', () => {
-  describe('addDays', () => {
-    it('should add given days to date', () => {
-      const result = DateManipulator(new Date('2020-01-01T00:00:00.000Z'))
-        .addDays(32)
-        .valueOf();
-
-      expect(result).toEqual(new Date('2020-02-02T00:00:00.000Z'));
-    });
-
-    it('should not change the date if passed 0 days', () => {
-      const result = DateManipulator(new Date('2020-01-01T00:00:00.000Z'))
-        .addDays(0)
-        .valueOf();
-
-      expect(result).toEqual(new Date('2020-01-01T00:00:00.000Z'));
-    });
-
-    it('should not mutate the input date', () => {
-      const originalDate = new Date('2020-01-01T00:00:00.000Z');
-
-      const result = DateManipulator(originalDate).addDays(1).valueOf();
-
-      expect(result).not.toEqual(originalDate);
-    });
-  });
-
-  describe('addMonths', () => {
-    it('should add given days to date', () => {
-      const result = DateManipulator(new Date('2020-01-01T00:00:00.000Z'))
-        .addMonths(12)
-        .valueOf();
-
-      expect(result).toEqual(new Date('2021-01-01T00:00:00.000Z'));
-    });
-
-    it('should not change the date if passed 0 months', () => {
-      const result = DateManipulator(new Date('2020-01-01T00:00:00.000Z'))
-        .addMonths(0)
-        .valueOf();
-
-      expect(result).toEqual(new Date('2020-01-01T00:00:00.000Z'));
-    });
-
-    it('should not mutate the input date', () => {
-      const originalDate = new Date('2020-01-01T00:00:00.000Z');
-
-      const result = DateManipulator(originalDate).addMonths(1).valueOf();
-
-      expect(result).not.toEqual(originalDate);
-    });
-  });
-
-  it('should return combined result', () => {
-    const result = DateManipulator(new Date('2020-01-01T00:00:00.000Z'))
-      .addMonths(12)
-      .addDays(1)
-      .valueOf();
-
-    expect(result).toEqual(new Date('2021-01-02T00:00:00.000Z'));
-  });
-});

package/src/event/AggregateRoot.ts

@@ -1,5 +0,0 @@
-import { DomainEvent } from './DomainEvent';
-
-export interface AggregateRoot {
-  events(): Array<DomainEvent>;
-}

package/src/event/DomainEvent.ts

@@ -1,53 +0,0 @@
-import 'reflect-metadata';
-
-export interface DomainEvent<
-  TData extends Record<string, unknown> = Record<string, unknown>,
-> {
-  readonly eventId: string;
-  readonly name: string;
-  readonly detail: TData;
-  readonly time: Date;
-  readonly version: string;
-  readonly entityId: string;
-}
-
-const DOMAIN_EVENT_SYMBOL = Symbol();
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type DomainEventConstructor = new (...any: Array<any>) => DomainEvent;
-export type DomainEventName = string;
-
-export function getDomainEventType(
-  name: DomainEventName,
-): DomainEventConstructor | undefined {
-  const domainEvents = getDomainMetadata();
-
-  return domainEvents.find((d) => d.name === name);
-}
-
-export function getDomainMetadata(): Array<DomainEventConstructor> {
-  return Reflect.getMetadata(DOMAIN_EVENT_SYMBOL, Object) ?? [];
-}
-
-function setDomainMetadata(domainEvent: DomainEventConstructor): void {
-  const metadata = getDomainMetadata();
-  const isDomainEventExist = getDomainEventType(domainEvent.name);
-
-  if (isDomainEventExist) {
-    throw new Error(
-      `The DomainEvent Name has been used two times: "${domainEvent.name}". Each event name should be uniq`,
-    );
-  }
-
-  Reflect.defineMetadata(
-    DOMAIN_EVENT_SYMBOL,
-    [...metadata, domainEvent],
-    Object,
-  );
-}
-
-export function AsDomainEvent(): ClassDecorator {
-  return (target) => {
-    setDomainMetadata(target as unknown as DomainEventConstructor);
-  };
-}

package/src/event/DynamoDBEventMapper.ts

@@ -1,75 +0,0 @@
-import { DomainEvent, getDomainEventType } from './DomainEvent';
-import { z } from 'zod';
-import { MarshalledResult } from '../typesUtils/DynamoDB';
-import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
-import { AttributeValue } from '@aws-sdk/client-dynamodb';
-import { DateManipulator } from '../date/DateManipulator';
-
-const notEmptyString = z.string().min(1);
-const EVENT_DYNAMO_DB_MODEL_SCHEMA = z.object({
-  eventId: notEmptyString,
-  name: notEmptyString,
-  detail: z.object({}).catchall(z.any()),
-  time: z.string().datetime(),
-  version: notEmptyString,
-  ttl: z.number(),
-  entityId: z.string(),
-});
-
-export type EventDynamoDBModel = z.infer<typeof EVENT_DYNAMO_DB_MODEL_SCHEMA>;
-type EventDynamoMarshalledModel = MarshalledResult<EventDynamoDBModel>;
-
-export const eventToDynamoDB = (
-  event: DomainEvent,
-): EventDynamoMarshalledModel => {
-  const timestampPlus30Days = DateManipulator(event.time)
-    .addDays(30)
-    .valueOf()
-    .getTime();
-
-  const dynamoDBModel: EventDynamoDBModel = {
-    eventId: event.eventId,
-    name: event.name,
-    detail: JSON.parse(JSON.stringify(event.detail)),
-    time: event.time.toISOString(),
-    version: event.version,
-    ttl: timestampPlus30Days / 1000,
-    entityId: event.entityId,
-  };
-
-  return marshall(dynamoDBModel, {
-    removeUndefinedValues: true,
-  }) as EventDynamoMarshalledModel;
-};
-
-export const toEventFromDynamoDb = <TData extends DomainEvent>(
-  dynamoItem: Record<string, AttributeValue>,
-): TData => {
-  const unmarshalled = unmarshall(dynamoItem);
-
-  return toEventFromPlain(unmarshalled);
-};
-
-export const toEventFromPlain = <TData extends DomainEvent>(
-  plainObject: Record<string, unknown>,
-): TData => {
-  const dynamoDBModel = EVENT_DYNAMO_DB_MODEL_SCHEMA.omit({ ttl: true }).parse(
-    plainObject,
-  );
-  const eventType = getDomainEventType(dynamoDBModel.name);
-
-  if (!eventType) {
-    throw new Error(
-      `Cannot map the event "${dynamoDBModel.name}" because does not exist`,
-    );
-  }
-
-  return Object.assign(new eventType({}), {
-    eventId: dynamoDBModel.eventId,
-    detail: dynamoDBModel.detail,
-    time: new Date(dynamoDBModel.time),
-    version: dynamoDBModel.version,
-    name: dynamoDBModel.name,
-    entityId: dynamoDBModel.entityId,
-  }) as TData;
-};

package/src/event/EventHandler.ts

@@ -1,57 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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;
-  readonly entityId: 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;
-    this.entityId = data.entityId;
-  }
-}
-
-const createPlainExampleEvent: () => {
-  eventId: string;
-  name: string;
-  detail: ExampleEventDetail;
-  time: string;
-  version: string;
-  entityId: 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,
-    entityId: 'example-id',
-  };
-};
-
-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,
-        entityId: 'example-id',
-      }),
-    );
-  });
-});
-
-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,
-        entityId: 'example-id',
-      }),
-    );
-  });
-});
-
-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(),
-      entityId: 'example-id',
-    });
-
-    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,
-        entityId: 'example-id',
-      } as EventDynamoDBModel),
-    );
-  });
-});

package/src/exception/DomainException.ts

@@ -1,34 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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);
-  }
-}