@squiz/optimization-utils 2.0.2 → 3.0.0

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 '@squiz/optimization-value-objects';
-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/index.ts

@@ -1,21 +0,0 @@
-export * from './typesUtils/utilities';
-export * from './typesUtils/DynamoDB';
-
-export * from './testing/mock';
-
-export * from './scheduler/Scheduler';
-export * from './scheduler/EventBridgeScheduler';
-
-export * from './event/DynamoDBEventMapper';
-export * from './event/DomainEvent';
-export * from './event/AggregateRoot';
-
-export * from './date/DateManipulator';
-export * from './event/EventHandler';
-
-export * from './config/ConfigurationLoader';
-
-export * from './cloudflare/ImplCloudflareKVHttpService';
-export * from './cloudflare/CloudflareKVHttpService';
-
-export * from './object/getProperty';

package/src/object/__tests__/getProperty.spec.ts

@@ -1,17 +0,0 @@
-import { getProperty } from '../getProperty';
-
-it('should return a passed property', () => {
-  const object = { a: [{ b: { c: 3 } }] };
-
-  const result = getProperty(object, 'a[0].b.c');
-
-  expect(result).toBe(3);
-});
-
-it('should return undefined if property does not exist', () => {
-  const object = { a: [{ b: { c: 3 } }] };
-
-  const result = getProperty(object, 'a[0].z.c');
-
-  expect(result).toBeUndefined();
-});

package/src/object/getProperty.ts

@@ -1,21 +0,0 @@
-export const getProperty = (
-  obj: Record<string | symbol | number, unknown>,
-  path: string,
-  defaultValue: unknown = undefined,
-): unknown => {
-  const travel = (regexp: RegExp) =>
-    path
-      .split(regexp)
-      .filter(Boolean)
-      .reduce<unknown>(
-        (res, key) =>
-          res !== null && res !== undefined
-            ? (res as Record<string, unknown>)[key]
-            : res,
-        obj,
-      );
-
-  const result = travel(/[,[\]]+?/) || travel(/[,[\].]+?/);
-
-  return result === undefined || result === obj ? defaultValue : result;
-};

package/src/scheduler/EventBridgeScheduler.ts

@@ -1,172 +0,0 @@
-import { injectable } from 'inversify';
-import {
-  CreateScheduleCommand,
-  DeleteScheduleCommand,
-  FlexibleTimeWindowMode,
-  GetScheduleCommand,
-  ResourceNotFoundException,
-  SchedulerClient,
-} from '@aws-sdk/client-scheduler';
-import { DomainEvent } from '../event/DomainEvent';
-import { PutItemCommandInput } from '@aws-sdk/client-dynamodb';
-import { eventToDynamoDB } from '../event/DynamoDBEventMapper';
-import { randomUUID } from 'crypto';
-import { ScheduleName, Scheduler, SchedulerOptions } from './Scheduler';
-import { marshall } from '@aws-sdk/util-dynamodb';
-import { createLog, Logger, LogMessage } from '@squiz/optimization-logger';
-
-export type EventBridgeSchedulerConfig = {
-  region: string;
-  groupName: string;
-  eventTableName: string;
-  schedulerRole: string;
-};
-
-@injectable()
-export class EventBridgeScheduler implements Scheduler {
-  constructor(
-    private readonly config: EventBridgeSchedulerConfig,
-    private readonly client: SchedulerClient,
-    private readonly logger: Logger,
-  ) {}
-
-  async schedule(
-    domainEvent: DomainEvent,
-    options: SchedulerOptions,
-  ): Promise<void> {
-    const logMessage = createLog()
-      .attachEventName(domainEvent.name)
-      .create(this);
-
-    this.logger.debug(...logMessage('started scheduling'));
-    // I putted here "the schedule attributes" because in that way we ensure that every PutItem command
-    // it will create always a new record in dynamoDB
-    const putItemCommand: PutItemCommandInput = {
-      TableName: this.config.eventTableName,
-      Item: {
-        ...eventToDynamoDB(domainEvent),
-        // https://docs.aws.amazon.com/scheduler/latest/UserGuide/managing-schedule-context-attributes.html
-        ...marshall({
-          eventId: '<aws.scheduler.execution-id>',
-          time: '<aws.scheduler.scheduled-time>',
-        }),
-      },
-    };
-
-    this.logger.debug(...logMessage('finished mapping to PutItemCommandInput'));
-
-    const scheduleName = this.createScheduleName(options.name);
-    const scheduleExpression = this.createScheduleExpression(options);
-
-    this.logger.debug(
-      ...logMessage(
-        `started calling AWS Scheduler with ScheduleName: ` +
-          `${scheduleName}, ScheduleExpression: ${scheduleExpression}`,
-      ),
-    );
-    await this._deleteSchedule(scheduleName, logMessage);
-    const command = new CreateScheduleCommand({
-      Name: scheduleName,
-      GroupName: this.config.groupName,
-      ScheduleExpression: scheduleExpression,
-      ScheduleExpressionTimezone: 'UTC',
-      State: 'ENABLED',
-      FlexibleTimeWindow: {
-        Mode: FlexibleTimeWindowMode.OFF,
-      },
-      ActionAfterCompletion: 'DELETE',
-      Target: {
-        Arn: 'arn:aws:scheduler:::aws-sdk:dynamodb:putItem',
-        Input: JSON.stringify(putItemCommand),
-        RoleArn: this.config.schedulerRole,
-      },
-      ClientToken: randomUUID(),
-    });
-
-    await this.client.send(command);
-    this.logger.debug(...logMessage('finished calling AWS Scheduler'));
-  }
-
-  private createScheduleName(scheduleName: ScheduleName): string {
-    const truncateString = (str: string, maxLength: number): string =>
-      str.length > maxLength ? str.substring(0, maxLength) : str;
-    const maxLengthOfScheduleName = 64;
-
-    return truncateString(scheduleName, maxLengthOfScheduleName);
-  }
-
-  private createScheduleExpression(options: SchedulerOptions): string {
-    switch (options.type) {
-      case 'at': {
-        const dateString = options.value.toISOString().replace(/\..*/, '');
-
-        return `at(${dateString})`;
-      }
-
-      case 'cron':
-        return `cron(${options.value})`;
-      case 'rate':
-        return `rate(${options.value} ${options.unit})`;
-      default:
-        throw new Error(`Passed unresolved ScheduleOption type.`);
-    }
-  }
-
-  async deleteSchedule(scheduleName: ScheduleName): Promise<void> {
-    const logMessage = createLog()
-      .attachMetadata({ scheduleName })
-      .create(this);
-
-    return this._deleteSchedule(scheduleName, logMessage);
-  }
-
-  private async _deleteSchedule(
-    scheduleName: ScheduleName,
-    logMessage: LogMessage,
-  ): Promise<void> {
-    const trimmedScheduleName = this.createScheduleName(scheduleName);
-
-    try {
-      this.logger.debug(
-        ...logMessage(
-          `started getting schedule, scheduleName: ${trimmedScheduleName}`,
-        ),
-      );
-
-      const getCommand = new GetScheduleCommand({
-        GroupName: this.config.groupName,
-        Name: trimmedScheduleName,
-      });
-
-      await this.client.send(getCommand);
-
-      this.logger.debug(
-        ...logMessage(
-          `finished getting schedule, scheduleName: ${trimmedScheduleName}`,
-        ),
-      );
-    } catch (e) {
-      if (e instanceof ResourceNotFoundException) {
-        this.logger.debug(
-          ...logMessage(
-            `the schedule does not exist, skipped deleting existing schedule, scheduleName: ${trimmedScheduleName}`,
-          ),
-        );
-        return;
-      }
-
-      throw e;
-    }
-
-    this.logger.debug(...logMessage('started deleting schedule'));
-
-    const deleteCommand = new DeleteScheduleCommand({
-      GroupName: this.config.groupName,
-      Name: trimmedScheduleName,
-    });
-
-    await this.client.send(deleteCommand);
-
-    this.logger.debug(...logMessage('finished deleting schedule'));
-  }
-}

package/src/scheduler/Scheduler.ts

@@ -1,32 +0,0 @@
-import { DomainEvent } from './../event/DomainEvent';
-import { injectable } from 'inversify';
-
-export type CronExpression =
-  `${string} ${string} ${string} ${string} ${string} ${string}`;
-export type RateUnit = 'minutes' | 'hours' | 'days';
-export type ScheduleName = string;
-export type SchedulerOptions = (
-  | {
-      type: 'at';
-      value: Date;
-    }
-  | {
-      type: 'cron';
-      value: CronExpression;
-    }
-  | {
-      type: 'rate';
-      value: number;
-      unit: RateUnit;
-    }
-) & { name: ScheduleName };
-
-@injectable()
-export abstract class Scheduler {
-  abstract schedule(
-    domainEvent: DomainEvent,
-    options: SchedulerOptions,
-  ): Promise<void>;
-
-  abstract deleteSchedule(scheduleName: ScheduleName): Promise<void>;
-}

package/src/scheduler/__tests__/EventBridgeScheduler.spec.ts

@@ -1,308 +0,0 @@
-import { Container } from 'inversify';
-import {
-  CreateScheduleCommand,
-  CreateScheduleCommandInput,
-  DeleteScheduleCommand,
-  DeleteScheduleCommandInput,
-  GetScheduleCommand,
-  GetScheduleCommandInput,
-  ResourceNotFoundException,
-  SchedulerClient,
-} from '@aws-sdk/client-scheduler';
-import { randomUUID } from 'crypto';
-import { faker } from '@faker-js/faker';
-import { ExceptionOptionType } from '@smithy/smithy-client/dist-types/exceptions';
-import { SchedulerServiceException } from '@aws-sdk/client-scheduler/dist-types/models/SchedulerServiceException';
-import { Logger, createLoggerMock } from '@squiz/optimization-logger';
-import { createSchedulerClientMock } from '../../testing/mock';
-import { eventToDynamoDB } from '../../event/DynamoDBEventMapper';
-import { Scheduler } from '../Scheduler';
-import {
-  EventBridgeScheduler,
-  EventBridgeSchedulerConfig,
-} from '../EventBridgeScheduler';
-import { DomainEvent } from '../../event/DomainEvent';
-
-jest.mock('@aws-sdk/client-scheduler', () => {
-  return {
-    ...jest.requireActual('@aws-sdk/client-scheduler'),
-    CreateScheduleCommand: jest.fn(),
-    GetScheduleCommand: jest.fn(),
-    DeleteScheduleCommand: jest.fn(),
-  };
-});
-
-class ExampleEvent implements DomainEvent {
-  readonly detail: Record<string, unknown> = {};
-  readonly eventId: string = randomUUID();
-  readonly name: string = ExampleEvent.name;
-  readonly time: Date = new Date();
-  readonly version: string = '1';
-  readonly entityId = 'uuid';
-}
-
-describe('EventBridgeScheduler', () => {
-  let scheduler: Scheduler;
-  let schedulerClient: SchedulerClient;
-  let event: ExampleEvent;
-  const config: EventBridgeSchedulerConfig = {
-    eventTableName: 'event-table',
-    groupName: 'experiment',
-    region: 'eu-north-1',
-    schedulerRole: 'example-arn',
-  };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-
-    const container = new Container({ defaultScope: 'Singleton' });
-
-    container.bind(Scheduler).toDynamicValue(({ container: c }) => {
-      return new EventBridgeScheduler(
-        config,
-        c.get(SchedulerClient),
-        c.get(Logger),
-      );
-    });
-    container
-      .bind(SchedulerClient)
-      .toConstantValue(createSchedulerClientMock());
-    container.bind(Logger).toConstantValue(createLoggerMock());
-
-    event = new ExampleEvent();
-    schedulerClient = container.get(SchedulerClient);
-    scheduler = container.get(Scheduler);
-  });
-
-  describe('schedule', () => {
-    it('should call the CreateScheduleCommand with the PutItemCommandInput', async () => {
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Target: {
-            Arn: 'arn:aws:scheduler:::aws-sdk:dynamodb:putItem',
-            Input: JSON.stringify({
-              TableName: config.eventTableName,
-              Item: {
-                ...eventToDynamoDB(event),
-                eventId: {
-                  S: '<aws.scheduler.execution-id>',
-                },
-                time: {
-                  S: '<aws.scheduler.scheduled-time>',
-                },
-              },
-            }),
-            RoleArn: config.schedulerRole,
-          },
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "at" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: new Date('2023-01-01T00:00:00.000Z'),
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'at(2023-01-01T00:00:00)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "rate" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'rate',
-        value: 15,
-        unit: 'days',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'rate(15 days)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should schedule with the "cron" schedule expression', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          ScheduleExpression: 'cron(* * * * ? *)',
-          ScheduleExpressionTimezone: 'UTC',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should create a schedule name which includes the event name', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: 'ExampleSchedule',
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: 'ExampleSchedule',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should trim end if the name contains more than 64 characters', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: 'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4Y',
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: 'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4',
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should call CreateScheduleCommand with correct params', async () => {
-      await scheduler.schedule(event, {
-        type: 'cron',
-        value: '* * * * ? *',
-        name: randomUUID(),
-      });
-
-      expect(schedulerClient.send).toHaveBeenCalledWith(
-        expect.any(CreateScheduleCommand),
-      );
-      expect(CreateScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          GroupName: config.groupName,
-          State: 'ENABLED',
-          FlexibleTimeWindow: {
-            Mode: 'OFF',
-          },
-          ActionAfterCompletion: 'DELETE',
-          ClientToken: expect.any(String),
-        } as CreateScheduleCommandInput),
-      );
-    });
-
-    it('should remove the existing schedule if it exists', async () => {
-      const scheduleName = randomUUID();
-
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: scheduleName,
-      });
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as GetScheduleCommandInput);
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as DeleteScheduleCommandInput);
-    });
-  });
-
-  describe('deleteSchedule', () => {
-    it('should delete schedule if it exists', async () => {
-      const scheduleName = 'example-schedule';
-
-      await scheduler.deleteSchedule(scheduleName);
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as GetScheduleCommandInput);
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith({
-        GroupName: config.groupName,
-        Name: scheduleName,
-      } as DeleteScheduleCommandInput);
-    });
-
-    it('should skip deleting schedule if it does not exist', async () => {
-      (schedulerClient.send as jest.Mock).mockRejectedValueOnce(
-        new ResourceNotFoundException(
-          {} as ExceptionOptionType<
-            ResourceNotFoundException,
-            SchedulerServiceException
-          >,
-        ),
-      );
-      const scheduleName = randomUUID();
-
-      await scheduler.schedule(event, {
-        type: 'at',
-        value: faker.date.future(),
-        name: scheduleName,
-      });
-
-      expect(GetScheduleCommand).toHaveBeenCalledTimes(1);
-      expect(DeleteScheduleCommand).toHaveBeenCalledTimes(0);
-    });
-
-    it('should rethrow exception if the GetScheduleCommand return exception other than ResourceNotFound', async () => {
-      (schedulerClient.send as jest.Mock).mockRejectedValueOnce(new Error());
-      const scheduleName = randomUUID();
-
-      await expect(() =>
-        scheduler.deleteSchedule(scheduleName),
-      ).rejects.toThrow();
-    });
-
-    it('should trim the scheduleName up to 64 characters', async () => {
-      const scheduleNameWith65Characters =
-        'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4Y';
-      const expectedScheduleName =
-        'pVlH%46KTS).@KFhaumnG!#>dcZ#FTh=yBwD$rwDz@s41BO5C=?>gr9J.#[)!T^4';
-
-      await scheduler.deleteSchedule(scheduleNameWith65Characters);
-
-      expect(GetScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: expectedScheduleName,
-        }),
-      );
-      expect(DeleteScheduleCommand).toHaveBeenCalledWith(
-        expect.objectContaining({
-          Name: expectedScheduleName,
-        }),
-      );
-    });
-  });
-});