@squiz/optimization-utils 2.0.2 → 2.0.3

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 '@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>;
-}