@eresearchqut/ddb-repository 1.5.7 → 1.13.4

package/src/DynamoDbRepository.ts

@@ -1,379 +0,0 @@
-import {
-    BatchGetItemCommand,
-    BatchGetItemCommandInput,
-    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";
-
-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 expressionAttributeKey = (key: string) => replace(key, /-/g, "_");
-
-const mapInKeys = (filterExpression: FilterExpression) =>
-    Array.isArray(filterExpression.value)
-        ? filterExpression.value.map(
-            (_, index) => `:${filterExpression.attribute}${index}`,
-        )
-        : `:${filterExpression.attribute}`;
-
-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)}`
-            );
-    }
-};
-
-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 interface DynamoDbRepositoryOptions {
-    client: DynamoDBClient;
-    tableName: string;
-    hashKey: string;
-    rangeKey?: string;
-    returnConsumedCapacity?: ReturnConsumedCapacity;
-}
-
-export class DynamoDbRepository<K, T> {
-    private readonly dynamoDBClient: DynamoDBClient;
-    private readonly tableName: string;
-    private readonly hashKey: string;
-    private readonly rangKey?: string;
-    private readonly returnConsumedCapacity: ReturnConsumedCapacity | undefined;
-
-    constructor(options: DynamoDbRepositoryOptions) {
-        this.dynamoDBClient = options.client;
-        this.tableName = options.tableName;
-        this.hashKey = options.hashKey;
-        this.rangKey = options.rangeKey;
-        this.returnConsumedCapacity = options.returnConsumedCapacity ?? ReturnConsumedCapacity.TOTAL;
-    }
-
-    getItem = async (key: K): Promise<T | undefined> => {
-        return this.dynamoDBClient
-            .send(
-                new GetItemCommand({
-                    TableName: this.tableName,
-                    Key: marshall(key, {removeUndefinedValues: true}),
-                    ReturnConsumedCapacity: this.returnConsumedCapacity,
-                }),
-            )
-            .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,
-                    ReturnConsumedCapacity: this.returnConsumedCapacity,
-                    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,
-            ReturnConsumedCapacity: this.returnConsumedCapacity,
-        };
-        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,
-            ReturnConsumedCapacity: this.returnConsumedCapacity,
-            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,
-                    }
-                },
-                ReturnConsumedCapacity: this.returnConsumedCapacity,
-            }
-            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/consumed-capacity-middleware.ts

@@ -1,41 +0,0 @@
-import {
-    ConsumedCapacity,
-    ReturnConsumedCapacity
-} from "@aws-sdk/client-dynamodb";
-
-import {
-    HandlerExecutionContext,
-    InitializeHandler,
-    InitializeHandlerArguments,
-    InitializeHandlerOutput,
-    MetadataBearer
-} from "@smithy/types";
-
-import {get} from "lodash";
-
-export interface ConsumedCapacityDetail {
-    ReturnConsumedCapacity: ReturnConsumedCapacity | undefined
-    ConsumedCapacity: ConsumedCapacity | ConsumedCapacity[] | undefined
-}
-
-export interface ConsumedCapacityMiddlewareConfig {
-    onConsumedCapacity: (consumedCapacity: ConsumedCapacityDetail) => Promise<unknown>;
-}
-
-/* eslint-disable  @typescript-eslint/no-explicit-any  */
-/* eslint-disable  @typescript-eslint/no-unused-vars  */
-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>> => {
-                const {input} = args;
-                const {ReturnConsumedCapacity} = input;
-                const response = await next(args);
-                const {output} = response;
-                const consumedCapacity = get(output, "ConsumedCapacity") as ConsumedCapacity | ConsumedCapacity[] | undefined;
-                await consumedCapacityMiddlewareConfig.onConsumedCapacity({ReturnConsumedCapacity, ConsumedCapacity: consumedCapacity});
-                return response;
-            };

package/src/index.ts

@@ -1,4 +0,0 @@
-export {Query, IndexedQuery, ProjectedQuery, FilterableQuery, FilterExpression, FilterOperator, DynamoDbRepository} from "./DynamoDbRepository";
-export {consumedCapacityMiddleware, ConsumedCapacityDetail, ConsumedCapacityMiddlewareConfig} from "./consumed-capacity-middleware"
-
-