@eresearchqut/ddb-repository 1.1.0 → 1.3.0

package/.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Publish
+name: Release
 
 on:
   push:

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.3.0](https://github.com/eresearchqut/ddb-repository/compare/v1.2.0...v1.3.0) (2025-11-20)
+
+
+### Features
+
+* Add test for the tracking of the consumed capacity ([4a1b23c](https://github.com/eresearchqut/ddb-repository/commit/4a1b23cadadbbb02d78507ca9d34715219fc952c))
+
+# [1.2.0](https://github.com/eresearchqut/ddb-repository/compare/v1.1.0...v1.2.0) (2025-11-19)
+
+
+### Features
+
+* return the consumed capacity for each operation ([3910953](https://github.com/eresearchqut/ddb-repository/commit/391095398381a950c3393f9103d97d355c119538))
+
 # [1.1.0](https://github.com/eresearchqut/ddb-repository/compare/v1.0.2...v1.1.0) (2025-11-19)
 
 

package/dist/DynamoDbRepository.js

@@ -27,7 +27,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDbRepository = exports.mapFilterExpressions = exports.mapFilterExpression = exports.FilterOperator = void 0;
+exports.DynamoDbRepository = exports.consumedCapacityMiddleware = exports.mapFilterExpressions = exports.mapFilterExpression = exports.FilterOperator = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const lodash_1 = require("lodash");
@@ -79,17 +79,34 @@ const paginate = (array, pageSize) => {
         return acc;
     }, []);
 };
+const consumedCapacityMiddleware = (consumedCapacityMiddlewareConfig) => (next, context) => (args) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { input } = args;
+        const { ReturnConsumedCapacity } = input;
+        const response = yield next(args);
+        const { output } = response;
+        const consumedCapacity = (0, lodash_1.get)(output, "ConsumedCapacity");
+        yield consumedCapacityMiddlewareConfig.onConsumedCapacity({ ReturnConsumedCapacity, ConsumedCapacity: consumedCapacity });
+        return response;
+    }
+    catch (error) {
+        throw error;
+    }
+});
+exports.consumedCapacityMiddleware = consumedCapacityMiddleware;
 class DynamoDbRepository {
-    constructor(dynamoDBClient, tableName, hashKey, rangKey) {
+    constructor(dynamoDBClient, tableName, hashKey, rangKey, returnConsumedCapacity = client_dynamodb_1.ReturnConsumedCapacity.TOTAL) {
         this.dynamoDBClient = dynamoDBClient;
         this.tableName = tableName;
         this.hashKey = hashKey;
         this.rangKey = rangKey;
+        this.returnConsumedCapacity = returnConsumedCapacity;
         this.getItem = (key) => __awaiter(this, void 0, void 0, function* () {
             return this.dynamoDBClient
                 .send(new client_dynamodb_1.GetItemCommand({
                 TableName: this.tableName,
                 Key: (0, util_dynamodb_1.marshall)(key, { removeUndefinedValues: true }),
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
             }))
                 .then((result) => result.Item ? (0, util_dynamodb_1.unmarshall)(result.Item) : undefined);
         });
@@ -98,6 +115,7 @@ class DynamoDbRepository {
             return this.dynamoDBClient
                 .send(new client_dynamodb_1.PutItemCommand({
                 TableName: this.tableName,
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
                 Item,
             }))
                 .then(() => this.getItem(key));
@@ -129,6 +147,7 @@ class DynamoDbRepository {
                     .filter(([, value]) => value !== undefined)
                     .reduce((acc, [key]) => (Object.assign(Object.assign({}, acc), { [`#${expressionAttributeKey(key)}`]: key })), Object.assign(removeAttributeNames)),
                 ExpressionAttributeValues: hasUpdates ? (0, util_dynamodb_1.marshall)(Object.entries(updates).reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [`:${expressionAttributeKey(key)}`]: value })), Object.assign({})), { removeUndefinedValues: true }) : undefined,
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
             };
             return this.dynamoDBClient
                 .send(new client_dynamodb_1.UpdateItemCommand(updateItemCommandInput))
@@ -160,6 +179,7 @@ class DynamoDbRepository {
                 : {};
             const queryCommandInput = {
                 TableName: this.tableName,
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
                 IndexName: index,
                 KeyConditionExpression,
                 FilterExpression,
@@ -226,9 +246,10 @@ class DynamoDbRepository {
                         [this.tableName]: {
                             Keys: keyPage.map((key) => ((0, util_dynamodb_1.marshall)(key))),
                             ProjectionExpression,
-                            ExpressionAttributeNames
+                            ExpressionAttributeNames,
                         }
-                    }
+                    },
+                    ReturnConsumedCapacity: this.returnConsumedCapacity,
                 };
                 return this.dynamoDBClient.send(new client_dynamodb_1.BatchGetItemCommand(batchRequest)).then(result => { var _a; return (_a = result.Responses) === null || _a === void 0 ? void 0 : _a[this.tableName].map((item) => (0, util_dynamodb_1.unmarshall)(item)); });
             }))))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eresearchqut/ddb-repository",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -23,6 +23,7 @@
     "@semantic-release/git": "^10.0.1",
     "@semantic-release/github": "^12.0.2",
     "@semantic-release/npm": "^13.1.2",
+    "@smithy/types": "^4.9.0",
     "@testcontainers/localstack": "^10.15.0",
     "@types/jest": "^29.5.0",
     "@types/lodash": "^4.17.20",

package/src/DynamoDbRepository.ts

@@ -1,16 +1,25 @@
 import {
     BatchGetItemCommand,
     BatchGetItemCommandInput,
+    ConsumedCapacity,
     DeleteItemCommand,
     DynamoDBClient,
     GetItemCommand,
     paginateQuery,
     PutItemCommand,
     QueryCommandInput,
+    ReturnConsumedCapacity,
     UpdateItemCommand,
 } from "@aws-sdk/client-dynamodb";
 import {marshall, unmarshall} from "@aws-sdk/util-dynamodb";
-import {replace, uniqWith, isEqual, pickBy} from "lodash";
+import {replace, uniqWith, isEqual, pickBy, get} from "lodash";
+import {
+    HandlerExecutionContext,
+    InitializeHandler,
+    InitializeHandlerArguments,
+    InitializeHandlerOutput,
+    MetadataBearer
+} from "@smithy/types";
 
 const expressionAttributeKey = (key: string) => replace(key, /-/g, "_");
 
@@ -118,6 +127,35 @@ const paginate = <T>(array: Array<T>, pageSize: number) => {
     }, [] as Array<Array<T>>);
 }
 
+export interface ConsumedCapacityDetail {
+    ReturnConsumedCapacity: ReturnConsumedCapacity | undefined
+    ConsumedCapacity: ConsumedCapacity | undefined
+}
+
+export interface ConsumedCapacityMiddlewareConfig {
+    onConsumedCapacity: (consumedCapacity: ConsumedCapacityDetail) => Promise<unknown>;
+}
+
+export const consumedCapacityMiddleware =
+    (consumedCapacityMiddlewareConfig: ConsumedCapacityMiddlewareConfig) =>
+        <Output extends MetadataBearer = MetadataBearer>(
+            next: InitializeHandler<any, Output>,
+            context: HandlerExecutionContext
+        ): InitializeHandler<any, Output> =>
+            async (args: InitializeHandlerArguments<any>): Promise<InitializeHandlerOutput<Output>> => {
+                try {
+                    const {input} = args;
+                    const {ReturnConsumedCapacity} = input;
+                    const response = await next(args);
+                    const {output} = response;
+                    const consumedCapacity = get(output, "ConsumedCapacity") as ConsumedCapacity | undefined;
+                    await consumedCapacityMiddlewareConfig.onConsumedCapacity({ReturnConsumedCapacity, ConsumedCapacity: consumedCapacity});
+                    return response;
+                } catch (error) {
+                    throw error;
+                }
+            };
+
 export class DynamoDbRepository<K, T> {
 
     constructor(
@@ -125,6 +163,7 @@ export class DynamoDbRepository<K, T> {
         private readonly tableName: string,
         private readonly hashKey: string,
         private readonly rangKey?: string,
+        private readonly returnConsumedCapacity: ReturnConsumedCapacity | undefined = ReturnConsumedCapacity.TOTAL,
     ) {
 
     }
@@ -135,6 +174,7 @@ export class DynamoDbRepository<K, T> {
                 new GetItemCommand({
                     TableName: this.tableName,
                     Key: marshall(key, {removeUndefinedValues: true}),
+                    ReturnConsumedCapacity: this.returnConsumedCapacity,
                 }),
             )
             .then((result) =>
@@ -148,6 +188,7 @@ export class DynamoDbRepository<K, T> {
             .send(
                 new PutItemCommand({
                     TableName: this.tableName,
+                    ReturnConsumedCapacity: this.returnConsumedCapacity,
                     Item,
                 }),
             )
@@ -215,6 +256,7 @@ export class DynamoDbRepository<K, T> {
                 ),
                 {removeUndefinedValues: true},
             ) : undefined,
+            ReturnConsumedCapacity: this.returnConsumedCapacity,
         };
         return this.dynamoDBClient
             .send(new UpdateItemCommand(updateItemCommandInput))
@@ -275,6 +317,7 @@ export class DynamoDbRepository<K, T> {
             : {};
         const queryCommandInput: QueryCommandInput = {
             TableName: this.tableName,
+            ReturnConsumedCapacity: this.returnConsumedCapacity,
             IndexName: index,
             KeyConditionExpression,
             FilterExpression,
@@ -348,9 +391,10 @@ export class DynamoDbRepository<K, T> {
                     [this.tableName]: {
                         Keys: keyPage.map((key) => (marshall(key))),
                         ProjectionExpression,
-                        ExpressionAttributeNames
+                        ExpressionAttributeNames,
                     }
-                }
+                },
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
             }
             return this.dynamoDBClient.send(new BatchGetItemCommand(batchRequest)).then(result =>
                 result.Responses?.[this.tableName].map((item) => unmarshall(item) as T));

package/test/repository.test.ts

@@ -1,7 +1,7 @@
 
 import { DynamoDBClient, CreateTableCommand, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
 import { LocalstackContainer, StartedLocalStackContainer } from "@testcontainers/localstack";
-import {DynamoDbRepository, FilterOperator} from "../src";
+import {ConsumedCapacityDetail, consumedCapacityMiddleware, DynamoDbRepository, FilterOperator} from "../src";
 
 describe('DynamoDbRepository Integration Tests', () => {
     let container: StartedLocalStackContainer;
@@ -12,6 +12,11 @@ describe('DynamoDbRepository Integration Tests', () => {
     const tableName = 'test-table';
     const compositeTableName = 'test-composite-table';
     const gsiTableName = 'test-gsi-table';
+    const consumedCapacityRegister = new Array<ConsumedCapacityDetail>() ;
+
+    const sumConsumedCapacity = () =>
+        consumedCapacityRegister.reduce((total, value) =>
+            total + (value.ConsumedCapacity?.CapacityUnits || 0), 0);
 
     beforeAll(async () => {
         // Start LocalStack container with DynamoDB
@@ -28,7 +33,10 @@ describe('DynamoDbRepository Integration Tests', () => {
             },
         });
 
-        // Create the test table with simple key
+        dynamoDBClient.middlewareStack
+            .add(consumedCapacityMiddleware({onConsumedCapacity: async (consumedCapacity) => consumedCapacityRegister.push(consumedCapacity)}));
+
+        // Create the test table with a simple key
         await dynamoDBClient.send(
             new CreateTableCommand({
                 TableName: tableName,
@@ -42,7 +50,7 @@ describe('DynamoDbRepository Integration Tests', () => {
             })
         );
 
-        // Create the test table with composite key (partition key + sort key)
+        // Create the test table with a composite key (partition key + sort key)
         await dynamoDBClient.send(
             new CreateTableCommand({
                 TableName: compositeTableName,
@@ -108,6 +116,10 @@ describe('DynamoDbRepository Integration Tests', () => {
         gsiRepository = new DynamoDbRepository(dynamoDBClient, gsiTableName, "userId", "itemId");
     });
 
+    afterEach(async () => {
+        consumedCapacityRegister.splice(0, consumedCapacityRegister.length);
+    });
+
     afterAll(async () => {
         // Clean up
         if (dynamoDBClient) {
@@ -122,6 +134,7 @@ describe('DynamoDbRepository Integration Tests', () => {
         it('should return undefined when item does not exist', async () => {
             const result = await repository.getItem({ id: 'non-existent' });
             expect(result).toBeUndefined();
+            expect(sumConsumedCapacity()).toEqual(0.5);
         });
 
         it('should return the item when it exists', async () => {
@@ -132,6 +145,7 @@ describe('DynamoDbRepository Integration Tests', () => {
             const result = await repository.getItem(key);
 
             expect(result).toEqual(record);
+            expect(sumConsumedCapacity()).toEqual(2);
         });
     });
 
@@ -143,6 +157,7 @@ describe('DynamoDbRepository Integration Tests', () => {
             const result = await repository.putItem(key, record);
 
             expect(result).toEqual(record);
+            expect(sumConsumedCapacity()).toEqual(1.5);
         });
     });
 
@@ -155,6 +170,7 @@ describe('DynamoDbRepository Integration Tests', () => {
             await repository.deleteItem(key);
             const afterDelete = await repository.getItem(key);
             expect(afterDelete).toBeUndefined();
+            expect(sumConsumedCapacity()).toEqual(2);
         });
     });