@squiz/optimization-utils 1.0.0

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

@@ -0,0 +1,310 @@
+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';
+}
+
+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

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

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

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

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

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

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