event-store-adapter-js 1.0.2-snapshot.0

package/src/internal/default-serializer.ts

@@ -0,0 +1,50 @@
+import {
+  Aggregate,
+  AggregateId,
+  Event,
+  EventSerializer,
+  SnapshotSerializer,
+} from "../types";
+
+class JsonEventSerializer<AID extends AggregateId, E extends Event<AID>>
+  implements EventSerializer<AID, E>
+{
+  private encoder = new TextEncoder();
+  private decoder = new TextDecoder();
+
+  deserialize(bytes: Uint8Array, converter: (json: string) => E): E {
+    const jsonString = this.decoder.decode(bytes);
+    return converter(jsonString);
+  }
+
+  serialize(event: E): Uint8Array {
+    const jsonString = JSON.stringify({
+      type: event.constructor.name,
+      data: event,
+    });
+    return this.encoder.encode(jsonString);
+  }
+}
+
+class JsonSnapshotSerializer<
+  AID extends AggregateId,
+  A extends Aggregate<A, AID>,
+> implements SnapshotSerializer<AID, A>
+{
+  private encoder = new TextEncoder();
+  private decoder = new TextDecoder();
+  deserialize(bytes: Uint8Array, converter: (json: string) => A): A {
+    const jsonString = this.decoder.decode(bytes);
+    return converter(jsonString);
+  }
+
+  serialize(aggregate: A): Uint8Array {
+    const jsonString = JSON.stringify({
+      type: aggregate.constructor.name,
+      data: aggregate,
+    });
+    return this.encoder.encode(jsonString);
+  }
+}
+
+export { JsonEventSerializer, JsonSnapshotSerializer };

package/src/internal/event-store-for-dynamodb.test.ts

@@ -0,0 +1,142 @@
+import {
+  GenericContainer,
+  StartedTestContainer,
+  TestContainer,
+  Wait,
+} from "testcontainers";
+import { describe } from "node:test";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { EventStoreForDynamoDB } from "./event-store-for-dynamodb";
+import { ulid } from "ulid";
+import { UserAccountId } from "./test/user-account-id";
+import { convertJSONToUserAccount, UserAccount } from "./test/user-account";
+import { UserAccountEvent } from "./test/user-account-event";
+import {
+  createDynamoDBClient,
+  createJournalTable,
+  createSnapshotTable,
+} from "./test/dynamodb-utils";
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+describe("EventStoreForDynamoDB", () => {
+  const TEST_TIME_FACTOR = parseFloat(process.env.TEST_TIME_FACTOR ?? "1.0");
+  const TIMEOUT: number = 10 * 1000 * TEST_TIME_FACTOR;
+  console.log("TIMEOUT = ", TIMEOUT);
+
+  let container: TestContainer;
+  let startedContainer: StartedTestContainer;
+  let eventStore: EventStoreForDynamoDB<
+    UserAccountId,
+    UserAccount,
+    UserAccountEvent
+  >;
+
+  const JOURNAL_TABLE_NAME = "journal";
+  const SNAPSHOT_TABLE_NAME = "snapshot";
+  const JOURNAL_AID_INDEX_NAME = "journal-aid-index";
+  const SNAPSHOTS_AID_INDEX_NAME = "snapshots-aid-index";
+
+  function createEventStore(
+    dynamodbClient: DynamoDBClient,
+  ): EventStoreForDynamoDB<UserAccountId, UserAccount, UserAccountEvent> {
+    return new EventStoreForDynamoDB<
+      UserAccountId,
+      UserAccount,
+      UserAccountEvent
+    >(
+      dynamodbClient,
+      JOURNAL_TABLE_NAME,
+      SNAPSHOT_TABLE_NAME,
+      JOURNAL_AID_INDEX_NAME,
+      SNAPSHOTS_AID_INDEX_NAME,
+      32,
+    );
+  }
+
+  beforeAll(async () => {
+    container = new GenericContainer("localstack/localstack:2.1.0")
+      .withEnvironment({
+        SERVICES: "dynamodb",
+        DEFAULT_REGION: "us-west-1",
+        EAGER_SERVICE_LOADING: "1",
+        DYNAMODB_SHARED_DB: "1",
+        DYNAMODB_IN_MEMORY: "1",
+      })
+      .withWaitStrategy(Wait.forLogMessage("Ready."))
+      .withExposedPorts(4566);
+    startedContainer = await container.start();
+    const dynamodbClient = createDynamoDBClient(startedContainer);
+    await createJournalTable(
+      dynamodbClient,
+      JOURNAL_TABLE_NAME,
+      JOURNAL_AID_INDEX_NAME,
+    );
+    await createSnapshotTable(
+      dynamodbClient,
+      SNAPSHOT_TABLE_NAME,
+      SNAPSHOTS_AID_INDEX_NAME,
+    );
+    eventStore = createEventStore(dynamodbClient);
+  }, TIMEOUT);
+
+  afterAll(async () => {
+    if (startedContainer !== undefined) {
+      await startedContainer.stop();
+    }
+  }, TIMEOUT);
+
+  test(
+    "persistAndSnapshot",
+    async () => {
+      const id = new UserAccountId(ulid());
+      const name = "Alice";
+      const [userAccount1, created] = UserAccount.create(id, name);
+
+      await eventStore.persistEventAndSnapshot(created, userAccount1);
+
+      const userAccount2 = await eventStore.getLatestSnapshotById(
+        id,
+        convertJSONToUserAccount,
+      );
+      if (userAccount2 === undefined) {
+        throw new Error("userAccount2 is undefined");
+      }
+      expect(userAccount2.id).toEqual(id);
+      expect(userAccount2.name).toEqual(name);
+      expect(userAccount2.version).toEqual(1);
+    },
+    TIMEOUT,
+  );
+
+  test(
+    "persistAndSnapshot2",
+    async () => {
+      const id = new UserAccountId(ulid());
+      const name = "Alice";
+      const [userAccount1, created] = UserAccount.create(id, name);
+
+      await eventStore.persistEventAndSnapshot(created, userAccount1);
+
+      const [userAccount2, renamed] = userAccount1.rename("Bob");
+
+      await eventStore.persistEvent(renamed, userAccount2.version);
+
+      const userAccount3 = await eventStore.getLatestSnapshotById(
+        id,
+        convertJSONToUserAccount,
+      );
+      if (userAccount3 === undefined) {
+        throw new Error("userAccount2 is undefined");
+      }
+
+      expect(userAccount3.id).toEqual(id);
+      expect(userAccount3.name).toEqual(name);
+      expect(userAccount3.sequenceNumber).toEqual(1);
+      expect(userAccount3.version).toEqual(2);
+    },
+    TIMEOUT,
+  );
+});

package/src/internal/event-store-for-dynamodb.ts

@@ -0,0 +1,416 @@
+import {
+  Aggregate,
+  AggregateId,
+  Event,
+  EventSerializer,
+  KeyResolver,
+  SnapshotSerializer,
+} from "../types";
+import { EventStore } from "../event-store";
+import {
+  DynamoDBClient,
+  Put,
+  QueryCommand,
+  QueryCommandInput,
+  TransactWriteItemsCommand,
+  TransactWriteItemsInput,
+  Update,
+} from "@aws-sdk/client-dynamodb";
+import * as moment from "moment/moment";
+import { DefaultKeyResolver } from "./default-key-resolver";
+import {
+  JsonEventSerializer,
+  JsonSnapshotSerializer,
+} from "./default-serializer";
+import { LoggerFactory } from "./logger-factory";
+import * as winston from "winston";
+
+class EventStoreForDynamoDB<
+  AID extends AggregateId,
+  A extends Aggregate<A, AID>,
+  E extends Event<AID>,
+> implements EventStore<AID, A, E>
+{
+  static logger: winston.Logger;
+  constructor(
+    private dynamodbClient: DynamoDBClient,
+    private journalTableName: string,
+    private snapshotTableName: string,
+    private journalAidIndexName: string,
+    private snapshotAidIndexName: string,
+    private shardCount: number,
+    private keepSnapshotCount: number | undefined = undefined,
+    private deleteTtl: moment.Duration | undefined = undefined,
+    private keyResolver: KeyResolver<AID> = new DefaultKeyResolver(),
+    private eventSerializer: EventSerializer<AID, E> = new JsonEventSerializer<
+      AID,
+      E
+    >(),
+    private snapshotSerializer: SnapshotSerializer<
+      AID,
+      A
+    > = new JsonSnapshotSerializer<AID, A>(),
+  ) {
+    EventStoreForDynamoDB.logger = LoggerFactory.createLogger(
+      process.env.STAGE ?? "dev",
+    );
+  }
+
+  async getEventsByIdSinceSequenceNumber(
+    id: AID,
+    sequenceNumber: number,
+    converter: (json: string) => E,
+  ): Promise<E[]> {
+    const request: QueryCommandInput = {
+      TableName: this.journalTableName,
+      IndexName: this.journalAidIndexName,
+      KeyConditionExpression: "#aid = :aid AND #seq_nr >= :seq_nr",
+      ExpressionAttributeNames: {
+        "#aid": "aid",
+        "#seq_nr": "seq_nr",
+      },
+      ExpressionAttributeValues: {
+        ":aid": { S: id.asString },
+        ":seq_nr": { N: sequenceNumber.toString() },
+      },
+    };
+    const result = await this.dynamodbClient.send(new QueryCommand(request));
+    if (result.Items === undefined) {
+      return Promise.resolve([]);
+    } else {
+      return Promise.resolve(
+        result.Items.map((item) => {
+          const payload = item.payload.B;
+          if (payload === undefined) {
+            throw new Error("Payload is undefined");
+          }
+          return this.eventSerializer.deserialize(payload, converter);
+        }),
+      );
+    }
+  }
+
+  async getLatestSnapshotById(
+    id: AID,
+    converter: (json: string) => A,
+  ): Promise<A | undefined> {
+    const request: QueryCommandInput = {
+      TableName: this.snapshotTableName,
+      IndexName: this.snapshotAidIndexName,
+      KeyConditionExpression: "#aid = :aid AND #seq_nr = :seq_nr",
+      ExpressionAttributeNames: {
+        "#aid": "aid",
+        "#seq_nr": "seq_nr",
+      },
+      ExpressionAttributeValues: {
+        ":aid": { S: id.asString },
+        ":seq_nr": { N: "0" },
+      },
+      Limit: 1,
+    };
+    const queryResult = await this.dynamodbClient.send(
+      new QueryCommand(request),
+    );
+    if (queryResult.Items === undefined || queryResult.Items.length === 0) {
+      return undefined;
+    } else {
+      const item = queryResult.Items[0];
+      const version = item.version.N;
+      if (version === undefined) {
+        throw new Error("Version is undefined");
+      }
+      const payload = item.payload.B;
+      if (payload === undefined) {
+        throw new Error("Payload is undefined");
+      }
+      const result = this.snapshotSerializer.deserialize(payload, converter);
+      EventStoreForDynamoDB.logger.info("result: " + JSON.stringify(result));
+      return result.withVersion(Number(version));
+    }
+  }
+
+  async persistEvent(event: E, version: number): Promise<void> {
+    EventStoreForDynamoDB.logger.info(
+      `persistEvent(${JSON.stringify(event)}, ${version}): start`,
+    );
+    if (event.isCreated) {
+      throw new Error("Cannot persist created event");
+    }
+    await this.updateEventAndSnapshotOpt(event, version, undefined);
+    EventStoreForDynamoDB.logger.info(
+      `persistEvent(${JSON.stringify(event)}, ${version}): finished`,
+    );
+  }
+
+  async persistEventAndSnapshot(event: E, aggregate: A): Promise<void> {
+    EventStoreForDynamoDB.logger.info(
+      `persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(
+        aggregate,
+      )}): start`,
+    );
+    if (event.isCreated) {
+      await this.createEventAndSnapshot(event, aggregate);
+      EventStoreForDynamoDB.logger.info(
+        `persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(
+          aggregate,
+        )}): finished`,
+      );
+    } else {
+      EventStoreForDynamoDB.logger.info("update!!!");
+      await this.updateEventAndSnapshotOpt(
+        event,
+        aggregate.sequenceNumber,
+        aggregate,
+      );
+      EventStoreForDynamoDB.logger.info(
+        `persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(
+          aggregate,
+        )}): finished`,
+      );
+    }
+  }
+
+  withDeleteTtl(deleteTtl: moment.Duration): EventStore<AID, A, E> {
+    return new EventStoreForDynamoDB(
+      this.dynamodbClient,
+      this.journalTableName,
+      this.snapshotTableName,
+      this.journalAidIndexName,
+      this.snapshotAidIndexName,
+      this.shardCount,
+      this.keepSnapshotCount,
+      deleteTtl,
+      this.keyResolver,
+      this.eventSerializer,
+      this.snapshotSerializer,
+    );
+  }
+
+  withEventSerializer(
+    eventSerializer: EventSerializer<AID, E>,
+  ): EventStore<AID, A, E> {
+    return new EventStoreForDynamoDB(
+      this.dynamodbClient,
+      this.journalTableName,
+      this.snapshotTableName,
+      this.journalAidIndexName,
+      this.snapshotAidIndexName,
+      this.shardCount,
+      this.keepSnapshotCount,
+      this.deleteTtl,
+      this.keyResolver,
+      eventSerializer,
+      this.snapshotSerializer,
+    );
+  }
+
+  withKeepSnapshotCount(keepSnapshotCount: number): EventStore<AID, A, E> {
+    return new EventStoreForDynamoDB(
+      this.dynamodbClient,
+      this.journalTableName,
+      this.snapshotTableName,
+      this.journalAidIndexName,
+      this.snapshotAidIndexName,
+      this.shardCount,
+      keepSnapshotCount,
+      this.deleteTtl,
+      this.keyResolver,
+      this.eventSerializer,
+      this.snapshotSerializer,
+    );
+  }
+
+  withKeyResolver(keyResolver: KeyResolver<AID>): EventStore<AID, A, E> {
+    return new EventStoreForDynamoDB(
+      this.dynamodbClient,
+      this.journalTableName,
+      this.snapshotTableName,
+      this.journalAidIndexName,
+      this.snapshotAidIndexName,
+      this.shardCount,
+      this.keepSnapshotCount,
+      this.deleteTtl,
+      keyResolver,
+      this.eventSerializer,
+      this.snapshotSerializer,
+    );
+  }
+
+  withSnapshotSerializer(
+    snapshotSerializer: SnapshotSerializer<AID, A>,
+  ): EventStore<AID, A, E> {
+    return new EventStoreForDynamoDB(
+      this.dynamodbClient,
+      this.journalTableName,
+      this.snapshotTableName,
+      this.journalAidIndexName,
+      this.snapshotAidIndexName,
+      this.shardCount,
+      this.keepSnapshotCount,
+      this.deleteTtl,
+      this.keyResolver,
+      this.eventSerializer,
+      snapshotSerializer,
+    );
+  }
+
+  private async createEventAndSnapshot(event: E, aggregate: A): Promise<void> {
+    const putSnapshot = this.putSnapshot(event, 0, aggregate);
+    const putJournal = this.putJournal(event);
+    const transactWriteItems = [
+      {
+        Put: putSnapshot,
+      },
+      {
+        Put: putJournal,
+      },
+    ];
+    const input: TransactWriteItemsInput = {
+      TransactItems: transactWriteItems,
+    };
+    await this.dynamodbClient.send(new TransactWriteItemsCommand(input));
+  }
+
+  private async updateEventAndSnapshotOpt(
+    event: E,
+    version: number,
+    aggregate: A | undefined,
+  ): Promise<void> {
+    const update = this.updateSnapshot(event, 0, version, aggregate);
+    const put = this.putJournal(event);
+    const transactWriteItems = [
+      {
+        Update: update,
+      },
+      {
+        Put: put,
+      },
+    ];
+    const input: TransactWriteItemsInput = {
+      TransactItems: transactWriteItems,
+    };
+    await this.dynamodbClient.send(new TransactWriteItemsCommand(input));
+  }
+
+  private putJournal(event: E): Put {
+    const pkey = this.keyResolver.resolvePartitionKey(
+      event.aggregateId,
+      this.shardCount,
+    );
+    const skey = this.keyResolver.resolveSortKey(
+      event.aggregateId,
+      event.sequenceNumber,
+    );
+    const payload = this.eventSerializer.serialize(event);
+    return {
+      TableName: this.journalTableName,
+      Item: {
+        pkey: { S: pkey },
+        skey: { S: skey },
+        aid: { S: event.aggregateId.asString },
+        seq_nr: { N: event.sequenceNumber.toString() },
+        payload: { B: payload },
+        occurred_at: { N: event.occurredAt.getUTCMilliseconds().toString() },
+      },
+      ConditionExpression:
+        "attribute_not_exists(pkey) AND attribute_not_exists(skey)",
+    };
+  }
+
+  private putSnapshot(event: E, sequenceNumber: number, aggregate: A): Put {
+    const pkey = this.keyResolver.resolvePartitionKey(
+      event.aggregateId,
+      this.shardCount,
+    );
+    const skey = this.keyResolver.resolveSortKey(
+      event.aggregateId,
+      sequenceNumber,
+    );
+    const payload = this.snapshotSerializer.serialize(aggregate);
+    return {
+      TableName: this.snapshotTableName,
+      Item: {
+        pkey: { S: pkey },
+        skey: { S: skey },
+        payload: { B: payload },
+        aid: { S: event.aggregateId.asString },
+        seq_nr: { N: sequenceNumber.toString() },
+        version: { N: "1" },
+        ttl: { N: "0" },
+        last_updated_at: {
+          N: event.occurredAt.getUTCMilliseconds().toString(),
+        },
+      },
+      ConditionExpression:
+        "attribute_not_exists(pkey) AND attribute_not_exists(skey)",
+    };
+  }
+
+  private updateSnapshot(
+    event: E,
+    sequenceNumber: number,
+    version: number,
+    aggregate: A | undefined,
+  ): Update {
+    const pkey = this.keyResolver.resolvePartitionKey(
+      event.aggregateId,
+      this.shardCount,
+    );
+    const skey = this.keyResolver.resolveSortKey(
+      event.aggregateId,
+      sequenceNumber,
+    );
+    const keys = {
+      pkey: { S: pkey },
+      skey: { S: skey },
+    };
+    const names = {
+      "#version": "version",
+      "#last_updated_at": "last_updated_at",
+    };
+    const values = {
+      ":before_version": { N: version.toString() },
+      ":after_version": { N: (version + 1).toString() },
+      ":last_updated_at": {
+        N: event.occurredAt.getUTCMilliseconds().toString(),
+      },
+    };
+
+    if (aggregate === undefined) {
+      const update: Update = {
+        TableName: this.snapshotTableName,
+        UpdateExpression:
+          "SET #version=:after_version, #last_updated_at=:last_updated_at",
+        Key: { ...keys },
+        ExpressionAttributeNames: { ...names },
+        ExpressionAttributeValues: { ...values },
+        ConditionExpression: "#version=:before_version",
+      };
+      EventStoreForDynamoDB.logger.info("update1: " + JSON.stringify(update));
+      return update;
+    } else {
+      const payload = this.snapshotSerializer.serialize(aggregate);
+      const update: Update = {
+        TableName: this.snapshotTableName,
+        UpdateExpression:
+          "SET #payload=:payload, #seq_nr=:seq_nr, #version=:after_version, #last_updated_at=:last_updated_at",
+        Key: { ...keys },
+        ExpressionAttributeNames: {
+          ...names,
+          "#seq_nr": "seq_nr",
+          "#payload": "payload",
+        },
+        ExpressionAttributeValues: {
+          ...values,
+          ":seq_nr": { N: sequenceNumber.toString() },
+          ":payload": { B: payload },
+        },
+        ConditionExpression: "#version=:before_version",
+      };
+      EventStoreForDynamoDB.logger.info("update2: " + JSON.stringify(update));
+      return update;
+    }
+  }
+}
+
+export { EventStoreForDynamoDB };

package/src/internal/logger-factory.ts

@@ -0,0 +1,31 @@
+import * as winston from "winston";
+
+export class LoggerFactory {
+  public static createLogger(stage: string = "dev"): winston.Logger {
+    const logger = winston.createLogger({
+      level: "info",
+      format: winston.format.simple(),
+      // format: winston.format.combine(
+      //     winston.format.timestamp({
+      //         format: "YYYY-MM-DD HH:mm:ss"
+      //     }),
+      //     winston.format.errors({ stack: true }),
+      //     winston.format.splat(),
+      //     winston.format.json()
+      // ),
+      defaultMeta: { service: "winston-lambda" },
+      transports: new winston.transports.Console(),
+    });
+    // 検証環境の場合、loggingをdebugレベルまで上げる
+    if (stage !== "prd") {
+      // clear()をする事によって、createLoggerの際に指定したtransportsの設定を消せる
+      logger.clear();
+      logger.add(
+        new winston.transports.Console({
+          level: "debug",
+        }),
+      );
+    }
+    return logger;
+  }
+}