@factorearth/recordmiddleware-dataaccesslayer 0.0.1-y.23 → 0.0.1-y.25

package/dist/aws-services.d.ts

@@ -0,0 +1,2 @@
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+export declare const dynamoDbDocClient: DynamoDBDocumentClient;

package/dist/aws-services.js

@@ -0,0 +1,4 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+const dynamoDbClient = new DynamoDBClient();
+export const dynamoDbDocClient = DynamoDBDocumentClient.from(dynamoDbClient);

package/dist/batchDeleteItems.d.ts

@@ -0,0 +1,2 @@
+import { BatchInput } from "./index.js";
+export declare function batchDeleteItems(items: BatchInput[], tableName: string): Promise<void>;

package/dist/batchDeleteItems.js

@@ -0,0 +1,29 @@
+import { BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+import chunkBatch from "./chunkBatch.js";
+import { MAX_ITEMS_BATCH_OPERATIONS } from "./index.js";
+export async function batchDeleteItems(items, tableName) {
+    const chunks = chunkBatch(items, MAX_ITEMS_BATCH_OPERATIONS);
+    for (const chunk of chunks) {
+        const deleteRequests = chunk.map((id) => {
+            return {
+                DeleteRequest: {
+                    Key: { id }
+                }
+            };
+        });
+        const commandInput = {
+            RequestItems: {
+                [tableName]: deleteRequests
+            }
+        };
+        const command = new BatchWriteCommand(commandInput);
+        try {
+            await dynamoDbDocClient.send(command);
+        }
+        catch (err) {
+            console.error(`ERROR BATCH DELETING FROM TABLE ${tableName}`, err);
+            console.log('IDS', deleteRequests);
+        }
+    }
+}

package/dist/batchGetItems.d.ts

@@ -0,0 +1,2 @@
+import { BatchInput } from "./index.js";
+export declare function batchGetItems(ids: BatchInput[], tableName: string): Promise<Record<string, any>[]>;

package/dist/batchGetItems.js

@@ -0,0 +1,24 @@
+import { BatchGetCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+export async function batchGetItems(ids, tableName) {
+    const commandInput = {
+        RequestItems: {
+            [tableName]: {
+                Keys: ids
+            }
+        }
+    };
+    const command = new BatchGetCommand(commandInput);
+    try {
+        const sendResult = await dynamoDbDocClient.send(command);
+        const items = sendResult.Responses?.[tableName];
+        if (items)
+            return items;
+    }
+    catch (err) {
+        console.error(`ERROR BATCH GETTING ITEMS FROM ${tableName}`);
+        console.error("IDS ", ids);
+        console.error(err);
+    }
+    return [];
+}

package/dist/batchPutItems.d.ts

@@ -0,0 +1,2 @@
+import { BatchInput } from "./index.js";
+export declare function batchPutItems(items: BatchInput[], tableName: string): Promise<void>;

package/dist/batchPutItems.js

@@ -0,0 +1,29 @@
+import { BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+import chunkBatch from "./chunkBatch.js";
+import { MAX_ITEMS_BATCH_OPERATIONS } from "./index.js";
+export async function batchPutItems(items, tableName) {
+    const chunks = chunkBatch(items, MAX_ITEMS_BATCH_OPERATIONS);
+    for (const chunk of chunks) {
+        const putRequests = chunk.map((Item) => {
+            return {
+                PutRequest: {
+                    Item
+                }
+            };
+        });
+        const commandInput = {
+            RequestItems: {
+                [tableName]: putRequests
+            }
+        };
+        const command = new BatchWriteCommand(commandInput);
+        try {
+            await dynamoDbDocClient.send(command);
+        }
+        catch (err) {
+            console.error(`ERROR BATCH PUTTING DOCUMENTS  IN ${tableName}`, err);
+            console.error(`DOCUMENTS `, putRequests);
+        }
+    }
+}

package/dist/chunkBatch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Given an array of items, this module chunks them out into smaller arrays of {@link itemMax} length
+ * @param array An array of items that we want to divide into a subset of arrays
+ * @param itemMax The maximum number of items that can be in each array
+ * @returns An array of item arrays
+ */
+export default function chunkBatch<T>(array: T[], itemMax: number): T[][];

package/dist/chunkBatch.js

@@ -0,0 +1,25 @@
+/**
+ * Given an array of items, this module chunks them out into smaller arrays of {@link itemMax} length
+ * @param array An array of items that we want to divide into a subset of arrays
+ * @param itemMax The maximum number of items that can be in each array
+ * @returns An array of item arrays
+ */
+export default function chunkBatch(array, itemMax) {
+    const final = [];
+    let chunk = [];
+    for (let i = 0; i < array.length; i++) {
+        const element = array[i];
+        if (i !== 0 && (i % itemMax === 0)) {
+            // Its the beginning of the next one
+            final.push(chunk);
+            chunk = [element];
+        }
+        else {
+            chunk.push(element);
+        }
+    }
+    if (chunk.length > 0) {
+        final.push(chunk);
+    }
+    return final;
+}

package/dist/deleteItem.d.ts

@@ -0,0 +1 @@
+export declare function deleteItem(id: string, tableName: string): Promise<void>;

package/dist/deleteItem.js

@@ -0,0 +1,18 @@
+import { DeleteCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+export async function deleteItem(id, tableName) {
+    const commandInput = {
+        TableName: tableName,
+        Key: {
+            id
+        }
+    };
+    const command = new DeleteCommand(commandInput);
+    try {
+        await dynamoDbDocClient.send(command);
+    }
+    catch (err) {
+        console.error(`ERROR DELETING DOCUMENT ${id} in ${tableName}`);
+        console.error(err);
+    }
+}

package/dist/getItem.d.ts

@@ -0,0 +1,2 @@
+export declare const getItem: (id: string, tableName: string) => Promise<Record<string, any> | null | undefined>;
+export declare const getItemsByIndex: (indexName: string, tableName: string, attributeValue: string, attribute: string, columns?: string[]) => Promise<Record<string, any>[]>;

package/dist/getItem.js

@@ -0,0 +1,42 @@
+import { dynamoDbDocClient } from "./aws-services.js";
+import { GetCommand, QueryCommand } from "@aws-sdk/lib-dynamodb";
+import { _columnsAndAttributeToReturn } from "./utils.js";
+export const getItem = async (id, tableName) => {
+    const params = {
+        TableName: tableName,
+        Key: {
+            id
+        }
+    };
+    try {
+        const data = await dynamoDbDocClient.send(new GetCommand(params));
+        return data.Item;
+    }
+    catch (err) {
+        console.error("Error", err);
+        return null;
+    }
+};
+export const getItemsByIndex = async (indexName, tableName, attributeValue, attribute, columns) => {
+    const { expressionAttributeNames, columnsToReturn } = _columnsAndAttributeToReturn({ attribute, columns });
+    const params = {
+        TableName: tableName,
+        IndexName: indexName,
+        KeyConditionExpression: `#fk = :fkval`,
+        ExpressionAttributeNames: expressionAttributeNames,
+        ExpressionAttributeValues: {
+            ":fkval": attributeValue
+        }
+    };
+    if (columnsToReturn) {
+        params.ProjectionExpression = columnsToReturn;
+    }
+    try {
+        const data = await dynamoDbDocClient.send(new QueryCommand(params));
+        return data.Items || [];
+    }
+    catch (err) {
+        console.error("Error", err);
+        return [];
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./aws-services";
+export * from "./batchDeleteItems";
+export * from "./batchGetItems";
+export * from "./batchPutItems";
+export * from "./chunkBatch";
+export * from "./deleteItem";
+export * from "./getItem";
+export * from "./putItem";
+export * from "./updateItem";
+export * from "./utils";
+export declare const MAX_ITEMS_BATCH_OPERATIONS = 25;
+export interface BatchInput {
+    id: string;
+}

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./aws-services";
+export * from "./batchDeleteItems";
+export * from "./batchGetItems";
+export * from "./batchPutItems";
+export * from "./chunkBatch";
+export * from "./deleteItem";
+export * from "./getItem";
+export * from "./putItem";
+export * from "./updateItem";
+export * from "./utils";
+export const MAX_ITEMS_BATCH_OPERATIONS = 25;

package/dist/putItem.d.ts

@@ -0,0 +1 @@
+export declare function putItem(item: Record<string, any>, tableName: string): Promise<void>;

package/dist/putItem.js

@@ -0,0 +1,17 @@
+import { PutCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+export async function putItem(item, tableName) {
+    const commandInput = {
+        Item: item,
+        TableName: tableName
+    };
+    const command = new PutCommand(commandInput);
+    try {
+        await dynamoDbDocClient.send(command);
+    }
+    catch (err) {
+        console.error(`ERROR PUTTING ITEM IN ${tableName}`);
+        console.error("ITEM: ", item);
+        console.error(err);
+    }
+}

package/dist/updateItem.d.ts

@@ -0,0 +1 @@
+export declare function updateItem(item: Record<string, any>, tableName: string): Promise<void>;

package/dist/updateItem.js

@@ -0,0 +1,17 @@
+import { UpdateCommand } from "@aws-sdk/lib-dynamodb";
+import { dynamoDbDocClient } from "./aws-services.js";
+export async function updateItem(item, tableName) {
+    const commandInput = {
+        TableName: tableName,
+        Key: item
+    };
+    const command = new UpdateCommand(commandInput);
+    try {
+        await dynamoDbDocClient.send(command);
+    }
+    catch (err) {
+        console.error(`ERROR UPDATING ITEM IN TABLE ${tableName}`);
+        console.error(`ITEM: `, item);
+        console.error(err);
+    }
+}

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const _columnsAndAttributeToReturn: ({ attribute, columns, }: {
+    attribute: string;
+    columns?: string[];
+}) => {
+    expressionAttributeNames: {
+        [key: string]: string;
+    };
+    columnsToReturn: string | undefined;
+};

package/dist/utils.js

@@ -0,0 +1,13 @@
+export const _columnsAndAttributeToReturn = ({ attribute, columns, }) => {
+    const expressionAttributeNames = {
+        "#fk": `${attribute}`,
+    };
+    const columnsToReturn = columns
+        ?.map((col, index) => {
+        const placeholder = `#col${index}`;
+        expressionAttributeNames[placeholder] = col;
+        return placeholder;
+    })
+        .join(", ");
+    return { expressionAttributeNames, columnsToReturn };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@factorearth/recordmiddleware-dataaccesslayer",
-  "version": "0.0.1-y.23",
+  "version": "0.0.1-y.25",
   "description": "A module for accessing dynamdb efficiently",
   "author": "madtrx <marlin.makori@gmail.com>",
   "homepage": "https://github.com/FactorEarth/RecordMiddleware#readme",
@@ -31,5 +31,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "d26e5dbae2f44a344075645f309d16cab0380094"
+  "gitHead": "45082bcb7811baf349b0febc1bf1a568b3d3e418"
 }