@eresearchqut/ddb-repository 1.5.3 → 1.5.5

package/.github/workflows/release.yml

@@ -24,9 +24,15 @@ jobs:
           node-version: 'lts/*'
       - name: Install dependencies
         run: npm clean-install
+      - name: Build package
+        run: npm run build
       - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
         run: npm audit signatures
-      - name: Release
+      - name: Semantic Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npx semantic-release
+        run: npx semantic-release
+      - name: NPM Publish
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: npm publish

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.5.5](https://github.com/eresearchqut/ddb-repository/compare/v1.5.4...v1.5.5) (2025-12-11)
+
+
+### Bug Fixes
+
+* Adding NPM Publish ([8246366](https://github.com/eresearchqut/ddb-repository/commit/824636610a803b8a0bc07f4b1227f9ddde997de7))
+
+## [1.5.4](https://github.com/eresearchqut/ddb-repository/compare/v1.5.3...v1.5.4) (2025-12-11)
+
+
+### Bug Fixes
+
+* adding build to release action ([a396d9f](https://github.com/eresearchqut/ddb-repository/commit/a396d9f507ec7da3ebac7664f1d0641f8897280d))
+
 ## [1.5.3](https://github.com/eresearchqut/ddb-repository/compare/v1.5.2...v1.5.3) (2025-12-10)
 
 

package/dist/DynamoDbRepository.js

@@ -0,0 +1,244 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    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.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");
+var FilterOperator;
+(function (FilterOperator) {
+    FilterOperator["EQUALS"] = "=";
+    FilterOperator["NOT_EQUALS"] = "<>";
+    FilterOperator["GREATER_THAN_OR_EQUALS"] = ">=";
+    FilterOperator["GREATER_THAN"] = ">";
+    FilterOperator["LESS_THAN"] = "<";
+    FilterOperator["LESS_THAN_OR_EQUALS"] = "<=";
+    FilterOperator["IN"] = "IN";
+    FilterOperator["BETWEEN"] = "BETWEEN";
+})(FilterOperator || (exports.FilterOperator = FilterOperator = {}));
+const expressionAttributeKey = (key) => (0, lodash_1.replace)(key, /-/g, "_");
+const mapInKeys = (filterExpression) => Array.isArray(filterExpression.value)
+    ? filterExpression.value.map((_, index) => `:${filterExpression.attribute}${index}`)
+    : `:${filterExpression.attribute}`;
+const mapFilterExpression = (filterExpression) => {
+    switch (filterExpression.operator) {
+        case FilterOperator.IN:
+            return (`#${expressionAttributeKey(filterExpression.attribute)} ${filterExpression.operator} ` +
+                `(${mapInKeys(filterExpression)})`);
+        case FilterOperator.BETWEEN:
+            return (`#${expressionAttributeKey(filterExpression.attribute)} ${filterExpression.operator} ` +
+                `:${expressionAttributeKey(filterExpression.attribute)}0 AND :${expressionAttributeKey(filterExpression.attribute)}1`);
+        default:
+            return (`#${expressionAttributeKey(filterExpression.attribute)} ${filterExpression.operator} ` +
+                `:${expressionAttributeKey(filterExpression.attribute)}`);
+    }
+};
+const mapFilterExpressions = (filterExpressions) => filterExpressions
+    .map((filterExpression) => filterExpression.negate
+    ? `NOT ${mapFilterExpression(filterExpression)}`
+    : mapFilterExpression(filterExpression))
+    .join(" AND ");
+const mapFilterExpressionValues = (filterExpression) => Array.isArray(filterExpression.value)
+    ? filterExpression.value.reduce((reduction, value, index) => (Object.assign(Object.assign({}, reduction), { [`:${expressionAttributeKey(filterExpression.attribute)}${index}`]: value })), Object.assign({}))
+    : {
+        [`:${expressionAttributeKey(filterExpression.attribute)}`]: filterExpression.value,
+    };
+const paginate = (array, pageSize) => {
+    return array.reduce((acc, val, i) => {
+        const idx = Math.floor(i / pageSize);
+        const page = acc[idx] || (acc[idx] = []);
+        page.push(val);
+        return acc;
+    }, []);
+};
+class DynamoDbRepository {
+    constructor(options) {
+        var _a;
+        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);
+        });
+        this.putItem = (key, record) => __awaiter(this, void 0, void 0, function* () {
+            const Item = (0, util_dynamodb_1.marshall)(Object.assign(Object.assign({}, record), key), { removeUndefinedValues: true });
+            return this.dynamoDBClient
+                .send(new client_dynamodb_1.PutItemCommand({
+                TableName: this.tableName,
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
+                Item,
+            }))
+                .then(() => this.getItem(key));
+        });
+        this.deleteItem = (key) => __awaiter(this, void 0, void 0, function* () {
+            return this.dynamoDBClient.send(new client_dynamodb_1.DeleteItemCommand({
+                TableName: this.tableName,
+                Key: (0, util_dynamodb_1.marshall)(key),
+            })).then((result) => result.Attributes ?
+                (0, util_dynamodb_1.unmarshall)(result.Attributes) : undefined);
+        });
+        this.updateItem = (key, updates, remove) => __awaiter(this, void 0, void 0, function* () {
+            const hasUpdates = Object.keys(updates).length > 0;
+            const setAttributesExpression = hasUpdates ? `SET ${Object.entries(updates)
+                .filter(([, value]) => value !== undefined)
+                .map(([key]) => `#${expressionAttributeKey(key)} = :${expressionAttributeKey(key)}`)
+                .join(", ")}` : '';
+            const removeAttributesExpression = remove
+                ? ` REMOVE ${remove.map((key) => `#${expressionAttributeKey(key)}`).join(", ")}`
+                : "";
+            const removeAttributeNames = remove
+                ? remove.map(expressionAttributeKey).reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [`#${expressionAttributeKey(key)}`]: key })), {})
+                : {};
+            const updateItemCommandInput = {
+                TableName: this.tableName,
+                Key: (0, util_dynamodb_1.marshall)(key),
+                UpdateExpression: `${setAttributesExpression}${removeAttributesExpression}`,
+                ExpressionAttributeNames: Object.entries(updates)
+                    .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))
+                .then(() => this.getItem(key));
+        });
+        this.getItems = (query) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c, _d, e_2, _e, _f;
+            var _g;
+            const { index, filterExpressions, projectedAttributes } = query, keys = __rest(query, ["index", "filterExpressions", "projectedAttributes"]);
+            const KeyConditionExpression = Object.keys(keys)
+                .map((key) => `#${expressionAttributeKey(key)} = :${expressionAttributeKey(key)}`).join(' AND ');
+            const keyExpressionAttributeNames = Object.keys(keys)
+                .reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [`#${expressionAttributeKey(key)}`]: key })), Object.assign({}));
+            const keyExpressionAttributeValues = Object.entries(keys)
+                .reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [`:${expressionAttributeKey(key)}`]: value })), Object.assign({}));
+            const ProjectionExpression = !index && projectedAttributes
+                ? projectedAttributes.map((attribute) => `#${expressionAttributeKey(attribute)}`).join(',')
+                : undefined;
+            const projectionAttributeNames = !index && projectedAttributes ? projectedAttributes.reduce((reduction, attribute) => (Object.assign(Object.assign({}, reduction), { [`#${expressionAttributeKey(attribute)}`]: attribute })), Object.assign({})) : {};
+            const hasFilterExpressions = Array.isArray(filterExpressions) && filterExpressions.length > 0;
+            const FilterExpression = hasFilterExpressions
+                ? mapFilterExpressions(filterExpressions)
+                : undefined;
+            const filterAttributeNames = hasFilterExpressions
+                ? filterExpressions.reduce((reduction, filterExpression) => (Object.assign(Object.assign({}, reduction), { [`#${expressionAttributeKey(filterExpression.attribute)}`]: filterExpression.attribute })), Object.assign({}))
+                : {};
+            const filterAttributeValues = filterExpressions
+                ? filterExpressions.reduce((reduction, filterExpression) => (Object.assign(Object.assign({}, reduction), mapFilterExpressionValues(filterExpression))), Object.assign({}))
+                : {};
+            const queryCommandInput = {
+                TableName: this.tableName,
+                ReturnConsumedCapacity: this.returnConsumedCapacity,
+                IndexName: index,
+                KeyConditionExpression,
+                FilterExpression,
+                ProjectionExpression,
+                ExpressionAttributeNames: Object.assign(Object.assign(Object.assign({}, keyExpressionAttributeNames), filterAttributeNames), projectionAttributeNames),
+                ExpressionAttributeValues: (0, util_dynamodb_1.marshall)(Object.assign(Object.assign({}, keyExpressionAttributeValues), filterAttributeValues), { removeUndefinedValues: true }),
+            };
+            const paginator = (0, client_dynamodb_1.paginateQuery)({ client: this.dynamoDBClient, pageSize: 100 }, queryCommandInput);
+            if (index) {
+                const keys = [];
+                try {
+                    for (var _h = true, paginator_1 = __asyncValues(paginator), paginator_1_1; paginator_1_1 = yield paginator_1.next(), _a = paginator_1_1.done, !_a; _h = true) {
+                        _c = paginator_1_1.value;
+                        _h = false;
+                        const page = _c;
+                        if (page.Items) {
+                            keys.push(...(page.Items.map((item) => (0, util_dynamodb_1.unmarshall)(item))
+                                .map((item) => (0, lodash_1.pickBy)(item, (_, key) => (key === this.hashKey || key === this.rangKey)))));
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_h && !_a && (_b = paginator_1.return)) yield _b.call(paginator_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                const items = yield this.batchGetItems(keys, query);
+                return items;
+            }
+            const items = [];
+            try {
+                for (var _j = true, paginator_2 = __asyncValues(paginator), paginator_2_1; paginator_2_1 = yield paginator_2.next(), _d = paginator_2_1.done, !_d; _j = true) {
+                    _f = paginator_2_1.value;
+                    _j = false;
+                    const page = _f;
+                    if (page.Items) {
+                        items.push(...(((_g = page.Items) === null || _g === void 0 ? void 0 : _g.map((item) => (0, util_dynamodb_1.unmarshall)(item))) || []));
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_j && !_d && (_e = paginator_2.return)) yield _e.call(paginator_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return items;
+        });
+        this.batchGetItems = (keys, projectedQuery) => __awaiter(this, void 0, void 0, function* () {
+            const uniqueKeys = (0, lodash_1.uniqWith)(keys, lodash_1.isEqual);
+            const keyPages = paginate(uniqueKeys, 100);
+            const { projectedAttributes } = projectedQuery || {};
+            const ProjectionExpression = projectedAttributes
+                ? projectedAttributes.map((attribute) => `#${expressionAttributeKey(attribute)}`).join(',')
+                : undefined;
+            const ExpressionAttributeNames = projectedAttributes ?
+                projectedAttributes.reduce((reduction, attribute) => (Object.assign(Object.assign({}, reduction), { [`#${expressionAttributeKey(attribute)}`]: attribute })), Object.assign({})) : undefined;
+            return Promise.all((keyPages.map((keyPage) => __awaiter(this, void 0, void 0, function* () {
+                const batchRequest = {
+                    RequestItems: {
+                        [this.tableName]: {
+                            Keys: keyPage.map((key) => ((0, util_dynamodb_1.marshall)(key))),
+                            ProjectionExpression,
+                            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)); });
+            }))))
+                .then((itemSets) => itemSets.flat());
+        });
+        this.dynamoDBClient = options.client;
+        this.tableName = options.tableName;
+        this.hashKey = options.hashKey;
+        this.rangKey = options.rangeKey;
+        this.returnConsumedCapacity = (_a = options.returnConsumedCapacity) !== null && _a !== void 0 ? _a : client_dynamodb_1.ReturnConsumedCapacity.TOTAL;
+    }
+}
+exports.DynamoDbRepository = DynamoDbRepository;

package/dist/consumed-capacity-middleware.js

@@ -0,0 +1,25 @@
+"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.consumedCapacityMiddleware = void 0;
+const lodash_1 = require("lodash");
+/* eslint-disable  @typescript-eslint/no-explicit-any  */
+/* eslint-disable  @typescript-eslint/no-unused-vars  */
+const consumedCapacityMiddleware = (consumedCapacityMiddlewareConfig) => (next, context) => (args) => __awaiter(void 0, void 0, void 0, function* () {
+    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;
+});
+exports.consumedCapacityMiddleware = consumedCapacityMiddleware;

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consumedCapacityMiddleware = exports.DynamoDbRepository = exports.FilterOperator = void 0;
+var DynamoDbRepository_1 = require("./DynamoDbRepository");
+Object.defineProperty(exports, "FilterOperator", { enumerable: true, get: function () { return DynamoDbRepository_1.FilterOperator; } });
+Object.defineProperty(exports, "DynamoDbRepository", { enumerable: true, get: function () { return DynamoDbRepository_1.DynamoDbRepository; } });
+var consumed_capacity_middleware_1 = require("./consumed-capacity-middleware");
+Object.defineProperty(exports, "consumedCapacityMiddleware", { enumerable: true, get: function () { return consumed_capacity_middleware_1.consumedCapacityMiddleware; } });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eresearchqut/ddb-repository",
-  "version": "1.5.3",
-  "description": "",
+  "version": "1.5.5",
+  "description": "A TypeScript library providing a generic repository pattern implementation for AWS DynamoDB, simplifying CRUD operations and common database interactions.",
   "type": "commonjs",
   "main": "dist/index.js",
   "publishConfig": {