@eresearchqut/ddb-repository 1.0.2

package/.github/workflows/build.yml

@@ -0,0 +1,61 @@
+name: Build
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linter
+        run: npm run lint
+
+      - name: Run tests with coverage
+        run: npm run test:coverage
+
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          file: ./coverage/lcov.info
+          flags: unittests
+          name: codecov-umbrella
+          fail_ci_if_error: false
+
+      - name: Upload coverage to Coveralls
+        uses: coverallsapp/github-action@v2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          path-to-lcov: ./coverage/lcov.info
+        continue-on-error: true
+
+      - name: Build package
+        run: npm run build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 7
+
+      - name: Upload coverage artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: coverage/
+          retention-days: 7

package/.github/workflows/release.yml

@@ -0,0 +1,42 @@
+name: Publish
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      issues: write
+      pull-requests: write
+      id-token: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 'lts/*'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build
+
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release

package/.releaserc.json

@@ -0,0 +1,17 @@
+{
+  "branches": ["main"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    [
+      "@semantic-release/git",
+      {
+        "assets": ["package.json", "package-lock.json", "CHANGELOG.md"],
+        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+      }
+    ],
+    "@semantic-release/github"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+## [1.0.2](https://github.com/eresearchqut/ddb-repository/compare/v1.0.1...v1.0.2) (2025-11-19)
+
+
+### Bug Fixes
+
+* setting publish config access to public ([eed3a3b](https://github.com/eresearchqut/ddb-repository/commit/eed3a3b382153c457e3508d844e111b7f5b3123d))
+
+## [1.0.1](https://github.com/eresearchqut/ddb-repository/compare/v1.0.0...v1.0.1) (2025-11-19)
+
+
+### Bug Fixes
+
+* remove npm registry url from the node setup as per comments on https://github.com/semantic-release/semantic-release/issues/2313 ([291d61b](https://github.com/eresearchqut/ddb-repository/commit/291d61b55c3c5c665623c264306c40e1c21977a2))
+* Repository and package are now public ([b07f151](https://github.com/eresearchqut/ddb-repository/commit/b07f151732f8a158a2b6f0a584e64ea9eb7f5825))
+* updated secret name for GITHUB_TOKEN ([7e00208](https://github.com/eresearchqut/ddb-repository/commit/7e00208f487f5987e72646c15a50fe78808f6ba4))
+* updated secret name for GITHUB_TOKEN ([6d3eff2](https://github.com/eresearchqut/ddb-repository/commit/6d3eff2fff43f0d0848cfc03b7e035d830a3ceb5))
+
+# 1.0.0 (2025-11-19)
+
+
+### Features
+
+* coverage badge ([0f3c9d1](https://github.com/eresearchqut/ddb-repository/commit/0f3c9d128b25466758062ea9e41d1c7d755c2191))

package/README.md

@@ -0,0 +1,202 @@
+# DynamoDB Repository
+
+[![Coverage Status](https://coveralls.io/repos/github/eresearchqut/ddb-repository/badge.svg?branch=main)](https://coveralls.io/github/eresearchqut/ddb-repository?branch=main)
+
+A TypeScript library providing a generic repository pattern implementation for AWS DynamoDB, simplifying CRUD operations and common database interactions.
+
+## Features
+
+- 🚀 Generic repository pattern for type-safe DynamoDB operations
+- 📦 Simple and intuitive API
+- 🔍 Support for common CRUD operations (Create, Read, Update, Delete)
+- 🎯 Batch operations support
+- 🧪 Fully tested with Jest and Testcontainers
+- 💪 Written in TypeScript with full type safety
+- ⚡ Built on top of AWS SDK v3
+
+## Installation
+```sh
+npm install ddb-repository
+```
+## Prerequisites
+
+- Node.js
+- AWS credentials configured (for production use)
+- DynamoDB table with appropriate schema
+
+## Usage
+
+### Basic Example
+```typescript
+import { DynamoDbRepository } from 'ddb-repository';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+
+// Define your entity type
+interface User {
+id: string;
+name: string;
+email: string;
+createdAt: string;
+}
+
+// Initialize DynamoDB client
+const client = new DynamoDBClient({ region: 'us-east-1' });
+
+// Create repository instance
+const userRepository = new DynamoDbRepository<User>(
+client,
+'users-table',
+'id' // partition key
+);
+
+// Create a new user
+await userRepository.create({
+id: '123',
+name: 'John Doe',
+email: 'john@example.com',
+createdAt: new Date().toISOString()
+});
+
+// Find a user by ID
+const user = await userRepository.findById('123');
+
+// Update a user
+await userRepository.update('123', {
+email: 'newemail@example.com'
+});
+
+// Delete a user
+await userRepository.delete('123');
+```
+
+## API Reference
+
+### Constructor
+```
+typescript
+new DynamoDbRepository<T>(client: DynamoDBClient, tableName: string, partitionKey: string, sortKey?: string)
+```
+### Methods
+
+- `create(item: T): Promise<T>` - Create a new item
+- `findById(id: string): Promise<T | null>` - Find item by partition key
+- `update(id: string, updates: Partial<T>): Promise<T>` - Update an existing item
+- `delete(id: string): Promise<void>` - Delete an item
+- `findAll(): Promise<T[]>` - Retrieve all items (use with caution on large tables)
+- `batchCreate(items: T[]): Promise<void>` - Create multiple items in batch
+- `query(options: QueryOptions): Promise<T[]>` - Query items with custom conditions
+
+## Development
+
+### Setup
+```sh
+# Install dependencies
+npm install
+
+# Run linter
+npm run lint
+
+# Fix linting issues automatically
+npm run lint:fix
+
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage report
+npm run test:coverage
+
+# Build the project
+npm run build
+```
+### Testing
+
+The project uses Jest with Testcontainers for integration testing against a real DynamoDB instance:
+```sh
+npm test
+```
+
+### Run tests with coverage
+
+Generate coverage report
+
+```sh
+npm run test:coverage
+```
+
+Coverage reports are generated in the coverage/ directory:
+* coverage/lcov-report/index.html - Interactive HTML report
+* coverage/lcov.info - LCOV format for CI/CD integration
+
+View HTML coverage report, open coverage/lcov-report/index.html
+
+## Configuration
+
+### AWS Credentials
+
+Ensure your AWS credentials are configured via:
+- Environment variables (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`)
+- AWS credentials file (`~/.aws/credentials`)
+- IAM role (when running on AWS infrastructure)
+
+### Required IAM Permissions
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": [
+        "dynamodb:PutItem",
+        "dynamodb:GetItem",
+        "dynamodb:UpdateItem",
+        "dynamodb:DeleteItem",
+        "dynamodb:Query",
+        "dynamodb:Scan",
+        "dynamodb:BatchWriteItem"
+      ],
+      "Resource": "arn:aws:dynamodb:*:*:table/your-table-name"
+    }
+  ]
+}
+```
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+
+### Commit message convention
+Semantic release uses conventional commits. Your commit messages should follow this format:
+
+* feat: new feature → triggers minor version bump (1.x.0)
+* fix: bug fix → triggers patch version bump (1.0.x)
+* perf: performance improvement → triggers patch version bump
+* docs: documentation change → no release
+* chore: maintenance task → no release
+* BREAKING CHANGE: in footer → triggers major version bump (x.0.0)
+
+Example:
+
+> feat: add batch write support
+>
+> Added support for batch write operations to improve performance
+
+Or with breaking change:
+
+> feat: change repository API
+> 
+> BREAKING CHANGE: The query method now returns a Promise instead of an Observable
+
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please open an issue on the GitHub repository.
+

package/dist/DynamoDbRepository.js

@@ -0,0 +1,239 @@
+"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.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");
+const expressionAttributeKey = (key) => (0, lodash_1.replace)(key, /-/g, "_");
+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 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)}`);
+    }
+};
+exports.mapFilterExpression = mapFilterExpression;
+const mapFilterExpressions = (filterExpressions) => filterExpressions
+    .map((filterExpression) => filterExpression.negate
+    ? `NOT ${(0, exports.mapFilterExpression)(filterExpression)}`
+    : (0, exports.mapFilterExpression)(filterExpression))
+    .join(" AND ");
+exports.mapFilterExpressions = mapFilterExpressions;
+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(dynamoDBClient, tableName, hashKey, rangKey) {
+        this.dynamoDBClient = dynamoDBClient;
+        this.tableName = tableName;
+        this.hashKey = hashKey;
+        this.rangKey = rangKey;
+        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 }),
+            }))
+                .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,
+                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,
+            };
+            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
+                ? (0, exports.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,
+                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
+                        }
+                    }
+                };
+                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());
+        });
+    }
+}
+exports.DynamoDbRepository = DynamoDbRepository;

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./DynamoDbRepository"), exports);

package/eslint.config.mjs

@@ -0,0 +1,13 @@
+import eslint from '@eslint/js';
+import { defineConfig, globalIgnores } from 'eslint/config';
+
+import tseslint from 'typescript-eslint';
+
+export default defineConfig([
+    globalIgnores([
+        "node_modules/*", // ignore its content
+        "dist/*",
+    ])],
+    eslint.configs.recommended,
+    tseslint.configs.recommended,
+);

package/jest.config.ts

@@ -0,0 +1,28 @@
+import type { Config } from '@jest/types';
+
+const config: Config.InitialOptions = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    roots: ['<rootDir>/src', '<rootDir>/test'],
+    testMatch: ['**/*.test.ts', '**/*.spec.ts'],
+    collectCoverage: false, // Set to true by default if you want coverage on every run
+    collectCoverageFrom: [
+        'src/**/*.ts',
+        '!src/**/*.d.ts',
+        '!src/**/*.interface.ts',
+        '!src/**/index.ts', // Typically just exports, can be excluded
+    ],
+    coverageDirectory: 'coverage',
+    coverageReporters: [
+        'text',           // Console output
+        'text-summary',   // Summary in console
+        'html',          // HTML report in coverage/
+        'lcov',          // For CI/CD tools
+        'json',          // JSON format
+    ],
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+    verbose: true,
+    testTimeout: 60000
+};
+
+export default config;