inlaweb-lib-dynamodb 1.0.15 → 1.0.16

package/index.js

@@ -81,10 +81,21 @@ class DynamoLib {
     async query(params) {
         try {
             const parameters = this.buildQueryParams(params);
-            this.logger.debug(`Query: ${JSON.stringify(parameters)}`);
-            const response = await this.docClient.send(new lib_dynamodb_1.QueryCommand(parameters));
-            this.logger.debug(`Query Result: ${JSON.stringify(response)}`);
-            return response.Items;
+            let allItems = [];
+            let lastEvaluatedKey;
+            do {
+                if (lastEvaluatedKey) {
+                    parameters.ExclusiveStartKey = lastEvaluatedKey;
+                }
+                this.logger.debug(`Query: ${JSON.stringify(parameters)}`);
+                const response = await this.docClient.send(new lib_dynamodb_1.QueryCommand(parameters));
+                this.logger.debug(`Query Result: ${JSON.stringify(response)}`);
+                if (response.Items) {
+                    allItems = allItems.concat(response.Items);
+                }
+                lastEvaluatedKey = response.LastEvaluatedKey;
+            } while (lastEvaluatedKey);
+            return allItems;
         }
         catch (error) {
             this.logger.error(error.message);

package/index.ts

@@ -0,0 +1,528 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  UpdateCommand,
+  BatchWriteCommand,
+  TransactWriteCommand,
+  DeleteCommand,
+} from "@aws-sdk/lib-dynamodb";
+import { Logger } from "@aws-lambda-powertools/logger";
+import {
+  ParamsPut,
+  ParamsGet,
+  ParamsQuery,
+  ParamsUpdate,
+  ProjectionExpression,
+  SearchParameters,
+  KeyValue,
+  InputUpdate,
+  Operation,
+} from "./commons/types";
+import moment from "moment-timezone";
+
+const templatesUpdateExpresion = {
+  SET: (atribute: string) => `#${atribute} = :${atribute},`,
+  ADD: (atribute: string) => `#${atribute} :${atribute},`,
+  REMOVE: (atribute: string) => `#${atribute},`,
+};
+
+export class DynamoLib {
+  private readonly client: DynamoDBClient;
+  private readonly docClient: DynamoDBDocumentClient;
+  private readonly logger: Logger;
+
+  constructor() {
+    this.client = new DynamoDBClient({
+      customUserAgent: "lib-dynamodb",
+      disableHostPrefix: true,
+      userAgentAppId: "lib-dynamodb",
+    });
+    this.docClient = DynamoDBDocumentClient.from(this.client);
+    this.logger = new Logger({
+      serviceName: "lib-dynamodb",
+      logLevel: "DEBUG",
+    });
+  }
+
+  async putItem(tableName: string, item: KeyValue): Promise<void> {
+    try {
+      const params: ParamsPut = {
+        TableName: tableName,
+        Item: item,
+        ReturnItemCollectionMetrics: "SIZE",
+        ReturnConsumedCapacity: "TOTAL",
+      };
+      this.logger.debug(`PutItem: ${JSON.stringify(params)}`);
+      const result = await this.docClient.send(new PutCommand(params));
+      this.logger.debug(`PutItem Result: ${JSON.stringify(result)}`);
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  async getItem<T>(
+    tableName: string,
+    key: KeyValue,
+    projectionExpression?: string,
+  ): Promise<T> {
+    try {
+      const params: ParamsGet = {
+        TableName: tableName,
+        Key: key,
+        ReturnConsumedCapacity: "TOTAL",
+      };
+      const projection = this.buildProjectionExpression(projectionExpression);
+      if (projection) {
+        params.ProjectionExpression = projection.projectionExpression;
+        params.ExpressionAttributeNames = projection.expressionAttributeNames;
+      }
+      this.logger.debug(`GetItem: ${JSON.stringify(params)}`);
+      const response = await this.docClient.send(new GetCommand(params));
+      this.logger.debug(`GetItem Result: ${JSON.stringify(response)}`);
+      return response.Item as T;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  async updateItem<T>(params: InputUpdate): Promise<T> {
+    try {
+      const itemUpdate = this.createUpdateParams(params);
+      this.logger.debug(`UpdateItem: ${JSON.stringify(itemUpdate.Update)}`);
+      const result = await this.docClient.send(
+        new UpdateCommand(itemUpdate.Update),
+      );
+      this.logger.debug(`UpdateItem Result: ${JSON.stringify(result)}`);
+      return result.Attributes as T;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  async query<T>(params: {
+    tableName: string;
+    searchParameters: SearchParameters;
+    permission?: string;
+    username?: string;
+  }): Promise<T[]> {
+    try {
+      const parameters: ParamsQuery = this.buildQueryParams(params);
+      let allItems: T[] = [];
+      let lastEvaluatedKey: KeyValue | undefined;
+
+      do {
+        if (lastEvaluatedKey) {
+          parameters.ExclusiveStartKey = lastEvaluatedKey;
+        }
+
+        this.logger.debug(`Query: ${JSON.stringify(parameters)}`);
+        const response = await this.docClient.send(
+          new QueryCommand(parameters),
+        );
+        this.logger.debug(`Query Result: ${JSON.stringify(response)}`);
+
+        if (response.Items) {
+          allItems = allItems.concat(response.Items as T[]);
+        }
+
+        lastEvaluatedKey = response.LastEvaluatedKey;
+      } while (lastEvaluatedKey);
+
+      return allItems;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  async deleteItem(tableName: string, key: KeyValue): Promise<void> {
+    try {
+      const params: ParamsGet = {
+        TableName: tableName,
+        Key: key,
+        ReturnConsumedCapacity: "TOTAL",
+      };
+      this.logger.debug(`DeleteItem: ${JSON.stringify(params)}`);
+      const response = await this.docClient.send(new DeleteCommand(params));
+      this.logger.debug(`DeleteItem Result: ${JSON.stringify(response)}`);
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  private buildQueryParams(params: {
+    tableName: string;
+    searchParameters: SearchParameters;
+    permission?: string;
+    username?: string;
+  }): ParamsQuery {
+    const projection = this.buildProjectionExpression(
+      params.searchParameters.projectionExpression,
+    );
+
+    const parameters: ParamsQuery = {
+      TableName: params.tableName,
+      KeyConditionExpression: "",
+      ExpressionAttributeNames: projection?.expressionAttributeNames || {},
+      ExpressionAttributeValues: {},
+    };
+
+    if (projection) {
+      parameters.ProjectionExpression = projection.projectionExpression;
+    }
+    if (params.searchParameters.exclusiveStartKey) {
+      parameters.ExclusiveStartKey = params.searchParameters.exclusiveStartKey;
+    }
+    if (params.searchParameters.limit) {
+      parameters.Limit = params.searchParameters.limit;
+    }
+    if (params.searchParameters.scanIndexForward) {
+      parameters.ScanIndexForward = params.searchParameters.scanIndexForward;
+    }
+    if (params.searchParameters.indexName !== "") {
+      parameters.IndexName = params.searchParameters.indexName;
+    }
+
+    if (params.permission && params.permission === "OWNS") {
+      params.searchParameters.parameters.push({
+        name: "creationUser",
+        value: params.username,
+        operator: "FILTER",
+        filterOperator: "=",
+      });
+    }
+
+    params.searchParameters.parameters.forEach((searchParameter, index) => {
+      this.buildExpressions(searchParameter, index, parameters);
+    });
+
+    return parameters;
+  }
+
+  private buildExpressions(
+    searchParameter: KeyValue,
+    index: number,
+    params: ParamsQuery,
+  ): void {
+    if (index !== 0 && searchParameter.operator !== "FILTER")
+      params.KeyConditionExpression += " and ";
+
+    switch (searchParameter.operator) {
+      case "begins_with":
+        params.KeyConditionExpression += `${searchParameter.operator}(#key${index}, :value${index})`;
+        break;
+      case "BETWEEN":
+        params.KeyConditionExpression += `#key${index} ${searchParameter.operator} :value${index} AND :value1${index}`;
+        params.ExpressionAttributeValues[`:value1${index}`] =
+          searchParameter.value1;
+        break;
+      case "FILTER":
+        this.buildFilterExpression(searchParameter, index, params);
+        break;
+      default:
+        params.KeyConditionExpression += `#key${index} ${searchParameter.operator} :value${index}`;
+        break;
+    }
+
+    params.ExpressionAttributeNames[`#key${index}`] = searchParameter.name;
+    params.ExpressionAttributeValues[`:value${index}`] = searchParameter.value;
+  }
+
+  private buildFilterExpression(
+    searchParameter: KeyValue,
+    index: number,
+    params: ParamsQuery,
+  ): void {
+    if (params.FilterExpression) params.FilterExpression += " and ";
+    else params.FilterExpression = "";
+
+    switch (searchParameter.filterOperator) {
+      case "contains":
+        params.FilterExpression += `contains (#key${index}, :value${index})`;
+        break;
+      case "begins_with":
+        params.FilterExpression += `${searchParameter.filterOperator}(#key${index}, :value${index})`;
+        break;
+      case "attribute_not_exists":
+        params.FilterExpression += `attribute_not_exists (#key${index})`;
+        break;
+      case "attribute_exists":
+        params.FilterExpression += `attribute_exists (#key${index})`;
+        break;
+      case "BETWEEN":
+        params.FilterExpression += `#key${index} ${searchParameter.filterOperator} :value${index} AND :value1${index}`;
+        params.ExpressionAttributeValues[`:value1${index}`] =
+          searchParameter.value1;
+        break;
+      default:
+        params.FilterExpression += `#key${index} ${searchParameter.filterOperator} :value${index}`;
+        break;
+    }
+  }
+
+  private buildProjectionExpression(
+    projectionExpression: string | undefined,
+  ): ProjectionExpression | undefined {
+    if (!projectionExpression) {
+      return undefined;
+    }
+    const fields = projectionExpression.split(",");
+    if (fields.length > 0) {
+      let projectionExpression = "";
+      const expressionAttributeNames: KeyValue = {};
+      fields.forEach((field) => {
+        projectionExpression += `#${field},`;
+        expressionAttributeNames[`#${field}`] = field;
+      });
+      projectionExpression = projectionExpression.slice(0, -1);
+      return { projectionExpression, expressionAttributeNames };
+    }
+  }
+
+  async saveBatch(table: string, items: KeyValue[]): Promise<boolean> {
+    try {
+      const executions = this.createBatch(items);
+      for (let i = 0; i < executions.length; i++) {
+        const params = {
+          RequestItems: {
+            [table]: executions[i] as any,
+          },
+          ReturnConsumedCapacity: "TOTAL" as const,
+        };
+        this.logger.debug(`BatchWrite: ${JSON.stringify(params)}`);
+        const response = await this.docClient.send(
+          new BatchWriteCommand(params),
+        );
+        this.logger.debug(`BatchWrite Result: ${JSON.stringify(response)}`);
+      }
+      return true;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  private createBatch(items: KeyValue[]): KeyValue[] {
+    const executions: KeyValue[] = [];
+    const numberOfBacthInsertions = Math.ceil(items.length / 25);
+    for (let i = 0; i < numberOfBacthInsertions; i++) {
+      executions[i] = [];
+    }
+    items.forEach((item, index) => {
+      const currentIndex = Math.ceil((index + 1) / 25);
+      executions[currentIndex - 1].push({ PutRequest: { Item: item } });
+    });
+    return executions;
+  }
+
+  async writeTransactions(items: KeyValue[], limit: number): Promise<boolean> {
+    try {
+      const executions = this.createWriteTransactions(items, limit);
+      for (let i = 0; i < executions.length; i++) {
+        const params = {
+          TransactItems: executions[i],
+          ReturnConsumedCapacity: "TOTAL" as const,
+        };
+        this.logger.debug(`TransactWrite: ${JSON.stringify(params)}`);
+        const response = await this.docClient.send(
+          new TransactWriteCommand(params),
+        );
+        this.logger.debug(`TransactWrite Result: ${JSON.stringify(response)}`);
+      }
+      return true;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  createWriteTransactions(items: KeyValue[], limit: number): KeyValue[][] {
+    const executions: KeyValue[][] = [];
+    const numberOfBacthInsertions = Math.ceil(items.length / limit);
+    for (let i = 0; i < numberOfBacthInsertions; i++) {
+      executions[i] = [];
+    }
+    items.forEach((item, index) => {
+      const currentIndex = Math.ceil((index + 1) / limit);
+      executions[currentIndex - 1].push(item);
+    });
+    return executions;
+  }
+
+  createUpdateParams(params: InputUpdate): KeyValue {
+    const {
+      table,
+      PK,
+      SK,
+      item,
+      setAttributes,
+      addAttributes,
+      removeAttributes,
+      username,
+    } = params;
+    // Se crea el objeto de la operación
+    let itemUpdate = {
+      Update: {
+        TableName: table,
+        Key: { PK, SK },
+        UpdateExpression: ``,
+        ExpressionAttributeNames: {},
+        ExpressionAttributeValues: {},
+        ReturnConsumedCapacity: "TOTAL",
+        ReturnValues: "ALL_NEW",
+      },
+    };
+    // Se agregan los campos a modificar
+    if (Array.isArray(setAttributes) && setAttributes.length) {
+      this.formatUpdateExpression("SET", itemUpdate, item, setAttributes);
+    }
+    // Se agragan los campos nuevos del item
+    if (Array.isArray(addAttributes) && addAttributes.length) {
+      this.formatUpdateExpression("ADD", itemUpdate, item, addAttributes);
+    }
+    // Se agregan los campos que deben ser borrados
+    if (Array.isArray(removeAttributes) && removeAttributes.length) {
+      this.formatUpdateExpressionRemove(itemUpdate, removeAttributes);
+    }
+    // Se remueve el espacio al final de la expresión
+    itemUpdate.Update.UpdateExpression =
+      itemUpdate.Update.UpdateExpression.slice(0, -1);
+    return itemUpdate;
+  }
+
+  private formatUpdateExpression(
+    operation: Operation,
+    updateObject: KeyValue,
+    item: KeyValue,
+    atributes: string[],
+  ): void {
+    // Se agrega la operación.
+    updateObject.Update.UpdateExpression += `${operation} `;
+    // Se obtiene el templete de acuerdo a la operación.
+    let operationTemplate = templatesUpdateExpresion[operation];
+    // Se añaden los items afectados por la operación.
+    for (let atribute of atributes) {
+      if (
+        typeof item[atribute] === "boolean" ||
+        typeof item[atribute] === "number" ||
+        item[atribute]
+      ) {
+        updateObject.Update.UpdateExpression += operationTemplate(atribute);
+        updateObject.Update.ExpressionAttributeNames[`#${atribute}`] = atribute;
+        updateObject.Update.ExpressionAttributeValues[`:${atribute}`] =
+          item[atribute];
+      }
+    }
+    // Se remueve la coma final para evitar errores con el SDK.
+    updateObject.Update.UpdateExpression =
+      updateObject.Update.UpdateExpression.slice(0, -1);
+    // Se añade un espacio para poder agregar nuevas operaciones.
+    updateObject.Update.UpdateExpression += " ";
+  }
+
+  private formatUpdateExpressionRemove(
+    updateObject: KeyValue,
+    atributes: string[],
+  ): void {
+    let operation: Operation = "REMOVE";
+    // Se agrega la operación.
+    updateObject.Update.UpdateExpression += `${operation} `;
+    // Se obtiene el templete de acuerdo a la operación.
+    let operationTemplate = templatesUpdateExpresion[operation];
+    // Se añaden los items afectados por la operación.
+    for (let atribute of atributes) {
+      updateObject.Update.UpdateExpression += operationTemplate(atribute);
+      updateObject.Update.ExpressionAttributeNames[`#${atribute}`] = atribute;
+    }
+    // Se remueve la coma final para evitar errores con el SDK.
+    updateObject.Update.UpdateExpression =
+      updateObject.Update.UpdateExpression.slice(0, -1);
+    // Se añade un espacio para poder agregar nuevas operaciones.
+    updateObject.Update.UpdateExpression += " ";
+  }
+
+  async getId(
+    table: string,
+    entity: string,
+    username: string,
+    quantity?: number,
+  ): Promise<number> {
+    try {
+      let item = await this.getItem<KeyValue>(
+        table,
+        { PK: "COUN", SK: entity },
+        "order",
+      );
+      if (!item) {
+        item = {
+          PK: "COUN",
+          SK: entity,
+          entity: "COUN",
+          order: 0,
+          creationUser: username,
+          creationDate: moment
+            .tz(new Date(), "America/Bogota")
+            .format("YYYY-MM-DD"),
+        };
+        await this.putItem(table, item);
+      }
+      const params: ParamsUpdate = {
+        TableName: table,
+        Key: { PK: "COUN", SK: entity },
+        UpdateExpression: `SET #id = #id + :increment`,
+        ExpressionAttributeNames: { "#id": "order" },
+        ExpressionAttributeValues: { ":increment": quantity || 1 },
+        ReturnValues: "UPDATED_OLD",
+      };
+      this.logger.debug(`GetId: ${JSON.stringify(params)}`);
+      const result = await this.docClient.send(new UpdateCommand(params));
+      this.logger.debug(`GetId Result: ${JSON.stringify(result)}`);
+      if (result.Attributes) return result.Attributes.order + 1;
+      return 1;
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+
+  async validatePermission(
+    table: string,
+    entity: string,
+    action: string,
+    profile: string,
+  ): Promise<string | undefined> {
+    try {
+      let result: KeyValue;
+      let searchParameters = {
+        indexName: "GSI2",
+        parameters: [
+          { name: "entity", value: "PERM", operator: "=" },
+          {
+            name: "relation2",
+            value: `${profile}|${entity}|${action}`,
+            operator: "=",
+          },
+        ],
+      };
+      let permissionQuery = await this.query<KeyValue>({
+        tableName: table,
+        searchParameters,
+      });
+      if (permissionQuery && permissionQuery.length > 0) {
+        result = permissionQuery[0];
+        return result.type === "ALL" ? "ALL" : "OWNS";
+      }
+      throw new Error("UNAUTHORIZE_REQUEST");
+    } catch (error) {
+      this.logger.error((error as Error).message);
+      throw error;
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inlaweb-lib-dynamodb",
-  "version": "1.0.15",
+  "version": "1.0.16",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
   "scripts": {