@moicky/dynamodb 1.2.2 → 1.3.0

package/dist/lib/client.d.ts

@@ -1,4 +1,20 @@
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import * as ops from "../operations";
+interface OperationArguments {
+    deleteItem?: Parameters<typeof ops.deleteItem>[1];
+    deleteItems?: Parameters<typeof ops.deleteItems>[1];
+    getItem?: Parameters<typeof ops.getItem>[1];
+    getItems?: Parameters<typeof ops.getItems>[1];
+    getAllItems?: Parameters<typeof ops.getAllItems>[0];
+    putItem?: Parameters<typeof ops.putItem>[1];
+    putItems?: Parameters<typeof ops.putItems>[1];
+    query?: Parameters<typeof ops.query>[2];
+    queryItems?: Parameters<typeof ops.queryItems>[2];
+    queryAllItems?: Parameters<typeof ops.queryAllItems>[2];
+    updateItem?: Parameters<typeof ops.updateItem>[2];
+    removeAttributes?: Parameters<typeof ops.removeAttributes>[2];
+}
+type Operation = keyof OperationArguments;
 declare interface KeySchema {
     hash: string;
     range?: string;
@@ -18,13 +34,18 @@ declare class DynamoDBConfig {
     getTableSchema(tableName?: string): KeySchema;
     getDefaultTableSchema(): KeySchema;
     validateSchema(schema: KeySchemaCollection): boolean;
+    initDefaults(newDefaults: OperationArguments): void;
+    withDefaults<T extends Operation>(args: OperationArguments[T], operation: T): OperationArguments[T];
     destroy(): void;
 }
 declare const config: DynamoDBConfig;
 export declare const client: DynamoDBClient;
+export declare const initSchema: (schema: KeySchemaCollection) => KeySchemaCollection;
 export declare const getDefaultTable: () => string;
-export declare const getTableSchema: (tableName?: string) => KeySchema;
 export declare const getDefaultTableSchema: () => KeySchema;
-export declare const initSchema: (schema: KeySchemaCollection) => KeySchemaCollection;
+export declare const validateSchema: (schema: KeySchemaCollection) => boolean;
+export declare const getTableSchema: (tableName?: string) => KeySchema;
+export declare const initDefaults: (newDefaults: OperationArguments) => void;
+export declare const withDefaults: <T extends keyof OperationArguments>(args: OperationArguments[T], operation: T) => OperationArguments[T];
 export declare const destroy: () => void;
 export default config;

package/dist/lib/client.js

@@ -1,22 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.destroy = exports.initSchema = exports.getDefaultTableSchema = exports.getTableSchema = exports.getDefaultTable = exports.client = void 0;
+exports.destroy = exports.withDefaults = exports.initDefaults = exports.getTableSchema = exports.validateSchema = exports.getDefaultTableSchema = exports.getDefaultTable = exports.initSchema = exports.client = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 class DynamoDBConfig {
     client;
     tablesSchema = {};
     #initialized = false;
+    #defaults = {};
     constructor({ region } = {}) {
         this.client = new client_dynamodb_1.DynamoDBClient({
             region: region || process.env.AWS_REGION || "eu-central-1",
         });
         const defaultTable = process.env.DYNAMODB_TABLE;
         if (defaultTable) {
-            this.tablesSchema[defaultTable] = {
-                hash: "PK",
-                range: "SK",
-            };
-            this.#initialized = true;
+            this.initSchema({
+                [defaultTable]: {
+                    hash: "PK",
+                    range: "SK",
+                },
+            });
         }
     }
     initSchema(schema) {
@@ -38,8 +40,7 @@ class DynamoDBConfig {
         if (!this.#initialized) {
             throw new Error("Schema not initialized");
         }
-        const table = Object.keys(this.tablesSchema)[0];
-        return table;
+        return Object.keys(this.tablesSchema)[0];
     }
     getTableSchema(tableName) {
         if (!this.#initialized) {
@@ -64,15 +65,30 @@ class DynamoDBConfig {
         });
         return true;
     }
+    initDefaults(newDefaults) {
+        this.#defaults = { ...newDefaults };
+    }
+    withDefaults(args, operation) {
+        return {
+            ...this.#defaults[operation],
+            ...args,
+        };
+    }
     destroy() {
         this.client.destroy();
     }
 }
 const config = new DynamoDBConfig();
+const bind = (fn) => {
+    return fn.bind(config);
+};
 exports.client = config.client;
-exports.getDefaultTable = config.getDefaultTable.bind(config);
-exports.getTableSchema = config.getTableSchema.bind(config);
-exports.getDefaultTableSchema = config.getDefaultTableSchema.bind(config);
-exports.initSchema = config.initSchema.bind(config);
-exports.destroy = config.destroy.bind(config);
+exports.initSchema = bind(config.initSchema);
+exports.getDefaultTable = bind(config.getDefaultTable);
+exports.getDefaultTableSchema = bind(config.getDefaultTableSchema);
+exports.validateSchema = bind(config.validateSchema);
+exports.getTableSchema = bind(config.getTableSchema);
+exports.initDefaults = bind(config.initDefaults);
+exports.withDefaults = bind(config.withDefaults);
+exports.destroy = bind(config.destroy);
 exports.default = config;

package/dist/lib/helpers.d.ts

@@ -5,6 +5,3 @@ export declare function splitEvery<T>(items: T[], limit?: number): T[][];
 export declare function getAttributeValues(key: any, attributesToGet?: string[]): Record<string, any>;
 export declare function getAttributeNames(key: any, attributesToGet?: string[]): Record<string, string>;
 export declare function getAttributesFromExpression(expression: string, prefix?: string): string[];
-export declare function handleAliases(aliases: {
-    [attr: string]: string[];
-}, args?: Record<string, any>): Record<string, any>;

package/dist/lib/helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleAliases = exports.getAttributesFromExpression = exports.getAttributeNames = exports.getAttributeValues = exports.splitEvery = exports.stripKey = void 0;
+exports.getAttributesFromExpression = exports.getAttributeNames = exports.getAttributeValues = exports.splitEvery = exports.stripKey = void 0;
 const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const client_1 = require("../lib/client");
 // Since dynamo only accepts key atrtributes which are described in table schema
@@ -42,15 +42,3 @@ function getAttributesFromExpression(expression, prefix = "#") {
         ?.map((attr) => attr.slice(1)) || []);
 }
 exports.getAttributesFromExpression = getAttributesFromExpression;
-function handleAliases(aliases, args = {}) {
-    Object.keys(aliases).forEach((key) => {
-        aliases[key].forEach((alias) => {
-            if (args[alias]) {
-                args[key] = args[alias];
-                delete args[alias];
-            }
-        });
-    });
-    return args;
-}
-exports.handleAliases = handleAliases;

package/dist/operations/delete.js

@@ -7,12 +7,13 @@ const helpers_1 = require("../lib/helpers");
 async function deleteItem(key, args = {}) {
     return client_1.client.send(new client_dynamodb_1.DeleteItemCommand({
         Key: (0, helpers_1.stripKey)(key, args),
-        ...args,
+        ...(0, client_1.withDefaults)(args, "deleteItem"),
         TableName: args?.TableName || (0, client_1.getDefaultTable)(),
     }));
 }
 exports.deleteItem = deleteItem;
 async function deleteItems(keys, args = {}, retry = 0) {
+    args = (0, client_1.withDefaults)(args, "deleteItems");
     const uniqueKeys = Object.values(keys.reduce((acc, key) => {
         const strippedKey = (0, helpers_1.stripKey)(key, args);
         const keyString = JSON.stringify(strippedKey);

package/dist/operations/get.js

@@ -6,6 +6,7 @@ const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const client_1 = require("../lib/client");
 const helpers_1 = require("../lib/helpers");
 async function getItem(key, args = {}) {
+    args = (0, client_1.withDefaults)(args, "getItem");
     return client_1.client
         .send(new client_dynamodb_1.GetItemCommand({
         Key: (0, helpers_1.stripKey)(key, args),
@@ -16,6 +17,7 @@ async function getItem(key, args = {}) {
 }
 exports.getItem = getItem;
 async function getItems(keys, args = {}, retry = 0) {
+    args = (0, client_1.withDefaults)(args, "getItems");
     // creates batches of 100 items each and performs batchGet on every batch.
     // also retries up to 3 times if there are unprocessed items (due to size limit of 16MB)
     // returns items in same order as keys (not sorted by default when using batchGet)
@@ -69,6 +71,7 @@ async function getItems(keys, args = {}, retry = 0) {
 }
 exports.getItems = getItems;
 async function getAllItems(args = {}) {
+    args = (0, client_1.withDefaults)(args, "getAllItems");
     return client_1.client
         .send(new client_dynamodb_1.ScanCommand({
         ...args,

package/dist/operations/put.js

@@ -6,6 +6,7 @@ const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const client_1 = require("../lib/client");
 const helpers_1 = require("../lib/helpers");
 async function putItem(data, args = {}) {
+    args = (0, client_1.withDefaults)(args, "putItem");
     if (!Object.keys(data).includes("createdAt")) {
         data.createdAt = Date.now();
     }
@@ -19,6 +20,7 @@ async function putItem(data, args = {}) {
 }
 exports.putItem = putItem;
 async function putItems(items, args = {}) {
+    args = (0, client_1.withDefaults)(args, "putItems");
     return new Promise(async (resolve, reject) => {
         const now = Date.now();
         const batches = (0, helpers_1.splitEvery)(items.map((item) => ({

package/dist/operations/query.d.ts

@@ -1,9 +1,4 @@
-import { QueryCommandInput as _QueryCommandInput, QueryCommandOutput } from "@aws-sdk/client-dynamodb";
-type QueryCommandInput = {
-    GSI: _QueryCommandInput["IndexName"];
-    Index: _QueryCommandInput["IndexName"];
-} & _QueryCommandInput;
+import { QueryCommandInput, QueryCommandOutput } from "@aws-sdk/client-dynamodb";
 export declare function query(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<QueryCommandOutput>;
 export declare function queryItems(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
 export declare function queryAllItems(keyCondition: string, key: any, args?: Partial<QueryCommandInput>): Promise<Record<string, any>[]>;
-export {};

package/dist/operations/query.js

@@ -5,11 +5,7 @@ const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const client_1 = require("../lib/client");
 const helpers_1 = require("../lib/helpers");
-const aliases = {
-    IndexName: ["GSI", "Index"],
-};
-async function query(keyCondition, key, args = {}) {
-    args = (0, helpers_1.handleAliases)(aliases, args);
+async function _query(keyCondition, key, args = {}) {
     return client_1.client.send(new client_dynamodb_1.QueryCommand({
         KeyConditionExpression: keyCondition,
         ExpressionAttributeValues: (0, helpers_1.getAttributeValues)(key, [
@@ -24,16 +20,23 @@ async function query(keyCondition, key, args = {}) {
         TableName: args?.TableName || (0, client_1.getDefaultTable)(),
     }));
 }
+async function query(keyCondition, key, args) {
+    return _query(keyCondition, key, (0, client_1.withDefaults)(args, "query"));
+}
 exports.query = query;
 async function queryItems(keyCondition, key, args = {}) {
-    return query(keyCondition, key, args).then((res) => (res?.Items || []).map((item) => item && (0, util_dynamodb_1.unmarshall)(item)));
+    args = (0, client_1.withDefaults)(args, "queryItems");
+    return _query(keyCondition, key, args).then((res) => (res?.Items || [])
+        .map((item) => item && (0, util_dynamodb_1.unmarshall)(item))
+        .filter((item) => item));
 }
 exports.queryItems = queryItems;
 async function queryAllItems(keyCondition, key, args = {}) {
-    let data = await query(keyCondition, key, args);
+    args = (0, client_1.withDefaults)(args, "queryAllItems");
+    let data = await _query(keyCondition, key, args);
     while (data.LastEvaluatedKey) {
         if (data.LastEvaluatedKey) {
-            let helper = await query(keyCondition, key, {
+            let helper = await _query(keyCondition, key, {
                 ...args,
                 ExclusiveStartKey: data.LastEvaluatedKey,
             });
@@ -43,6 +46,8 @@ async function queryAllItems(keyCondition, key, args = {}) {
             data && (data.LastEvaluatedKey = helper.LastEvaluatedKey);
         }
     }
-    return (data?.Items || []).map((item) => item && (0, util_dynamodb_1.unmarshall)(item));
+    return (data?.Items || [])
+        .map((item) => item && (0, util_dynamodb_1.unmarshall)(item))
+        .filter((item) => item);
 }
 exports.queryAllItems = queryAllItems;

package/dist/operations/update.js

@@ -6,6 +6,7 @@ const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
 const client_1 = require("../lib/client");
 const helpers_1 = require("../lib/helpers");
 async function updateItem(key, data, args = {}) {
+    args = (0, client_1.withDefaults)(args, "updateItem");
     if (!Object.keys(data).includes("updatedAt")) {
         data.updatedAt = Date.now();
     }
@@ -32,6 +33,7 @@ async function updateItem(key, data, args = {}) {
 }
 exports.updateItem = updateItem;
 async function removeAttributes(key, attributes, args = {}) {
+    args = (0, client_1.withDefaults)(args, "removeAttributes");
     const UpdateExpression = "REMOVE " + attributes.map((att) => `#${att}`).join(", ");
     return client_1.client.send(new client_dynamodb_1.UpdateItemCommand({
         Key: (0, helpers_1.stripKey)(key, args),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moicky/dynamodb",
-  "version": "1.2.2",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Contains a collection of convenience functions for working with AWS DynamoDB",
@@ -24,14 +24,15 @@
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.338.0",
-    "@aws-sdk/util-dynamodb": "^3.338.0"
+    "@aws-sdk/util-dynamodb": "^3.338.0",
+    "aws-crt": "^1.15.20"
   },
   "devDependencies": {
     "@types/jest": "^29.5.1",
     "@types/node": "^20.2.4",
     "dotenv": "^16.0.3",
-    "typescript": "^5.0.4",
-    "jest": "^29.5.0"
+    "jest": "^29.5.0",
+    "typescript": "^5.0.4"
   },
   "keywords": [
     "dynamodb-helpers",

package/readme.md

@@ -146,8 +146,7 @@ await deleteItem({
 });
 
 // Delete multiple items
-// KeySchemas will be grouped into batches of 25 and will be retried up to 3 times if there are unprocessed items
-// Will only delete each keySchema only once, even if it is present multiple times in the array to improve performance
+// Will only delete each keySchema once, even if it is present multiple times in the array to improve performance and avoid aws errors
 await deleteItems([
   { PK: "User/1", SK: "Book/1" },
   // ... infinite more items (will be grouped into batches of 25 due to aws limit) and retried up to 3 times
@@ -161,13 +160,13 @@ import { updateItem, removeAttributes } from "@moicky/dynamodb";
 
 // Update the item and overwrite all supplied fields
 await updateItem(
-  { PK: "User/1", SK: "Book/1" },
-  { description: "A book about a rich guy", author: "F. Scott Fitzgerald" }
+  { PK: "User/1", SK: "Book/1" }, // reference to item
+  { description: "A book about a rich guy", author: "F. Scott Fitzgerald" } // fields to update
 );
 
 await updateItem(
   { PK: "User/1", SK: "Book/1" },
-  { released: 2000, maxReleased: 1950 }, // maxReleased will not be updated, since it is referenced inside the ConditionExpression
+  { released: 2000, maxReleased: 1950 }, // maxReleased will not be updated on the item, since it is referenced inside the ConditionExpression
   { ConditionExpression: "#released < :maxReleased" }
 );
 
@@ -187,7 +186,7 @@ await removeAttributes({ PK: "User/1", SK: "Book/1" }, ["description"]);
 import { query, queryItems, queryAllItems } from "@moicky/dynamodb";
 
 // You HAVE TO use placeholders for the keyCondition & filterExpression:
-// prefix the attributeNames with a hash (#) and the attributeValues with a colon (:)
+// Prefix the attributeNames with a hash (#) and the attributeValues with a colon (:)
 
 // Query only using keyCondition and retrieve complete response
 const booksResponse = await query("#PK = :PK and begins_with(#SK, :SK)", {
@@ -217,8 +216,8 @@ const booksWithFilter = await queryAllItems(
     from: 1950,
     to: 2000,
   },
-  // additional args with filterExpression
-  { FilterExpression: "#released BETWEEN :from AND :to" } // allows to override all args
+  // additional args with filterExpression for example
+  { FilterExpression: "#released BETWEEN :from AND :to" }
 );
 ```
 
@@ -229,6 +228,7 @@ import { itemExists, getAscendingId } from "@moicky/dynamodb";
 
 // Check if an item exists using keySchema
 const exists = await itemExists({ PK: "User/1", SK: "Book/1" });
+console.log(exists); // true / false
 
 // Generate ascending ID
 // Specify keySchemaHash and optionally item to start at using keySchemaRange
@@ -240,18 +240,18 @@ console.log(id1); // "00000010"
 
 // Example Structure 2: PK: "User/1", SK: "Book/{{ ASCENDING_ID }}"
 // Last item: { PK: "User/1", SK: "Book/00000009" }
-const id2 = await getAscendingId({ PK: "User/1", SKPrefix: "Book" });
+const id2 = await getAscendingId({ PK: "User/1", SK: "Book" });
 console.log(id2); // "00000010"
 
 // Specify length of ID
-const id3 = await getAscendingId({ PK: "User/1", SKPrefix: "Book", length: 4 });
+const id3 = await getAscendingId({ PK: "User/1", SK: "Book", length: 4 });
 console.log(id3); // "0010"
 
 // Example Structure 3: someKeySchemaHash: "User/1", SK: "Book/{{ ASCENDING_ID }}"
 // Last item: { someKeySchemaHash: "User/1", SK: "Book/00000009" }
 const id4 = await getAscendingId({
   someKeySchemaHash: "User/1",
-  SKPrefix: "Book",
+  SK: "Book",
 });
 console.log(id4); // "00000010"
 ```