@squiz/optimization-utils 2.0.2 → 3.0.0

package/src/cloudflare/__tests__/ImplCloudflareKVHttpService.spec.ts

@@ -1,178 +0,0 @@
-import {
-  CloudflareConfig,
-  ImplCloudflareKVHttpService,
-} from '../ImplCloudflareKVHttpService';
-import { Container } from 'inversify';
-import {
-  createHttpClientMock,
-  HttpRequestBuilderFactory,
-  HttpClient,
-  HttpMethod,
-  HttpRequestOptions,
-  HttpResponse,
-} from '@squiz/optimization-http-client';
-import { Logger, createLoggerMock } from '@squiz/optimization-logger';
-import { faker } from '@faker-js/faker';
-import { z } from 'zod';
-
-describe('CloudflareKVHttpService', () => {
-  const EXAMPLE_SCHEMA = z.object({
-    example: z.string(),
-  });
-
-  type ExampleSchemaType = z.infer<typeof EXAMPLE_SCHEMA>;
-
-  let service: ImplCloudflareKVHttpService<ExampleSchemaType>;
-  let httpClient: HttpClient;
-  const config: CloudflareConfig = {
-    domain: 'test-domain.com',
-    accountId: 'test-account-id',
-    namespace: 'test-namespace-id',
-    apiKey: 'test-api-key',
-  };
-  const expectedHeaders = {
-    'Content-Type': 'application/json',
-    Authorization: `Bearer ${config.apiKey}`,
-  };
-
-  beforeEach(() => {
-    const container = new Container({ defaultScope: 'Singleton' });
-
-    container
-      .bind(ImplCloudflareKVHttpService)
-      .toDynamicValue(({ container: c }) => {
-        return new ImplCloudflareKVHttpService(
-          () => Promise.resolve(config),
-          c.get(HttpRequestBuilderFactory),
-          c.get(Logger),
-          EXAMPLE_SCHEMA,
-        );
-      });
-    container.bind(HttpRequestBuilderFactory).toSelf();
-    container.bind(HttpClient).toConstantValue(createHttpClientMock());
-    container.bind(Logger).toConstantValue(createLoggerMock());
-
-    service = container.get(ImplCloudflareKVHttpService);
-    httpClient = container.get(HttpClient);
-  });
-
-  describe('getValues', () => {
-    const key = 'example-key';
-
-    it('should get values from Cloudflare KV', async () => {
-      const expectedResponse = { example: faker.string.uuid() };
-
-      const expectedURL =
-        'https://test-domain.com/client/v4/accounts' +
-        '/test-account-id/storage/kv/namespaces/test-namespace-id' +
-        `/values/${key}`;
-
-      jest.spyOn(httpClient, 'sendRequest').mockResolvedValueOnce(
-        new HttpResponse({
-          statusCode: 200,
-          body: JSON.stringify(expectedResponse),
-        }),
-      );
-
-      const result = await service.getValues(key);
-
-      expect(result).toEqual(expectedResponse);
-      expect(httpClient.sendRequest).toHaveBeenCalledWith({
-        url: expectedURL,
-        method: HttpMethod.GET,
-        headers: expectedHeaders,
-        handleHttpErrorStatusCodes: [404],
-      } as HttpRequestOptions);
-    });
-
-    it('should throw an error if fetch fails', async () => {
-      jest.spyOn(httpClient, 'sendRequest').mockRejectedValueOnce(new Error());
-
-      await expect(service.getValues(key)).rejects.toThrow();
-    });
-  });
-
-  describe('putBulk', () => {
-    it('should call the put bulk endpoint', async () => {
-      const value: ExampleSchemaType = { example: faker.string.uuid() };
-      const expectedURL =
-        'https://test-domain.com/client/v4/accounts' +
-        '/test-account-id/storage/kv/namespaces/test-namespace-id' +
-        `/bulk`;
-
-      jest
-        .spyOn(httpClient, 'sendRequest')
-        .mockResolvedValueOnce(
-          new HttpResponse({ statusCode: 200, body: undefined }),
-        );
-
-      await service.putBulk([
-        {
-          key: 'someKey',
-          value: value,
-        },
-      ]);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith({
-        url: expectedURL,
-        method: HttpMethod.PUT,
-        headers: expectedHeaders,
-        body: [
-          {
-            key: 'someKey',
-            value: JSON.stringify(value),
-          },
-        ],
-      } as HttpRequestOptions);
-    });
-
-    it('should not call the put bulk endpoint if the batch data array is empty', async () => {
-      await service.putBulk([]);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledTimes(0);
-    });
-
-    it('should throw exception if the items amount exceeds 10_000', async () => {
-      const batch = Array(10_001)
-        .fill('')
-        .map(() => ({
-          key: faker.string.uuid(),
-          value: { example: faker.string.uuid() },
-        }));
-
-      await expect(() => service.putBulk(batch)).rejects.toThrow(
-        'The max items count has been exceeded. The max items count is 10000',
-      );
-    });
-  });
-
-  describe('deleteBulk', () => {
-    it('should call the delete bulk endpoint', async () => {
-      const expectedURL =
-        'https://test-domain.com/client/v4/accounts' +
-        '/test-account-id/storage/kv/namespaces/test-namespace-id' +
-        `/bulk`;
-
-      jest
-        .spyOn(httpClient, 'sendRequest')
-        .mockResolvedValueOnce(
-          new HttpResponse({ statusCode: 200, body: undefined }),
-        );
-
-      await service.deleteBulk(['someKey']);
-
-      expect(httpClient.sendRequest).toHaveBeenCalledWith({
-        url: expectedURL,
-        method: HttpMethod.DELETE,
-        headers: expectedHeaders,
-        body: ['someKey'],
-      } as HttpRequestOptions);
-    });
-  });
-
-  it('should not call the delete bulk endpoint if passed empty keys array', async () => {
-    await service.deleteBulk([]);
-
-    expect(httpClient.sendRequest).toHaveBeenCalledTimes(0);
-  });
-});

package/src/config/ConfigurationLoader.ts

@@ -1,74 +0,0 @@
-import { config } from 'dotenv';
-import * as process from 'process';
-import * as path from 'path';
-import { injectable } from 'inversify';
-import { z, ZodType } from 'zod';
-import {
-  HttpMethod,
-  HttpRequestBuilderFactory,
-} from '@squiz/optimization-http-client';
-
-export abstract class ConfigurationLoader<TSchema extends ZodType> {
-  abstract load(): Promise<z.infer<TSchema>>;
-}
-
-@injectable()
-export class DotEnvConfigurationLoader<TSchema extends ZodType>
-  implements ConfigurationLoader<TSchema>
-{
-  constructor(private readonly schema: TSchema) {}
-
-  async load(): Promise<z.infer<TSchema>> {
-    const output = config({
-      path: path.join(__dirname, '../../../../env/.env'),
-    });
-
-    if (output.error) {
-      throw output.error;
-    }
-
-    return this.schema.parse(process.env);
-  }
-}
-
-export type LambdaLayerAppConfigConfigurationLoaderConfig = {
-  appConfigName: string;
-  env: string;
-  configurationName: string;
-};
-
-@injectable()
-export class LambdaLayerAppConfigConfigurationLoader<TSchema extends ZodType>
-  implements ConfigurationLoader<TSchema>
-{
-  constructor(
-    private readonly opts: LambdaLayerAppConfigConfigurationLoaderConfig,
-    private readonly httpRequestBuilderFactory: HttpRequestBuilderFactory,
-    private readonly schema: TSchema,
-  ) {}
-
-  async load(): Promise<z.infer<TSchema>> {
-    const configuration = await this.fetchFromApi();
-
-    return this.schema.parse(configuration);
-  }
-
-  private async fetchFromApi(): Promise<unknown> {
-    const application = this.opts.appConfigName;
-    const environment = this.opts.env;
-    const configuration = this.opts.configurationName;
-    // the http://localhost:2772 represents the URL to the AWS AppConfig Lambda layer
-    // the documentation: https://docs.aws.amazon.com/appconfig/latest/userguide/appconfig-integration-lambda-extensions.html
-    const url =
-      `http://localhost:2772` +
-      `/applications/${application}/environments/${environment}/configurations/${configuration}`;
-
-    const response = await this.httpRequestBuilderFactory
-      .create()
-      .url(url)
-      .method(HttpMethod.GET)
-      .sendRequest();
-
-    return response.body;
-  }
-}

package/src/config/__tests__/ConfigurationLoader.spec.ts

@@ -1,62 +0,0 @@
-import {
-  ConfigurationLoader,
-  LambdaLayerAppConfigConfigurationLoader,
-  LambdaLayerAppConfigConfigurationLoaderConfig,
-} from '../ConfigurationLoader';
-import {
-  HttpRequestBuilderFactory,
-  HttpClient,
-  HttpMethod,
-  HttpResponse,
-  createHttpClientMock,
-} from '@squiz/optimization-http-client';
-import { faker } from '@faker-js/faker';
-import { z } from 'zod';
-
-describe('LambdaLayerAppConfigConfigurationLoader', () => {
-  const opts: LambdaLayerAppConfigConfigurationLoaderConfig = {
-    env: 'local',
-    appConfigName: 'example-app',
-    configurationName: 'main',
-  };
-  const CONFIG_SCHEMA = z.object({
-    EXAMPLE_VALUE: z.string(),
-  });
-
-  type Config = z.infer<typeof CONFIG_SCHEMA>;
-
-  let configurationLoader: ConfigurationLoader<typeof CONFIG_SCHEMA>;
-  let httpClient: HttpClient;
-
-  beforeEach(() => {
-    httpClient = createHttpClientMock();
-    configurationLoader = new LambdaLayerAppConfigConfigurationLoader<
-      typeof CONFIG_SCHEMA
-    >(opts, new HttpRequestBuilderFactory(httpClient), CONFIG_SCHEMA);
-  });
-
-  it('should call AWS AppConfig Layer with passed arguments', async () => {
-    const expectedResult: Config = {
-      EXAMPLE_VALUE: faker.word.words(),
-    };
-
-    jest.spyOn(httpClient, 'sendRequest').mockResolvedValueOnce(
-      new HttpResponse({
-        body: expectedResult,
-        statusCode: 200,
-      }),
-    );
-
-    const result = await configurationLoader.load();
-
-    const expectedURL =
-      `http://localhost:2772` +
-      `/applications/example-app/environments/local/configurations/main`;
-
-    expect(result).toEqual(expectedResult);
-    expect(httpClient.sendRequest).toHaveBeenCalledWith({
-      url: expectedURL,
-      method: HttpMethod.GET,
-    });
-  });
-});

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,
-    });
-  };
-}