event-store-adapter-js 2.2.167-snapshot.1 → 3.0.0

package/README.ja.md

@@ -13,7 +13,7 @@
 # 導入方法
 
 ```shell
-$ npm install event-store-adapter-js
+npm install event-store-adapter-js
 ```
 
 # 使い方
@@ -58,22 +58,32 @@ class UserAccountRepository {
 以下はリポジトリの使用例です。
 
 ```typescript
-const eventStore = EventStoreFactory.ofDynamoDB<
+const eventStore = EventStore.ofDynamoDB<
     UserAccountId,
     UserAccount,
     UserAccountEvent
->(
-    dynamodbClient,
-    JOURNAL_TABLE_NAME,
-    SNAPSHOT_TABLE_NAME,
-    JOURNAL_AID_INDEX_NAME,
-    SNAPSHOTS_AID_INDEX_NAME,
-    32,
-    convertJSONtoUserAccountEvent,
-    convertJSONToUserAccount,
-);
+>({
+    client: dynamodbClient,
+    journalTableName: JOURNAL_TABLE_NAME,
+    snapshotTableName: SNAPSHOT_TABLE_NAME,
+    journalAidIndexName: JOURNAL_AID_INDEX_NAME,
+    snapshotAidIndexName: SNAPSHOTS_AID_INDEX_NAME,
+    snapshotActiveTtlIndexName: SNAPSHOTS_ACTIVE_TTL_INDEX_NAME,
+    shardCount: 32,
+    eventConverter: convertJSONtoUserAccountEvent,
+    snapshotConverter: convertJSONToUserAccount,
+});
 // if you want to use in-memory event store, use the following code.
-// const eventStore = EventStoreFactory.ofMemory<UserAccountId, UserAccount, UserAccountEvent>();
+// const eventStore = EventStore.ofMemory<UserAccountId, UserAccount, UserAccountEvent>({});
+// Cloud Spannerを使う場合は、呼び出し側で管理するDatabaseを渡します。
+// const eventStore = EventStore.ofSpanner<UserAccountId, UserAccount, UserAccountEvent>({
+//     database: spannerDatabase,
+//     journalTableName: "journal",
+//     snapshotTableName: "snapshot",
+//     shardCount: 32,
+//     eventConverter: convertJSONtoUserAccountEvent,
+//     snapshotConverter: convertJSONToUserAccount,
+// });
 
 const userAccountRepository = new UserAccountRepository(eventStore);
 
@@ -98,13 +108,30 @@ expect(userAccount3.sequenceNumber).toEqual(2);
 expect(userAccount3.version).toEqual(2);
 ```
 
+## 開発
+
+このリポジトリは pnpm workspace を使います。ライブラリパッケージは
+`packages/library` に配置し、今後の example や test package の追加先として
+`packages/examples` と `packages/tests` を予約しています。
+
+```shell
+pnpm install
+pnpm run lint
+pnpm run build
+pnpm run test
+pnpm run coverage
+```
+
 ## テーブル仕様
 
 [docs/DATABASE_SCHEMA.ja.md](docs/DATABASE_SCHEMA.ja.md)を参照してください。
 
+Cloud Spannerについては[docs/SPANNER_DATABASE_SCHEMA.ja.md](docs/SPANNER_DATABASE_SCHEMA.ja.md)を参照してください。
+
 ## ライセンス
 
-MITライセンスです。詳細は[LICENSE](LICENSE)を参照してください。
+MIT と Apache-2.0 のデュアルライセンスです。詳細は
+[LICENSE-MIT](LICENSE-MIT) と [LICENSE-APACHE](LICENSE-APACHE) を参照してください。
 
 ## 他の言語のための実装
 
@@ -116,4 +143,3 @@ MITライセンスです。詳細は[LICENSE](LICENSE)を参照してくださ
 - [for JavaScript/TypeScript](https://github.com/j5ik2o/event-store-adapter-js)
 - [for .NET](https://github.com/j5ik2o/event-store-adapter-dotnet)
 - [for PHP](https://github.com/j5ik2o/event-store-adapter-php)
-

package/README.md

@@ -14,7 +14,7 @@ This library is designed to turn DynamoDB into an Event Store for CQRS/Event Sou
 # Installation
 
 ```shell
-$ npm install event-store-adapter-js
+npm install event-store-adapter-js
 ```
 
 # Usage
@@ -61,22 +61,32 @@ class UserAccountRepository {
 The following is an example of the repository usage.
 
 ```typescript
-const eventStore = EventStoreFactory.ofDynamoDB<
+const eventStore = EventStore.ofDynamoDB<
     UserAccountId,
     UserAccount,
     UserAccountEvent
->(
-    dynamodbClient,
-    JOURNAL_TABLE_NAME,
-    SNAPSHOT_TABLE_NAME,
-    JOURNAL_AID_INDEX_NAME,
-    SNAPSHOTS_AID_INDEX_NAME,
-    32,
-    convertJSONtoUserAccountEvent,
-    convertJSONToUserAccount,
-);
+>({
+    client: dynamodbClient,
+    journalTableName: JOURNAL_TABLE_NAME,
+    snapshotTableName: SNAPSHOT_TABLE_NAME,
+    journalAidIndexName: JOURNAL_AID_INDEX_NAME,
+    snapshotAidIndexName: SNAPSHOTS_AID_INDEX_NAME,
+    snapshotActiveTtlIndexName: SNAPSHOTS_ACTIVE_TTL_INDEX_NAME,
+    shardCount: 32,
+    eventConverter: convertJSONtoUserAccountEvent,
+    snapshotConverter: convertJSONToUserAccount,
+});
 // if you want to use in-memory event store, use the following code.
-// const eventStore = EventStoreFactory.ofMemory<UserAccountId, UserAccount, UserAccountEvent>();
+// const eventStore = EventStore.ofMemory<UserAccountId, UserAccount, UserAccountEvent>({});
+// if you want to use Cloud Spanner, pass a caller-managed Database.
+// const eventStore = EventStore.ofSpanner<UserAccountId, UserAccount, UserAccountEvent>({
+//     database: spannerDatabase,
+//     journalTableName: "journal",
+//     snapshotTableName: "snapshot",
+//     shardCount: 32,
+//     eventConverter: convertJSONtoUserAccountEvent,
+//     snapshotConverter: convertJSONToUserAccount,
+// });
 
 const userAccountRepository = new UserAccountRepository(eventStore);
 
@@ -101,19 +111,35 @@ expect(userAccount3.sequenceNumber).toEqual(2);
 expect(userAccount3.version).toEqual(2);
 ```
 
+## Development
+
+This repository uses pnpm workspaces. The library package is located at
+`packages/library`, with `packages/examples` and `packages/tests` reserved for
+future example and test packages.
+
+```shell
+pnpm install
+pnpm run lint
+pnpm run build
+pnpm run test
+pnpm run coverage
+```
+
 ## Table Specifications
 
 See [docs/DATABASE_SCHEMA.md](docs/DATABASE_SCHEMA.md).
 
+For Cloud Spanner, see [docs/SPANNER_DATABASE_SCHEMA.md](docs/SPANNER_DATABASE_SCHEMA.md).
+
 ## CQRS/Event Sourcing Example
 
 See [j5ik2o/cqrs-es-example-js](https://github.com/j5ik2o/cqrs-es-example-js).
 
-## License.
+## License
 
-MIT License. See [LICENSE](LICENSE) for details.
+Dual-licensed under MIT and Apache-2.0.
+See [LICENSE-MIT](LICENSE-MIT) and [LICENSE-APACHE](LICENSE-APACHE).
 
 ## Links
 
 - [Common Documents](https://github.com/j5ik2o/event-store-adapter)
-

package/dist/aggregate-id-value.d.ts

@@ -0,0 +1,7 @@
+declare const aggregateIdValueBrand: unique symbol;
+type AggregateIdValue = string & {
+    readonly [aggregateIdValueBrand]: "AggregateIdValue";
+};
+declare function createAggregateIdValue(value: string): AggregateIdValue;
+export type { AggregateIdValue };
+export { createAggregateIdValue };

package/dist/aggregate-id-value.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAggregateIdValue = createAggregateIdValue;
+function createAggregateIdValue(value) {
+    if (value.length === 0) {
+        throw new Error("aggregateId value must be non-empty");
+    }
+    return value;
+}

package/dist/aggregate-id.d.ts

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

package/dist/aggregate.d.ts

@@ -0,0 +1,10 @@
+import type { AggregateId } from "./aggregate-id";
+interface 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

@@ -0,0 +1,22 @@
+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>> {
+    client: DynamoDBClient;
+    journalTableName: string;
+    snapshotTableName: string;
+    journalAidIndexName: string;
+    snapshotAidIndexName: string;
+    snapshotActiveTtlIndexName: string;
+    shardCount: number;
+    /** Converts the deserialized event JSON payload from unknown into an event. */
+    eventConverter: (json: unknown) => E;
+    /** Converts the deserialized snapshot JSON payload from unknown into an aggregate. */
+    snapshotConverter: (json: unknown) => A;
+    keepSnapshotCount?: number;
+    deleteTtlMillis?: number;
+    shardSelector?: ShardSelector<AID>;
+    eventSerializer?: EventSerializer<AID, E>;
+    snapshotSerializer?: SnapshotSerializer<AID, A>;
+    logger?: Logger;
+}
+export type { DynamoDBEventStoreInput };

package/dist/dynamodb-event-store-input.js

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

package/dist/event-serializer.d.ts

@@ -0,0 +1,7 @@
+import type { AggregateId } from "./aggregate-id";
+import type { Event } from "./event";
+interface 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-serializer.js

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

package/dist/event-store.d.ts

@@ -1,15 +1,17 @@
-import type { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import type moment from "moment";
-import type { EventStoreWithOptions } from "./event-store-with-options";
-import type { Aggregate, AggregateId, Event, EventSerializer, KeyResolver, Logger, SnapshotSerializer } from "./types";
-interface EventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> {
-    persistEvent(event: E, version: number): Promise<void>;
+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>;
     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, 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): 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 { type EventStore, EventStoreFactory };
+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

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventStoreFactory = void 0;
-const default_key_resolver_1 = require("./internal/default-key-resolver");
-const default_serializer_1 = require("./internal/default-serializer");
-const event_store_for_dynamodb_1 = require("./internal/event-store-for-dynamodb");
-const event_store_for_memory_1 = require("./internal/event-store-for-memory");
-class EventStoreFactory {
-    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(), logger = undefined) {
-        return new event_store_for_dynamodb_1.EventStoreForDynamoDB(dynamodbClient, journalTableName, snapshotTableName, journalAidIndexName, snapshotAidIndexName, shardCount, eventConverter, snapshotConverter, keepSnapshotCount, deleteTtl, keyResolver, eventSerializer, snapshotSerializer, logger);
-    }
-    static ofMemory(events = new Map(), snapshots = new Map()) {
-        return new event_store_for_memory_1.EventStoreForMemory(events, snapshots);
-    }
-}
-exports.EventStoreFactory = EventStoreFactory;
+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);
+    },
+});

package/dist/event.d.ts

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

package/dist/event.js

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -14,5 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dynamodb-event-store-input"), exports);
 __exportStar(require("./event-store"), exports);
+__exportStar(require("./memory-event-store-input"), 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,14 +1,10 @@
-import type { Aggregate, AggregateId, Event, EventSerializer, SnapshotSerializer } from "../types";
-declare class JsonEventSerializer<AID extends AggregateId, E extends Event<AID>> implements EventSerializer<AID, E> {
-    private encoder;
-    private decoder;
-    deserialize(bytes: Uint8Array, converter: (json: any) => E): E;
-    serialize(event: E): Uint8Array;
+import type { Aggregate, AggregateId, Event } from "../types";
+declare class JsonEventSerializer {
+    deserialize<E>(bytes: Uint8Array, converter: (json: unknown) => E): E;
+    serialize<AID extends AggregateId, E extends Event<AID>>(event: E): Uint8Array;
 }
-declare class JsonSnapshotSerializer<AID extends AggregateId, A extends Aggregate<A, AID>> implements SnapshotSerializer<AID, A> {
-    private encoder;
-    private decoder;
-    deserialize(bytes: Uint8Array, converter: (json: any) => A): A;
-    serialize(aggregate: A): Uint8Array;
+declare class JsonSnapshotSerializer {
+    deserialize<A>(bytes: Uint8Array, converter: (json: unknown) => A): A;
+    serialize<AID extends AggregateId, A extends Aggregate<A, AID>>(aggregate: A): Uint8Array;
 }
 export { JsonEventSerializer, JsonSnapshotSerializer };

package/dist/internal/default-serializer.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonSnapshotSerializer = exports.JsonEventSerializer = void 0;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
 class JsonEventSerializer {
-    constructor() {
-        this.encoder = new TextEncoder();
-        this.decoder = new TextDecoder();
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: JSON deserialization requires dynamic typing
     deserialize(bytes, converter) {
-        const jsonString = this.decoder.decode(bytes);
+        const jsonString = decoder.decode(bytes);
         const json = JSON.parse(jsonString);
         return converter(json);
     }
@@ -17,18 +14,13 @@ class JsonEventSerializer {
             type: event.typeName,
             data: event,
         });
-        return this.encoder.encode(jsonString);
+        return encoder.encode(jsonString);
     }
 }
 exports.JsonEventSerializer = JsonEventSerializer;
 class JsonSnapshotSerializer {
-    constructor() {
-        this.encoder = new TextEncoder();
-        this.decoder = new TextDecoder();
-    }
-    // biome-ignore lint/suspicious/noExplicitAny: JSON deserialization requires dynamic typing
     deserialize(bytes, converter) {
-        const jsonString = this.decoder.decode(bytes);
+        const jsonString = decoder.decode(bytes);
         const obj = JSON.parse(jsonString);
         return converter(obj);
     }
@@ -37,7 +29,7 @@ class JsonSnapshotSerializer {
             type: aggregate.typeName,
             data: aggregate,
         });
-        return this.encoder.encode(jsonString);
+        return encoder.encode(jsonString);
     }
 }
 exports.JsonSnapshotSerializer = JsonSnapshotSerializer;

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

@@ -0,0 +1,7 @@
+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 };

package/dist/internal/default-shard-selector.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultShardSelector = void 0;
+const shard_id_1 = require("../shard-id");
+class DefaultShardSelector {
+    selectShardId(aggregateId, shardCount) {
+        if (aggregateId === undefined || aggregateId === null) {
+            throw new Error(`aggregateId is undefined or null: ${aggregateId}`);
+        }
+        if (!Number.isSafeInteger(shardCount) || shardCount <= 0) {
+            throw new Error(`shardCount must be a positive safe integer, got ${shardCount}`);
+        }
+        const hash = this.hashString(aggregateId.asString());
+        return (0, shard_id_1.createShardId)(hash % shardCount);
+    }
+    hashString(str) {
+        // AggregateId.asString() is user code, so validate runtime values despite the TypeScript type.
+        if (typeof str !== "string") {
+            throw new Error(`str is not a string: ${str}`);
+        }
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            // Keep the legacy DefaultKeyResolver result, using an explicit 32-bit mask instead of the opaque hash & hash idiom.
+            hash = hash & 0xffffffff;
+        }
+        return hash >>> 0;
+    }
+}
+exports.DefaultShardSelector = DefaultShardSelector;

package/dist/internal/dynamodb-aggregate-key.d.ts

@@ -0,0 +1,14 @@
+import type { ShardCount } from "../shard-count";
+import type { ShardId } from "../shard-id";
+import type { ShardSelector } from "../shard-selector";
+import type { AggregateId } from "../types";
+declare class DynamoDBAggregateKey<AID extends AggregateId> {
+    readonly shardId: ShardId;
+    readonly aggregateId: AID;
+    readonly sequenceNumber: number;
+    private constructor();
+    static create<AID extends AggregateId>(aggregateId: AID, sequenceNumber: number, shardSelector: ShardSelector<AID>, shardCount: ShardCount): DynamoDBAggregateKey<AID>;
+    get partitionKeyValue(): string;
+    get sortKeyValue(): string;
+}
+export { DynamoDBAggregateKey };

package/dist/internal/dynamodb-aggregate-key.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBAggregateKey = void 0;
+class DynamoDBAggregateKey {
+    constructor(shardId, aggregateId, sequenceNumber) {
+        this.shardId = shardId;
+        this.aggregateId = aggregateId;
+        this.sequenceNumber = sequenceNumber;
+    }
+    static create(aggregateId, sequenceNumber, shardSelector, shardCount) {
+        if (!Number.isSafeInteger(sequenceNumber) || sequenceNumber < 0) {
+            throw new Error(`sequenceNumber must be a non-negative safe integer, got ${sequenceNumber}`);
+        }
+        return new DynamoDBAggregateKey(shardSelector.selectShardId(aggregateId, shardCount), aggregateId, sequenceNumber);
+    }
+    get partitionKeyValue() {
+        return `${this.aggregateId.typeName}-${this.shardId}`;
+    }
+    get sortKeyValue() {
+        return `${this.aggregateId.typeName}-${this.aggregateId.value}-${this.sequenceNumber}`;
+    }
+}
+exports.DynamoDBAggregateKey = DynamoDBAggregateKey;

package/dist/internal/dynamodb-delete-ttl-millis.d.ts

@@ -0,0 +1,2 @@
+declare function normalizeDynamoDBDeleteTtlMillis(deleteTtlMillis: number | undefined): number | undefined;
+export { normalizeDynamoDBDeleteTtlMillis };

package/dist/internal/dynamodb-delete-ttl-millis.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDynamoDBDeleteTtlMillis = normalizeDynamoDBDeleteTtlMillis;
+function normalizeDynamoDBDeleteTtlMillis(deleteTtlMillis) {
+    if (deleteTtlMillis === undefined) {
+        return undefined;
+    }
+    if (!Number.isFinite(deleteTtlMillis)) {
+        throw new Error(`deleteTtlMillis must be finite, got ${formatDeleteTtlMillis(deleteTtlMillis)}`);
+    }
+    if (deleteTtlMillis < 0 || Object.is(deleteTtlMillis, -0)) {
+        throw new Error(`deleteTtlMillis must be non-negative, got ${formatDeleteTtlMillis(deleteTtlMillis)}`);
+    }
+    return Math.floor(deleteTtlMillis);
+}
+function formatDeleteTtlMillis(deleteTtlMillis) {
+    return Object.is(deleteTtlMillis, -0) ? "-0" : String(deleteTtlMillis);
+}

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

@@ -0,0 +1,36 @@
+import type { DynamoDBEventStoreInput } from "../dynamodb-event-store-input";
+import type { EventStore } from "../event-store";
+import { type Aggregate, type AggregateId, type Event } from "../types";
+declare class DynamoDBEventStore<AID extends AggregateId, A extends Aggregate<A, AID>, E extends Event<AID>> implements EventStore<AID, A, E> {
+    private readonly dynamodbClient;
+    private readonly journalTableName;
+    private readonly snapshotTableName;
+    private readonly journalAidIndexName;
+    private readonly snapshotAidIndexName;
+    private readonly snapshotActiveTtlIndexName;
+    private readonly shardCount;
+    private readonly eventConverter;
+    private readonly snapshotConverter;
+    private readonly keepSnapshotCount;
+    private readonly deleteTtlMillis;
+    private readonly shardSelector;
+    private readonly eventSerializer;
+    private readonly snapshotSerializer;
+    private readonly logger;
+    constructor(input: DynamoDBEventStoreInput<AID, A, E>);
+    getEventsByIdSinceSequenceNumber(id: AID, sequenceNumber: number): Promise<E[]>;
+    getLatestSnapshotById(id: AID): Promise<A | undefined>;
+    persistEvent(event: E, expectedVersion: number): Promise<void>;
+    persistEventAndSnapshot(event: E, aggregate: A): Promise<void>;
+    private createEventAndSnapshot;
+    private updateEventAndSnapshotOpt;
+    private putJournal;
+    private putSnapshot;
+    private putRedundantSnapshot;
+    private updateSnapshot;
+    private purgeExcessSnapshots;
+    private assertConverter;
+    private parseShardCount;
+    private normalizeDeleteTtlMillis;
+}
+export { DynamoDBEventStore };