inlaweb-lib-dynamodb 1.0.0

package/dist/index.js

@@ -0,0 +1,317 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoLib = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const logger_1 = require("@aws-lambda-powertools/logger");
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const templatesUpdateExpresion = {
+    SET: (atribute) => `#${atribute} = :${atribute},`,
+    ADD: (atribute) => `#${atribute} :${atribute},`,
+    REMOVE: (atribute) => `#${atribute},`,
+};
+class DynamoLib {
+    constructor() {
+        this.client = new client_dynamodb_1.DynamoDBClient({});
+        this.docClient = lib_dynamodb_1.DynamoDBDocumentClient.from(this.client);
+        this.logger = new logger_1.Logger();
+    }
+    async putItem(tableName, item) {
+        const params = {
+            TableName: tableName,
+            Item: item,
+            ReturnItemCollectionMetrics: "SIZE",
+            ReturnConsumedCapacity: "TOTAL",
+        };
+        this.logger.debug(`PutItem: ${JSON.stringify(params)}`);
+        const result = await this.docClient.send(new lib_dynamodb_1.PutCommand(params));
+        this.logger.debug(`PutItem Result: ${JSON.stringify(result)}`);
+    }
+    async getItem(tableName, key, projectionExpression) {
+        const params = {
+            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 lib_dynamodb_1.GetCommand(params));
+        this.logger.debug(`GetItem Result: ${JSON.stringify(response)}`);
+        if (response.Item) {
+            return response.Item;
+        }
+        return undefined;
+    }
+    async updateItem(params) {
+        const itemUpdate = this.createUpdateParams(params);
+        this.logger.debug(`UpdateItem: ${JSON.stringify(itemUpdate.Update)}`);
+        const result = await this.docClient.send(new lib_dynamodb_1.UpdateCommand(itemUpdate.Update));
+        this.logger.debug(`UpdateItem Result: ${JSON.stringify(result)}`);
+        return true;
+    }
+    async query(params) {
+        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)}`);
+        if (response.Items) {
+            return response.Items;
+        }
+        return [];
+    }
+    buildQueryParams(params) {
+        const projection = this.buildProjectionExpression(params.searchParameters.projectionExpression);
+        const parameters = {
+            TableName: params.tableName,
+            KeyConditionExpression: "",
+            ExpressionAttributeNames: projection?.expressionAttributeNames || {},
+            ExpressionAttributeValues: {}
+        };
+        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;
+    }
+    buildExpressions(searchParameter, index, params) {
+        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;
+    }
+    buildFilterExpression(searchParameter, index, params) {
+        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;
+            default:
+                params.FilterExpression += `#key${index} ${searchParameter.filterOperator} :value${index}`;
+                break;
+        }
+    }
+    buildProjectionExpression(projectionExpression) {
+        if (!projectionExpression) {
+            return undefined;
+        }
+        const fields = projectionExpression.split(",");
+        if (fields.length > 0) {
+            let projectionExpression = "";
+            const expressionAttributeNames = {};
+            fields.forEach((field) => {
+                projectionExpression += `#${field},`;
+                expressionAttributeNames[`#${field}`] = field;
+            });
+            projectionExpression = projectionExpression.slice(0, -1);
+            return { projectionExpression, expressionAttributeNames };
+        }
+    }
+    async saveBatch(table, items) {
+        const executions = this.createBatch(items);
+        for (let i = 0; i < executions.length; i++) {
+            const params = {
+                RequestItems: {
+                    [table]: executions[i]
+                },
+                ReturnConsumedCapacity: "TOTAL",
+            };
+            this.logger.debug(`BatchWrite: ${JSON.stringify(params)}`);
+            const response = await this.docClient.send(new lib_dynamodb_1.BatchWriteCommand(params));
+            this.logger.debug(`BatchWrite Result: ${JSON.stringify(response)}`);
+        }
+        return true;
+    }
+    createBatch(items) {
+        const executions = [];
+        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, limit) {
+        const executions = this.createWriteTransactions(items, limit);
+        for (let i = 0; i < executions.length; i++) {
+            const params = {
+                TransactItems: executions[i],
+                ReturnConsumedCapacity: "TOTAL",
+            };
+            this.logger.debug(`TransactWrite: ${JSON.stringify(params)}`);
+            const response = await this.docClient.send(new lib_dynamodb_1.TransactWriteCommand(params));
+            this.logger.debug(`TransactWrite Result: ${JSON.stringify(response)}`);
+        }
+        return true;
+    }
+    createWriteTransactions(items, limit) {
+        const executions = [];
+        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({ Put: { Item: item } });
+        });
+        return executions;
+    }
+    createUpdateParams(params) {
+        const { table, PK, SK, item, setAttributes, addAttributes, removeAttributes, username } = params;
+        // Se agregan los datos de auditoría para la actualización
+        item.updateUser = username;
+        item.updateDate = moment_timezone_1.default.tz(new Date(), "America/Bogota").format("YYYY-MM-DD");
+        if (!setAttributes.includes("updateUser"))
+            setAttributes.push("updateUser");
+        if (!setAttributes.includes("updateDate"))
+            setAttributes.push("updateDate");
+        // Se crea el objeto de la operación
+        let itemUpdate = {
+            Update: {
+                TableName: table,
+                Key: { PK, SK },
+                UpdateExpression: ``,
+                ExpressionAttributeNames: {},
+                ExpressionAttributeValues: {},
+                ReturnConsumedCapacity: "TOTAL",
+            },
+        };
+        // 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;
+    }
+    formatUpdateExpression(operation, updateObject, item, atributes) {
+        // 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 += " ";
+    }
+    formatUpdateExpressionRemove(updateObject, atributes) {
+        let 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, entity, username, quantity) {
+        let item = await this.getItem(table, { PK: "COUN", SK: entity }, "order");
+        if (!item) {
+            item = {
+                PK: "COUN",
+                SK: entity,
+                entity: "COUN",
+                order: 0,
+                creationUser: username,
+                creationDate: moment_timezone_1.default.tz(new Date(), "America/Bogota").format("YYYY-MM-DD"),
+            };
+            await this.putItem(table, item);
+        }
+        const params = {
+            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 lib_dynamodb_1.UpdateCommand(params));
+        this.logger.debug(`GetId Result: ${JSON.stringify(result)}`);
+        if (result.Attributes)
+            return result.Attributes.order + 1;
+        return 1;
+    }
+    async validatePermission(table, entity, action, profile) {
+        let result;
+        let searchParameters = {
+            indexName: "GSI2",
+            parameters: [
+                { name: "entity", value: "PERM", operator: "=" },
+                { name: "relation2", value: `${profile}|${entity}|${action}`, operator: "=" },
+            ],
+        };
+        let permissionQuery = await this.query({ tableName: table, searchParameters });
+        if (permissionQuery.length) {
+            result = permissionQuery[0];
+            return result.type === "ALL" ? "ALL" : "OWNS";
+        }
+        throw new Error("UNAUTHORIZE_REQUEST");
+    }
+}
+exports.DynamoLib = DynamoLib;

package/dist/types/commons/types.d.ts

@@ -0,0 +1,62 @@
+import { ReturnConsumedCapacity, ReturnValue, ReturnItemCollectionMetrics } from "@aws-sdk/client-dynamodb";
+export interface ParamsPut {
+    TableName: string;
+    Item: KeyValue;
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+    ReturnItemCollectionMetrics?: ReturnItemCollectionMetrics;
+}
+export interface ParamsGet {
+    TableName: string;
+    Key: KeyValue;
+    ProjectionExpression?: string;
+    ExpressionAttributeNames?: KeyValue;
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+}
+export interface ParamsQuery {
+    TableName: string;
+    KeyConditionExpression: string;
+    ExpressionAttributeNames: KeyValue;
+    ExpressionAttributeValues: KeyValue;
+    ProjectionExpression?: string;
+    ExclusiveStartKey?: KeyValue;
+    Limit?: number;
+    ScanIndexForward?: boolean;
+    IndexName?: string;
+    FilterExpression?: string;
+    ConsistentRead?: boolean;
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+}
+export interface ParamsUpdate {
+    TableName: string;
+    Key: KeyValue;
+    UpdateExpression: string;
+    ExpressionAttributeNames: KeyValue;
+    ExpressionAttributeValues: KeyValue;
+    ReturnValues?: ReturnValue;
+}
+export interface ProjectionExpression {
+    projectionExpression: string;
+    expressionAttributeNames: KeyValue;
+}
+export interface SearchParameters {
+    indexName: string;
+    parameters: KeyValue[];
+    projectionExpression?: string;
+    exclusiveStartKey?: KeyValue;
+    scanIndexForward?: boolean;
+    limit?: number;
+}
+export interface InputUpdate {
+    table: string;
+    PK: string;
+    SK: string;
+    username: string;
+    item: KeyValue;
+    setAttributes: string[];
+    addAttributes?: string[];
+    removeAttributes?: string[];
+}
+export interface KeyValue {
+    [key: string]: any;
+}
+export type Operation = "SET" | "ADD" | "REMOVE";

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+import { SearchParameters, KeyValue, InputUpdate } from "./commons/types";
+export declare class DynamoLib {
+    private readonly client;
+    private readonly docClient;
+    private readonly logger;
+    constructor();
+    putItem(tableName: string, item: KeyValue): Promise<void>;
+    getItem(tableName: string, key: KeyValue, projectionExpression?: string): Promise<KeyValue | undefined>;
+    updateItem(params: InputUpdate): Promise<boolean>;
+    query(params: {
+        tableName: string;
+        searchParameters: SearchParameters;
+        permission?: string;
+        username?: string;
+    }): Promise<KeyValue[]>;
+    private buildQueryParams;
+    private buildExpressions;
+    private buildFilterExpression;
+    private buildProjectionExpression;
+    saveBatch(table: string, items: KeyValue[]): Promise<boolean>;
+    private createBatch;
+    writeTransactions(items: KeyValue[], limit: number): Promise<boolean>;
+    createWriteTransactions(items: KeyValue[], limit: number): KeyValue[][];
+    createUpdateParams(params: InputUpdate): KeyValue;
+    private formatUpdateExpression;
+    private formatUpdateExpressionRemove;
+    getId(table: string, entity: string, username: string, quantity?: number): Promise<number>;
+    validatePermission(table: string, entity: string, action: string, profile: string): Promise<string | undefined>;
+}

package/jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+    preset: 'ts-jest', // Usa ts-jest para compilar los archivos TypeScript antes de ejecutar las pruebas
+    testEnvironment: 'node', // Establece el entorno de prueba a 'node' (ya que estamos trabajando con DynamoDB en Node.js)
+    moduleNameMapper: {
+      // Si usas el alias de módulos, puedes configurarlos aquí
+      // Ejemplo: '^@libs/(.*)$': '<rootDir>/src/libs/$1',
+    },
+};
+  

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "inlaweb-lib-dynamodb",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage"
+  },
+  "dependencies": {
+    "@aws-lambda-powertools/logger": "^2.15.0",
+    "@aws-sdk/client-dynamodb": "^3.731.1",
+    "@aws-sdk/lib-dynamodb": "^3.749.0",
+    "@types/aws-lambda": "^8.10.147",
+    "moment-timezone": "^0.5.47"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}

package/readme.MD

@@ -0,0 +1,8 @@
+# AWS DynamoDB Library
+
+A TypeScript library for AWS DynamoDB using `@aws-sdk/client-dynamodb` v3.
+
+## Installation
+
+```bash
+npm install inlaweb-lib-dynamodb

package/src/commons/types.ts

@@ -0,0 +1,71 @@
+import { ReturnConsumedCapacity, ReturnValue, ReturnItemCollectionMetrics } from "@aws-sdk/client-dynamodb";
+
+export interface ParamsPut {
+    TableName: string;
+    Item: KeyValue; 
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+    ReturnItemCollectionMetrics?: ReturnItemCollectionMetrics; 
+}
+
+export interface ParamsGet {
+    TableName: string;
+    Key: KeyValue;
+    ProjectionExpression?: string;
+    ExpressionAttributeNames?: KeyValue;
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+}
+
+export interface ParamsQuery {
+    TableName: string;
+    KeyConditionExpression: string;
+    ExpressionAttributeNames: KeyValue;
+    ExpressionAttributeValues: KeyValue;
+    ProjectionExpression?: string;
+    ExclusiveStartKey?: KeyValue;
+    Limit?: number;
+    ScanIndexForward?: boolean;
+    IndexName?: string;
+    FilterExpression?: string;
+    ConsistentRead?: boolean;
+    ReturnConsumedCapacity?: ReturnConsumedCapacity;
+}
+
+export interface ParamsUpdate {
+    TableName: string;
+    Key: KeyValue;
+    UpdateExpression: string;
+    ExpressionAttributeNames: KeyValue;
+    ExpressionAttributeValues: KeyValue;
+    ReturnValues?: ReturnValue;
+}
+
+export interface ProjectionExpression {
+    projectionExpression: string;
+    expressionAttributeNames: KeyValue;
+}
+
+export interface SearchParameters {
+    indexName: string;
+    parameters: KeyValue[];
+    projectionExpression?: string;
+    exclusiveStartKey?: KeyValue;
+    scanIndexForward?: boolean;
+    limit?: number;
+}
+
+export interface InputUpdate {
+    table: string;
+    PK: string;
+    SK: string;
+    username: string;
+    item: KeyValue;
+    setAttributes: string[];
+    addAttributes?: string[];
+    removeAttributes?: string[];
+}
+
+export interface KeyValue {
+    [key: string]: any;
+}
+
+export type Operation = "SET" | "ADD" | "REMOVE";