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

package/src/internal/test/dynamodb-utils.ts

@@ -0,0 +1,156 @@
+import {
+  CreateTableCommand,
+  CreateTableCommandInput,
+  DynamoDBClient,
+} from "@aws-sdk/client-dynamodb";
+import { StartedTestContainer } from "testcontainers";
+
+function createDynamoDBClient(startedContainer: StartedTestContainer) {
+  const port = startedContainer.getMappedPort(4566);
+  console.log(`port = ${port}`);
+
+  const dynamodbClient: DynamoDBClient = new DynamoDBClient({
+    region: "us-west-1",
+    endpoint: `http://localhost:${port}`,
+    credentials: {
+      accessKeyId: "x",
+      secretAccessKey: "x",
+    },
+    // logger: console,
+  });
+  return dynamodbClient;
+}
+
+async function createJournalTable(
+  dynamodbClient: DynamoDBClient,
+  tableName: string,
+  indexName: string,
+) {
+  const request: CreateTableCommandInput = {
+    TableName: tableName,
+    AttributeDefinitions: [
+      {
+        AttributeName: "pkey",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "skey",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "aid",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "seq_nr",
+        AttributeType: "N",
+      },
+    ],
+    KeySchema: [
+      {
+        AttributeName: "pkey",
+        KeyType: "HASH",
+      },
+      {
+        AttributeName: "skey",
+        KeyType: "RANGE",
+      },
+    ],
+    GlobalSecondaryIndexes: [
+      {
+        IndexName: indexName,
+        KeySchema: [
+          {
+            AttributeName: "aid",
+            KeyType: "HASH",
+          },
+          {
+            AttributeName: "seq_nr",
+            KeyType: "RANGE",
+          },
+        ],
+        Projection: {
+          ProjectionType: "ALL",
+        },
+        ProvisionedThroughput: {
+          ReadCapacityUnits: 10,
+          WriteCapacityUnits: 5,
+        },
+      },
+    ],
+    ProvisionedThroughput: {
+      ReadCapacityUnits: 10,
+      WriteCapacityUnits: 5,
+    },
+  };
+
+  await dynamodbClient.send(new CreateTableCommand(request));
+}
+
+async function createSnapshotTable(
+  dynamodbClient: DynamoDBClient,
+  tableName: string,
+  indexName: string,
+) {
+  const request: CreateTableCommandInput = {
+    TableName: tableName,
+    AttributeDefinitions: [
+      {
+        AttributeName: "pkey",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "skey",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "aid",
+        AttributeType: "S",
+      },
+      {
+        AttributeName: "seq_nr",
+        AttributeType: "N",
+      },
+    ],
+    KeySchema: [
+      {
+        AttributeName: "pkey",
+        KeyType: "HASH",
+      },
+      {
+        AttributeName: "skey",
+        KeyType: "RANGE",
+      },
+    ],
+    GlobalSecondaryIndexes: [
+      {
+        IndexName: indexName,
+        KeySchema: [
+          {
+            AttributeName: "aid",
+            KeyType: "HASH",
+          },
+          {
+            AttributeName: "seq_nr",
+            KeyType: "RANGE",
+          },
+        ],
+        Projection: {
+          ProjectionType: "ALL",
+        },
+        ProvisionedThroughput: {
+          ReadCapacityUnits: 10,
+          WriteCapacityUnits: 5,
+        },
+      },
+    ],
+    ProvisionedThroughput: {
+      ReadCapacityUnits: 10,
+      WriteCapacityUnits: 5,
+    },
+  };
+
+  await dynamodbClient.send(new CreateTableCommand(request));
+}
+
+export { createDynamoDBClient, createJournalTable, createSnapshotTable };

package/src/internal/test/user-account-event.ts

@@ -0,0 +1,62 @@
+import { Event } from "../../types";
+import { convertJSONToUserAccountId, UserAccountId } from "./user-account-id";
+
+interface UserAccountEvent extends Event<UserAccountId> {}
+
+function convertJSONtoUserAccountEvent(jsonString: string): UserAccountEvent {
+  const obj = JSON.parse(jsonString);
+  console.log("UserAccountEventFromJSON", obj);
+  const aggregateId = convertJSONToUserAccountId(
+    JSON.stringify(obj.data.aggregateId),
+  );
+  switch (obj.type) {
+    case "UserAccountCreated":
+      return new UserAccountCreated(
+        obj.data.id,
+        aggregateId,
+        obj.data.name,
+        obj.data.sequenceNumber,
+        obj.data.occurredAt,
+      );
+    case "UserAccountRenamed":
+      return new UserAccountRenamed(
+        obj.data.id,
+        aggregateId,
+        obj.data.name,
+        obj.data.sequenceNumber,
+        obj.data.occurredAt,
+      );
+    default:
+      throw new Error(`Unknown type: ${obj.type}`);
+  }
+}
+
+class UserAccountCreated implements UserAccountEvent {
+  public readonly isCreated: boolean = true;
+
+  constructor(
+    public readonly id: string,
+    public readonly aggregateId: UserAccountId,
+    public readonly name: string,
+    public readonly sequenceNumber: number,
+    public readonly occurredAt: Date,
+  ) {}
+}
+
+class UserAccountRenamed implements UserAccountEvent {
+  public readonly isCreated: boolean = false;
+  constructor(
+    public readonly id: string,
+    public readonly aggregateId: UserAccountId,
+    public readonly name: string,
+    public readonly sequenceNumber: number,
+    public readonly occurredAt: Date,
+  ) {}
+}
+
+export {
+  UserAccountEvent,
+  UserAccountCreated,
+  UserAccountRenamed,
+  convertJSONtoUserAccountEvent,
+};

package/src/internal/test/user-account-id.ts

@@ -0,0 +1,17 @@
+import { AggregateId } from "../../types";
+
+class UserAccountId implements AggregateId {
+  public readonly typeName = "user-account";
+  constructor(public readonly value: string) {}
+
+  get asString(): string {
+    return `${this.typeName}-${this.value}`;
+  }
+}
+
+function convertJSONToUserAccountId(jsonString: string): UserAccountId {
+  const obj = JSON.parse(jsonString);
+  return new UserAccountId(obj.value);
+}
+
+export { UserAccountId, convertJSONToUserAccountId };

package/src/internal/test/user-account-repository.test.ts

@@ -0,0 +1,119 @@
+import { describe } from "node:test";
+import {
+  GenericContainer,
+  StartedTestContainer,
+  TestContainer,
+  Wait,
+} from "testcontainers";
+import { EventStoreForDynamoDB } from "../event-store-for-dynamodb";
+import { UserAccountId } from "./user-account-id";
+import { UserAccount } from "./user-account";
+import { UserAccountEvent } from "./user-account-event";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  createDynamoDBClient,
+  createJournalTable,
+  createSnapshotTable,
+} from "./dynamodb-utils";
+import { ulid } from "ulid";
+import { UserAccountRepository } from "./user-account-repository";
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+describe("UserAccountRepository", () => {
+  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(
+    "storeAndFindById",
+    async () => {
+      const userAccountRepository = new UserAccountRepository(eventStore);
+
+      const id = new UserAccountId(ulid());
+      const name = "Alice";
+      const [userAccount1, created] = UserAccount.create(id, name);
+
+      await userAccountRepository.storeEventAndSnapshot(created, userAccount1);
+
+      const [userAccount2, renamed] = userAccount1.rename("Bob");
+
+      await userAccountRepository.storeEvent(renamed, userAccount2.version);
+
+      const userAccount3 = await userAccountRepository.findById(id);
+      if (userAccount3 === undefined) {
+        throw new Error("userAccount3 is undefined");
+      }
+
+      expect(userAccount3.id).toEqual(id);
+      expect(userAccount3.name).toEqual("Bob");
+      expect(userAccount3.sequenceNumber).toEqual(2);
+      expect(userAccount3.version).toEqual(2);
+    },
+    TIMEOUT,
+  );
+});

package/src/internal/test/user-account-repository.ts

@@ -0,0 +1,44 @@
+import {
+  UserAccountEvent,
+  convertJSONtoUserAccountEvent,
+} from "./user-account-event";
+import { UserAccountId } from "./user-account-id";
+import { convertJSONToUserAccount, UserAccount } from "./user-account";
+import { EventStore } from "../../event-store";
+
+class UserAccountRepository {
+  constructor(
+    private readonly eventStore: EventStore<
+      UserAccountId,
+      UserAccount,
+      UserAccountEvent
+    >,
+  ) {}
+
+  async storeEvent(event: UserAccountEvent, version: number) {
+    await this.eventStore.persistEvent(event, version);
+  }
+
+  async storeEventAndSnapshot(event: UserAccountEvent, snapshot: UserAccount) {
+    await this.eventStore.persistEventAndSnapshot(event, snapshot);
+  }
+
+  async findById(id: UserAccountId): Promise<UserAccount | undefined> {
+    const snapshot = await this.eventStore.getLatestSnapshotById(
+      id,
+      convertJSONToUserAccount,
+    );
+    if (snapshot === undefined) {
+      return undefined;
+    } else {
+      const events = await this.eventStore.getEventsByIdSinceSequenceNumber(
+        id,
+        snapshot.sequenceNumber + 1,
+        convertJSONtoUserAccountEvent,
+      );
+      return UserAccount.replay(events, snapshot);
+    }
+  }
+}
+
+export { UserAccountRepository };

package/src/internal/test/user-account.ts

@@ -0,0 +1,107 @@
+import { Aggregate } from "../../types";
+import { ulid } from "ulid";
+import { convertJSONToUserAccountId, UserAccountId } from "./user-account-id";
+import {
+  UserAccountCreated,
+  UserAccountEvent,
+  UserAccountRenamed,
+} from "./user-account-event";
+
+class UserAccount implements Aggregate<UserAccount, UserAccountId> {
+  constructor(
+    public readonly id: UserAccountId,
+    public readonly name: string,
+    public readonly sequenceNumber: number,
+    public readonly version: number,
+  ) {}
+
+  incrementSequenceNumber(): UserAccount {
+    return new UserAccount(
+      this.id,
+      this.name,
+      this.sequenceNumber + 1,
+      this.version,
+    );
+  }
+
+  withVersion(version: number): UserAccount {
+    return new UserAccount(this.id, this.name, this.sequenceNumber, version);
+  }
+
+  updateVersion(version: (value: number) => number): UserAccount {
+    return new UserAccount(
+      this.id,
+      this.name,
+      this.sequenceNumber,
+      version(this.version),
+    );
+  }
+
+  rename(name: string): [UserAccount, UserAccountEvent] {
+    const ua = new UserAccount(
+      this.id,
+      name,
+      this.sequenceNumber + 1,
+      this.version,
+    );
+    const eventId = ulid();
+    const event = new UserAccountRenamed(
+      eventId,
+      this.id,
+      name,
+      ua.sequenceNumber,
+      new Date(),
+    );
+    return [ua, event];
+  }
+
+  public static create(
+    id: UserAccountId,
+    name: string,
+  ): [UserAccount, UserAccountEvent] {
+    const ua = new UserAccount(id, name, 0, 1).incrementSequenceNumber();
+    const eventId = ulid();
+    const event = new UserAccountCreated(
+      eventId,
+      id,
+      name,
+      ua.sequenceNumber,
+      new Date(),
+    );
+    return [ua, event];
+  }
+
+  public static replay(
+    events: UserAccountEvent[],
+    snapshot: UserAccount,
+  ): UserAccount {
+    let acc = snapshot;
+    for (const event of events) {
+      acc = acc.applyEvent(event);
+    }
+    return acc;
+  }
+
+  public applyEvent(event: UserAccountEvent): UserAccount {
+    console.log("applyEvent", event);
+    if (event instanceof UserAccountRenamed) {
+      const [result] = this.rename(event.name);
+      return result;
+    } else {
+      throw new Error("Unknown event type");
+    }
+  }
+}
+
+function convertJSONToUserAccount(jsonString: string): UserAccount {
+  const obj = JSON.parse(jsonString);
+  const id = convertJSONToUserAccountId(JSON.stringify(obj.data.id));
+  return new UserAccount(
+    id,
+    obj.data.name,
+    obj.data.sequenceNumber,
+    obj.data.version,
+  );
+}
+
+export { UserAccount, convertJSONToUserAccount };

package/src/types.ts

@@ -0,0 +1,54 @@
+interface AggregateId {
+  typeName: string;
+  value: string;
+  asString: string;
+}
+
+interface Aggregate<
+  This extends Aggregate<This, AID>,
+  AID extends AggregateId,
+> {
+  id: AID;
+  sequenceNumber: number;
+  version: number;
+  withVersion(version: number): This;
+  updateVersion(version: (value: number) => number): This;
+}
+
+interface Event<AID extends AggregateId> {
+  id: string;
+  aggregateId: AID;
+  sequenceNumber: number;
+  occurredAt: Date;
+  isCreated: boolean;
+}
+
+interface KeyResolver<AID extends AggregateId> {
+  resolvePartitionKey(aggregateId: AID, shardCount: number): string;
+
+  resolveSortKey(aggregateId: AID, sequenceNumber: number): string;
+}
+
+interface EventSerializer<AID extends AggregateId, E extends Event<AID>> {
+  serialize(event: E): Uint8Array;
+
+  deserialize(bytes: Uint8Array, converter: (json: string) => E): E;
+}
+
+interface SnapshotSerializer<
+  AID extends AggregateId,
+  A extends Aggregate<A, AID>,
+> {
+  serialize(aggregate: A): Uint8Array;
+
+  deserialize(bytes: Uint8Array, converter: (json: string) => A): A;
+}
+
+export {
+  AggregateId,
+  Aggregate,
+  Event,
+  KeyResolver,
+  EventSerializer,
+  SnapshotSerializer,
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "module": "CommonJS",
+    "target": "es6",
+    "moduleResolution": "Node",
+    "lib": ["ESNext"],
+    "types": ["node", "jest"],
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/version

@@ -0,0 +1 @@
+1.0.0-SNAPSHOT