inlaweb-lib-dynamodb 1.0.1 → 1.0.3

package/src/index.ts

@@ -0,0 +1,350 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, QueryCommand, UpdateCommand, BatchWriteCommand, TransactWriteCommand } 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({});
+        this.docClient = DynamoDBDocumentClient.from(this.client);
+        this.logger = new Logger();
+    }
+
+    async putItem(tableName: string, item: KeyValue): Promise<void> {
+        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)}`);
+    }
+
+    async getItem<T>(tableName: string, key: KeyValue, projectionExpression?: string): Promise<T | undefined> {
+        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)}`);
+        if (response.Item) {
+            return response.Item as T;
+        }
+        return undefined;
+    }
+
+    async updateItem(params: InputUpdate): Promise<boolean> {
+        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 true;
+    }
+
+    async query<T>(params: {tableName: string, searchParameters: SearchParameters, permission?: string, username?: string}): Promise<T[] | undefined> {
+        try {
+            const parameters: ParamsQuery = this.buildQueryParams(params);
+            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) {
+                return response.Items as T[];
+            }
+            return;
+        } 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 (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;
+            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> {
+        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;
+    }
+
+    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> {
+        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;
+    }
+
+    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({ Put: { Item: item } });
+        });
+        return executions;
+    }
+
+    createUpdateParams(params: InputUpdate): KeyValue {
+        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.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;
+    }
+
+    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> {
+        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;
+    }
+
+    async validatePermission(table: string, entity: string, action: string, profile: string): Promise<string | undefined> {
+        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");        
+    }
+}

package/tests/index.test.ts

@@ -0,0 +1,249 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand, PutCommand, UpdateCommand, QueryCommand, BatchWriteCommand, TransactWriteCommand } from "@aws-sdk/lib-dynamodb"
+import { DynamoLib } from '../src/index';
+import { ParamsQuery, SearchParameters } from "../src/commons/types";
+import moment, { tz } from "moment-timezone";
+
+const mockSend = jest.fn();
+
+jest.mock("@aws-sdk/lib-dynamodb", () => ({
+  DynamoDBDocumentClient: {
+    from: () => ({
+      send: mockSend,
+    }),
+  },
+  GetCommand: jest.fn().mockImplementation((params) => params),
+  PutCommand: jest.fn(),
+  UpdateCommand: jest.fn().mockImplementation((params) => params),
+  QueryCommand: jest.fn().mockImplementation((params) => params),
+  BatchWriteCommand: jest.fn().mockImplementation((params) => params),
+  TransactWriteCommand: jest.fn().mockImplementation((params) => params),
+}));
+
+jest.mock("moment-timezone", () => {
+  return{
+    tz: jest.fn().mockReturnValue({
+      format: jest.fn().mockReturnValue("2025-02-25"),
+    }),
+  }
+});
+
+describe('DynamoLib', () => {
+  let dynamoLib: DynamoLib;
+  let tableName: string;
+  let item: { [key: string]: any };
+  let items: { [key: string]: any }[];
+  let key: { [key: string]: any };
+  let projection: string | undefined;
+  let searchParameters: SearchParameters = { indexName: "", parameters: [] };
+  
+
+  beforeEach(() => {
+      tableName = 'testTable';
+      item = { id: '1', name: 'test' };
+      items = [{ id: '1', name: 'test' }, { id: '2', name: 'test2' }];
+      key = { id: '1' };
+      projection = "key,name";
+      searchParameters.indexName = "GSI2";
+      searchParameters.parameters = [
+          { name: "entity", value: "entity", operator: "=" },
+      ];
+      dynamoLib = new DynamoLib();
+  });
+
+  afterEach(() => {
+      jest.clearAllMocks();
+  });
+
+  describe('putItem', () => {
+      it('should put an item into the table', async () => {
+
+        await dynamoLib.putItem(tableName, item);
+    
+        expect(PutCommand).toHaveBeenCalledWith({"Item": {"id": "1", "name": "test"}, "TableName": "testTable", "ReturnConsumedCapacity": "TOTAL", "ReturnItemCollectionMetrics": "SIZE"});
+        expect(mockSend).toHaveBeenCalledWith({});
+      });
+  });
+
+  describe('getItem', () => {
+
+      it('should get an item from the table', async () => {
+        mockSend.mockResolvedValue({ Item: item });
+
+        const result = await dynamoLib.getItem(tableName, key, projection);
+    
+        expect(GetCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key": "key", "#name": "name"}, "Key": {"id": "1"}, "ProjectionExpression": "#key,#name", "TableName": "testTable", "ReturnConsumedCapacity": "TOTAL"});
+        expect(mockSend).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key": "key", "#name": "name"}, "Key": {"id": "1"}, "ProjectionExpression": "#key,#name", "TableName": "testTable", "ReturnConsumedCapacity": "TOTAL"});
+        expect(result).toEqual(item);
+      });
+      it('should return undefined if item is not found', async () => {
+               
+        mockSend.mockResolvedValue({});
+
+        const result = await dynamoLib.getItem(tableName, key);
+
+        expect(result).toEqual(undefined);
+      });
+  });
+
+  describe('updateItem', () => {
+    it('should update an item', async () => {
+
+      await dynamoLib.updateItem({table: tableName, PK: "PK", SK: "SK", username: "username", item, setAttributes: ["name"]});
+  
+      expect(UpdateCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#name": "name", "#updateDate": "updateDate", "#updateUser": "updateUser"}, "ExpressionAttributeValues": {":name": "test", ":updateDate": "2025-02-25", ":updateUser": "username"}, "Key": {"PK": "PK", "SK": "SK"}, "TableName": "testTable", "UpdateExpression": "SET #name = :name,#updateUser = :updateUser,#updateDate = :updateDate", "ReturnConsumedCapacity": "TOTAL"});
+    });
+  });
+
+  describe('query', () => {
+    it('should get items of the table', async () => {
+      searchParameters.parameters.push({ name: "filter1", value: "filter1", operator: "="});
+      mockSend.mockResolvedValue({ Items: items });
+
+      const result = await dynamoLib.query({tableName, searchParameters});
+  
+      expect(QueryCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity", "#key1": "filter1"}, "ExpressionAttributeValues": {":value0": "entity", ":value1": "filter1"}, "KeyConditionExpression": "#key0 = :value0 and #key1 = :value1", "TableName": "testTable"});
+      expect(mockSend).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity", "#key1": "filter1"}, "ExpressionAttributeValues": {":value0": "entity", ":value1": "filter1"}, "KeyConditionExpression": "#key0 = :value0 and #key1 = :value1", "TableName": "testTable"});
+      expect(result).toEqual(items);
+    });
+    it('should call QueryCommand with filterexpressions', async () => {
+      searchParameters.parameters.push({ name: "filter1", value: "filter1", operator: "FILTER", filterOperator: "="});
+      searchParameters.parameters.push({ name: "filter2", value: "filter", operator: "FILTER", filterOperator: "contains"});
+      searchParameters.parameters.push({ name: "filter3", value: "filter3", operator: "FILTER", filterOperator: "begins_with"});
+      searchParameters.parameters.push({ name: "filter4", value: "filter4", operator: "FILTER", filterOperator: "attribute_exists"});
+      searchParameters.parameters.push({ name: "filter5", value: "filter5", operator: "FILTER", filterOperator: "attribute_not_exists"});
+      mockSend.mockResolvedValue({ Items: items });
+
+      await dynamoLib.query({tableName, searchParameters});
+  
+      expect(QueryCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity", "#key1": "filter1", "#key2": "filter2", "#key3": "filter3", "#key4": "filter4", "#key5": "filter5"}, "ExpressionAttributeValues": {":value0": "entity", ":value1": "filter1", ":value2": "filter", ":value3": "filter3", ":value4": "filter4", ":value5": "filter5"}, "FilterExpression": "#key1 = :value1 and contains (#key2, :value2) and begins_with(#key3, :value3) and attribute_exists (#key4) and attribute_not_exists (#key5)", "KeyConditionExpression": "#key0 = :value0", "TableName": "testTable"});
+    });
+    it('should call QueryCommand with filterexpression for own registers', async () => {
+      const permission = 'OWNS';
+      const username = 'testUser';
+      mockSend.mockResolvedValue({ Items: items });
+
+      await dynamoLib.query({tableName, searchParameters, permission, username});
+  
+      expect(QueryCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity", "#key1": "creationUser"}, "ExpressionAttributeValues": {":value0": "entity", ":value1": "testUser"}, "FilterExpression": "#key1 = :value1", "KeyConditionExpression": "#key0 = :value0", "TableName": "testTable"});
+    });
+    it('should call QueryCommand with keyCondition begins_with', async () => {
+      searchParameters.parameters[0].operator = "begins_with";
+      mockSend.mockResolvedValue({ Items: items });
+
+      await dynamoLib.query({tableName, searchParameters});
+  
+      expect(QueryCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity"}, "ExpressionAttributeValues": {":value0": "entity"}, "KeyConditionExpression": "begins_with(#key0, :value0)", "TableName": "testTable"});
+    });
+    it('should throw error', async () => {
+      mockSend.mockRejectedValue(new Error("error"));
+
+      await expect(dynamoLib.query({tableName, searchParameters})).rejects.toThrow('error');
+    });
+    it('should call QueryCommand with keyCondition between', async () => {
+      searchParameters.parameters[0].operator = "BETWEEN";
+      searchParameters.parameters[0].value = "2025-01-01";
+      searchParameters.parameters[0].value1 = "2025-01-31";
+      mockSend.mockResolvedValue({ Items: items });
+
+      await dynamoLib.query({tableName, searchParameters});
+  
+      expect(QueryCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#key0": "entity"}, "ExpressionAttributeValues": {":value0": "2025-01-01", ":value10": "2025-01-31"}, "KeyConditionExpression": "#key0 BETWEEN :value0 AND :value10", "TableName": "testTable"});
+    });
+    it('should return undefined if items is not found', async () => {
+               
+      mockSend.mockResolvedValue({});
+
+      const result = await dynamoLib.query({tableName, searchParameters});
+
+      expect(result).toEqual(undefined);
+    });
+  });
+
+  describe('saveBatch', () => {
+    it('should save batch of items', async () => {
+
+      await dynamoLib.saveBatch(tableName, items);
+  
+      expect(BatchWriteCommand).toHaveBeenCalledWith({"RequestItems": {"testTable": [{"PutRequest": {"Item": {"id": "1", "name": "test"}}}, {"PutRequest": {"Item": {"id": "2", "name": "test2"}}}]}, "ReturnConsumedCapacity": "TOTAL"});
+      expect(mockSend).toHaveBeenCalledWith({"RequestItems": {"testTable": [{"PutRequest": {"Item": {"id": "1", "name": "test"}}}, {"PutRequest": {"Item": {"id": "2", "name": "test2"}}}]}, "ReturnConsumedCapacity": "TOTAL"});
+    });
+  });
+
+  describe('writeTransaction', () => {
+    it('should save transaction', async () => {
+
+      await dynamoLib.writeTransactions(items, 24);
+  
+      expect(TransactWriteCommand).toHaveBeenCalledWith({"ReturnConsumedCapacity": "TOTAL", "TransactItems": [{"Put": {"Item": {"id": "1", "name": "test"}}}, {"Put": {"Item": {"id": "2", "name": "test2"}}}]});
+      expect(mockSend).toHaveBeenCalledWith({"ReturnConsumedCapacity": "TOTAL", "TransactItems": [{"Put": {"Item": {"id": "1", "name": "test"}}}, {"Put": {"Item": {"id": "2", "name": "test2"}}}]});
+    });
+  });
+
+  describe('createUpdateParams', () => {
+    it('should create item formatted to update', async () => {
+
+      const result = dynamoLib.createUpdateParams({table: tableName, PK: "PK", SK: "SK", username: "username", item, setAttributes: ["name"], addAttributes: ["id"], removeAttributes: ["address"]});
+  
+      expect(result).toEqual({"Update": {"ExpressionAttributeNames": {"#address": "address", "#id": "id", "#name": "name", "#updateDate": "updateDate", "#updateUser": "updateUser"}, "ExpressionAttributeValues": {":id": "1", ":name": "test", ":updateDate": "2025-02-25", ":updateUser": "username"}, "Key": {"PK": "PK", "SK": "SK"}, "ReturnConsumedCapacity": "TOTAL", "TableName": "testTable", "UpdateExpression": "SET #name = :name,#updateUser = :updateUser,#updateDate = :updateDate ADD #id :id REMOVE #address"}});
+    });
+  });
+
+  describe('getId', () => {
+    it('should return next id to use', async () => {
+      const spyGetItem = jest.spyOn(dynamoLib, 'getItem');
+      spyGetItem.mockImplementation((table, key) => Promise.resolve(undefined));
+      const spyPutItem = jest.spyOn(dynamoLib, 'putItem');
+      spyPutItem.mockImplementation((table, item) => Promise.resolve());
+      mockSend.mockResolvedValue({ Attributes: { order: 0 }});
+
+      const result = await dynamoLib.getId(tableName, "entity", "username");
+
+      expect(spyGetItem).toHaveBeenCalledWith("testTable", {"PK": "COUN", "SK": "entity"}, "order");
+      expect(spyPutItem).toHaveBeenCalledWith("testTable", {"PK": "COUN", "SK": "entity", "creationDate": "2025-02-25", "creationUser": "username", "entity": "COUN", "order": 0});
+      expect(UpdateCommand).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#id": "order"}, "ExpressionAttributeValues": {":increment": 1}, "Key": {"PK": "COUN", "SK": "entity"}, "ReturnValues": "UPDATED_OLD", "TableName": "testTable", "UpdateExpression": "SET #id = #id + :increment"});
+      expect(mockSend).toHaveBeenCalledWith({"ExpressionAttributeNames": {"#id": "order"}, "ExpressionAttributeValues": {":increment": 1}, "Key": {"PK": "COUN", "SK": "entity"}, "ReturnValues": "UPDATED_OLD", "TableName": "testTable", "UpdateExpression": "SET #id = #id + :increment"});
+      expect(result).toEqual(1);
+    });
+    it('should return 1 if element not exists', async () => {
+      const spyGetItem = jest.spyOn(dynamoLib, 'getItem');
+      spyGetItem.mockImplementation((table, key) => Promise.resolve(undefined));
+      const spyPutItem = jest.spyOn(dynamoLib, 'putItem');
+      spyPutItem.mockImplementation((table, item) => Promise.resolve());
+      mockSend.mockResolvedValue({});
+
+      const result = await dynamoLib.getId(tableName, "entity", "username");
+
+      expect(result).toEqual(1);
+    });
+  });
+
+  describe('validatePermission', () => {
+    it('should return ALL', async () => {
+      const spyQuery = jest.spyOn(dynamoLib, 'query');
+      spyQuery.mockImplementation((params) => Promise.resolve([{type: "ALL"}]));
+      mockSend.mockResolvedValue({ Attributes: { order: 0 }});
+
+      const result = await dynamoLib.validatePermission(tableName, "entity", "INSERT", "PROF1");
+
+      expect(spyQuery).toHaveBeenCalledWith({"searchParameters": {"indexName": "GSI2", "parameters": [{"name": "entity", "operator": "=", "value": "PERM"}, {"name": "relation2", "operator": "=", "value": "PROF1|entity|INSERT"}]}, "tableName": "testTable"});
+      expect(result).toEqual("ALL");
+    });
+    it('should return OWNS', async () => {
+      const spyQuery = jest.spyOn(dynamoLib, 'query');
+      spyQuery.mockImplementation((params) => Promise.resolve([{type: "OWNS"}]));
+      mockSend.mockResolvedValue({ Attributes: { order: 0 }});
+
+      const result = await dynamoLib.validatePermission(tableName, "entity", "INSERT", "PROF1");
+
+      expect(spyQuery).toHaveBeenCalledWith({"searchParameters": {"indexName": "GSI2", "parameters": [{"name": "entity", "operator": "=", "value": "PERM"}, {"name": "relation2", "operator": "=", "value": "PROF1|entity|INSERT"}]}, "tableName": "testTable"});
+      expect(result).toEqual("OWNS");
+    });
+    it('should trow error if permission not exists', async () => {
+      const spyQuery = jest.spyOn(dynamoLib, 'query');
+      spyQuery.mockImplementation((params) => Promise.resolve([]));
+
+      await expect(dynamoLib.validatePermission(tableName, "entity", "INSERT", "PROF1")).rejects.toThrow("UNAUTHORIZE_REQUEST");
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+    "compilerOptions": {
+      "target": "ES2020",
+      "module": "commonjs",
+      "declaration": true,
+      "declarationDir": "./dist/types",
+      "outDir": "./dist",
+      "strict": true,
+      "esModuleInterop": true
+    },
+    "include": ["src/**/*.ts"]
+  }