@itzworking/single-table 0.0.162 → 0.0.196

package/dist-cjs/dynamodb/dynamodb.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamodb = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const marshallOptions = {
+    convertEmptyValues: false,
+    removeUndefinedValues: true,
+    convertClassInstanceToMap: true,
+};
+const unmarshallOptions = {
+    wrapNumbers: false,
+};
+exports.dynamodb = lib_dynamodb_1.DynamoDBDocumentClient.from(new client_dynamodb_1.DynamoDBClient({}), {
+    marshallOptions,
+    unmarshallOptions,
+});

package/{dist → dist-cjs}/errors/decorators-error.js

@@ -8,7 +8,7 @@ class DecoratorsError extends single_table_error_1.SingleTableError {
             message,
         });
         this.name = "DecoratorsError";
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.DecoratorsError = DecoratorsError;

package/{dist → dist-cjs}/errors/generate-update-expression-error.js

@@ -8,7 +8,7 @@ class GenerateUpdateExpressionError extends single_table_error_1.SingleTableErro
             message,
         });
         this.name = "GenerateUpdateExpressionError";
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.GenerateUpdateExpressionError = GenerateUpdateExpressionError;

package/{dist → dist-cjs}/errors/index-decorator-error.js

@@ -8,7 +8,7 @@ class IndexDecoratorError extends single_table_error_1.SingleTableError {
             message,
         });
         this.name = "IndexDecoratorError";
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.IndexDecoratorError = IndexDecoratorError;

package/{dist → dist-cjs}/errors/key-composition-error.js

@@ -8,7 +8,7 @@ class KeyCompositionError extends single_table_error_1.SingleTableError {
             message,
         });
         this.name = "KeyCompositionError";
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.KeyCompositionError = KeyCompositionError;

package/{dist → dist-cjs}/errors/single-table-error.js

@@ -8,7 +8,7 @@ class SingleTableError extends Error {
         const { statusCode = 500 } = props;
         this.name = "SingleTableError";
         this.statusCode = statusCode;
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.SingleTableError = SingleTableError;

package/{dist → dist-cjs}/errors/single-table-item-format-error.js

@@ -8,7 +8,7 @@ class SingleTableItemFormatError extends single_table_error_1.SingleTableError {
             message,
         });
         this.name = "SingleTableItemFormatError";
-        Object.setPrototypeOf(this, new.target.prototype); // maintain prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 exports.SingleTableItemFormatError = SingleTableItemFormatError;

package/dist-cjs/single-table-item/single-table-item.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleTableItem = void 0;
+const tslib_1 = require("tslib");
+const uuid_1 = require("uuid");
+const decorators_1 = require("../decorators");
+const utils_1 = require("./utils");
+const errors_1 = require("../errors");
+const decorated_class_1 = require("@itzworking/decorated-class");
+class SingleTableItem extends decorated_class_1.DecoratedClass {
+    id;
+    createdAt;
+    updatedAt;
+    createdBy;
+    updatedBy;
+    deletedBy;
+    deletedAt;
+    constructor(props = {}) {
+        super(props);
+        (0, utils_1.validateEntityAnnotations)(this);
+        if (!props?.id) {
+            this.generateId();
+        }
+        if (!props?.createdAt) {
+            this.createdAt = new Date();
+        }
+        if (!props?.updatedAt) {
+            this.updatedAt = new Date();
+        }
+    }
+    generateId() {
+        this.id = (0, uuid_1.v4)();
+        return this.id;
+    }
+    type() {
+        return (0, decorators_1.getEntityName)(this);
+    }
+    pk() {
+        const keys = (0, decorators_1.getPKComposition)(this);
+        if (!keys?.length) {
+            throw new errors_1.IndexDecoratorError(`@Entity("${this.type()}") @Index: PK is not defined`);
+        }
+        return (0, utils_1.handleCompositePrimaryKey)(this, keys);
+    }
+    sk() {
+        const keys = (0, decorators_1.getSKComposition)(this);
+        if (!keys?.length) {
+            throw new errors_1.IndexDecoratorError(`@Entity("${this.type()}") @Index: SK is not defined`);
+        }
+        return (0, utils_1.handleCompositePrimaryKey)(this, keys);
+    }
+    key() {
+        return {
+            PK: this.pk(),
+            SK: this.sk(),
+        };
+    }
+    gsi1pk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getPKComposition)(this, "GSI1"));
+    }
+    gsi1sk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getSKComposition)(this, "GSI1"));
+    }
+    gsi2pk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getPKComposition)(this, "GSI2"));
+    }
+    gsi2sk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getSKComposition)(this, "GSI2"));
+    }
+    gsi3pk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getPKComposition)(this, "GSI3"));
+    }
+    gsi3sk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getSKComposition)(this, "GSI3"));
+    }
+    gsi4pk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getPKComposition)(this, "GSI4"));
+    }
+    gsi4sk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getSKComposition)(this, "GSI4"));
+    }
+    gsi5pk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getPKComposition)(this, "GSI5"));
+    }
+    gsi5sk() {
+        return (0, utils_1.handleCompositePrimaryKey)(this, (0, decorators_1.getSKComposition)(this, "GSI5"));
+    }
+    generateUpdateExpression(attributes = []) {
+        const attributesToUpdate = [];
+        const entityAttributes = (0, decorated_class_1.listAttributes)(this);
+        if (attributes?.length) {
+            for (const attribute of attributes) {
+                if (entityAttributes.find((ef) => ef.attributeName === attribute)) {
+                    attributesToUpdate.push(attribute);
+                }
+                else {
+                    throw new errors_1.GenerateUpdateExpressionError(`@Entity("${this.type()}"): ${attribute} is not an @Attribute`);
+                }
+            }
+        }
+        else {
+            for (const attribute of entityAttributes) {
+                if (!(0, decorators_1.isEditable)(this, attribute.attributeName)) {
+                    continue;
+                }
+                attributesToUpdate.push(attribute.attributeName);
+            }
+        }
+        if (attributesToUpdate.length === 0) {
+            throw new errors_1.GenerateUpdateExpressionError(`@Entity("${this.type()}"): attributesToUpdate is empty; attributes = ${attributes}`);
+        }
+        else {
+            const indexComposition = {
+                PK: (0, decorators_1.getPKComposition)(this),
+                SK: (0, decorators_1.getSKComposition)(this),
+            };
+            const indexPkSkAttributes = [
+                ...(indexComposition.PK || []),
+                ...(indexComposition.SK || []),
+            ];
+            const notAllowedAttributes = indexPkSkAttributes.filter((attribute) => attributesToUpdate.includes(attribute));
+            if (notAllowedAttributes.length > 0) {
+                throw new errors_1.GenerateUpdateExpressionError(`@Entity("${this.type()}"): cannot update @Index notAllowedAttributes = ${notAllowedAttributes}`);
+            }
+        }
+        const attributeValues = {};
+        const attributeNames = {};
+        const namesAndValues = [];
+        const attributesToRemove = [];
+        const gsis = {
+            GSI1: {
+                PK: (0, decorators_1.getPKComposition)(this, "GSI1"),
+                SK: (0, decorators_1.getSKComposition)(this, "GSI1"),
+            },
+            GSI2: {
+                PK: (0, decorators_1.getPKComposition)(this, "GSI2"),
+                SK: (0, decorators_1.getSKComposition)(this, "GSI2"),
+            },
+            GSI3: {
+                PK: (0, decorators_1.getPKComposition)(this, "GSI3"),
+                SK: (0, decorators_1.getSKComposition)(this, "GSI3"),
+            },
+            GSI4: {
+                PK: (0, decorators_1.getPKComposition)(this, "GSI4"),
+                SK: (0, decorators_1.getSKComposition)(this, "GSI4"),
+            },
+            GSI5: {
+                PK: (0, decorators_1.getPKComposition)(this, "GSI5"),
+                SK: (0, decorators_1.getSKComposition)(this, "GSI5"),
+            },
+        };
+        for (const [gsiKey, gsiComposition] of Object.entries(gsis)) {
+            for (const [gsiAttributeKey, gsiAttributeComposition] of Object.entries(gsiComposition)) {
+                if (gsiAttributeComposition?.some((key) => attributesToUpdate.includes(key))) {
+                    attributeNames[`#key${gsiKey}${gsiAttributeKey}`] = `${gsiKey}${gsiAttributeKey}`;
+                    attributeValues[`:value${gsiKey}${gsiAttributeKey}`] = this[`${gsiKey}${gsiAttributeKey}`.toLowerCase()]();
+                    namesAndValues.push(`#key${gsiKey}${gsiAttributeKey} = :value${gsiKey}${gsiAttributeKey}`);
+                }
+            }
+        }
+        for (const key of attributesToUpdate) {
+            const keyToUse = (0, utils_1.capitalizeFirstLetter)(key);
+            const value = this[key];
+            attributeNames[`#key${keyToUse}`] = key;
+            if (value === undefined) {
+                attributesToRemove.push(`#key${keyToUse}`);
+            }
+            else {
+                attributeValues[`:value${keyToUse}`] =
+                    value instanceof Date ? value.toISOString() : value;
+                namesAndValues.push(`#key${keyToUse} = :value${keyToUse}`);
+            }
+        }
+        return {
+            UpdateExpression: ((namesAndValues.length ? `SET ${namesAndValues.join(", ")} ` : "") +
+                (attributesToRemove.length
+                    ? `REMOVE ${attributesToRemove.join(", ")}`
+                    : "")).trim(),
+            ExpressionAttributeNames: attributeNames,
+            ExpressionAttributeValues: attributeValues,
+        };
+    }
+    toSingleTableItem() {
+        const result = {
+            type: this.type(),
+            ...this.key(),
+        };
+        if (this.gsi1pk() && this.gsi1sk()) {
+            result.GSI1PK = this.gsi1pk();
+            result.GSI1SK = this.gsi1sk();
+        }
+        if (this.gsi2pk() && this.gsi2sk()) {
+            result.GSI2PK = this.gsi2pk();
+            result.GSI2SK = this.gsi2sk();
+        }
+        if (this.gsi3pk() && this.gsi3sk()) {
+            result.GSI3PK = this.gsi3pk();
+            result.GSI3SK = this.gsi3sk();
+        }
+        if (this.gsi4pk() && this.gsi4sk()) {
+            result.GSI4PK = this.gsi4pk();
+            result.GSI4SK = this.gsi4sk();
+        }
+        if (this.gsi5pk() && this.gsi5sk()) {
+            result.GSI5PK = this.gsi5pk();
+            result.GSI5SK = this.gsi5sk();
+        }
+        const attributes = (0, decorated_class_1.listAttributes)(this);
+        const reservedKeys = [
+            "type",
+            "PK",
+            "SK",
+            "GSI1PK",
+            "GSI1SK",
+            "GSI2PK",
+            "GSI2SK",
+            "GSI3PK",
+            "GSI3SK",
+            "GSI4PK",
+            "GSI4SK",
+            "GSI5PK",
+            "GSI5SK",
+        ];
+        const reservedKeysInUse = reservedKeys.filter((reservedKey) => attributes.find((f) => f.attributeName === reservedKey));
+        if (reservedKeysInUse.length > 0) {
+            throw new errors_1.SingleTableItemFormatError(`@Entity("${this.type()}"): cannot use reserved keys in attributes = ${reservedKeysInUse}`);
+        }
+        for (const attribute of attributes) {
+            const value = this[attribute.attributeName];
+            if (value !== undefined) {
+                result[attribute.attributeName] =
+                    value instanceof Date ? value.toISOString() : value;
+            }
+        }
+        return result;
+    }
+}
+exports.SingleTableItem = SingleTableItem;
+tslib_1.__decorate([
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.String)
+], SingleTableItem.prototype, "id", void 0);
+tslib_1.__decorate([
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.Date)
+], SingleTableItem.prototype, "createdAt", void 0);
+tslib_1.__decorate([
+    decorators_1.Editable,
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.Date)
+], SingleTableItem.prototype, "updatedAt", void 0);
+tslib_1.__decorate([
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.String)
+], SingleTableItem.prototype, "createdBy", void 0);
+tslib_1.__decorate([
+    decorators_1.Editable,
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.String)
+], SingleTableItem.prototype, "updatedBy", void 0);
+tslib_1.__decorate([
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.String)
+], SingleTableItem.prototype, "deletedBy", void 0);
+tslib_1.__decorate([
+    (0, decorated_class_1.Attribute)(decorated_class_1.AttributeType.Date)
+], SingleTableItem.prototype, "deletedAt", void 0);

package/dist-cjs/single-table-item/utils/validate-entity-annotations.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEntityAnnotations = void 0;
+const errors_1 = require("../../errors");
+const validateEntityAnnotations = (entity) => {
+    const errors = [];
+    if (!entity.type()) {
+        errors.push("missing @Entity annotation on SingleTableItem class");
+    }
+    try {
+        entity.key();
+    }
+    catch (e) {
+        errors.push("missing @Index annotation on SingleTableItem class");
+    }
+    if (errors.length) {
+        throw new errors_1.DecoratorsError(errors.join(","));
+    }
+};
+exports.validateEntityAnnotations = validateEntityAnnotations;

package/{dist → dist-cjs}/single-table-repository/single-table-repository.js

@@ -187,28 +187,6 @@ class SingleTableRepository {
             }
             response.items.push(new entityClass(dynamodbItem));
         }
-        // if (response.items.length > 0) {
-        //   const classPriority: Map<EntityConstructor<U>, number> = new Map();
-        //   let index = 0;
-        //   for (const entityClass of options.entityClasses) {
-        //     classPriority.set(entityClass, index);
-        //     index++;
-        //   }
-        //   const classPriorityArray = Array.from(classPriority.keys());
-        //   response.items.sort((a, b) => {
-        //     const aPriority = classPriorityArray.findIndex(
-        //       (constructorFn) => a instanceof constructorFn
-        //     );
-        //     const bPriority = classPriorityArray.findIndex(
-        //       (constructorFn) => b instanceof constructorFn
-        //     );
-        //
-        //     const classCompare = aPriority - bPriority;
-        //     if (classCompare !== 0) return classCompare;
-        //
-        //     return a.createdAt.getTime() - b.createdAt.getTime();
-        //   });
-        // }
         return response;
     }
 }

package/dist-es/decorators/editable/editable.js

@@ -0,0 +1,4 @@
+import { symbol } from "./symbol";
+export const Editable = (target, context) => {
+    Reflect.defineMetadata(symbol, true, target, typeof context === "string" ? context : context.name);
+};

package/dist-es/decorators/editable/index.js

@@ -0,0 +1,2 @@
+export * from "./editable";
+export * from "./is-editable";

package/dist-es/decorators/editable/is-editable.js

@@ -0,0 +1,4 @@
+import { symbol } from "./symbol";
+export const isEditable = (target, propertyKey) => {
+    return !!Reflect.getMetadata(symbol, target, propertyKey);
+};

package/dist-es/decorators/editable/symbol.js

@@ -0,0 +1 @@
+export const symbol = Symbol("Editable");

package/dist-es/decorators/entity/entity.js

@@ -0,0 +1,6 @@
+import { symbol } from "./symbol";
+export const Entity = (name) => {
+    return (constructor, ctx) => {
+        Reflect.defineMetadata(constructor.name + "#" + symbol.toString(), name, constructor);
+    };
+};

package/dist-es/decorators/entity/get-entity-name.js

@@ -0,0 +1,4 @@
+import { symbol } from "./symbol";
+export const getEntityName = (target) => {
+    return Reflect.getMetadata(target.constructor.name + "#" + symbol.toString(), target.constructor);
+};

package/dist-es/decorators/entity/index.js

@@ -0,0 +1,2 @@
+export * from "./entity";
+export * from "./get-entity-name";

package/dist-es/decorators/entity/symbol.js

@@ -0,0 +1 @@
+export const symbol = Symbol("EntityName");

package/dist-es/decorators/gsis/get-pk-composition.js

@@ -0,0 +1,4 @@
+import { symbols } from "./symbols";
+export const getPKComposition = (target, name = "Index") => {
+    return Reflect.getMetadata(target.constructor.name + "#" + symbols[name].PK.toString(), target.constructor);
+};

package/dist-es/decorators/gsis/get-sk-composition.js

@@ -0,0 +1,4 @@
+import { symbols } from "./symbols";
+export const getSKComposition = (target, name = "Index") => {
+    return Reflect.getMetadata(target.constructor.name + "#" + symbols[name].SK.toString(), target.constructor);
+};

package/dist-es/decorators/gsis/gsis.js

@@ -0,0 +1,15 @@
+import { symbols } from "./symbols";
+const buildIndex = (name = "Index") => {
+    return (keyComposition) => {
+        return (constructor, context) => {
+            Reflect.defineMetadata(constructor.name + "#" + symbols[name].PK.toString(), keyComposition.PK, constructor);
+            Reflect.defineMetadata(constructor.name + "#" + symbols[name].SK.toString(), keyComposition.SK, constructor);
+        };
+    };
+};
+export const Index = buildIndex();
+export const GSI1 = buildIndex("GSI1");
+export const GSI2 = buildIndex("GSI2");
+export const GSI3 = buildIndex("GSI3");
+export const GSI4 = buildIndex("GSI4");
+export const GSI5 = buildIndex("GSI5");

package/dist-es/decorators/gsis/index.js

@@ -0,0 +1,3 @@
+export * from "./gsis";
+export * from "./get-pk-composition";
+export * from "./get-sk-composition";

package/dist-es/decorators/gsis/symbols.js

@@ -0,0 +1,8 @@
+export const symbols = {
+    Index: { PK: Symbol("IndexPK"), SK: Symbol("IndexSK") },
+    GSI1: { PK: Symbol("GSI1PK"), SK: Symbol("GSI1SK") },
+    GSI2: { PK: Symbol("GSI2PK"), SK: Symbol("GSI2SK") },
+    GSI3: { PK: Symbol("GSI3PK"), SK: Symbol("GSI3SK") },
+    GSI4: { PK: Symbol("GSI4PK"), SK: Symbol("GSI4SK") },
+    GSI5: { PK: Symbol("GSI5PK"), SK: Symbol("GSI5SK") },
+};

package/dist-es/decorators/gsis/types.js

@@ -0,0 +1 @@
+export {};

package/dist-es/decorators/index.js

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+export * from "./editable";
+export * from "./entity";
+export * from "./gsis";

package/dist-es/dynamodb/delete-dynamodb-item.js

@@ -0,0 +1,24 @@
+import { DeleteCommand } from "@aws-sdk/lib-dynamodb";
+import { logger } from "@itzworking/powertools";
+import { dynamodb } from "./dynamodb";
+export const deleteDynamodbItem = async (input) => {
+    logger.debug({
+        message: "send dynamodb DeleteCommand",
+        awsService: "dynamodb",
+        action: "DeleteCommand",
+        input,
+    });
+    try {
+        return dynamodb.send(new DeleteCommand(input));
+    }
+    catch (error) {
+        logger.error({
+            message: "send dynamodb DeleteCommand",
+            awsService: "dynamodb",
+            action: "DeleteCommand",
+            input,
+            error,
+        });
+        throw error;
+    }
+};

package/dist-es/dynamodb/dynamodb.js

@@ -0,0 +1,14 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+const marshallOptions = {
+    convertEmptyValues: false,
+    removeUndefinedValues: true,
+    convertClassInstanceToMap: true,
+};
+const unmarshallOptions = {
+    wrapNumbers: false,
+};
+export const dynamodb = DynamoDBDocumentClient.from(new DynamoDBClient({}), {
+    marshallOptions,
+    unmarshallOptions,
+});

package/dist-es/dynamodb/get-dynamodb-item.js

@@ -0,0 +1,24 @@
+import { GetCommand } from "@aws-sdk/lib-dynamodb";
+import { logger } from "@itzworking/powertools";
+import { dynamodb } from "./dynamodb";
+export const getDynamodbItem = async (input) => {
+    logger.debug({
+        message: "send dynamodb GetCommand",
+        awsService: "dynamodb",
+        action: "GetCommand",
+        input,
+    });
+    try {
+        return dynamodb.send(new GetCommand(input));
+    }
+    catch (error) {
+        logger.error({
+            message: "send dynamodb GetCommand",
+            awsService: "dynamodb",
+            action: "GetCommand",
+            input,
+            error,
+        });
+        throw error;
+    }
+};

package/dist-es/dynamodb/index.js

@@ -0,0 +1,7 @@
+export * from "./dynamodb";
+export * from "./delete-dynamodb-item";
+export * from "./get-dynamodb-item";
+export * from "./put-dynamodb-item";
+export * from "./query-all-dynamodb";
+export * from "./query-dynamodb";
+export * from "./update-dynamodb-item";

package/dist-es/dynamodb/put-dynamodb-item.js

@@ -0,0 +1,28 @@
+import { PutCommand } from "@aws-sdk/lib-dynamodb";
+import { logger } from "@itzworking/powertools";
+import { dynamodb } from "./dynamodb";
+export const putDynamodbItem = async (input) => {
+    const updatedParams = {
+        ReturnValues: "NONE",
+        ...input,
+    };
+    logger.debug({
+        message: "send dynamodb PutCommand",
+        awsService: "dynamodb",
+        action: "PutCommand",
+        input: updatedParams,
+    });
+    try {
+        return dynamodb.send(new PutCommand(updatedParams));
+    }
+    catch (error) {
+        logger.error({
+            message: "send dynamodb PutCommand",
+            awsService: "dynamodb",
+            action: "PutCommand",
+            input: updatedParams,
+            error,
+        });
+        throw error;
+    }
+};

package/dist-es/dynamodb/query-all-dynamodb.js

@@ -0,0 +1,19 @@
+import { logger } from "@itzworking/powertools";
+import { queryDynamodb } from "./query-dynamodb";
+export const queryAllDynamodb = async (input) => {
+    logger.debug({
+        message: "send multiple dynamodb QueryCommand",
+        input,
+    });
+    const items = [];
+    let lastEvaluatedKey;
+    do {
+        const dynamodbResponse = await queryDynamodb({
+            ...input,
+            ExclusiveStartKey: lastEvaluatedKey,
+        });
+        lastEvaluatedKey = dynamodbResponse.LastEvaluatedKey;
+        items.push(...(dynamodbResponse.Items || []));
+    } while (lastEvaluatedKey);
+    return items;
+};

package/dist-es/dynamodb/query-dynamodb.js

@@ -0,0 +1,28 @@
+import { QueryCommand } from "@aws-sdk/lib-dynamodb";
+import { logger } from "@itzworking/powertools";
+import { dynamodb } from "./dynamodb";
+export const queryDynamodb = async (input) => {
+    const updatedParams = {
+        ScanIndexForward: false,
+        ...input,
+    };
+    logger.debug({
+        message: "send dynamodb QueryCommand",
+        awsService: "dynamodb",
+        action: "QueryCommand",
+        input: updatedParams,
+    });
+    try {
+        return dynamodb.send(new QueryCommand(updatedParams));
+    }
+    catch (error) {
+        logger.error({
+            message: "send dynamodb QueryCommand",
+            awsService: "dynamodb",
+            action: "QueryCommand",
+            input: updatedParams,
+            error,
+        });
+        throw error;
+    }
+};

package/dist-es/dynamodb/update-dynamodb-item.js

@@ -0,0 +1,24 @@
+import { UpdateCommand } from "@aws-sdk/lib-dynamodb";
+import { logger } from "@itzworking/powertools";
+import { dynamodb } from "./dynamodb";
+export const updateDynamodbItem = async (input) => {
+    logger.debug({
+        message: "send dynamodb UpdateCommand",
+        awsService: "dynamodb",
+        action: "UpdateCommand",
+        input,
+    });
+    try {
+        return dynamodb.send(new UpdateCommand(input));
+    }
+    catch (error) {
+        logger.error({
+            message: "send dynamodb UpdateCommand",
+            awsService: "dynamodb",
+            action: "UpdateCommand",
+            input,
+            error,
+        });
+        throw error;
+    }
+};