chatbot-nc 2.0.80 → 2.0.83

package/dist/esm/repository/dynamodb.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; // ES Modules import
 import { DynamoDBDocumentClient, ScanCommand, QueryCommand, PutCommand, UpdateCommand, DeleteCommand, GetCommand, BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
 const awsRegion = process.env.AWS_DEFAULT_REGION || 'us-east-1';
@@ -27,53 +18,49 @@ export default class BaseDynamoDBRepository {
      * Add item in DynamoDB table
      * @param {object} item // Object containing add for target item
      */
-    add(item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = yield this.documentClient.send(new PutCommand(params));
-                console.log('dbItem');
-                return response;
-            }
-            catch (error) {
-                this.handleError(error);
-                // // throw new DatabaseException( error.code );
-            }
-        });
+    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 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
      */
-    update(key, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 yield this.documentClient.send(new UpdateCommand(params));
-            }
-            catch (error) {
-                this.handleError(error);
-            }
-        });
+    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 UpdateCommand(params));
+        }
+        catch (error) {
+            this.handleError(error);
+        }
     }
     /**
      * Update item in DynamoDB table
@@ -81,29 +68,27 @@ export default class BaseDynamoDBRepository {
      * @param {object} item // Object containing updates for target item
      * @returns
     */
-    updateByMutiple(keys, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 yield this.documentClient.send(new UpdateCommand(params));
-            }
-            catch (error) {
-                this.handleError(error);
-            }
-        });
+    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 UpdateCommand(params));
+        }
+        catch (error) {
+            this.handleError(error);
+        }
     }
     /**
      *
@@ -143,29 +128,27 @@ export default class BaseDynamoDBRepository {
      * @param {object} id // Object containing target item key(s)
      * @param {object} version // Object containing updates for target item
      */
-    getById(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 GetCommand(params);
-                const response = yield 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 );
+    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 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
@@ -183,202 +166,198 @@ export default class BaseDynamoDBRepository {
      * Get items in DynamoDB table
      * @param {object} item // Object containing target item key(s)
      */
-    query(item, condition, indexName, projectionExpression, limit, scanIndexForward = true, exclusiveStartKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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] = yield 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);
-                        }
+    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 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
-                            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 = yield this.documentClient.send(new 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)];
-                        }
+                            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);
-            }
-        });
+                }
+                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)
      */
-    queryWithPagination(item, condition, indexName, projectionExpression, limit = 1000, scanIndexForward = true, exclusiveStartKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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] = yield 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 });
+    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 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 = Object.assign(params, { Limit: limit });
-                let response, acc = { exclusiveStartKey: "", data: [] };
-                do {
-                    response = yield this.documentClient.send(new 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;
+                    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;
             }
-            catch (error) {
-                this.handleError(error);
-            }
-        });
+            else
+                return null;
+        }
+        catch (error) {
+            this.handleError(error);
+        }
     }
     /**
      * Get items in DynamoDB table
@@ -386,137 +365,129 @@ export default class BaseDynamoDBRepository {
      * @param {Array} condition // Array containing target item key(s) condition
      * @param {String} projectionExpression // if you want only selected filed should return
      */
-    scan(item, condition, projectionExpression, exclusiveStartKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = yield this.documentClient.send(new 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);
-            }
-        });
+    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 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)
      */
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.info("Dynamo db Repository: delete Start");
-            var params = {
-                TableName: this.TABLE_NAME,
-                Key: key
-            };
-            try {
-                const command = new DeleteCommand(params);
-                const data = yield 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 );
-            }
-        });
+    async delete(key) {
+        console.info("Dynamo db Repository: delete Start");
+        var params = {
+            TableName: this.TABLE_NAME,
+            Key: key
+        };
+        try {
+            const command = new 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
      */
-    getAll(exclusiveStartKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 = yield this.documentClient.send(new 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 );
-            }
-        });
+    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 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
      */
-    bulkUpload(items) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let insertItem = yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
-                    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 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 = yield this.documentClient.send(command);
-                    console.log('dbItem');
-                }
-                console.log("Upload Successfully");
-                return true;
-            }
-            catch (error) {
-                this.handleError(error);
-                // // throw new DatabaseException( error.code );
+    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 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 );
+        }
     }
     /**
      *