event-store-adapter-js 1.1.99-snapshot.1 → 2.0.0

package/README.ja.md

@@ -41,7 +41,6 @@ class UserAccountRepository {
     async findById(id: UserAccountId): Promise<UserAccount | undefined> {
         const snapshot = await this.eventStore.getLatestSnapshotById(
             id,
-            convertJSONToUserAccount,
         );
         if (snapshot === undefined) {
             return undefined;
@@ -49,7 +48,6 @@ class UserAccountRepository {
             const events = await this.eventStore.getEventsByIdSinceSequenceNumber(
                 id,
                 snapshot.sequenceNumber + 1,
-                convertJSONtoUserAccountEvent,
             );
             return UserAccount.replay(events, snapshot);
         }
@@ -71,6 +69,8 @@ const eventStore = EventStoreFactory.ofDynamoDB<
     JOURNAL_AID_INDEX_NAME,
     SNAPSHOTS_AID_INDEX_NAME,
     32,
+    convertJSONtoUserAccountEvent,
+    convertJSONToUserAccount,
 );
 const userAccountRepository = new UserAccountRepository(eventStore);
 

package/README.md

@@ -71,6 +71,8 @@ const eventStore = EventStoreFactory.ofDynamoDB<
     JOURNAL_AID_INDEX_NAME,
     SNAPSHOTS_AID_INDEX_NAME,
     32,
+    convertJSONtoUserAccountEvent,
+    convertJSONToUserAccount,
 );
 const userAccountRepository = new UserAccountRepository(eventStore);
 

package/dist/event-store-with-options.d.ts

@@ -0,0 +1,6 @@
+import { Aggregate, AggregateId, Event } from "./types";
+import { EventStoreOptions } from "./event-store-options";
+import { EventStore } from "./event-store";
+interface EventStoreWithOptions<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> extends EventStore<AID, A, E>, EventStoreOptions<EventStoreWithOptions<AID, A, E>, AID, A, E> {
+}
+export { EventStoreWithOptions };

package/dist/event-store-with-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/event-store.d.ts

@@ -1,15 +1,15 @@
 import { Aggregate, AggregateId, Event, EventSerializer, KeyResolver, SnapshotSerializer } from "./types";
-import { EventStoreOptions } from "./event-store-options";
-import { EventStoreForDynamoDB } from "./internal/event-store-for-dynamodb";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import moment from "moment";
-interface EventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> extends EventStoreOptions<EventStore<AID, A, E>, AID, A, E> {
+import { EventStoreWithOptions } from "./event-store-with-options";
+interface EventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> {
     persistEvent(event: E, version: number): Promise<void>;
     persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
-    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number, converter: (json: string) => E): Promise<E[]>;
-    getLatestSnapshotById(id: AID, converter: (json: string) => A): Promise<A | undefined>;
+    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number): Promise<E[]>;
+    getLatestSnapshotById(id: AID): Promise<A | undefined>;
 }
 declare class EventStoreFactory {
-    static ofDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(dynamodbClient: DynamoDBClient, journalTableName: string, snapshotTableName: string, journalAidIndexName: string, snapshotAidIndexName: string, shardCount: number, keepSnapshotCount?: number | undefined, deleteTtl?: moment.Duration | undefined, keyResolver?: KeyResolver<AID>, eventSerializer?: EventSerializer<AID, E>, snapshotSerializer?: SnapshotSerializer<AID, A>): EventStoreForDynamoDB<AID, A, E>;
+    static ofDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(dynamodbClient: DynamoDBClient, journalTableName: string, snapshotTableName: string, journalAidIndexName: string, snapshotAidIndexName: string, shardCount: number, eventConverter: (json: string) => E, snapshotConverter: (json: string) => A, keepSnapshotCount?: number | undefined, deleteTtl?: moment.Duration | undefined, keyResolver?: KeyResolver<AID>, eventSerializer?: EventSerializer<AID, E>, snapshotSerializer?: SnapshotSerializer<AID, A>): EventStoreWithOptions<AID, A, E>;
+    static ofMemory<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(events: Map<AID, E[]>, snapshots: Map<AID, A>): EventStore<AID, A, E>;
 }
 export { EventStore, EventStoreFactory };

package/dist/event-store.js

@@ -4,9 +4,13 @@ exports.EventStoreFactory = void 0;
 const event_store_for_dynamodb_1 = require("./internal/event-store-for-dynamodb");
 const default_key_resolver_1 = require("./internal/default-key-resolver");
 const default_serializer_1 = require("./internal/default-serializer");
+const event_store_for_memory_1 = require("./internal/event-store-for-memory");
 class EventStoreFactory {
-    static ofDynamoDB(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, keepSnapshotCount = undefined, deleteTtl = undefined, keyResolver = new default_key_resolver_1.DefaultKeyResolver(), eventSerializer = new default_serializer_1.JsonEventSerializer(), snapshotSerializer = new default_serializer_1.JsonSnapshotSerializer()) {
-        return new event_store_for_dynamodb_1.EventStoreForDynamoDB(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, keepSnapshotCount, deleteTtl, keyResolver, eventSerializer, snapshotSerializer);
+    static ofDynamoDB(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, eventConverter, snapshotConverter, keepSnapshotCount = undefined, deleteTtl = undefined, keyResolver = new default_key_resolver_1.DefaultKeyResolver(), eventSerializer = new default_serializer_1.JsonEventSerializer(), snapshotSerializer = new default_serializer_1.JsonSnapshotSerializer()) {
+        return new event_store_for_dynamodb_1.EventStoreForDynamoDB(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, eventConverter, snapshotConverter, keepSnapshotCount, deleteTtl, keyResolver, eventSerializer, snapshotSerializer);
+    }
+    static ofMemory(events, snapshots) {
+        return new event_store_for_memory_1.EventStoreForMemory(events, snapshots);
     }
 }
 exports.EventStoreFactory = EventStoreFactory;

package/dist/internal/event-store-for-dynamodb.d.ts

@@ -1,30 +1,32 @@
 import { Aggregate, AggregateId, Event, EventSerializer, KeyResolver, Logger, SnapshotSerializer } from "../types";
-import { EventStore } from "../event-store";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import moment from "moment/moment";
-declare class EventStoreForDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> implements EventStore<AID, A, E> {
+import { EventStoreWithOptions } from "../event-store-with-options";
+declare class EventStoreForDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> implements EventStoreWithOptions<AID, A, E> {
     private dynamodbClient;
     private journalTableName;
     private snapshotTableName;
     private journalAidIndexName;
     private snapshotAidIndexName;
     private shardCount;
+    private eventConverter;
+    private snapshotConverter;
     private keepSnapshotCount;
     private deleteTtl;
     private keyResolver;
     private eventSerializer;
     private snapshotSerializer;
     private logger;
-    constructor(dynamodbClient: DynamoDBClient, journalTableName: string, snapshotTableName: string, journalAidIndexName: string, snapshotAidIndexName: string, shardCount: number, keepSnapshotCount?: number | undefined, deleteTtl?: moment.Duration | undefined, keyResolver?: KeyResolver<AID>, eventSerializer?: EventSerializer<AID, E>, snapshotSerializer?: SnapshotSerializer<AID, A>, logger?: Logger | undefined);
-    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number, converter: (json: string) => E): Promise<E[]>;
-    getLatestSnapshotById(id: AID, converter: (json: string) => A): Promise<A | undefined>;
+    constructor(dynamodbClient: DynamoDBClient, journalTableName: string, snapshotTableName: string, journalAidIndexName: string, snapshotAidIndexName: string, shardCount: number, eventConverter: (json: string) => E, snapshotConverter: (json: string) => A, keepSnapshotCount?: number | undefined, deleteTtl?: moment.Duration | undefined, keyResolver?: KeyResolver<AID>, eventSerializer?: EventSerializer<AID, E>, snapshotSerializer?: SnapshotSerializer<AID, A>, logger?: Logger | undefined);
+    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number): Promise<E[]>;
+    getLatestSnapshotById(id: AID): Promise<A | undefined>;
     persistEvent(event: E, version: number): Promise<void>;
     persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
-    withDeleteTtl(deleteTtl: moment.Duration): EventStore<AID, A, E>;
-    withEventSerializer(eventSerializer: EventSerializer<AID, E>): EventStore<AID, A, E>;
-    withKeepSnapshotCount(keepSnapshotCount: number): EventStore<AID, A, E>;
-    withKeyResolver(keyResolver: KeyResolver<AID>): EventStore<AID, A, E>;
-    withSnapshotSerializer(snapshotSerializer: SnapshotSerializer<AID, A>): EventStore<AID, A, E>;
+    withDeleteTtl(deleteTtl: moment.Duration): EventStoreWithOptions<AID, A, E>;
+    withEventSerializer(eventSerializer: EventSerializer<AID, E>): EventStoreWithOptions<AID, A, E>;
+    withKeepSnapshotCount(keepSnapshotCount: number): EventStoreWithOptions<AID, A, E>;
+    withKeyResolver(keyResolver: KeyResolver<AID>): EventStoreWithOptions<AID, A, E>;
+    withSnapshotSerializer(snapshotSerializer: SnapshotSerializer<AID, A>): EventStoreWithOptions<AID, A, E>;
     private createEventAndSnapshot;
     private updateEventAndSnapshotOpt;
     private putJournal;

package/dist/internal/event-store-for-dynamodb.js

@@ -18,13 +18,15 @@ const moment_1 = __importDefault(require("moment/moment"));
 const default_key_resolver_1 = require("./default-key-resolver");
 const default_serializer_1 = require("./default-serializer");
 class EventStoreForDynamoDB {
-    constructor(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, keepSnapshotCount = undefined, deleteTtl = undefined, keyResolver = new default_key_resolver_1.DefaultKeyResolver(), eventSerializer = new default_serializer_1.JsonEventSerializer(), snapshotSerializer = new default_serializer_1.JsonSnapshotSerializer(), logger = undefined) {
+    constructor(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, eventConverter, snapshotConverter, keepSnapshotCount = undefined, deleteTtl = undefined, keyResolver = new default_key_resolver_1.DefaultKeyResolver(), eventSerializer = new default_serializer_1.JsonEventSerializer(), snapshotSerializer = new default_serializer_1.JsonSnapshotSerializer(), logger = undefined) {
         this.dynamodbClient = dynamodbClient;
         this.journalTableName = journalTableName;
         this.snapshotTableName = snapshotTableName;
         this.journalAidIndexName = journalAidIndexName;
         this.snapshotAidIndexName = snapshotAidIndexName;
         this.shardCount = shardCount;
+        this.eventConverter = eventConverter;
+        this.snapshotConverter = snapshotConverter;
         this.keepSnapshotCount = keepSnapshotCount;
         this.deleteTtl = deleteTtl;
         this.keyResolver = keyResolver;
@@ -32,7 +34,7 @@ class EventStoreForDynamoDB {
         this.snapshotSerializer = snapshotSerializer;
         this.logger = logger;
     }
-    getEventsByIdSinceSequenceNumber(id, sequenceNumber, converter) {
+    getEventsByIdSinceSequenceNumber(id, sequenceNumber) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`getEventsByIdSinceSequenceNumber(${JSON.stringify(id)}, ${sequenceNumber}, ...): start`);
@@ -60,14 +62,14 @@ class EventStoreForDynamoDB {
                     if (payload === undefined) {
                         throw new Error("Payload is undefined");
                     }
-                    return this.eventSerializer.deserialize(payload, converter);
+                    return this.eventSerializer.deserialize(payload, this.eventConverter);
                 });
             }
             (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`getEventsByIdSinceSequenceNumber(${JSON.stringify(id)}, ${sequenceNumber}, ...): finished`);
             return result;
         });
     }
-    getLatestSnapshotById(id, converter) {
+    getLatestSnapshotById(id) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`getLatestSnapshotById(${JSON.stringify(id)}, ...): start`);
@@ -99,7 +101,7 @@ class EventStoreForDynamoDB {
                 if (payload === undefined) {
                     throw new Error("Payload is undefined");
                 }
-                const result = this.snapshotSerializer.deserialize(payload, converter);
+                const result = this.snapshotSerializer.deserialize(payload, this.snapshotConverter);
                 (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`getLatestSnapshotById(${JSON.stringify(id)}, ...): finished`);
                 return result.withVersion(Number(version));
             }
@@ -120,6 +122,9 @@ class EventStoreForDynamoDB {
     persistEventAndSnapshot(event, aggregate) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
+            if (event.aggregateId.asString !== aggregate.id.asString) {
+                throw new Error(`aggregateId mismatch: expected ${event.aggregateId.asString}, got ${aggregate.id.asString}`);
+            }
             (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(aggregate)}): start`);
             if (event.isCreated) {
                 yield this.createEventAndSnapshot(event, aggregate);
@@ -132,19 +137,19 @@ class EventStoreForDynamoDB {
         });
     }
     withDeleteTtl(deleteTtl) {
-        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.keepSnapshotCount, deleteTtl, this.keyResolver, this.eventSerializer, this.snapshotSerializer);
+        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.eventConverter, this.snapshotConverter, this.keepSnapshotCount, deleteTtl, this.keyResolver, this.eventSerializer, this.snapshotSerializer);
     }
     withEventSerializer(eventSerializer) {
-        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.keepSnapshotCount, this.deleteTtl, this.keyResolver, eventSerializer, this.snapshotSerializer);
+        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.eventConverter, this.snapshotConverter, this.keepSnapshotCount, this.deleteTtl, this.keyResolver, eventSerializer, this.snapshotSerializer);
     }
     withKeepSnapshotCount(keepSnapshotCount) {
-        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, keepSnapshotCount, this.deleteTtl, this.keyResolver, this.eventSerializer, this.snapshotSerializer);
+        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.eventConverter, this.snapshotConverter, keepSnapshotCount, this.deleteTtl, this.keyResolver, this.eventSerializer, this.snapshotSerializer);
     }
     withKeyResolver(keyResolver) {
-        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.keepSnapshotCount, this.deleteTtl, keyResolver, this.eventSerializer, this.snapshotSerializer);
+        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.eventConverter, this.snapshotConverter, this.keepSnapshotCount, this.deleteTtl, keyResolver, this.eventSerializer, this.snapshotSerializer);
     }
     withSnapshotSerializer(snapshotSerializer) {
-        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.keepSnapshotCount, this.deleteTtl, this.keyResolver, this.eventSerializer, snapshotSerializer);
+        return new EventStoreForDynamoDB(this.dynamodbClient, this.journalTableName, this.snapshotTableName, this.journalAidIndexName, this.snapshotAidIndexName, this.shardCount, this.eventConverter, this.snapshotConverter, this.keepSnapshotCount, this.deleteTtl, this.keyResolver, this.eventSerializer, snapshotSerializer);
     }
     createEventAndSnapshot(event, aggregate) {
         var _a, _b;
@@ -379,7 +384,9 @@ class EventStoreForDynamoDB {
                                 ":ttl": { N: ttl.seconds().toString() },
                             },
                         };
-                        return this.dynamodbClient.send(new client_dynamodb_1.UpdateItemCommand(request));
+                        return this.dynamodbClient
+                            .send(new client_dynamodb_1.UpdateItemCommand(request))
+                            .then((_) => { });
                     });
                     return yield Promise.all(result);
                 }
@@ -401,7 +408,7 @@ class EventStoreForDynamoDB {
                     if (keys === undefined) {
                         return undefined;
                     }
-                    const result = keys.map((key) => {
+                    const request = keys.map((key) => {
                         const request = {
                             DeleteRequest: {
                                 Key: {
@@ -410,13 +417,15 @@ class EventStoreForDynamoDB {
                                 },
                             },
                         };
-                        return this.dynamodbClient.send(new client_dynamodb_1.BatchWriteItemCommand({
-                            RequestItems: {
-                                [this.snapshotTableName]: [request],
-                            },
-                        }));
+                        return request;
                     });
-                    return yield Promise.all(result);
+                    return this.dynamodbClient
+                        .send(new client_dynamodb_1.BatchWriteItemCommand({
+                        RequestItems: {
+                            [this.snapshotTableName]: request,
+                        },
+                    }))
+                        .then((_) => { });
                 }
             }
             return undefined;

package/dist/internal/event-store-for-memory.d.ts

@@ -0,0 +1,12 @@
+import { Aggregate, AggregateId, Event } from "../types";
+import { EventStore } from "../event-store";
+declare class EventStoreForMemory<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> implements EventStore<AID, A, E> {
+    private readonly events;
+    private readonly snapshots;
+    constructor(events: Map<AID, E[]>, snapshots: Map<AID, A>);
+    persistEvent(event: E, version: number): Promise<void>;
+    persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
+    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number): Promise<E[]>;
+    getLatestSnapshotById(id: AID): Promise<A | undefined>;
+}
+export { EventStoreForMemory };

package/dist/internal/event-store-for-memory.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStoreForMemory = void 0;
+class EventStoreForMemory {
+    constructor(events, snapshots) {
+        this.events = new Map(Array.from(events).map(([key, values]) => {
+            return [key.asString, values];
+        }));
+        this.snapshots = new Map(Array.from(snapshots).map(([key, value]) => {
+            return [key.asString, value];
+        }));
+    }
+    persistEvent(event, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (event.isCreated) {
+                throw new Error("event is created");
+            }
+            const aggregateIdString = event.aggregateId.asString;
+            const snapshot = this.snapshots.get(aggregateIdString);
+            if (snapshot === undefined) {
+                throw new Error("snapshot is undefined");
+            }
+            if (snapshot.id.asString !== event.aggregateId.asString) {
+                throw new Error("aggregateId mismatch: snapshot.id = " +
+                    snapshot.id.asString +
+                    ", event.aggregateId = " +
+                    event.aggregateId.asString);
+            }
+            if (snapshot.version !== version) {
+                throw new Error("version mismatch");
+            }
+            const events = this.events.get(aggregateIdString);
+            if (events === undefined) {
+                throw new Error("events is undefined");
+            }
+            events.push(event);
+            this.events.set(aggregateIdString, events);
+            const newVersion = snapshot.version + 1;
+            const newSnapshot = snapshot.withVersion(newVersion);
+            this.snapshots.set(aggregateIdString, newSnapshot);
+        });
+    }
+    persistEventAndSnapshot(event, aggregate) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (event.aggregateId.asString !== aggregate.id.asString) {
+                throw new Error(`aggregateId mismatch: expected ${event.aggregateId.asString}, got ${aggregate.id.asString}`);
+            }
+            const aggregateIdString = event.aggregateId.asString;
+            const events = (_a = this.events.get(aggregateIdString)) !== null && _a !== void 0 ? _a : [];
+            const snapshot = (_b = this.snapshots.get(aggregateIdString)) !== null && _b !== void 0 ? _b : aggregate;
+            let newVersion = 1;
+            if (!event.isCreated) {
+                const version = snapshot.version;
+                if (version !== aggregate.version) {
+                    throw new Error("version mismatch");
+                }
+                newVersion = snapshot.version + 1;
+            }
+            events.push(event);
+            this.events.set(aggregateIdString, events);
+            const newSnapshot = snapshot.withVersion(newVersion);
+            this.snapshots.set(aggregateIdString, newSnapshot);
+        });
+    }
+    getEventsByIdSinceSequenceNumber(id, sequenceNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aggregateIdString = id.asString;
+            const events = this.events.get(aggregateIdString);
+            if (events === undefined) {
+                throw new Error("events is undefined");
+            }
+            return events.filter((event) => event.sequenceNumber >= sequenceNumber);
+        });
+    }
+    getLatestSnapshotById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aggregateIdString = id.asString;
+            return this.snapshots.get(aggregateIdString);
+        });
+    }
+}
+exports.EventStoreForMemory = EventStoreForMemory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "event-store-adapter-js",
-  "version": "1.1.99-snapshot.1",
+  "version": "2.0.0",
   "description": "This library is designed to turn DynamoDB into an Event Store for Event Sourcing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/event-store-with-options.ts

@@ -0,0 +1,12 @@
+import { Aggregate, AggregateId, Event } from "./types";
+import { EventStoreOptions } from "./event-store-options";
+import { EventStore } from "./event-store";
+
+interface EventStoreWithOptions<
+  AID extends AggregateId,
+  A extends Aggregate<A, AID>,
+  E extends Event<AID>,
+> extends EventStore<AID, A, E>,
+    EventStoreOptions<EventStoreWithOptions<AID, A, E>, AID, A, E> {}
+
+export { EventStoreWithOptions };

package/src/event-store.ts

@@ -6,7 +6,6 @@ import {
   KeyResolver,
   SnapshotSerializer,
 } from "./types";
-import { EventStoreOptions } from "./event-store-options";
 import { EventStoreForDynamoDB } from "./internal/event-store-for-dynamodb";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import moment from "moment";
@@ -15,23 +14,21 @@ import {
   JsonEventSerializer,
   JsonSnapshotSerializer,
 } from "./internal/default-serializer";
+import { EventStoreForMemory } from "./internal/event-store-for-memory";
+import { EventStoreWithOptions } from "./event-store-with-options";
 
 interface EventStore<
   AID extends AggregateId,
   A extends Aggregate<A, AID>,
   E extends Event<AID>,
-> extends EventStoreOptions<EventStore<AID, A, E>, AID, A, E> {
+> {
   persistEvent(event: E, version: number): Promise<void>;
   persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
   getEventsByIdSinceSequenceNumber(
     id: AID,
     sequenceNumber: number,
-    converter: (json: string) => E,
   ): Promise<E[]>;
-  getLatestSnapshotById(
-    id: AID,
-    converter: (json: string) => A,
-  ): Promise<A | undefined>;
+  getLatestSnapshotById(id: AID): Promise<A | undefined>;
 }
 
 class EventStoreFactory {
@@ -46,6 +43,8 @@ class EventStoreFactory {
     journalAidIndexName: string,
     snapshotAidIndexName: string,
     shardCount: number,
+    eventConverter: (json: string) => E,
+    snapshotConverter: (json: string) => A,
     keepSnapshotCount: number | undefined = undefined,
     deleteTtl: moment.Duration | undefined = undefined,
     keyResolver: KeyResolver<AID> = new DefaultKeyResolver(),
@@ -57,7 +56,7 @@ class EventStoreFactory {
       AID,
       A
     >(),
-  ) {
+  ): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB<AID, A, E>(
       dynamodbClient,
       journalTableName,
@@ -65,6 +64,8 @@ class EventStoreFactory {
       journalAidIndexName,
       snapshotAidIndexName,
       shardCount,
+      eventConverter,
+      snapshotConverter,
       keepSnapshotCount,
       deleteTtl,
       keyResolver,
@@ -72,6 +73,14 @@ class EventStoreFactory {
       snapshotSerializer,
     );
   }
+
+  static ofMemory<
+    AID extends AggregateId,
+    A extends Aggregate<A, AID>,
+    E extends Event<AID>,
+  >(events: Map<AID, E[]>, snapshots: Map<AID, A>): EventStore<AID, A, E> {
+    return new EventStoreForMemory(events, snapshots);
+  }
 }
 
 export { EventStore, EventStoreFactory };

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

@@ -10,7 +10,10 @@ 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 {
+  convertJSONtoUserAccountEvent,
+  UserAccountEvent,
+} from "./test/user-account-event";
 import {
   createDynamoDBClient,
   createJournalTable,
@@ -52,6 +55,8 @@ describe("EventStoreForDynamoDB", () => {
       JOURNAL_AID_INDEX_NAME,
       SNAPSHOTS_AID_INDEX_NAME,
       32,
+      convertJSONtoUserAccountEvent,
+      convertJSONToUserAccount,
     );
   }
 
@@ -96,10 +101,7 @@ describe("EventStoreForDynamoDB", () => {
 
       await eventStore.persistEventAndSnapshot(created, userAccount1);
 
-      const userAccount2 = await eventStore.getLatestSnapshotById(
-        id,
-        convertJSONToUserAccount,
-      );
+      const userAccount2 = await eventStore.getLatestSnapshotById(id);
       if (userAccount2 === undefined) {
         throw new Error("userAccount2 is undefined");
       }
@@ -123,17 +125,23 @@ describe("EventStoreForDynamoDB", () => {
 
       await eventStore.persistEvent(renamed, userAccount2.version);
 
-      const userAccount3 = await eventStore.getLatestSnapshotById(
-        id,
-        convertJSONToUserAccount,
-      );
-      if (userAccount3 === undefined) {
-        throw new Error("userAccount2 is undefined");
+      const latestSnapshot = await eventStore.getLatestSnapshotById(id);
+      if (latestSnapshot === undefined) {
+        throw new Error("latestSnapshot is undefined");
       }
+      const eventsAfterSnapshot =
+        await eventStore.getEventsByIdSinceSequenceNumber(
+          id,
+          latestSnapshot.sequenceNumber + 1,
+        );
+      const userAccount3 = UserAccount.replay(
+        eventsAfterSnapshot,
+        latestSnapshot,
+      );
 
       expect(userAccount3.id).toEqual(id);
-      expect(userAccount3.name).toEqual(name);
-      expect(userAccount3.sequenceNumber).toEqual(1);
+      expect(userAccount3.name).toEqual("Bob");
+      expect(userAccount3.sequenceNumber).toEqual(2);
       expect(userAccount3.version).toEqual(2);
     },
     TIMEOUT,

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

@@ -7,7 +7,6 @@ import {
   Logger,
   SnapshotSerializer,
 } from "../types";
-import { EventStore } from "../event-store";
 import {
   BatchWriteItemCommand,
   DynamoDBClient,
@@ -27,12 +26,13 @@ import {
   JsonEventSerializer,
   JsonSnapshotSerializer,
 } from "./default-serializer";
+import { EventStoreWithOptions } from "../event-store-with-options";
 
 class EventStoreForDynamoDB<
   AID extends AggregateId,
   A extends Aggregate<A, AID>,
   E extends Event<AID>,
-> implements EventStore<AID, A, E>
+> implements EventStoreWithOptions<AID, A, E>
 {
   constructor(
     private dynamodbClient: DynamoDBClient,
@@ -41,6 +41,8 @@ class EventStoreForDynamoDB<
     private journalAidIndexName: string,
     private snapshotAidIndexName: string,
     private shardCount: number,
+    private eventConverter: (json: string) => E,
+    private snapshotConverter: (json: string) => A,
     private keepSnapshotCount: number | undefined = undefined,
     private deleteTtl: moment.Duration | undefined = undefined,
     private keyResolver: KeyResolver<AID> = new DefaultKeyResolver(),
@@ -58,7 +60,7 @@ class EventStoreForDynamoDB<
   async getEventsByIdSinceSequenceNumber(
     id: AID,
     sequenceNumber: number,
-    converter: (json: string) => E,
+    // converter: (json: string) => E,
   ): Promise<E[]> {
     this.logger?.debug(
       `getEventsByIdSinceSequenceNumber(${JSON.stringify(
@@ -90,7 +92,7 @@ class EventStoreForDynamoDB<
         if (payload === undefined) {
           throw new Error("Payload is undefined");
         }
-        return this.eventSerializer.deserialize(payload, converter);
+        return this.eventSerializer.deserialize(payload, this.eventConverter);
       });
     }
     this.logger?.debug(
@@ -103,7 +105,7 @@ class EventStoreForDynamoDB<
 
   async getLatestSnapshotById(
     id: AID,
-    converter: (json: string) => A,
+    // converter: (json: string) => A,
   ): Promise<A | undefined> {
     this.logger?.debug(
       `getLatestSnapshotById(${JSON.stringify(id)}, ...): start`,
@@ -137,7 +139,10 @@ class EventStoreForDynamoDB<
       if (payload === undefined) {
         throw new Error("Payload is undefined");
       }
-      const result = this.snapshotSerializer.deserialize(payload, converter);
+      const result = this.snapshotSerializer.deserialize(
+        payload,
+        this.snapshotConverter,
+      );
       this.logger?.debug(
         `getLatestSnapshotById(${JSON.stringify(id)}, ...): finished`,
       );
@@ -160,6 +165,11 @@ class EventStoreForDynamoDB<
   }
 
   async persistEventAndSnapshot(event: E, aggregate: A): Promise<void> {
+    if (event.aggregateId.asString !== aggregate.id.asString) {
+      throw new Error(
+        `aggregateId mismatch: expected ${event.aggregateId.asString}, got ${aggregate.id.asString}`,
+      );
+    }
     this.logger?.debug(
       `persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(
         aggregate,
@@ -182,7 +192,7 @@ class EventStoreForDynamoDB<
     );
   }
 
-  withDeleteTtl(deleteTtl: moment.Duration): EventStore<AID, A, E> {
+  withDeleteTtl(deleteTtl: moment.Duration): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB(
       this.dynamodbClient,
       this.journalTableName,
@@ -190,6 +200,8 @@ class EventStoreForDynamoDB<
       this.journalAidIndexName,
       this.snapshotAidIndexName,
       this.shardCount,
+      this.eventConverter,
+      this.snapshotConverter,
       this.keepSnapshotCount,
       deleteTtl,
       this.keyResolver,
@@ -200,7 +212,7 @@ class EventStoreForDynamoDB<
 
   withEventSerializer(
     eventSerializer: EventSerializer<AID, E>,
-  ): EventStore<AID, A, E> {
+  ): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB(
       this.dynamodbClient,
       this.journalTableName,
@@ -208,6 +220,8 @@ class EventStoreForDynamoDB<
       this.journalAidIndexName,
       this.snapshotAidIndexName,
       this.shardCount,
+      this.eventConverter,
+      this.snapshotConverter,
       this.keepSnapshotCount,
       this.deleteTtl,
       this.keyResolver,
@@ -216,7 +230,9 @@ class EventStoreForDynamoDB<
     );
   }
 
-  withKeepSnapshotCount(keepSnapshotCount: number): EventStore<AID, A, E> {
+  withKeepSnapshotCount(
+    keepSnapshotCount: number,
+  ): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB(
       this.dynamodbClient,
       this.journalTableName,
@@ -224,6 +240,8 @@ class EventStoreForDynamoDB<
       this.journalAidIndexName,
       this.snapshotAidIndexName,
       this.shardCount,
+      this.eventConverter,
+      this.snapshotConverter,
       keepSnapshotCount,
       this.deleteTtl,
       this.keyResolver,
@@ -232,7 +250,9 @@ class EventStoreForDynamoDB<
     );
   }
 
-  withKeyResolver(keyResolver: KeyResolver<AID>): EventStore<AID, A, E> {
+  withKeyResolver(
+    keyResolver: KeyResolver<AID>,
+  ): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB(
       this.dynamodbClient,
       this.journalTableName,
@@ -240,6 +260,8 @@ class EventStoreForDynamoDB<
       this.journalAidIndexName,
       this.snapshotAidIndexName,
       this.shardCount,
+      this.eventConverter,
+      this.snapshotConverter,
       this.keepSnapshotCount,
       this.deleteTtl,
       keyResolver,
@@ -250,7 +272,7 @@ class EventStoreForDynamoDB<
 
   withSnapshotSerializer(
     snapshotSerializer: SnapshotSerializer<AID, A>,
-  ): EventStore<AID, A, E> {
+  ): EventStoreWithOptions<AID, A, E> {
     return new EventStoreForDynamoDB(
       this.dynamodbClient,
       this.journalTableName,
@@ -258,6 +280,8 @@ class EventStoreForDynamoDB<
       this.journalAidIndexName,
       this.snapshotAidIndexName,
       this.shardCount,
+      this.eventConverter,
+      this.snapshotConverter,
       this.keepSnapshotCount,
       this.deleteTtl,
       this.keyResolver,
@@ -571,7 +595,9 @@ class EventStoreForDynamoDB<
               ":ttl": { N: ttl.seconds().toString() },
             },
           };
-          return this.dynamodbClient.send(new UpdateItemCommand(request));
+          return this.dynamodbClient
+            .send(new UpdateItemCommand(request))
+            .then((_) => {});
         });
         return await Promise.all(result);
       }
@@ -592,7 +618,7 @@ class EventStoreForDynamoDB<
         if (keys === undefined) {
           return undefined;
         }
-        const result = keys.map((key) => {
+        const request = keys.map((key) => {
           const request: WriteRequest = {
             DeleteRequest: {
               Key: {
@@ -601,15 +627,17 @@ class EventStoreForDynamoDB<
               },
             },
           };
-          return this.dynamodbClient.send(
+          return request;
+        });
+        return this.dynamodbClient
+          .send(
             new BatchWriteItemCommand({
               RequestItems: {
-                [this.snapshotTableName]: [request],
+                [this.snapshotTableName]: request,
               },
             }),
-          );
-        });
-        return await Promise.all(result);
+          )
+          .then((_) => {});
       }
     }
     return undefined;

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

@@ -0,0 +1,89 @@
+import { describe } from "node:test";
+import { UserAccountId } from "./test/user-account-id";
+// import {ulid} from "ulid";
+import { UserAccount } from "./test/user-account";
+import { UserAccountEvent } from "./test/user-account-event";
+import { EventStore } from "../event-store";
+import { EventStoreForMemory } from "./event-store-for-memory";
+
+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;
+
+  let eventStore: EventStore<UserAccountId, UserAccount, UserAccountEvent>;
+
+  function createEventStore(): EventStore<
+    UserAccountId,
+    UserAccount,
+    UserAccountEvent
+  > {
+    return new EventStoreForMemory<
+      UserAccountId,
+      UserAccount,
+      UserAccountEvent
+    >(new Map(), new Map());
+  }
+
+  beforeAll(async () => {
+    eventStore = createEventStore();
+  });
+
+  test(
+    "persistAndSnapshot",
+    async () => {
+      const id = new UserAccountId("1");
+      const name = "Alice";
+      const [userAccount1, created] = UserAccount.create(id, name);
+
+      await eventStore.persistEventAndSnapshot(created, userAccount1);
+
+      const userAccount2 = await eventStore.getLatestSnapshotById(id);
+      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("2");
+      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 latestSnapshot = await eventStore.getLatestSnapshotById(id);
+      if (latestSnapshot === undefined) {
+        throw new Error("latestSnapshot is undefined");
+      }
+      const eventsAfterSnapshot =
+        await eventStore.getEventsByIdSinceSequenceNumber(
+          id,
+          latestSnapshot.sequenceNumber + 1,
+        );
+      const userAccount3 = UserAccount.replay(
+        eventsAfterSnapshot,
+        latestSnapshot,
+      );
+
+      expect(userAccount3.id).toEqual(id);
+      expect(userAccount3.name).toEqual("Bob");
+      expect(userAccount3.sequenceNumber).toEqual(2);
+      expect(userAccount3.version).toEqual(2);
+    },
+    TIMEOUT,
+  );
+});

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

@@ -0,0 +1,99 @@
+import { Aggregate, AggregateId, Event } from "../types";
+import { EventStore } from "../event-store";
+
+class EventStoreForMemory<
+  AID extends AggregateId,
+  A extends Aggregate<A, AID>,
+  E extends Event<AID>,
+> implements EventStore<AID, A, E>
+{
+  private readonly events: Map<string, E[]>;
+  private readonly snapshots: Map<string, A>;
+
+  constructor(events: Map<AID, E[]>, snapshots: Map<AID, A>) {
+    this.events = new Map(
+      Array.from(events).map(([key, values]) => {
+        return [key.asString, values];
+      }),
+    );
+    this.snapshots = new Map(
+      Array.from(snapshots).map(([key, value]) => {
+        return [key.asString, value];
+      }),
+    );
+  }
+
+  async persistEvent(event: E, version: number): Promise<void> {
+    if (event.isCreated) {
+      throw new Error("event is created");
+    }
+    const aggregateIdString = event.aggregateId.asString;
+    const snapshot = this.snapshots.get(aggregateIdString);
+    if (snapshot === undefined) {
+      throw new Error("snapshot is undefined");
+    }
+    if (snapshot.id.asString !== event.aggregateId.asString) {
+      throw new Error(
+        "aggregateId mismatch: snapshot.id = " +
+          snapshot.id.asString +
+          ", event.aggregateId = " +
+          event.aggregateId.asString,
+      );
+    }
+    if (snapshot.version !== version) {
+      throw new Error("version mismatch");
+    }
+    const events = this.events.get(aggregateIdString);
+    if (events === undefined) {
+      throw new Error("events is undefined");
+    }
+    events.push(event);
+    this.events.set(aggregateIdString, events);
+    const newVersion = snapshot.version + 1;
+    const newSnapshot = snapshot.withVersion(newVersion);
+    this.snapshots.set(aggregateIdString, newSnapshot);
+  }
+
+  async persistEventAndSnapshot(event: E, aggregate: A): Promise<void> {
+    if (event.aggregateId.asString !== aggregate.id.asString) {
+      throw new Error(
+        `aggregateId mismatch: expected ${event.aggregateId.asString}, got ${aggregate.id.asString}`,
+      );
+    }
+    const aggregateIdString = event.aggregateId.asString;
+    const events = this.events.get(aggregateIdString) ?? [];
+    const snapshot = this.snapshots.get(aggregateIdString) ?? aggregate;
+
+    let newVersion = 1;
+    if (!event.isCreated) {
+      const version = snapshot.version;
+      if (version !== aggregate.version) {
+        throw new Error("version mismatch");
+      }
+      newVersion = snapshot.version + 1;
+    }
+    events.push(event);
+    this.events.set(aggregateIdString, events);
+    const newSnapshot = snapshot.withVersion(newVersion);
+    this.snapshots.set(aggregateIdString, newSnapshot);
+  }
+
+  async getEventsByIdSinceSequenceNumber(
+    id: AID,
+    sequenceNumber: number,
+  ): Promise<E[]> {
+    const aggregateIdString = id.asString;
+    const events = this.events.get(aggregateIdString);
+    if (events === undefined) {
+      throw new Error("events is undefined");
+    }
+    return events.filter((event) => event.sequenceNumber >= sequenceNumber);
+  }
+
+  async getLatestSnapshotById(id: AID): Promise<A | undefined> {
+    const aggregateIdString = id.asString;
+    return this.snapshots.get(aggregateIdString);
+  }
+}
+
+export { EventStoreForMemory };

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

@@ -6,8 +6,11 @@ import {
   Wait,
 } from "testcontainers";
 import { UserAccountId } from "./user-account-id";
-import { UserAccount } from "./user-account";
-import { UserAccountEvent } from "./user-account-event";
+import { convertJSONToUserAccount, UserAccount } from "./user-account";
+import {
+  convertJSONtoUserAccountEvent,
+  UserAccountEvent,
+} from "./user-account-event";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import {
   createDynamoDBClient,
@@ -49,6 +52,8 @@ describe("UserAccountRepository", () => {
       JOURNAL_AID_INDEX_NAME,
       SNAPSHOTS_AID_INDEX_NAME,
       32,
+      convertJSONtoUserAccountEvent,
+      convertJSONToUserAccount,
     );
   }
 

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

@@ -1,9 +1,6 @@
-import {
-  UserAccountEvent,
-  convertJSONtoUserAccountEvent,
-} from "./user-account-event";
+import { UserAccountEvent } from "./user-account-event";
 import { UserAccountId } from "./user-account-id";
-import { convertJSONToUserAccount, UserAccount } from "./user-account";
+import { UserAccount } from "./user-account";
 import { EventStore } from "../../event-store";
 
 class UserAccountRepository {
@@ -24,17 +21,13 @@ class UserAccountRepository {
   }
 
   async findById(id: UserAccountId): Promise<UserAccount | undefined> {
-    const snapshot = await this.eventStore.getLatestSnapshotById(
-      id,
-      convertJSONToUserAccount,
-    );
+    const snapshot = await this.eventStore.getLatestSnapshotById(id);
     if (snapshot === undefined) {
       return undefined;
     } else {
       const events = await this.eventStore.getEventsByIdSinceSequenceNumber(
         id,
         snapshot.sequenceNumber + 1,
-        convertJSONtoUserAccountEvent,
       );
       return UserAccount.replay(events, snapshot);
     }