@blnlpa/asf-tools/tools.db.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const AWS = require("aws-sdk");
const tools_1 = require("./tools");
AWS.config.update({ region: 'us-east-1' });
const kms = new AWS.KMS({ apiVersion: '2014-11-01' });
function encrypt(data, kmsKeyId) {
    return new Promise((res, rej) => {
        try {
            if (!data || data === '') {
                return res(null);
            }
            kms.encrypt({ KeyId: kmsKeyId, Plaintext: data }, function (err, _data) {
                if (err) {
                    rej(err);
                }
                else {
                    res(_data);
                }
            });
        }
        catch (error) {
            rej(error.message);
        }
    });
}
function decrypt(blob, kmsKeyId) {
    return new Promise((res, rej) => {
        try {
            if ((blob && !blob.CiphertextBlob) || !blob) {
                return res(blob);
            }
            kms.decrypt({ CiphertextBlob: blob.CiphertextBlob }, function (err, _data) {
                if (err) {
                    console.log(err);
                    rej(err);
                }
                else {
                    res(_data);
                }
            });
        }
        catch (error) {
            console.log(143, error.message);
            rej(error.message);
        }
    });
}
class DynamoDbApi {
    constructor(dynamoDb, _kmsKeyId) {
        this.dynamoDb = dynamoDb;
        this.kmsKeyId = _kmsKeyId;
        process.setMaxListeners(Infinity);
    }
    decryptItem(item, decryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const Keys = Object.keys(item);
                for (let i = 0; i < Keys.length; i++) {
                    if (item[Keys[i]] && item[Keys[i]]['CiphertextBlob'] && decryptFields.indexOf(Keys[i]) > -1) {
                        const decryptedTmp = yield decrypt(item[Keys[i]], this.kmsKeyId);
                        if (decryptedTmp && decryptedTmp.Plaintext) {
                            const val = decryptedTmp.Plaintext.toString();
                            item[Keys[i]] = val.indexOf('{') > -1 ? JSON.parse(val) : val;
                        }
                    }
                }
            }
            catch (error) {
                console.log('decryptItem():', error);
            }
            return item;
        });
    }
    encryptItem(item, encryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const Keys = Object.keys(item);
                for (let i = 0; i < Keys.length; i++) {
                    if (item[Keys[i]] && encryptFields.indexOf(Keys[i]) > -1) {
                        const encryptedTmp = yield encrypt(typeof item[Keys[i]] === 'object' ? JSON.stringify(item[Keys[i]]) : item[Keys[i]], this.kmsKeyId);
                        if (encryptedTmp) {
                            item[Keys[i]] = encryptedTmp;
                        }
                    }
                }
            }
            catch (error) {
                console.log('tools.encryptItem() error:', error.message);
            }
            finally {
                return item;
            }
        });
    }
    get(params, context, decryptFields) {
        const dynamoDb = this.dynamoDb;
        return new Promise((res, rej) => {
            if (!dynamoDb) {
                return rej(tools_1.response(false, 'dynamoDbTable undefined'));
            }
            try {
                dynamoDb.get(params, (error, result) => __awaiter(this, void 0, void 0, function* () {
                    if (error) {
                        return rej(tools_1.response(false, error, `Could not get '${context}' info`));
                    }
                    else if (result.Item) {
                        if (decryptFields && decryptFields.length) {
                            result.Item = yield this.decryptItem(result.Item, decryptFields);
                        }
                        return res(tools_1.response(true, null, result.Item));
                    }
                    else {
                        return res(tools_1.response(false, `'${context}' info not found`));
                    }
                }));
            }
            catch (error) {
                console.log(479, error.message);
                rej(tools_1.response(false, error));
            }
        });
    }
    _scan(dynamoDb, params, context, decryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!dynamoDb) {
                return tools_1.response(false, 'dynamoDbTable undefined');
            }
            try {
                let count = 0;
                const result = yield dynamoDb.scan(params).promise();
                if (result.Items && result.Items.length) {
                    if (decryptFields && decryptFields.length) {
                        for (let i = 0; i < result.Items.length; i++) {
                            result.Items[i] = yield this.decryptItem(result.Items[i], decryptFields);
                        }
                    }
                    return tools_1.response(true, null, result);
                }
                else {
                    return tools_1.response(false, `${context} info not found`, result);
                }
            }
            catch (error) {
                console.log('263 Error tools.db._scan()', error.message, params);
                return tools_1.response(false, error);
            }
        });
    }
    scan(params, context, decryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            const dynamoDb = this.dynamoDb;
            try {
                let items = [], result, whileMax = 1000, i = 0, count = 0, done = false, LastEvaluatedKey = null;
                while (!done && (i < whileMax)) {
                    result = yield this._scan(dynamoDb, params, context, decryptFields);
                    if (!result.success && !params.Limit) {
                        done = true;
                        return result;
                    }
                    else {
                        if (params.Limit) {
                            if (result.data) {
                                count += result.data.Count;
                                if (!result.data.LastEvaluatedKey) {
                                    done = true;
                                    items.push(...result.data.Items);
                                }
                                else {
                                    if (count === params.Limit) {
                                        done = true;
                                        items.push(...result.data.Items);
                                        LastEvaluatedKey = result.data.LastEvaluatedKey;
                                    }
                                    else if (count > params.Limit) {
                                        done = true;
                                        const keys = Object.keys(result.data.LastEvaluatedKey);
                                        items.push(...result.data.Items.slice(0, (count - params.Limit)));
                                        for (let j = 0; j < keys.length; j++) {
                                            LastEvaluatedKey[keys[j]] = result.data.Items[count - params.Limit - 1][keys[j]];
                                        }
                                    }
                                    else {
                                        LastEvaluatedKey = result.data.LastEvaluatedKey;
                                        params['ExclusiveStartKey'] = LastEvaluatedKey;
                                        items.push(...result.data.Items);
                                    }
                                }
                            }
                            else {
                                LastEvaluatedKey = result.data.LastEvaluatedKey;
                                params['ExclusiveStartKey'] = LastEvaluatedKey;
                            }
                        }
                        else {
                            done = true;
                            LastEvaluatedKey = result.data.LastEvaluatedKey;
                            items.push(...result.data.Items);
                        }
                    }
                    i++;
                }
                return tools_1.response(true, null, {
                    Items: items,
                    Count: items.length,
                    CountV2: result.data.ScannedCount,
                    LastEvaluatedKey: LastEvaluatedKey,
                    Loops: i
                });
            }
            catch (error) {
                return tools_1.response(false, error);
            }
        });
    }
    query(params, context, decryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            const dynamoDb = this.dynamoDb;
            if (!dynamoDb) {
                return tools_1.response(false, 'dynamoDbTable undefined');
            }
            try {
                const result = yield dynamoDb.query(params).promise();
                if (result.Items && result.Items.length) {
                    if (decryptFields && decryptFields.length) {
                        for (let i = 0; i < result.Items.length; i++) {
                            result.Items[i] = yield this.decryptItem(result.Items[i], decryptFields);
                        }
                    }
                    return tools_1.response(true, null, result.Items.length > 1 ? result.Items : result.Items[0]);
                }
                else {
                    return tools_1.response(false, `'${context}' info not found`);
                }
            }
            catch (error) {
                console.log('263 Error tools.db.query()', error.message, params);
                return tools_1.response(false, error.message, `Could not get '${context}' info`);
            }
        });
    }
    queryRAW(params, context, decryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            const dynamoDb = this.dynamoDb;
            if (!dynamoDb) {
                return tools_1.response(false, 'dynamoDbTable undefined');
            }
            try {
                let result = yield dynamoDb.query(params).promise();
                if (!result) {
                    return tools_1.response(false, `'${context}' - Error on  dynamoDb.query(params).promise().`);
                }
                let promises = [];
                if (result.Items && result.Items.length) {
                    if (decryptFields && decryptFields.length) {
                        for (let i = 0; i < result.Items.length; i++) {
                            promises.push(this.decryptItem(result.Items[i], decryptFields));
                        }
                        result = yield Promise.all(promises).then(results => {
                            delete result.Items;
                            result['Items'] = results;
                            return result;
                        });
                    }
                    return tools_1.response(true, null, result);
                }
                else {
                    return tools_1.response(false, `'${context}' info not found`, result);
                }
            }
            catch (error) {
                console.log('263 Error tools.db.query()', error.message, params);
                return tools_1.response(false, error.message, `Could not get '${context}' info`);
            }
        });
    }
    delete(params, context, decryptFields) {
        const dynamoDb = this.dynamoDb;
        return new Promise((res, rej) => {
            if (!dynamoDb) {
                return rej(tools_1.response(false, 'dynamoDbTable undefined'));
            }
            try {
                if (params.force) {
                    dynamoDb.delete(params, (error, result) => __awaiter(this, void 0, void 0, function* () {
                        if (error) {
                            return rej(tools_1.response(false, error, `Could not delete '${context}' info`));
                        }
                        return res(tools_1.response(true, null, result));
                    }));
                }
                else {
                    if (!params.Key) {
                        return tools_1.response(false, 'Key is required. Cannot delete item');
                    }
                    const _params = {
                        TableName: params.TableName,
                        Key: params.Key,
                        UpdateExpression: "set deleted =:d",
                        ExpressionAttributeValues: {
                            ":d": true
                        }
                    };
                    dynamoDb.update(_params, (error, result) => {
                        if (error) {
                            console.log(params, error);
                            return rej(tools_1.response(false, error, `Could not update '${context}' item to 'deleted' state`));
                        }
                        else {
                            return res(tools_1.response(true, null, result));
                        }
                    });
                }
            }
            catch (error) {
                console.log(479, error.message);
                rej(tools_1.response(false, error));
            }
        });
    }
    put(params, context, encryptFields) {
        return new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
            const dynamoDb = this.dynamoDb;
            try {
                if (!dynamoDb) {
                    return rej(tools_1.response(false, 'dynamoDbTable undefined'));
                }
                if (encryptFields && encryptFields.length) {
                    params.Item = yield this.encryptItem(params.Item, encryptFields);
                }
                params.Item.updatedAt = new Date().toISOString();
                params.Item.createdAt = new Date().toISOString();
                dynamoDb.put(params, (error, result) => {
                    if (error) {
                        console.log(params, error);
                        return rej(tools_1.response(false, error, `Could not insert '${context}' item`));
                    }
                    else {
                        return res(tools_1.response(true, null, result));
                    }
                });
            }
            catch (error) {
                console.log('295 tools.db.put()', error);
                rej(tools_1.response(false, error.message));
            }
        }));
    }
    getUpdateExpression(item, encryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            let expressions = {}, updates = '';
            if (encryptFields) {
                item = yield this.encryptItem(item, encryptFields);
            }
            const Keys = Object.keys(item);
            for (let i = 0; i < Keys.length; i++) {
                expressions[`:v${i}`] = item[Keys[i]];
                updates += `${Keys[i]} =:v${i},`;
            }
            updates = updates.replace(/(^,)|(,$)/g, "");
            return {
                expressions: expressions,
                updates: updates
            };
        });
    }
    getUpdateExpressionV2(item, encryptFields) {
        return __awaiter(this, void 0, void 0, function* () {
            let attributesValue = {}, attributesName = {}, updates = '';
            if (encryptFields) {
                item = yield this.encryptItem(item, encryptFields);
            }
            const Keys = Object.keys(item);
            for (let i = 0; i < Keys.length; i++) {
                attributesValue[`:v${i}`] = item[Keys[i]];
                attributesName[`#a${i}`] = Keys[i];
                updates += `#a${i} =:v${i},`;
            }
            updates = updates.replace(/(^,)|(,$)/g, "");
            return {
                attributesValue: attributesValue,
                updates: updates,
                attributesName: attributesName
            };
        });
    }
    update(params, context, encryptFields) {
        const dynamoDb = this.dynamoDb;
        return new Promise((res, rej) => {
            if (!dynamoDb) {
                return rej(tools_1.response(false, 'dynamoDbTable undefined'));
            }
            try {
                params.ExpressionAttributeValues[':upd'] = new Date().toISOString();
                params.UpdateExpression += ', updatedAt =:upd';
                dynamoDb.update(params, (error, result) => {
                    if (error) {
                        console.log(params, error);
                        return rej(tools_1.response(false, error));
                    }
                    else {
                        return res(tools_1.response(true, null, result));
                    }
                });
            }
            catch (error) {
                console.log(error);
                rej(tools_1.response(false, error));
            }
        });
    }
}
exports.DynamoDbApi = DynamoDbApi;
//# sourceMappingURL=tools.db.js.map