@squiz/optimization-utils 2.0.1 → 2.0.3

package/src/scheduler/EventBridgeScheduler.ts

@@ -1,173 +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 { Logger } from '../logger/Logger';
-import { createLog, LogMessage } from '../logger/LoggerMessage';
-import { marshall } from '@aws-sdk/util-dynamodb';
-
-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,311 +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 } from '../../logger/Logger';
-import {
-  createLoggerMock,
-  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,
-        }),
-      );
-    });
-  });
-});

package/src/testing/mock.ts

@@ -1,62 +0,0 @@
-import { HttpClient } from '../httpClient/HttpClient';
-import { Logger } from '../logger/Logger';
-import { RemoteLogger } from '../logger/RemoteLogger';
-import { SchedulerClient } from '@aws-sdk/client-scheduler';
-import { Scheduler } from '../scheduler/Scheduler';
-
-export type FetchMock = jest.Mock<
-  ReturnType<typeof fetch>,
-  Parameters<typeof fetch>
->;
-
-export const createResponse = <T>(
-  status: number,
-  body?: T,
-  headers?: Record<string, string>,
-): Response =>
-  ({
-    status,
-    ok: status < 400,
-    headers: new Map(Object.entries(headers ?? {})) as unknown as Headers,
-    json: async () => body,
-    text: async () => JSON.stringify(body),
-  }) as Response;
-
-export const createHttpClientMock = (): HttpClient => {
-  return {
-    sendRequest: jest.fn(),
-  };
-};
-
-export const createLoggerMock = (): Logger => {
-  return {
-    debug: jest.fn(),
-    error: jest.fn(),
-    info: jest.fn(),
-    log: jest.fn(),
-    verbose: jest.fn(),
-    warn: jest.fn(),
-  };
-};
-
-export const createRemoteLoggerMock = (): RemoteLogger => {
-  return {
-    log: jest.fn(),
-    info: jest.fn(),
-    warn: jest.fn(),
-    error: jest.fn(),
-  };
-};
-
-export const createSchedulerClientMock = (): SchedulerClient => {
-  return {
-    send: jest.fn(),
-  } as unknown as SchedulerClient;
-};
-
-export const createSchedulerMock = (): Scheduler => {
-  return {
-    schedule: jest.fn(),
-    deleteSchedule: jest.fn(),
-  };
-};

package/src/typesUtils/DynamoDB.ts

@@ -1,17 +0,0 @@
-import { AttributeValue } from '@aws-sdk/client-dynamodb';
-
-export type MarshalledResult<T> = {
-  [K in keyof T]: T[K] extends string
-    ? AttributeValue.SMember
-    : T[K] extends number
-      ? AttributeValue.NMember
-      : T[K] extends Record<string, unknown>
-        ? AttributeValue.MMember
-        : T[K] extends Array<unknown>
-          ? AttributeValue.LMember
-          : T[K] extends boolean
-            ? AttributeValue.BOOLMember
-            : T[K] extends undefined
-              ? Partial<T[K]>
-              : never;
-};

package/src/typesUtils/utilities.ts

@@ -1,11 +0,0 @@
-type MethodKeysOrNever<T> = {
-  [K in keyof T]: T[K] extends Function ? K : never;
-};
-export type MethodKeys<T> = MethodKeysOrNever<T>[keyof T];
-export type ClassFields<T> = Omit<T, Exclude<MethodKeys<T>, undefined>>;
-export type OverwriteValueOf<TInstance, DValueOfReturn> = Omit<
-  TInstance,
-  'valueOf'
-> & {
-  valueOf(): DValueOfReturn;
-};

package/src/validation/handleValidation.ts

@@ -1,13 +0,0 @@
-import { SafeParseReturnType } from 'zod';
-import { ValidationException } from '../exception/DomainException';
-
-export function handleValidation<T, O>(
-  safeParseResult: SafeParseReturnType<T, O>,
-  errorMessage = 'Validation Failed',
-): O {
-  if (!safeParseResult.success) {
-    throw new ValidationException(errorMessage, safeParseResult.error.issues);
-  }
-
-  return safeParseResult.data;
-}

package/src/valueObject/TenantId.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { handleValidation } from '../validation/handleValidation';
-
-export const TENANT_ID_SCHEMA = z.string().min(1);
-
-export type TenantIdValue = z.infer<typeof TENANT_ID_SCHEMA>;
-
-export class TenantId {
-  static parse(data: unknown): TenantId {
-    return new TenantId(
-      handleValidation(
-        TENANT_ID_SCHEMA.safeParse(data),
-        'The validation of tenant id failed',
-      ),
-    );
-  }
-
-  constructor(private readonly value: TenantIdValue) {}
-
-  valueOf(): TenantIdValue {
-    return this.value;
-  }
-
-  equals(tenantId: TenantId): boolean {
-    return this.value === tenantId.value;
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "@tsconfig/node20/tsconfig.json",
-  "compilerOptions": {
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "sourceMap": true,
-    "declaration": true,
-    "outDir": "dist",
-    "baseUrl": "."
-  },
-  "include": ["src"],
-  "exclude": ["dist", "**/*.spec.ts"]
-}