event-store-adapter-js 1.0.9 → 1.0.10-snapshot.2

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

@@ -1,7 +1,7 @@
 import { Aggregate, AggregateId, Event, EventSerializer, KeyResolver, Logger, SnapshotSerializer } from "../types";
 import { EventStore } from "../event-store";
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import * as moment from "moment/moment";
+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> {
     private dynamodbClient;
     private journalTableName;
@@ -30,5 +30,10 @@ declare class EventStoreForDynamoDB<AID extends AggregateId, A extends Aggregate
     private putJournal;
     private putSnapshot;
     private updateSnapshot;
+    private tryPurgeExcessSnapshots;
+    private getSnapshotCount;
+    private getLastSnapshotKeys;
+    private updateTtlOfExcessSnapshots;
+    private deleteExcessSnapshots;
 }
 export { EventStoreForDynamoDB };

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

@@ -8,9 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventStoreForDynamoDB = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+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 {
@@ -109,21 +113,22 @@ class EventStoreForDynamoDB {
                 throw new Error("Cannot persist created event");
             }
             yield this.updateEventAndSnapshotOpt(event, version, undefined);
+            yield this.tryPurgeExcessSnapshots(event);
             (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`persistEvent(${JSON.stringify(event)}, ${version}): finished`);
         });
     }
     persistEventAndSnapshot(event, aggregate) {
-        var _a, _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             (_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);
             }
             else {
-                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug("update!!!");
                 yield this.updateEventAndSnapshotOpt(event, aggregate.sequenceNumber, aggregate);
+                yield this.tryPurgeExcessSnapshots(event);
             }
-            (_c = this.logger) === null || _c === void 0 ? void 0 : _c.debug(`persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(aggregate)}): finished`);
+            (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(aggregate)}): finished`);
         });
     }
     withDeleteTtl(deleteTtl) {
@@ -274,5 +279,148 @@ class EventStoreForDynamoDB {
         (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`updateSnapshot(${JSON.stringify(event)}, ${sequenceNumber}, ${version}, ${JSON.stringify(aggregate)}): finished`);
         return result;
     }
+    tryPurgeExcessSnapshots(event) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.keepSnapshotCount !== undefined) {
+                if (this.deleteTtl !== undefined) {
+                    yield this.updateTtlOfExcessSnapshots(event.aggregateId);
+                }
+                else {
+                    yield this.deleteExcessSnapshots(event.aggregateId);
+                }
+            }
+        });
+    }
+    getSnapshotCount(aggregateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const request = {
+                TableName: this.snapshotTableName,
+                IndexName: this.snapshotAidIndexName,
+                KeyConditionExpression: "#aid = :aid",
+                ExpressionAttributeNames: {
+                    "#aid": "aid",
+                },
+                ExpressionAttributeValues: {
+                    ":aid": { S: aggregateId.asString },
+                },
+                Select: "COUNT",
+            };
+            const queryResult = yield this.dynamodbClient.send(new client_dynamodb_1.QueryCommand(request));
+            return queryResult.Count;
+        });
+    }
+    getLastSnapshotKeys(aggregateId, limit) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const names = {
+                "#aid": "aid",
+                "#seq_nr": "seq_nr",
+            };
+            const values = {
+                ":aid": { S: aggregateId.asString },
+                ":seq_nr": { N: "0" },
+            };
+            const request = {
+                TableName: this.snapshotTableName,
+                IndexName: this.snapshotAidIndexName,
+                KeyConditionExpression: "#aid = :aid AND #seq_nr > :seq_nr",
+                ExpressionAttributeNames: Object.assign({}, names),
+                ExpressionAttributeValues: Object.assign({}, values),
+                ScanIndexForward: false,
+                Limit: limit,
+            };
+            if (this.deleteTtl !== undefined) {
+                request.FilterExpression = "#ttl = :ttl";
+                request.ExpressionAttributeNames = Object.assign(Object.assign({}, names), { "#ttl": "ttl" });
+                request.ExpressionAttributeValues = Object.assign(Object.assign({}, values), { ":ttl": { N: "0" } });
+            }
+            const queryResult = yield this.dynamodbClient.send(new client_dynamodb_1.QueryCommand(request));
+            if (queryResult.Items === undefined || queryResult.Items.length === 0) {
+                return undefined;
+            }
+            else {
+                return queryResult.Items.map((item) => {
+                    const pkey = item.pkey.S;
+                    const skey = item.skey.S;
+                    if (pkey === undefined || skey === undefined) {
+                        throw new Error("pkey or skey is undefined");
+                    }
+                    return { pkey, skey };
+                });
+            }
+        });
+    }
+    updateTtlOfExcessSnapshots(aggregateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.keepSnapshotCount !== undefined && this.deleteTtl !== undefined) {
+                let snapshotCount = yield this.getSnapshotCount(aggregateId);
+                if (snapshotCount === undefined) {
+                    return undefined;
+                }
+                snapshotCount -= 1;
+                const excessCount = snapshotCount - this.keepSnapshotCount;
+                if (excessCount > 0) {
+                    const keys = yield this.getLastSnapshotKeys(aggregateId, excessCount);
+                    if (keys === undefined) {
+                        return undefined;
+                    }
+                    const ttl = (0, moment_1.default)().add(this.deleteTtl);
+                    const result = keys.map((key) => {
+                        const request = {
+                            TableName: this.snapshotTableName,
+                            Key: {
+                                pkey: { S: key.pkey },
+                                skey: { S: key.skey },
+                            },
+                            UpdateExpression: "SET #ttl = :ttl",
+                            ExpressionAttributeNames: {
+                                "#ttl": "ttl",
+                            },
+                            ExpressionAttributeValues: {
+                                ":ttl": { N: ttl.seconds().toString() },
+                            },
+                        };
+                        return this.dynamodbClient.send(new client_dynamodb_1.UpdateItemCommand(request));
+                    });
+                    return yield Promise.all(result);
+                }
+            }
+            return undefined;
+        });
+    }
+    deleteExcessSnapshots(aggregateId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.keepSnapshotCount !== undefined && this.deleteTtl !== undefined) {
+                let snapshotCount = yield this.getSnapshotCount(aggregateId);
+                if (snapshotCount === undefined) {
+                    return undefined;
+                }
+                snapshotCount -= 1;
+                const excessCount = snapshotCount - this.keepSnapshotCount;
+                if (excessCount > 0) {
+                    const keys = yield this.getLastSnapshotKeys(aggregateId, excessCount);
+                    if (keys === undefined) {
+                        return undefined;
+                    }
+                    const result = keys.map((key) => {
+                        const request = {
+                            DeleteRequest: {
+                                Key: {
+                                    pkey: { S: key.pkey },
+                                    skey: { S: key.skey },
+                                },
+                            },
+                        };
+                        return this.dynamodbClient.send(new client_dynamodb_1.BatchWriteItemCommand({
+                            RequestItems: {
+                                [this.snapshotTableName]: [request],
+                            },
+                        }));
+                    });
+                    return yield Promise.all(result);
+                }
+            }
+            return undefined;
+        });
+    }
 }
 exports.EventStoreForDynamoDB = EventStoreForDynamoDB;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "event-store-adapter-js",
-  "version": "1.0.9",
+  "version": "1.0.10-snapshot.2",
   "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/internal/event-store-for-dynamodb.ts

@@ -9,6 +9,7 @@ import {
 } from "../types";
 import { EventStore } from "../event-store";
 import {
+  BatchWriteItemCommand,
   DynamoDBClient,
   Put,
   QueryCommand,
@@ -16,8 +17,11 @@ import {
   TransactWriteItemsCommand,
   TransactWriteItemsInput,
   Update,
+  UpdateItemCommand,
+  UpdateItemInput,
+  WriteRequest,
 } from "@aws-sdk/client-dynamodb";
-import * as moment from "moment/moment";
+import moment from "moment/moment";
 import { DefaultKeyResolver } from "./default-key-resolver";
 import {
   JsonEventSerializer,
@@ -149,6 +153,7 @@ class EventStoreForDynamoDB<
       throw new Error("Cannot persist created event");
     }
     await this.updateEventAndSnapshotOpt(event, version, undefined);
+    await this.tryPurgeExcessSnapshots(event);
     this.logger?.debug(
       `persistEvent(${JSON.stringify(event)}, ${version}): finished`,
     );
@@ -163,12 +168,12 @@ class EventStoreForDynamoDB<
     if (event.isCreated) {
       await this.createEventAndSnapshot(event, aggregate);
     } else {
-      this.logger?.debug("update!!!");
       await this.updateEventAndSnapshotOpt(
         event,
         aggregate.sequenceNumber,
         aggregate,
       );
+      await this.tryPurgeExcessSnapshots(event);
     }
     this.logger?.debug(
       `persistEventAndSnapshot(${JSON.stringify(event)}, ${JSON.stringify(
@@ -461,6 +466,154 @@ class EventStoreForDynamoDB<
     );
     return result;
   }
+
+  private async tryPurgeExcessSnapshots(event: E) {
+    if (this.keepSnapshotCount !== undefined) {
+      if (this.deleteTtl !== undefined) {
+        await this.updateTtlOfExcessSnapshots(event.aggregateId);
+      } else {
+        await this.deleteExcessSnapshots(event.aggregateId);
+      }
+    }
+  }
+
+  private async getSnapshotCount(aggregateId: AID) {
+    const request: QueryCommandInput = {
+      TableName: this.snapshotTableName,
+      IndexName: this.snapshotAidIndexName,
+      KeyConditionExpression: "#aid = :aid",
+      ExpressionAttributeNames: {
+        "#aid": "aid",
+      },
+      ExpressionAttributeValues: {
+        ":aid": { S: aggregateId.asString },
+      },
+      Select: "COUNT",
+    };
+    const queryResult = await this.dynamodbClient.send(
+      new QueryCommand(request),
+    );
+    return queryResult.Count;
+  }
+
+  private async getLastSnapshotKeys(aggregateId: AID, limit: number) {
+    const names = {
+      "#aid": "aid",
+      "#seq_nr": "seq_nr",
+    };
+    const values = {
+      ":aid": { S: aggregateId.asString },
+      ":seq_nr": { N: "0" },
+    };
+    const request: QueryCommandInput = {
+      TableName: this.snapshotTableName,
+      IndexName: this.snapshotAidIndexName,
+      KeyConditionExpression: "#aid = :aid AND #seq_nr > :seq_nr",
+      ExpressionAttributeNames: { ...names },
+      ExpressionAttributeValues: { ...values },
+      ScanIndexForward: false,
+      Limit: limit,
+    };
+    if (this.deleteTtl !== undefined) {
+      request.FilterExpression = "#ttl = :ttl";
+      request.ExpressionAttributeNames = {
+        ...names,
+        "#ttl": "ttl",
+      };
+      request.ExpressionAttributeValues = {
+        ...values,
+        ":ttl": { N: "0" },
+      };
+    }
+    const queryResult = await this.dynamodbClient.send(
+      new QueryCommand(request),
+    );
+    if (queryResult.Items === undefined || queryResult.Items.length === 0) {
+      return undefined;
+    } else {
+      return queryResult.Items.map((item) => {
+        const pkey = item.pkey.S;
+        const skey = item.skey.S;
+        if (pkey === undefined || skey === undefined) {
+          throw new Error("pkey or skey is undefined");
+        }
+        return { pkey, skey };
+      });
+    }
+  }
+
+  private async updateTtlOfExcessSnapshots(aggregateId: AID) {
+    if (this.keepSnapshotCount !== undefined && this.deleteTtl !== undefined) {
+      let snapshotCount = await this.getSnapshotCount(aggregateId);
+      if (snapshotCount === undefined) {
+        return undefined;
+      }
+      snapshotCount -= 1;
+      const excessCount = snapshotCount - this.keepSnapshotCount;
+      if (excessCount > 0) {
+        const keys = await this.getLastSnapshotKeys(aggregateId, excessCount);
+        if (keys === undefined) {
+          return undefined;
+        }
+        const ttl = moment().add(this.deleteTtl);
+        const result = keys.map((key) => {
+          const request: UpdateItemInput = {
+            TableName: this.snapshotTableName,
+            Key: {
+              pkey: { S: key.pkey },
+              skey: { S: key.skey },
+            },
+            UpdateExpression: "SET #ttl = :ttl",
+            ExpressionAttributeNames: {
+              "#ttl": "ttl",
+            },
+            ExpressionAttributeValues: {
+              ":ttl": { N: ttl.seconds().toString() },
+            },
+          };
+          return this.dynamodbClient.send(new UpdateItemCommand(request));
+        });
+        return await Promise.all(result);
+      }
+    }
+    return undefined;
+  }
+
+  private async deleteExcessSnapshots(aggregateId: AID) {
+    if (this.keepSnapshotCount !== undefined && this.deleteTtl !== undefined) {
+      let snapshotCount = await this.getSnapshotCount(aggregateId);
+      if (snapshotCount === undefined) {
+        return undefined;
+      }
+      snapshotCount -= 1;
+      const excessCount = snapshotCount - this.keepSnapshotCount;
+      if (excessCount > 0) {
+        const keys = await this.getLastSnapshotKeys(aggregateId, excessCount);
+        if (keys === undefined) {
+          return undefined;
+        }
+        const result = keys.map((key) => {
+          const request: WriteRequest = {
+            DeleteRequest: {
+              Key: {
+                pkey: { S: key.pkey },
+                skey: { S: key.skey },
+              },
+            },
+          };
+          return this.dynamodbClient.send(
+            new BatchWriteItemCommand({
+              RequestItems: {
+                [this.snapshotTableName]: [request],
+              },
+            }),
+          );
+        });
+        return await Promise.all(result);
+      }
+    }
+    return undefined;
+  }
 }
 
 export { EventStoreForDynamoDB };