event-store-adapter-js 3.0.1 → 3.0.2-snapshot.2

package/README.ja.md

@@ -21,44 +21,33 @@ npm install event-store-adapter-js
 EventStoreを使えば、Event Sourcing対応リポジトリを簡単に実装できます。
 
 ```typescript
-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,
-        );
-        if (snapshot === undefined) {
-            return undefined;
-        } else {
-            const events = await this.eventStore.getEventsByIdSinceSequenceNumber(
-                id,
-                snapshot.sequenceNumber + 1,
-            );
-            return UserAccount.replay(events, snapshot);
-        }
-    }
-}
+const UserAccountRepository = Object.freeze({
+    create(eventStore: EventStore<UserAccountId, UserAccount, UserAccountEvent>) {
+        return Object.freeze({
+            storeEvent: (event: UserAccountEvent, version: number) =>
+                eventStore.persistEvent(event, version),
+            storeEventAndSnapshot: (event: UserAccountEvent, snapshot: UserAccount) =>
+                eventStore.persistEventAndSnapshot(event, snapshot),
+            async findById(id: UserAccountId): Promise<UserAccount | undefined> {
+                const snapshot = await eventStore.getLatestSnapshotById(id);
+                if (snapshot === undefined) {
+                    return undefined;
+                }
+                const events = await eventStore.getEventsByIdSinceSequenceNumber(
+                    id,
+                    snapshot.sequenceNumber + 1,
+                );
+                return UserAccount.replay(events, snapshot);
+            },
+        });
+    },
+});
 ```
 
 以下はリポジトリの使用例です。
 
 ```typescript
-const eventStore = EventStore.ofDynamoDB<
+const eventStore = EventStore.createDynamoDB<
     UserAccountId,
     UserAccount,
     UserAccountEvent
@@ -74,9 +63,9 @@ const eventStore = EventStore.ofDynamoDB<
     snapshotConverter: convertJSONToUserAccount,
 });
 // if you want to use in-memory event store, use the following code.
-// const eventStore = EventStore.ofMemory<UserAccountId, UserAccount, UserAccountEvent>({});
+// const eventStore = EventStore.createMemory<UserAccountId, UserAccount, UserAccountEvent>({});
 // Cloud Spannerを使う場合は、呼び出し側で管理するDatabaseを渡します。
-// const eventStore = EventStore.ofSpanner<UserAccountId, UserAccount, UserAccountEvent>({
+// const eventStore = EventStore.createSpanner<UserAccountId, UserAccount, UserAccountEvent>({
 //     database: spannerDatabase,
 //     journalTableName: "journal",
 //     snapshotTableName: "snapshot",
@@ -85,17 +74,23 @@ const eventStore = EventStore.ofDynamoDB<
 //     snapshotConverter: convertJSONToUserAccount,
 // });
 
-const userAccountRepository = new UserAccountRepository(eventStore);
+const userAccountRepository = UserAccountRepository.create(eventStore);
 
-const id = new UserAccountId(ulid());
+const id = UserAccountId.create(ulid());
 const name = "Alice";
 const [userAccount1, created] = UserAccount.create(id, name);
 
-await userAccountRepository.storeEventAndSnapshot(created, userAccount1);
+const createdResult = await userAccountRepository.storeEventAndSnapshot(created, userAccount1);
+if (createdResult.type === "err") {
+    throw new Error(createdResult.error.message);
+}
 
 const [userAccount2, renamed] = userAccount1.rename("Bob");
 
-await userAccountRepository.storeEvent(renamed, userAccount2.version);
+const renamedResult = await userAccountRepository.storeEvent(renamed, userAccount2.version);
+if (renamedResult.type === "err") {
+    throw new Error(renamedResult.error.message);
+}
 
 const userAccount3 = await userAccountRepository.findById(id);
 if (userAccount3 === undefined) {
@@ -108,6 +103,55 @@ expect(userAccount3.sequenceNumber).toEqual(2);
 expect(userAccount3.version).toEqual(2);
 ```
 
+## runtime brand と JSON 変換
+
+サンプルのドメイン値は module-private な `unique symbol` brand を使い、
+プロセス内で factory が生成した値と plain object を区別します。`typeName`
+は JSON 境界の discriminant として残し、symbol brand は serialize されない
+ため factory で復元します。
+
+```typescript
+const USER_ACCOUNT_ID_BRAND: unique symbol = Symbol("UserAccountId");
+
+type UserAccountId = AggregateId & {
+    typeName: "user-account";
+    readonly [USER_ACCOUNT_ID_BRAND]: true;
+};
+
+namespace UserAccountId {
+    export function create(value: string): UserAccountId {
+        return Object.freeze({
+            [USER_ACCOUNT_ID_BRAND]: true,
+            typeName: "user-account",
+            value,
+            asString: () => `user-account-${value}`,
+        });
+    }
+
+    export function is(value: unknown): value is UserAccountId {
+        return (
+            typeof value === "object" &&
+            value !== null &&
+            (value as Partial<UserAccountId>)[USER_ACCOUNT_ID_BRAND] === true
+        );
+    }
+
+    export function toJSON(value: UserAccountId) {
+        return { typeName: value.typeName, value: value.value };
+    }
+
+    export function fromJSON(json: { typeName: "user-account"; value: string }) {
+        return create(json.value);
+    }
+}
+```
+
+`JSON.stringify(...)` 後は symbol brand が消えます。EventStore の converter
+ではドメイン側の `fromJSON(...)` を呼び、deserialize した event / snapshot
+を再び branded value にしてください。`EventSerializer` と
+`SnapshotSerializer` の API は変更せず、`deserialize(bytes, converter)` の
+契約どおり converter にドメイン復元を委ねます。
+
 ## 開発
 
 このリポジトリは pnpm workspace を使います。ライブラリパッケージは

package/README.md

@@ -22,44 +22,33 @@ npm install event-store-adapter-js
 You can easily implement an Event Sourcing-enabled repository using EventStore.
 
 ```typescript
-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,
-        );
-        if (snapshot === undefined) {
-            return undefined;
-        } else {
-            const events = await this.eventStore.getEventsByIdSinceSequenceNumber(
-                id,
-                snapshot.sequenceNumber + 1,
-            );
-            return UserAccount.replay(events, snapshot);
-        }
-    }
-}
+const UserAccountRepository = Object.freeze({
+    create(eventStore: EventStore<UserAccountId, UserAccount, UserAccountEvent>) {
+        return Object.freeze({
+            storeEvent: (event: UserAccountEvent, version: number) =>
+                eventStore.persistEvent(event, version),
+            storeEventAndSnapshot: (event: UserAccountEvent, snapshot: UserAccount) =>
+                eventStore.persistEventAndSnapshot(event, snapshot),
+            async findById(id: UserAccountId): Promise<UserAccount | undefined> {
+                const snapshot = await eventStore.getLatestSnapshotById(id);
+                if (snapshot === undefined) {
+                    return undefined;
+                }
+                const events = await eventStore.getEventsByIdSinceSequenceNumber(
+                    id,
+                    snapshot.sequenceNumber + 1,
+                );
+                return UserAccount.replay(events, snapshot);
+            },
+        });
+    },
+});
 ```
 
 The following is an example of the repository usage.
 
 ```typescript
-const eventStore = EventStore.ofDynamoDB<
+const eventStore = EventStore.createDynamoDB<
     UserAccountId,
     UserAccount,
     UserAccountEvent
@@ -75,9 +64,9 @@ const eventStore = EventStore.ofDynamoDB<
     snapshotConverter: convertJSONToUserAccount,
 });
 // if you want to use in-memory event store, use the following code.
-// const eventStore = EventStore.ofMemory<UserAccountId, UserAccount, UserAccountEvent>({});
+// const eventStore = EventStore.createMemory<UserAccountId, UserAccount, UserAccountEvent>({});
 // if you want to use Cloud Spanner, pass a caller-managed Database.
-// const eventStore = EventStore.ofSpanner<UserAccountId, UserAccount, UserAccountEvent>({
+// const eventStore = EventStore.createSpanner<UserAccountId, UserAccount, UserAccountEvent>({
 //     database: spannerDatabase,
 //     journalTableName: "journal",
 //     snapshotTableName: "snapshot",
@@ -86,17 +75,23 @@ const eventStore = EventStore.ofDynamoDB<
 //     snapshotConverter: convertJSONToUserAccount,
 // });
 
-const userAccountRepository = new UserAccountRepository(eventStore);
+const userAccountRepository = UserAccountRepository.create(eventStore);
 
-const id = new UserAccountId(ulid());
+const id = UserAccountId.create(ulid());
 const name = "Alice";
 const [userAccount1, created] = UserAccount.create(id, name);
 
-await userAccountRepository.storeEventAndSnapshot(created, userAccount1);
+const createdResult = await userAccountRepository.storeEventAndSnapshot(created, userAccount1);
+if (createdResult.type === "err") {
+    throw new Error(createdResult.error.message);
+}
 
 const [userAccount2, renamed] = userAccount1.rename("Bob");
 
-await userAccountRepository.storeEvent(renamed, userAccount2.version);
+const renamedResult = await userAccountRepository.storeEvent(renamed, userAccount2.version);
+if (renamedResult.type === "err") {
+    throw new Error(renamedResult.error.message);
+}
 
 const userAccount3 = await userAccountRepository.findById(id);
 if (userAccount3 === undefined) {
@@ -109,6 +104,55 @@ expect(userAccount3.sequenceNumber).toEqual(2);
 expect(userAccount3.version).toEqual(2);
 ```
 
+## Runtime brands and JSON conversion
+
+The sample domain values use module-private `unique symbol` brands to tell
+factory-created values apart from plain objects inside the current process.
+`typeName` remains the JSON boundary discriminant; the symbol brand is not
+serialized and must be restored by a factory.
+
+```typescript
+const USER_ACCOUNT_ID_BRAND: unique symbol = Symbol("UserAccountId");
+
+type UserAccountId = AggregateId & {
+    typeName: "user-account";
+    readonly [USER_ACCOUNT_ID_BRAND]: true;
+};
+
+namespace UserAccountId {
+    export function create(value: string): UserAccountId {
+        return Object.freeze({
+            [USER_ACCOUNT_ID_BRAND]: true,
+            typeName: "user-account",
+            value,
+            asString: () => `user-account-${value}`,
+        });
+    }
+
+    export function is(value: unknown): value is UserAccountId {
+        return (
+            typeof value === "object" &&
+            value !== null &&
+            (value as Partial<UserAccountId>)[USER_ACCOUNT_ID_BRAND] === true
+        );
+    }
+
+    export function toJSON(value: UserAccountId) {
+        return { typeName: value.typeName, value: value.value };
+    }
+
+    export function fromJSON(json: { typeName: "user-account"; value: string }) {
+        return create(json.value);
+    }
+}
+```
+
+`JSON.stringify(...)` drops the symbol brand. In EventStore converters, call the
+domain `fromJSON(...)` function so deserialized events and snapshots become
+branded values again. The `EventSerializer` and `SnapshotSerializer` APIs stay
+unchanged; their `deserialize(bytes, converter)` contract still delegates
+domain reconstruction to the converter.
+
 ## Development
 
 This repository uses pnpm workspaces. The library package is located at

package/dist/aggregate-id.d.ts

@@ -1,7 +1,6 @@
-import type { AggregateIdValue } from "./aggregate-id-value";
-interface AggregateId {
+type AggregateId = {
     typeName: string;
-    value: AggregateIdValue;
+    value: string;
     asString: () => string;
-}
+};
 export type { AggregateId };

package/dist/aggregate.d.ts

@@ -1,10 +1,10 @@
 import type { AggregateId } from "./aggregate-id";
-interface Aggregate<This extends Aggregate<This, AID>, AID extends AggregateId> {
+type Aggregate<This extends Aggregate<This, AID>, AID extends AggregateId> = {
     typeName: string;
     id: AID;
     sequenceNumber: number;
     version: number;
     withVersion(version: number): This;
     updateVersion(version: (value: number) => number): This;
-}
+};
 export type { Aggregate };

package/dist/dynamodb-event-store-input.d.ts

@@ -1,6 +1,6 @@
 import type { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import type { Aggregate, AggregateId, Event, EventSerializer, Logger, ShardSelector, SnapshotSerializer } from "./types";
-interface DynamoDBEventStoreInput<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> {
+type DynamoDBEventStoreInput<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> = {
     client: DynamoDBClient;
     journalTableName: string;
     snapshotTableName: string;
@@ -18,5 +18,5 @@ interface DynamoDBEventStoreInput<AID extends AggregateId, A extends Aggregate<A
     eventSerializer?: EventSerializer<AID, E>;
     snapshotSerializer?: SnapshotSerializer<AID, A>;
     logger?: Logger;
-}
+};
 export type { DynamoDBEventStoreInput };

package/dist/event-serializer.d.ts

@@ -1,7 +1,7 @@
 import type { AggregateId } from "./aggregate-id";
 import type { Event } from "./event";
-interface EventSerializer<AID extends AggregateId, E extends Event<AID>> {
+type EventSerializer<AID extends AggregateId, E extends Event<AID>> = {
     serialize(event: E): Uint8Array;
     deserialize(bytes: Uint8Array, converter: (json: unknown) => E): E;
-}
+};
 export type { EventSerializer };

package/dist/event-store-error.d.ts

@@ -0,0 +1,25 @@
+export type EventStoreError = {
+    type: "optimistic-lock-conflict";
+    message: string;
+    cause?: unknown;
+} | {
+    type: "configuration-error";
+    fieldName: string;
+    message: string;
+    cause?: unknown;
+} | {
+    type: "serialization-error";
+    operation: "serialize" | "deserialize";
+    message: string;
+    cause?: unknown;
+} | {
+    type: "storage-error";
+    message: string;
+    cause?: unknown;
+};
+export declare namespace EventStoreError {
+    function optimisticLockConflict(message?: string, cause?: unknown): EventStoreError;
+    function configuration(fieldName: string, message: string, cause?: unknown): EventStoreError;
+    function serialization(operation: "serialize" | "deserialize", message: string, cause?: unknown): EventStoreError;
+    function storage(message: string, cause?: unknown): EventStoreError;
+}

package/dist/event-store-error.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStoreError = void 0;
+var EventStoreError;
+(function (EventStoreError) {
+    function optimisticLockConflict(message = "Optimistic locking failed", cause) {
+        return Object.freeze({
+            type: "optimistic-lock-conflict",
+            message,
+            cause,
+        });
+    }
+    EventStoreError.optimisticLockConflict = optimisticLockConflict;
+    function configuration(fieldName, message, cause) {
+        return Object.freeze({
+            type: "configuration-error",
+            fieldName,
+            message,
+            cause,
+        });
+    }
+    EventStoreError.configuration = configuration;
+    function serialization(operation, message, cause) {
+        return Object.freeze({
+            type: "serialization-error",
+            operation,
+            message,
+            cause,
+        });
+    }
+    EventStoreError.serialization = serialization;
+    function storage(message, cause) {
+        return Object.freeze({
+            type: "storage-error",
+            message,
+            cause,
+        });
+    }
+    EventStoreError.storage = storage;
+})(EventStoreError || (exports.EventStoreError = EventStoreError = {}));
+// Object.freeze mutates the existing EventStoreError namespace object in place;
+// the returned reference is intentionally ignored to preserve the public binding.
+Object.freeze(EventStoreError);

package/dist/event-store.d.ts

@@ -1,17 +1,15 @@
 import type { DynamoDBEventStoreInput } from "./dynamodb-event-store-input";
 import type { MemoryEventStoreInput } from "./memory-event-store-input";
 import type { SpannerEventStoreInput } from "./spanner-event-store-input";
-import type { Aggregate, AggregateId, Event } from "./types";
-export interface EventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> {
-    persistEvent(event: E, expectedVersion: number): Promise<void>;
-    persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
+import type { Aggregate, AggregateId, Event, EventStoreError, Result } from "./types";
+export type EventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> = {
+    persistEvent(event: E, expectedVersion: number): Promise<Result<void, EventStoreError>>;
+    persistEventAndSnapshot(event: E, aggregate: A): Promise<Result<void, EventStoreError>>;
     getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number): Promise<E[]>;
     getLatestSnapshotById(id: AID): Promise<A | undefined>;
+};
+export declare namespace EventStore {
+    function createDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input: DynamoDBEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
+    function createMemory<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input?: MemoryEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
+    function createSpanner<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input: SpannerEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
 }
-type EventStoreConstructors = Readonly<{
-    ofDynamoDB<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input: DynamoDBEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
-    ofMemory<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input?: MemoryEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
-    ofSpanner<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>>(input: SpannerEventStoreInput<AID, A, E>): EventStore<AID, A, E>;
-}>;
-export declare const EventStore: EventStoreConstructors;
-export {};

package/dist/event-store.js

@@ -4,14 +4,19 @@ exports.EventStore = void 0;
 const dynamodb_event_store_1 = require("./internal/dynamodb-event-store");
 const memory_event_store_1 = require("./internal/memory-event-store");
 const spanner_event_store_1 = require("./internal/spanner-event-store");
-exports.EventStore = Object.freeze({
-    ofDynamoDB(input) {
-        return new dynamodb_event_store_1.DynamoDBEventStore(input);
-    },
-    ofMemory(input) {
-        return new memory_event_store_1.MemoryEventStore(input !== null && input !== void 0 ? input : {});
-    },
-    ofSpanner(input) {
-        return new spanner_event_store_1.SpannerEventStore(input);
-    },
-});
+var EventStore;
+(function (EventStore) {
+    function createDynamoDB(input) {
+        return (0, dynamodb_event_store_1.createDynamoDBEventStore)(input);
+    }
+    EventStore.createDynamoDB = createDynamoDB;
+    function createMemory(input) {
+        return (0, memory_event_store_1.createMemoryEventStore)(input !== null && input !== void 0 ? input : {});
+    }
+    EventStore.createMemory = createMemory;
+    function createSpanner(input) {
+        return (0, spanner_event_store_1.createSpannerEventStore)(input);
+    }
+    EventStore.createSpanner = createSpanner;
+})(EventStore || (exports.EventStore = EventStore = {}));
+Object.freeze(EventStore);

package/dist/event.d.ts

@@ -1,10 +1,10 @@
 import type { AggregateId } from "./aggregate-id";
-interface Event<AID extends AggregateId> {
+type Event<AID extends AggregateId> = {
     typeName: string;
     id: string;
     aggregateId: AID;
     sequenceNumber: number;
     occurredAt: Date;
     isCreated: boolean;
-}
+};
 export type { Event };

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./dynamodb-event-store-input";
 export * from "./event-store";
+export * from "./event-store-error";
 export * from "./memory-event-store-input";
+export * from "./result";
 export * from "./shard-id";
 export * from "./spanner-event-store-input";
 export * from "./types";

package/dist/index.js

@@ -16,7 +16,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./dynamodb-event-store-input"), exports);
 __exportStar(require("./event-store"), exports);
+__exportStar(require("./event-store-error"), exports);
 __exportStar(require("./memory-event-store-input"), exports);
+__exportStar(require("./result"), exports);
 __exportStar(require("./shard-id"), exports);
 __exportStar(require("./spanner-event-store-input"), exports);
 __exportStar(require("./types"), exports);

package/dist/internal/default-serializer.d.ts

@@ -1,10 +1,10 @@
 import type { Aggregate, AggregateId, Event } from "../types";
-declare class JsonEventSerializer {
+declare function createJsonEventSerializer(): Readonly<{
     deserialize<E>(bytes: Uint8Array, converter: (json: unknown) => E): E;
     serialize<AID extends AggregateId, E extends Event<AID>>(event: E): Uint8Array;
-}
-declare class JsonSnapshotSerializer {
+}>;
+declare function createJsonSnapshotSerializer(): Readonly<{
     deserialize<A>(bytes: Uint8Array, converter: (json: unknown) => A): A;
     serialize<AID extends AggregateId, A extends Aggregate<A, AID>>(aggregate: A): Uint8Array;
-}
-export { JsonEventSerializer, JsonSnapshotSerializer };
+}>;
+export { createJsonEventSerializer, createJsonSnapshotSerializer };

package/dist/internal/default-serializer.js

@@ -1,35 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonSnapshotSerializer = exports.JsonEventSerializer = void 0;
+exports.createJsonEventSerializer = createJsonEventSerializer;
+exports.createJsonSnapshotSerializer = createJsonSnapshotSerializer;
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
-class JsonEventSerializer {
-    deserialize(bytes, converter) {
-        const jsonString = decoder.decode(bytes);
-        const json = JSON.parse(jsonString);
-        return converter(json);
-    }
-    serialize(event) {
-        const jsonString = JSON.stringify({
-            type: event.typeName,
-            data: event,
-        });
-        return encoder.encode(jsonString);
-    }
+function createJsonEventSerializer() {
+    return Object.freeze({
+        deserialize(bytes, converter) {
+            const jsonString = decoder.decode(bytes);
+            const json = JSON.parse(jsonString);
+            return converter(json);
+        },
+        serialize(event) {
+            const jsonString = JSON.stringify({
+                type: event.typeName,
+                data: event,
+            });
+            return encoder.encode(jsonString);
+        },
+    });
 }
-exports.JsonEventSerializer = JsonEventSerializer;
-class JsonSnapshotSerializer {
-    deserialize(bytes, converter) {
-        const jsonString = decoder.decode(bytes);
-        const obj = JSON.parse(jsonString);
-        return converter(obj);
-    }
-    serialize(aggregate) {
-        const jsonString = JSON.stringify({
-            type: aggregate.typeName,
-            data: aggregate,
-        });
-        return encoder.encode(jsonString);
-    }
+function createJsonSnapshotSerializer() {
+    return Object.freeze({
+        deserialize(bytes, converter) {
+            const jsonString = decoder.decode(bytes);
+            const obj = JSON.parse(jsonString);
+            return converter(obj);
+        },
+        serialize(aggregate) {
+            const jsonString = JSON.stringify({
+                type: aggregate.typeName,
+                data: aggregate,
+            });
+            return encoder.encode(jsonString);
+        },
+    });
 }
-exports.JsonSnapshotSerializer = JsonSnapshotSerializer;

package/dist/internal/default-shard-selector.d.ts

@@ -1,7 +1,3 @@
-import { type ShardId } from "../shard-id";
-import type { AggregateId, ShardCount, ShardSelector } from "../types";
-declare class DefaultShardSelector<AID extends AggregateId> implements ShardSelector<AID> {
-    selectShardId(aggregateId: AID, shardCount: ShardCount): ShardId;
-    private hashString;
-}
-export { DefaultShardSelector };
+import type { AggregateId, ShardSelector } from "../types";
+declare function createDefaultShardSelector<AID extends AggregateId>(): ShardSelector<AID>;
+export { createDefaultShardSelector };