@eresearchqut/ddb-repository 1.0.2

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@eresearchqut/ddb-repository",
+  "version": "1.0.2",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-dynamodb": "^3.700.0",
+    "@aws-sdk/util-dynamodb": "^3.700.0",
+    "@eslint/js": "^9.39.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.2",
+    "@testcontainers/localstack": "^10.15.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash": "^4.17.20",
+    "@types/node": "^24.10.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-jest": "^29.1.0",
+    "jest": "^29.7.0",
+    "semantic-release": "^25.0.2",
+    "testcontainers": "^10.15.0",
+    "ts-jest": "^29.2.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3",
+    "typescript-eslint": "^8.47.0"
+  },
+  "peerDependencies": {
+    "@aws-sdk/client-dynamodb": ">= 3.49.0",
+    "@aws-sdk/util-dynamodb": ">= 3.49.0",
+    "lodash": "^4.17.20"
+  }
+}

package/src/DynamoDbRepository.ts

@@ -0,0 +1,363 @@
+import {
+    BatchGetItemCommand,
+    BatchGetItemCommandInput,
+    DeleteItemCommand,
+    DynamoDBClient,
+    GetItemCommand,
+    paginateQuery,
+    PutItemCommand,
+    QueryCommandInput,
+    UpdateItemCommand,
+} from "@aws-sdk/client-dynamodb";
+import {marshall, unmarshall} from "@aws-sdk/util-dynamodb";
+import {replace, uniqWith, isEqual, pickBy} from "lodash";
+
+const expressionAttributeKey = (key: string) => replace(key, /-/g, "_");
+
+export enum FilterOperator {
+    EQUALS = "=",
+    NOT_EQUALS = "<>",
+    GREATER_THAN_OR_EQUALS = ">=",
+    GREATER_THAN = ">",
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUALS = "<=",
+    IN = "IN",
+    BETWEEN = "BETWEEN",
+}
+
+export interface FilterExpression {
+    attribute: string;
+    value:
+        | string
+        | number
+        | boolean
+        | Array<string | number>
+        | [string, string]
+        | [number, number];
+    operator: FilterOperator;
+    negate?: boolean;
+}
+
+export interface FilterableQuery {
+    filterExpressions: Array<FilterExpression>;
+}
+
+export interface ProjectedQuery {
+    projectedAttributes: string[];
+}
+
+export interface IndexedQuery {
+    index: string;
+}
+
+export interface Query extends Partial<FilterableQuery>, Partial<ProjectedQuery>, Partial<IndexedQuery> {
+    [key: string]: unknown;
+}
+
+
+const mapInKeys = (filterExpression: FilterExpression) =>
+    Array.isArray(filterExpression.value)
+        ? filterExpression.value.map(
+            (_, index) => `:${filterExpression.attribute}${index}`,
+        )
+        : `:${filterExpression.attribute}`;
+
+export const mapFilterExpression = (filterExpression: 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)}`
+            );
+    }
+};
+
+export const mapFilterExpressions = (
+    filterExpressions: Array<FilterExpression>,
+) =>
+    filterExpressions
+        .map((filterExpression) =>
+            filterExpression.negate
+                ? `NOT ${mapFilterExpression(filterExpression)}`
+                : mapFilterExpression(filterExpression),
+        )
+        .join(" AND ");
+
+const mapFilterExpressionValues = (
+    filterExpression: FilterExpression,
+): Record<string, string | number | boolean> =>
+    Array.isArray(filterExpression.value)
+        ? filterExpression.value.reduce(
+            (reduction, value, index) => ({
+                ...reduction,
+                [`:${expressionAttributeKey(filterExpression.attribute)}${index}`]: value,
+            }),
+            Object.assign({}),
+        )
+        : {
+            [`:${expressionAttributeKey(filterExpression.attribute)}`]:
+            filterExpression.value,
+        };
+
+const paginate = <T>(array: Array<T>, pageSize: number) => {
+    return array.reduce((acc, val, i) => {
+        const idx = Math.floor(i / pageSize)
+        const page = acc[idx] || (acc[idx] = [])
+        page.push(val)
+        return acc
+    }, [] as Array<Array<T>>);
+}
+
+export class DynamoDbRepository<K, T> {
+
+    constructor(
+        private readonly dynamoDBClient: DynamoDBClient,
+        private readonly tableName: string,
+        private readonly hashKey: string,
+        private readonly rangKey?: string,
+    ) {
+
+    }
+
+    getItem = async (key: K): Promise<T | undefined> => {
+        return this.dynamoDBClient
+            .send(
+                new GetItemCommand({
+                    TableName: this.tableName,
+                    Key: marshall(key, {removeUndefinedValues: true}),
+                }),
+            )
+            .then((result) =>
+                result.Item ? unmarshall(result.Item) as T : undefined,
+            )
+    };
+
+    putItem = async (key: K, record: T): Promise<T> => {
+        const Item = marshall({...record, ...key}, {removeUndefinedValues: true});
+        return this.dynamoDBClient
+            .send(
+                new PutItemCommand({
+                    TableName: this.tableName,
+                    Item,
+                }),
+            )
+            .then(() => this.getItem(key) as Promise<T>);
+    };
+
+    deleteItem = async (key: K) => {
+        return this.dynamoDBClient.send(new DeleteItemCommand({
+            TableName: this.tableName,
+            Key: marshall(key),
+        })).then((result) => result.Attributes ?
+            unmarshall(result.Attributes) : undefined);
+    };
+
+
+    updateItem = async (
+        key: K,
+        updates: Partial<T>,
+        remove?: string[],
+    ): Promise<T | undefined> => {
+        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) => ({
+                    ...acc,
+                    [`#${expressionAttributeKey(key)}`]: key,
+                }),
+                {},
+            )
+            : {};
+        const updateItemCommandInput = {
+            TableName: this.tableName,
+            Key: marshall(key),
+            UpdateExpression: `${setAttributesExpression}${removeAttributesExpression}`,
+            ExpressionAttributeNames: Object.entries(updates)
+                .filter(([, value]) => value !== undefined)
+                .reduce(
+                    (acc, [key]) => ({
+                        ...acc,
+                        [`#${expressionAttributeKey(key)}`]: key,
+                    }),
+                    Object.assign(
+                        removeAttributeNames,
+                    ),
+                ) as Record<string, string>,
+            ExpressionAttributeValues: hasUpdates ? marshall(
+                Object.entries(updates).reduce(
+                    (acc, [key, value]) => ({
+                        ...acc,
+                        [`:${expressionAttributeKey(key)}`]: value,
+                    }),
+                    Object.assign(
+                        {},
+                    ),
+                ),
+                {removeUndefinedValues: true},
+            ) : undefined,
+        };
+        return this.dynamoDBClient
+            .send(new UpdateItemCommand(updateItemCommandInput))
+            .then(() => this.getItem(key));
+    };
+
+
+    getItems = async (
+        query: Query
+    ): Promise<Array<T> | undefined> => {
+        const {index, filterExpressions, projectedAttributes, ...keys} = query;
+        const KeyConditionExpression = Object.keys(keys)
+            .map((key) => `#${expressionAttributeKey(key)} = :${expressionAttributeKey(key)}`).join(' AND ');
+        const keyExpressionAttributeNames = Object.keys(keys)
+            .reduce((acc, key) => ({...acc, [`#${expressionAttributeKey(key)}`]: key}), Object.assign({}));
+        const keyExpressionAttributeValues = Object.entries(keys)
+            .reduce((acc, [key, value]) => ({...acc, [`:${expressionAttributeKey(key)}`]: value}), Object.assign({}));
+
+        const ProjectionExpression = !index && projectedAttributes
+            ? projectedAttributes.map((attribute) => `#${expressionAttributeKey(attribute)}`).join(',')
+            : undefined;
+        const projectionAttributeNames: Record<string, string> = !index && projectedAttributes ? projectedAttributes.reduce(
+            (
+                reduction: Record<string, string>,
+                attribute: string,
+            ) => ({
+                ...reduction,
+                [`#${expressionAttributeKey(attribute)}`]:
+                attribute,
+            }),
+            Object.assign({}),
+        ) : {}
+        const hasFilterExpressions = Array.isArray(filterExpressions) && filterExpressions.length > 0;
+        const FilterExpression = hasFilterExpressions
+            ? mapFilterExpressions(filterExpressions)
+            : undefined;
+        const filterAttributeNames: Record<string, string> = hasFilterExpressions
+            ? filterExpressions.reduce(
+                (
+                    reduction: Record<string, string>,
+                    filterExpression: FilterExpression,
+                ) => ({
+                    ...reduction,
+                    [`#${expressionAttributeKey(filterExpression.attribute)}`]:
+                    filterExpression.attribute,
+                }),
+                Object.assign({}),
+            )
+            : {};
+        const filterAttributeValues = filterExpressions
+            ? filterExpressions.reduce(
+                (reduction, filterExpression) => ({
+                    ...reduction,
+                    ...mapFilterExpressionValues(filterExpression),
+                }),
+                Object.assign({}),
+            )
+            : {};
+        const queryCommandInput: QueryCommandInput = {
+            TableName: this.tableName,
+            IndexName: index,
+            KeyConditionExpression,
+            FilterExpression,
+            ProjectionExpression,
+            ExpressionAttributeNames: {
+                ...keyExpressionAttributeNames,
+                ...filterAttributeNames,
+                ...projectionAttributeNames
+            },
+            ExpressionAttributeValues: marshall(
+                {...keyExpressionAttributeValues, ...filterAttributeValues},
+                {removeUndefinedValues: true},
+            ),
+        };
+        const paginator = paginateQuery(
+            {client: this.dynamoDBClient, pageSize: 100},
+            queryCommandInput,
+        );
+
+        if (index) {
+            const keys: Array<K> = [];
+            for await (const page of paginator) {
+                if (page.Items) {
+                    keys.push(
+                        ...(page.Items.map((item) => unmarshall(item) as T)
+                            .map((item: T) =>
+                                pickBy(item as object, (_, key) => (key === this.hashKey || key === this.rangKey)) as K)),
+                    )
+                }
+            }
+            const items = await this.batchGetItems(keys, query as ProjectedQuery);
+            return items as Array<T>;
+        }
+
+        const items: Array<T> = [];
+        for await (const page of paginator) {
+            if (page.Items) {
+                items.push(
+                    ...(page.Items?.map((item) => unmarshall(item) as T) || []),
+                )
+            }
+        }
+        return items;
+    };
+
+
+    batchGetItems = async (
+        keys: K[], projectedQuery?: ProjectedQuery
+    ): Promise<Array<T | undefined>> => {
+        const uniqueKeys = uniqWith(keys, 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: Record<string, string>,
+                attribute: string,
+            ) => ({
+                ...reduction,
+                [`#${expressionAttributeKey(attribute)}`]:
+                attribute,
+            }),
+            Object.assign({}),
+        ) : undefined;
+        return Promise.all((keyPages.map(async (keyPage) => {
+            const batchRequest: BatchGetItemCommandInput = {
+                RequestItems: {
+                    [this.tableName]: {
+                        Keys: keyPage.map((key) => (marshall(key))),
+                        ProjectionExpression,
+                        ExpressionAttributeNames
+                    }
+                }
+            }
+            return this.dynamoDBClient.send(new BatchGetItemCommand(batchRequest)).then(result =>
+                result.Responses?.[this.tableName].map((item) => unmarshall(item) as T));
+        })))
+            .then((itemSets) => itemSets.flat());
+
+    };
+
+}
+

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./DynamoDbRepository";
+
+