chatbot-nc 2.0.83 → 2.0.84

package/dist/cjs/repository/dynamodb.js

@@ -0,0 +1,696 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb"); // ES Modules import
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const awsRegion = process.env.AWS_DEFAULT_REGION || 'us-east-1';
+/**
+* Base Repository of Dynamodb
+* @param {object} item // Object containing add for target item
+*/
+class BaseDynamoDBRepository {
+    constructor() {
+        this.TABLE_NAME = '';
+        this.PRIMARY_KEY = [];
+        let client = new client_dynamodb_1.DynamoDBClient({
+            region: awsRegion,
+        });
+        this.documentClient = lib_dynamodb_1.DynamoDBDocumentClient.from(client);
+    }
+    /**
+     * Add item in DynamoDB table
+     * @param {object} item // Object containing add for target item
+     */
+    async add(item) {
+        try {
+            item = this.parseDate(item);
+            var params = {
+                TableName: this.TABLE_NAME,
+                Item: Object.assign({}, item)
+            };
+            if (!("createdAt" in params.Item))
+                params.Item.createdAt = Number(Date.now());
+            if (!("updatedAt" in params.Item))
+                params.Item.updatedAt = Number(Date.now());
+            const response = await this.documentClient.send(new lib_dynamodb_1.PutCommand(params));
+            console.log('dbItem');
+            return response;
+        }
+        catch (error) {
+            this.handleError(error);
+            // // throw new DatabaseException( error.code );
+        }
+    }
+    /**
+     * Update item in DynamoDB table
+     * @param {object} key // Object containing target item key(s)
+     * @param {object} item // Object containing updates for target item
+     */
+    async update(key, item) {
+        try {
+            const itemKeys = Object.keys(item).filter(k => k !== key);
+            const params = {
+                TableName: this.TABLE_NAME,
+                UpdateExpression: `SET ${itemKeys.map((k, index) => `#field${index} = :value${index}`).join(', ')}`,
+                ExpressionAttributeNames: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`#field${index}`]: k })), {}),
+                ExpressionAttributeValues: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`:value${index}`]: item[k] })), {}),
+                Key: {
+                    [key]: item[key]
+                },
+                ReturnValues: 'ALL_NEW'
+            };
+            return await this.documentClient.send(new lib_dynamodb_1.UpdateCommand(params));
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Update item in DynamoDB table
+     * @param {String[]} keys // String Array containing target item key(s)
+     * @param {object} item // Object containing updates for target item
+     * @returns
+    */
+    async updateByMutiple(keys, item) {
+        try {
+            // const itemKeys = Object.keys(item).filter(k => !key.includes(k));
+            const itemKeys = Object.keys(item).filter(k => !keys.includes(k));
+            const keyItem = Object.keys(item).filter(k => keys.includes(k));
+            const params = {
+                TableName: this.TABLE_NAME,
+                UpdateExpression: `SET ${itemKeys.map((k, index) => `#field${index} = :value${index}`).join(', ')}`,
+                ExpressionAttributeNames: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`#field${index}`]: k })), {}),
+                ExpressionAttributeValues: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`:value${index}`]: item[k] })), {}),
+                Key: keyItem.reduce((obj, key) => {
+                    obj[key] = item[key];
+                    return obj;
+                }, {}),
+                ReturnValues: 'ALL_NEW'
+            };
+            return await this.documentClient.send(new lib_dynamodb_1.UpdateCommand(params));
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     *
+     * @param key Only Partition Key (No Primary Key or Combination Key)
+     * @param item Object of Keys
+     * @returns
+     */
+    // public async updateByMutipleValue (key: string, item: any) {
+    // 	try {
+    // 		const keyItem  = Object.keys(item).filter(k => k == key).reduce((obj: any, key: any) => {
+    // 			obj[key] = item[key];
+    // 			return obj;
+    // 		}, {});
+    // 		let responseItem = await this.getSingleItem(keyItem);
+    // 		if(responseItem)
+    // 		{
+    // 			const itemKeys = Object.keys(item).filter(k => k !== key).reduce((obj: any, key: any) => {
+    // 				obj[key] = item[key];
+    // 				return obj;
+    // 			}, {});
+    // 			let returnResponse = this.parseDate({...responseItem,...itemKeys,updatedAt:Number(Date.now())});
+    // 			var params: PutCommandInput = {
+    // 				TableName: this.TABLE_NAME,
+    // 				Item: returnResponse
+    // 			}
+    // 		    console.log(returnResponse);
+    // 		    await this.documentClient.send(new PutCommand(params))
+    // 			return returnResponse;
+    // 		}
+    // 		return responseItem;
+    // 	} catch (error) {
+    // 		this.handleError(error);
+    // 	}
+    // }
+    /**
+     * Get item in DynamoDB table
+     * @param {object} id // Object containing target item key(s)
+     * @param {object} version // Object containing updates for target item
+     */
+    async getById(key) {
+        console.info("Dynamo db Repository: getById Start");
+        var params = {
+            TableName: this.TABLE_NAME,
+            Key: key
+        };
+        try {
+            console.info("Dynamo db Repository: getById End");
+            const command = new lib_dynamodb_1.GetCommand(params);
+            const response = await this.documentClient.send(command);
+            if (response && response.Item) {
+                return this.unparseDate(response.Item);
+            }
+            return null;
+        }
+        catch (error) {
+            console.error(`error occured while getting custom order log by primary keys - customOrderLog - ${error}`);
+            console.error("Dynamo db Repository: Error: ");
+            this.handleError(error);
+            // throw new DatabaseException( error.code );
+        }
+    }
+    /**
+     * Get item in DynamoDB table
+     * @param {object} id // Object containing target item key(s)
+     * @param {object} version // Object containing updates for target item
+    */
+    // public async getSingleItem (key: object) {
+    // 	let response = await this.query(key);
+    // 	if(response)
+    // 	return response[0];
+    //     else
+    // 	return null;
+    // }
+    /**
+     * Get items in DynamoDB table
+     * @param {object} item // Object containing target item key(s)
+     */
+    async query(item, condition, indexName, projectionExpression, limit, scanIndexForward = true, exclusiveStartKey) {
+        console.info("Dynamo db Repository: query Start");
+        try {
+            const itemKeys = Object.keys(item);
+            // let Key, Filter;
+            // if (!indexName) {
+            // 	Key = `${itemKeys.map((k, index) => {
+            // 		if (this.PRIMARY_KEY.length === 0 || this.PRIMARY_KEY.includes(k))
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 	}).filter(a => a).join(' and ')}`;
+            // 	Filter = `${itemKeys.map((k, index) => {
+            // 		if (!this.PRIMARY_KEY.includes(k))
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 			   if(condition![index].toUpperCase() == 'IN')
+            // 				return `#field${index} ${condition![index]}(${Object.keys(this.getArrayValue(item[k],index)).toString()})`
+            // 			   else
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 	}).filter(a => a).join(' and ')}`;
+            // }
+            // else {
+            // 	Key = `${itemKeys.map((k, index) => {
+            // 		if (indexName.split('-').includes(k)) {
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 		}
+            // 	}).filter(a => a).join(' and ')}`;
+            // 	Filter = `${itemKeys.map((k, index) => {
+            // 		if (!indexName.split('-').includes(k)) {
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 			   if(condition![index].toUpperCase() == 'IN')
+            // 				return `#field${index} ${condition![index]}(${Object.keys(this.getArrayValue(item[k],index)).toString()})`
+            // 			   else
+            // 			   return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 		}
+            // 	}).filter(a => a).join(' and ')}`;
+            // }
+            let [Key, Filter] = await this.getKeyAndFilter(item, condition, indexName);
+            let params = {
+                TableName: this.TABLE_NAME,
+                ExpressionAttributeNames: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`#field${index}`]: k })), {}),
+                ExpressionAttributeValues: itemKeys.reduce((accumulator, k, index) => {
+                    if (Array.isArray(item[k])) {
+                        let data = this.getArrayValue(item[k], index);
+                        return Object.assign(Object.assign({}, accumulator), data);
+                    }
+                    else
+                        return Object.assign(Object.assign({}, accumulator), { [`:value${index}`]: item[k] });
+                }, {}),
+                KeyConditionExpression: Key,
+                ScanIndexForward: scanIndexForward
+            };
+            if (exclusiveStartKey)
+                params = Object.assign(params, { ExclusiveStartKey: exclusiveStartKey });
+            if (indexName)
+                params = Object.assign(params, { IndexName: indexName });
+            if (projectionExpression)
+                params = Object.assign(params, { ProjectionExpression: projectionExpression });
+            if (Filter)
+                params = Object.assign(params, { FilterExpression: Filter });
+            // if (limit)
+            //     params = Object.assign(params, { Limit:limit});
+            let response, acc = [];
+            do {
+                response = await this.documentClient.send(new lib_dynamodb_1.QueryCommand(params));
+                console.info("Repository: query End");
+                params.ExclusiveStartKey = response.LastEvaluatedKey;
+                console.log("Last Evaluated Key");
+                if (limit) {
+                    if (response && response.Items) {
+                        if (response.Items.length <= limit - acc.length)
+                            acc = [...acc, ...response.Items];
+                        else
+                            acc = [...acc, ...response.Items.slice(0, limit - acc.length)];
+                    }
+                }
+                else if (response && response.Items)
+                    acc = [...acc, ...response.Items];
+            } while (response && response.Items && response.LastEvaluatedKey && (!limit || acc.length < limit));
+            if (acc.length > 0)
+                return this.unparseDate(acc);
+            else
+                return null;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Get items in DynamoDB table with Pagination
+     * @param {object} item // Object containing target item key(s)
+     */
+    async queryWithPagination(item, condition, indexName, projectionExpression, limit = 1000, scanIndexForward = true, exclusiveStartKey) {
+        console.info("Dynamo db Repository: query Start");
+        try {
+            const itemKeys = Object.keys(item);
+            // let Key, Filter;
+            // if (!indexName) {
+            // 	Key = `${itemKeys.map((k, index) => {
+            // 		if (this.PRIMARY_KEY.length === 0 || this.PRIMARY_KEY.includes(k))
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 	}).filter(a => a).join(' and ')}`;
+            // 	Filter = `${itemKeys.map((k, index) => {
+            // 		if (!this.PRIMARY_KEY.includes(k))
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 			   if(condition![index].toUpperCase() == 'IN')
+            // 				return `#field${index} ${condition![index]}(${Object.keys(this.getArrayValue(item[k],index)).toString()})`
+            // 			   else
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 	}).filter(a => a).join(' and ')}`;
+            // }
+            // else {
+            // 	Key = `${itemKeys.map((k, index) => {
+            // 		if (indexName.split('-').includes(k)) {
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 				return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 		}
+            // 	}).filter(a => a).join(' and ')}`;
+            // 	Filter = `${itemKeys.map((k, index) => {
+            // 		if (!indexName.split('-').includes(k)) {
+            // 			if (!this.isComparator(condition![index] || '='))
+            // 			   if(condition![index].toUpperCase() == 'IN')
+            // 				return `#field${index} ${condition![index]}(${Object.keys(this.getArrayValue(item[k],index)).toString()})`
+            // 			   else
+            // 			   return `${condition![index]}(#field${index} ,:value${index})`
+            // 			else
+            // 				return `#field${index} ${condition![index] || '='} :value${index}`
+            // 		}
+            // 	}).filter(a => a).join(' and ')}`;
+            // }
+            let [Key, Filter] = await this.getKeyAndFilter(item, condition, indexName);
+            let params = {
+                TableName: this.TABLE_NAME,
+                ExpressionAttributeNames: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`#field${index}`]: k })), {}),
+                ExpressionAttributeValues: itemKeys.reduce((accumulator, k, index) => {
+                    if (Array.isArray(item[k])) {
+                        let data = this.getArrayValue(item[k], index);
+                        return Object.assign(Object.assign({}, accumulator), data);
+                    }
+                    else
+                        return Object.assign(Object.assign({}, accumulator), { [`:value${index}`]: item[k] });
+                }, {}),
+                KeyConditionExpression: Key,
+                ScanIndexForward: scanIndexForward
+            };
+            if (exclusiveStartKey)
+                params = Object.assign(params, { ExclusiveStartKey: exclusiveStartKey });
+            if (indexName)
+                params = Object.assign(params, { IndexName: indexName });
+            if (projectionExpression)
+                params = Object.assign(params, { ProjectionExpression: projectionExpression });
+            if (Filter)
+                params = Object.assign(params, { FilterExpression: Filter });
+            if (limit)
+                params = Object.assign(params, { Limit: limit });
+            let response, acc = { exclusiveStartKey: "", data: [] };
+            do {
+                response = await this.documentClient.send(new lib_dynamodb_1.QueryCommand(params));
+                console.info("Repository: query End");
+                params.ExclusiveStartKey = response.LastEvaluatedKey;
+                console.log("Last Evaluated Key");
+                acc.exclusiveStartKey = response.LastEvaluatedKey;
+                if (response && response.Items)
+                    acc.data = [...acc.data, ...response.Items];
+                if (limit)
+                    params.Limit = limit - acc.data.length;
+            } while (response && response.Items && response.LastEvaluatedKey && acc.data.length < limit);
+            if (acc.data.length > 0) {
+                acc.data = this.unparseDate(acc.data);
+                return acc;
+            }
+            else
+                return null;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Get items in DynamoDB table
+     * @param {object} item // Object containing target item key(s)
+     * @param {Array} condition // Array containing target item key(s) condition
+     * @param {String} projectionExpression // if you want only selected filed should return
+     */
+    async scan(item, condition, projectionExpression, exclusiveStartKey) {
+        console.info("Dynamo db Repository: query Start");
+        try {
+            const itemKeys = Object.keys(item);
+            const Key = `${itemKeys.map((k, index) => `#field${index} ${condition[index]} :value${index}`).join(' and ')}`;
+            let params = {
+                TableName: this.TABLE_NAME,
+                ExpressionAttributeNames: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`#field${index}`]: k })), {}),
+                ExpressionAttributeValues: itemKeys.reduce((accumulator, k, index) => (Object.assign(Object.assign({}, accumulator), { [`:value${index}`]: item[k] })), {}),
+                FilterExpression: Key
+            };
+            if (projectionExpression)
+                params = Object.assign(params, { ProjectionExpression: projectionExpression });
+            if (exclusiveStartKey)
+                params = Object.assign(params, { ExclusiveStartKey: exclusiveStartKey });
+            let response, acc = [];
+            do {
+                response = await this.documentClient.send(new lib_dynamodb_1.ScanCommand(params));
+                console.info("Repository: query End");
+                params.ExclusiveStartKey = response.LastEvaluatedKey;
+                console.log("Last Evaluated Key");
+                if (response && response.Items)
+                    acc = [...acc, ...response.Items];
+            } while (response && response.Items && response.LastEvaluatedKey);
+            if (acc.length > 0)
+                return this.unparseDate(acc);
+            else
+                return null;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    /**
+     * Delete item in DynamoDB table
+     * @param {object} key // Object containing target item key(s)
+     */
+    async delete(key) {
+        console.info("Dynamo db Repository: delete Start");
+        var params = {
+            TableName: this.TABLE_NAME,
+            Key: key
+        };
+        try {
+            const command = new lib_dynamodb_1.DeleteCommand(params);
+            const data = await this.documentClient.send(command);
+            console.info("Dynamo db Repository: delete End");
+        }
+        catch (error) {
+            console.error(`error occured while deleting custom order log by primary keys - customOrderLog - ${error}`);
+            console.error("Dynamo db Repository: Error: ");
+            this.handleError(error);
+            // throw new DatabaseException( error.code );
+        }
+    }
+    /**
+     * Get All items in DynamoDB table
+     */
+    async getAll(exclusiveStartKey) {
+        var params = {
+            TableName: this.TABLE_NAME
+        };
+        try {
+            console.info("Dynamo Repository: getAll Start");
+            if (exclusiveStartKey)
+                params = Object.assign(params, { ExclusiveStartKey: exclusiveStartKey });
+            let response, acc = [];
+            do {
+                response = await this.documentClient.send(new lib_dynamodb_1.ScanCommand(params));
+                console.info("Repository: query End");
+                params.ExclusiveStartKey = response.LastEvaluatedKey;
+                console.log("Last Evaluated Key");
+                if (response && response.Items)
+                    acc = [...acc, ...response.Items];
+            } while (response && response.Items && response.LastEvaluatedKey);
+            console.info("Dynamo db Repository: getAll End");
+            return this.unparseDate(acc);
+        }
+        catch (error) {
+            console.error(`error occured while get all custom order log by primary keys - customOrderLog - ${error}`);
+            console.error("Dynamo db Repository: Error: ");
+            this.handleError(error);
+            // throw new DatabaseException( error.code );
+        }
+    }
+    /**
+     * Bulk Upload item in DynamoDB table
+     * @param {object} item // Object containing add for target item
+     */
+    async bulkUpload(items) {
+        try {
+            let insertItem = await Promise.all(items.map(async (item) => {
+                item = this.parseDate(item);
+                return item;
+                // return {PutRequest:{Item:item}};
+            }));
+            // chunkArray is a local convenience function. It takes an array and returns
+            // a generator function. The generator function yields every N items.
+            const itemChunks = [...Array(Math.ceil(insertItem.length / 25))].map(_ => insertItem.splice(0, 25));
+            // For every chunk of 25 items, make one BatchWrite request.
+            for (const chunk of itemChunks) {
+                const putRequests = chunk.map((data) => ({
+                    PutRequest: {
+                        Item: data,
+                    },
+                }));
+                const command = new lib_dynamodb_1.BatchWriteCommand({
+                    RequestItems: {
+                        // An existing table is required. A composite key of 'title' and 'year' is recommended
+                        // to account for duplicate titles.
+                        [this.TABLE_NAME]: putRequests
+                    }
+                });
+                const response = await this.documentClient.send(command);
+                console.log('dbItem');
+            }
+            console.log("Upload Successfully");
+            return true;
+        }
+        catch (error) {
+            this.handleError(error);
+            // // throw new DatabaseException( error.code );
+        }
+    }
+    /**
+     *
+     * @param data
+     * @returns
+     */
+    parseDate(data) {
+        return JSON.parse(JSON.stringify(data));
+    }
+    /**
+     *
+     * @param data
+     * @returns
+     */
+    unparseDate(data) {
+        //const dateFormat = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+        var ISO_8601_FULL = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?(([+-]\d\d:\d\d)|Z)?$/i;
+        var DATE_STRING = /^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d$/i;
+        function reviver(key, value) {
+            if ((typeof value === "string" && ISO_8601_FULL.test(value))) {
+                //var tzoffset = (new Date(value)).getTimezoneOffset() * 60000; //offset in milliseconds
+                var localISOTime = new Date(value).toISOString();
+                return new Date(localISOTime);
+            }
+            if (typeof value === "string" && DATE_STRING.test(value)) {
+                return new Date(value);
+            }
+            return value;
+        }
+        const text = JSON.stringify(data);
+        const obj = JSON.parse(text, reviver);
+        return obj;
+    }
+    /**
+     *
+     * @param err
+     * @returns
+     */
+    // Handles errors during PutItem execution. Use recommendations in error messages below to 
+    // add error handling specific to your application use-case. 
+    handleError(err) {
+        if (!err) {
+            console.error("Encountered error object was empty");
+            return;
+        }
+        if (!err.code) {
+            console.error(`An exception occurred, investigate and configure retry strategy. Error: ${JSON.stringify(err)}`);
+        }
+        switch (err.code) {
+            case "ConditionalCheckFailedException":
+                console.error(`Condition check specified in the operation failed, review and update the condition check before retrying. Error: ${err.message}`);
+                break;
+            case "TransactionConflictException":
+                console.error(`Operation was rejected because there is an ongoing transaction for the item, generally safe to retry ' +
+         'with exponential back-off. Error: ${err.message}`);
+                break;
+            case "ItemCollectionSizeLimitExceededException":
+                console.error("An item collection is too large, you're using Local Secondary Index and exceeded size limit of" +
+                    `items per partition key. Consider using Global Secondary Index instead. Error: ${err.message}`);
+                break;
+            default:
+                break;
+            // Common DynamoDB API errors are handled below
+        }
+        this.handleCommonErrors(err);
+    }
+    /**
+     *
+     * @param err
+     */
+    handleCommonErrors(err) {
+        switch (err.code) {
+            case "InternalServerError":
+                console.error(`Internal Server Error, generally safe to retry with exponential back-off. Error: ${err.message}`);
+                break;
+            case "ProvisionedThroughputExceededException":
+                console.error("Request rate is too high. If you're using a custom retry strategy make sure to retry with exponential back-off."
+                    + `Otherwise consider reducing frequency of requests or increasing provisioned capacity for your table or secondary index. Error: ${err.message}`);
+                break;
+            case "ResourceNotFoundException":
+                console.error(`One of the tables was not found, verify table exists before retrying. Error: ${err.message}`);
+                break;
+            case "ServiceUnavailable":
+                console.error(`Had trouble reaching DynamoDB. generally safe to retry with exponential back-off. Error: ${err.message}`);
+                break;
+            case "ThrottlingException":
+                console.error(`Request denied due to throttling, generally safe to retry with exponential back-off. Error: ${err.message}`);
+                break;
+            case "UnrecognizedClientException":
+                console.error("The request signature is incorrect most likely due to an invalid AWS access key ID or secret key, fix before retrying."
+                    + `Error: ${err.message}`);
+                break;
+            case "ValidationException":
+                console.error("The input fails to satisfy the constraints specified by DynamoDB, "
+                    + `fix input before retrying. Error: ${err.message}`);
+                break;
+            case "RequestLimitExceeded":
+                console.error("Throughput exceeds the current throughput limit for your account, "
+                    + `increase account level throughput before retrying. Error: ${err.message}`);
+                break;
+            default:
+                console.error(`An exception occurred, investigate and configure retry strategy. Error: ${err.message}`);
+                break;
+        }
+        // throw new DatabaseException( err.code );
+    }
+    /**
+     *
+     * @param str
+     * @returns
+     */
+    isComparator(str) {
+        return ['=', '<>', '<', '<=', '>', '>='].includes(str);
+    }
+    /**
+     *
+     * @param item
+     * @param index
+     * @returns
+     */
+    getArrayValue(item, index) {
+        return item.reduce((acc, key, idx) => {
+            acc[`:value${index}${idx}`] = key;
+            return acc;
+        }, {});
+    }
+    /**
+     *
+     * @param item
+     * @param condition
+     * @param indexName
+     * @returns
+     */
+    getKeyAndFilter(item, condition, indexName) {
+        try {
+            const itemKeys = Object.keys(item);
+            let Key, Filter;
+            if (!indexName) {
+                Key = `${itemKeys.map((k, index) => {
+                    if (this.PRIMARY_KEY.length === 0 || this.PRIMARY_KEY.includes(k))
+                        if (!this.isComparator(condition[index] || '=')) {
+                            if (condition[index].toUpperCase() == 'BETWEEN')
+                                return `#field${index} ${condition[index]} ${Object.keys(this.getArrayValue(item[k], index)).join(' and ')}`;
+                            else if (condition[index].toUpperCase() == 'IN')
+                                return `#field${index} ${condition[index]}(${Object.keys(this.getArrayValue(item[k], index)).toString()})`;
+                            else
+                                return `${condition[index]}(#field${index} ,:value${index})`;
+                        }
+                        else
+                            return `#field${index} ${condition[index] || '='} :value${index}`;
+                }).filter(a => a).join(' and ')}`;
+                Filter = `${itemKeys.map((k, index) => {
+                    if (!this.PRIMARY_KEY.includes(k))
+                        if (!this.isComparator(condition[index] || '=')) {
+                            if (condition[index].toUpperCase() == 'BETWEEN')
+                                return `#field${index} ${condition[index]} ${Object.keys(this.getArrayValue(item[k], index)).join(' and ')}`;
+                            else if (condition[index].toUpperCase() == 'IN')
+                                return `#field${index} ${condition[index]}(${Object.keys(this.getArrayValue(item[k], index)).toString()})`;
+                            else
+                                return `${condition[index]}(#field${index} ,:value${index})`;
+                        }
+                        else
+                            return `#field${index} ${condition[index] || '='} :value${index}`;
+                }).filter(a => a).join(' and ')}`;
+            }
+            else {
+                Key = `${itemKeys.map((k, index) => {
+                    if (indexName.split('-').includes(k)) {
+                        if (!this.isComparator(condition[index] || '=')) {
+                            if (condition[index].toUpperCase() == 'BETWEEN')
+                                return `#field${index} ${condition[index]} ${Object.keys(this.getArrayValue(item[k], index)).join(' and ')}`;
+                            else if (condition[index].toUpperCase() == 'IN')
+                                return `#field${index} ${condition[index]}(${Object.keys(this.getArrayValue(item[k], index)).toString()})`;
+                            else
+                                return `${condition[index]}(#field${index} ,:value${index})`;
+                        }
+                        else
+                            return `#field${index} ${condition[index] || '='} :value${index}`;
+                    }
+                }).filter(a => a).join(' and ')}`;
+                Filter = `${itemKeys.map((k, index) => {
+                    if (!indexName.split('-').includes(k)) {
+                        if (!this.isComparator(condition[index] || '=')) {
+                            if (condition[index].toUpperCase() == 'BETWEEN')
+                                return `#field${index} ${condition[index]} ${Object.keys(this.getArrayValue(item[k], index)).join(' and ')}`;
+                            else if (condition[index].toUpperCase() == 'IN')
+                                return `#field${index} ${condition[index]}(${Object.keys(this.getArrayValue(item[k], index)).toString()})`;
+                            else
+                                return `${condition[index]}(#field${index} ,:value${index})`;
+                        }
+                        else
+                            return `#field${index} ${condition[index] || '='} :value${index}`;
+                    }
+                }).filter(a => a).join(' and ')}`;
+            }
+            return [Key, Filter];
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.default = BaseDynamoDBRepository;
+//# sourceMappingURL=dynamodb.js.map