drapcode-utility 2.0.1 → 2.0.3

package/build/encryption/index.js

@@ -1,222 +1,96 @@
 "use strict";
-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());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processKMSDecryption = exports.cryptFile = exports.drapcodeEncryptDecrypt = exports.decryptDataWithKMS = exports.encryptDataWithKMS = exports.createKMSDataKey = exports.processDataEncryptionDecryption = exports.processItemEncryptDecrypt = exports.crypt = void 0;
-var client_kms_1 = require("@aws-sdk/client-kms");
-var crypt_1 = require("./crypt");
-var file_1 = require("./file");
-var KMS_1 = require("./KMS");
-var drapcode_constant_1 = require("drapcode-constant");
-var crypt = function (data, fields, encryption, decrypt, encryptedRefCollections) {
-    if (encryptedRefCollections === void 0) { encryptedRefCollections = []; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var _a, accessKeyId, secretAccessKey, region, config, plainTextData, promises;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!(encryption.encryptionType === "KMS")) return [3 /*break*/, 2];
-                    _a = encryption.awsConfig, accessKeyId = _a.accessKeyId, secretAccessKey = _a.secretAccessKey, region = _a.region;
-                    config = {
-                        region: region,
-                        accessKeyId: accessKeyId,
-                        secretAccessKey: secretAccessKey,
-                    };
-                    return [4 /*yield*/, (0, exports.processKMSDecryption)(config, encryption.dataKey, {})];
-                case 1:
-                    plainTextData = _b.sent();
-                    if (plainTextData.status === "FAILED") {
-                        return [2 /*return*/, plainTextData];
-                    }
-                    encryption.dataKey = plainTextData.data;
-                    _b.label = 2;
-                case 2:
-                    if (!Array.isArray(data)) return [3 /*break*/, 4];
-                    promises = data.map(function (item) {
-                        return (0, exports.processItemEncryptDecrypt)(item, fields, encryption, decrypt, encryptedRefCollections);
-                    });
-                    return [4 /*yield*/, Promise.all(promises)];
-                case 3:
-                    data = _b.sent();
-                    return [3 /*break*/, 6];
-                case 4: return [4 /*yield*/, (0, exports.processItemEncryptDecrypt)(data, fields, encryption, decrypt, encryptedRefCollections)];
-                case 5:
-                    data = _b.sent();
-                    _b.label = 6;
-                case 6: return [2 /*return*/, data];
-            }
-        });
-    });
+const client_kms_1 = require("@aws-sdk/client-kms");
+const drapcode_constant_1 = require("drapcode-constant");
+const crypt_1 = require("./crypt");
+const file_1 = require("./file");
+const KMS_1 = require("./KMS");
+const crypt = async (data, fields, encryption, decrypt, encryptedRefCollections = []) => {
+    if (encryption.encryptionType === "KMS") {
+        const { accessKeyId, secretAccessKey, region } = encryption.awsConfig;
+        const config = {
+            region,
+            accessKeyId,
+            secretAccessKey,
+        };
+        const plainTextData = await (0, exports.processKMSDecryption)(config, encryption.dataKey, {});
+        if (plainTextData.status === "FAILED") {
+            return plainTextData;
+        }
+        encryption.dataKey = plainTextData.data;
+    }
+    if (Array.isArray(data)) {
+        const promises = data.map((item) => (0, exports.processItemEncryptDecrypt)(item, fields, encryption, decrypt, encryptedRefCollections));
+        data = await Promise.all(promises);
+    }
+    else {
+        data = await (0, exports.processItemEncryptDecrypt)(data, fields, encryption, decrypt, encryptedRefCollections);
+    }
+    return data;
 };
 exports.crypt = crypt;
-var processItemEncryptDecrypt = function (item, fields, encryption, decrypt, encryptedRefCollections) {
-    if (encryptedRefCollections === void 0) { encryptedRefCollections = []; }
-    return __awaiter(void 0, void 0, void 0, function () {
-        var _loop_1, _i, _a, fieldName;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!item && typeof item !== "object") {
-                        return [2 /*return*/, item];
-                    }
-                    _loop_1 = function (fieldName) {
-                        var field, promises, _c, _d, _e, _f, refField, _g, _h;
-                        return __generator(this, function (_j) {
-                            switch (_j.label) {
-                                case 0:
-                                    field = fields.find(function (field) { return field.fieldName === fieldName; });
-                                    if (!(field && field.encrypted)) return [3 /*break*/, 4];
-                                    if (!(Array.isArray(item[fieldName]) &&
-                                        drapcode_constant_1.OptionTypeFields.includes(field.type))) return [3 /*break*/, 2];
-                                    promises = item[fieldName].map(function (value) {
-                                        return (item[fieldName] = (0, exports.processDataEncryptionDecryption)(value, encryption, decrypt));
-                                    });
-                                    _c = item;
-                                    _d = fieldName;
-                                    return [4 /*yield*/, Promise.all(promises)];
-                                case 1:
-                                    _c[_d] = _j.sent();
-                                    return [3 /*break*/, 4];
-                                case 2:
-                                    _e = item;
-                                    _f = fieldName;
-                                    return [4 /*yield*/, (0, exports.processDataEncryptionDecryption)(item[fieldName], encryption, decrypt)];
-                                case 3:
-                                    _e[_f] = _j.sent();
-                                    _j.label = 4;
-                                case 4:
-                                    if (!decrypt) return [3 /*break*/, 6];
-                                    if (!(decrypt && drapcode_constant_1.BelongsCreatedByRefField.includes(field === null || field === void 0 ? void 0 : field.type))) return [3 /*break*/, 6];
-                                    refField = field;
-                                    if (!refField.refCollection &&
-                                        [drapcode_constant_1.FieldTypes.createdBy.id, drapcode_constant_1.FieldTypes.updatedBy.id].includes(field.type)) {
-                                        refField.refCollection = {
-                                            collectionField: "userName",
-                                            collectionName: "user",
-                                        };
-                                    }
-                                    _g = item;
-                                    _h = fieldName;
-                                    return [4 /*yield*/, processReferenceItemDecrypt(item[fieldName], encryption, decrypt, refField, encryptedRefCollections)];
-                                case 5:
-                                    _g[_h] = _j.sent();
-                                    _j.label = 6;
-                                case 6: return [2 /*return*/];
-                            }
-                        });
-                    };
-                    _i = 0, _a = Object.keys(item);
-                    _b.label = 1;
-                case 1:
-                    if (!(_i < _a.length)) return [3 /*break*/, 4];
-                    fieldName = _a[_i];
-                    return [5 /*yield**/, _loop_1(fieldName)];
-                case 2:
-                    _b.sent();
-                    _b.label = 3;
-                case 3:
-                    _i++;
-                    return [3 /*break*/, 1];
-                case 4: return [2 /*return*/, item];
+const processItemEncryptDecrypt = async (item, fields, encryption, decrypt, encryptedRefCollections = []) => {
+    if (!item && typeof item !== "object") {
+        return item;
+    }
+    //TODO: Need to refactor
+    // Instead of iterating over item, iterate over encrypted field
+    for (const fieldName of Object.keys(item)) {
+        const field = fields.find((field) => field.fieldName === fieldName);
+        if (field && field.encrypted) {
+            if (Array.isArray(item[fieldName]) &&
+                drapcode_constant_1.OptionTypeFields.includes(field.type)) {
+                const promises = item[fieldName].map((value) => (item[fieldName] = (0, exports.processDataEncryptionDecryption)(value, encryption, decrypt)));
+                item[fieldName] = await Promise.all(promises);
             }
-        });
-    });
+            else {
+                item[fieldName] = await (0, exports.processDataEncryptionDecryption)(item[fieldName], encryption, decrypt);
+            }
+        }
+        if (decrypt && drapcode_constant_1.BelongsCreatedByRefField.includes(field?.type)) {
+            let refField = field;
+            if (!refField.refCollection && drapcode_constant_1.byFields.has(field.type)) {
+                refField.refCollection = {
+                    collectionField: "userName",
+                    collectionName: "user",
+                };
+            }
+            item[fieldName] = await processReferenceItemDecrypt(item[fieldName], encryption, decrypt, refField, encryptedRefCollections);
+        }
+    }
+    return item;
 };
 exports.processItemEncryptDecrypt = processItemEncryptDecrypt;
-var processDataEncryptionDecryption = function (data, encryption, decrypt) { return __awaiter(void 0, void 0, void 0, function () {
-    var encryptionType, dataKey, _a, result, _b;
-    return __generator(this, function (_c) {
-        switch (_c.label) {
-            case 0:
-                encryptionType = encryption.encryptionType, dataKey = encryption.dataKey;
-                if (!data)
-                    return [2 /*return*/, data];
-                console.log("data :>> ", data);
-                _a = encryptionType;
-                switch (_a) {
-                    case "KMS": return [3 /*break*/, 1];
-                }
-                return [3 /*break*/, 6];
-            case 1:
-                if (!decrypt) return [3 /*break*/, 3];
-                return [4 /*yield*/, (0, crypt_1.decryptData)(data, dataKey)];
-            case 2:
-                _b = _c.sent();
-                return [3 /*break*/, 5];
-            case 3: return [4 /*yield*/, (0, crypt_1.encryptData)(data, dataKey)];
-            case 4:
-                _b = _c.sent();
-                _c.label = 5;
-            case 5:
-                result = _b;
-                return [2 /*return*/, result];
-            case 6: return [2 /*return*/, data];
-        }
-    });
-}); };
+const processDataEncryptionDecryption = async (data, encryption, decrypt) => {
+    const { encryptionType, dataKey } = encryption;
+    if (!data)
+        return data;
+    switch (encryptionType) {
+        case "KMS":
+            return decrypt ? (0, crypt_1.decryptData)(data, dataKey) : (0, crypt_1.encryptData)(data, dataKey);
+        default:
+            return data;
+    }
+};
 exports.processDataEncryptionDecryption = processDataEncryptionDecryption;
-var processReferenceItemDecrypt = function (data, encryption, decrypt, refField, encryptedRefCollections) { return __awaiter(void 0, void 0, void 0, function () {
-    var refCollection, promises;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                refCollection = getEncryptedReferenceCollection(encryptedRefCollections, refField).refCollection;
-                if (!refCollection) return [3 /*break*/, 2];
-                if (!Array.isArray(data)) return [3 /*break*/, 2];
-                promises = data.map(function (item) {
-                    return (0, exports.processItemEncryptDecrypt)(item, refCollection.fields, encryption, decrypt);
-                });
-                return [4 /*yield*/, Promise.all(promises)];
-            case 1:
-                data = _a.sent();
-                _a.label = 2;
-            case 2: return [2 /*return*/, data];
-        }
-    });
-}); };
-var getEncryptedReferenceCollection = function (encryptedRefCollections, refField) {
-    var _a = refField === null || refField === void 0 ? void 0 : refField.refCollection, refCollectionName = _a.collectionName, refCollectionFieldName = _a.collectionField;
-    var refCollection;
+const processReferenceItemDecrypt = async (data, encryption, decrypt, refField, encryptedRefCollections) => {
+    const { refCollection } = getEncryptedReferenceCollection(encryptedRefCollections, refField);
+    if (refCollection && Array.isArray(data)) {
+        const promises = data.map((item) => (0, exports.processItemEncryptDecrypt)(item, refCollection.fields, encryption, decrypt));
+        data = await Promise.all(promises);
+    }
+    return data;
+};
+const getEncryptedReferenceCollection = (encryptedRefCollections, refField) => {
+    const { collectionName: refCollectionName, collectionField: refCollectionFieldName, } = refField?.refCollection;
+    let refCollection;
     if (encryptedRefCollections.length) {
         if (refCollectionName) {
-            refCollection = encryptedRefCollections.find(function (encColl) { return encColl.collectionName === refCollectionName; });
+            refCollection = encryptedRefCollections.find((encColl) => encColl.collectionName === refCollectionName);
         }
     }
-    return { refCollectionName: refCollectionName, refCollectionFieldName: refCollectionFieldName, refCollection: refCollection };
+    return { refCollectionName, refCollectionFieldName, refCollection };
 };
 /**
  * This method is used to generate private KEY for KMS ARN
@@ -225,17 +99,10 @@ var getEncryptedReferenceCollection = function (encryptedRefCollections, refFiel
  * @param arn KMS Key
  * @returns {status: string, dataKey: string, message: ""}
  */
-var createKMSDataKey = function (config, arn) { return __awaiter(void 0, void 0, void 0, function () {
-    var dataKeyRes;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, KMS_1.processKMSGenerateDataKey)(config, arn)];
-            case 1:
-                dataKeyRes = _a.sent();
-                return [2 /*return*/, dataKeyRes];
-        }
-    });
-}); };
+const createKMSDataKey = async (config, arn) => {
+    const dataKeyRes = await (0, KMS_1.processKMSGenerateDataKey)(config, arn);
+    return dataKeyRes;
+};
 exports.createKMSDataKey = createKMSDataKey;
 /**
  * This method is used to encrypt plaintext upto 4KB
@@ -246,17 +113,10 @@ exports.createKMSDataKey = createKMSDataKey;
  * @param context Extra setting for extra security
  * @returns {status: string, message: string, cipherText: string}
  */
-var encryptDataWithKMS = function (config, arn, plainText, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var cryptData;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, KMS_1.processKMSEncryption)(config, arn, plainText, context)];
-            case 1:
-                cryptData = _a.sent();
-                return [2 /*return*/, cryptData];
-        }
-    });
-}); };
+const encryptDataWithKMS = async (config, arn, plainText, context) => {
+    const cryptData = await (0, KMS_1.processKMSEncryption)(config, arn, plainText, context);
+    return cryptData;
+};
 exports.encryptDataWithKMS = encryptDataWithKMS;
 /**
  * This method is used to decrypt secure text
@@ -266,113 +126,81 @@ exports.encryptDataWithKMS = encryptDataWithKMS;
  * @param context Extra setting which given for extra security
  * @returns {status: string, message: string, plainText: string}
  */
-var decryptDataWithKMS = function (config, cipherText, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var plainTextData;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, exports.processKMSDecryption)(config, cipherText, context)];
-            case 1:
-                plainTextData = _a.sent();
-                return [2 /*return*/, plainTextData];
-        }
-    });
-}); };
+const decryptDataWithKMS = async (config, cipherText, context) => {
+    const plainTextData = await (0, exports.processKMSDecryption)(config, cipherText, context);
+    return plainTextData;
+};
 exports.decryptDataWithKMS = decryptDataWithKMS;
-var drapcodeEncryptDecrypt = function (data, encrypt) { return __awaiter(void 0, void 0, void 0, function () {
-    var region, accessKey, secretKey, privateDataKey, config, plainTextData, publicKey, response;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                region = process.env.AWS_KMS_REGION;
-                accessKey = process.env.AWS_KMS_ACCESS_KEY;
-                secretKey = process.env.AWS_KMS_SECRET_KEY;
-                privateDataKey = process.env.AWS_KMS_PRIVATE_DATA_KEY;
-                if (!region)
-                    return [2 /*return*/, { status: "FAILED", message: "AWS Region is missing", data: "" }];
-                if (!accessKey)
-                    return [2 /*return*/, { status: "FAILED", message: "AWS Access Key is missing", data: "" }];
-                if (!secretKey)
-                    return [2 /*return*/, {
-                            status: "FAILED",
-                            message: "AWS Access Secret Key is missing",
-                            data: "",
-                        }];
-                if (!privateDataKey)
-                    return [2 /*return*/, {
-                            status: "FAILED",
-                            message: "KMS Private Key is missing",
-                            data: "",
-                        }];
-                console.log("privateDataKey", privateDataKey);
-                config = {
-                    region: region,
-                    accessKeyId: accessKey,
-                    secretAccessKey: secretKey,
-                };
-                return [4 /*yield*/, (0, exports.processKMSDecryption)(config, privateDataKey, {})];
-            case 1:
-                plainTextData = _a.sent();
-                if (plainTextData.status === "FAILED") {
-                    return [2 /*return*/, plainTextData];
-                }
-                publicKey = plainTextData.data;
-                response = null;
-                if (!encrypt) return [3 /*break*/, 3];
-                console.log("Encrypting");
-                return [4 /*yield*/, (0, crypt_1.encryptData)(data, publicKey)];
-            case 2:
-                response = _a.sent();
-                return [3 /*break*/, 5];
-            case 3:
-                console.log("Decrypting");
-                return [4 /*yield*/, (0, crypt_1.decryptData)(data, publicKey)];
-            case 4:
-                response = _a.sent();
-                _a.label = 5;
-            case 5: return [2 /*return*/, { status: "SUCCESS", message: "", data: response }];
-        }
-    });
-}); };
+const drapcodeEncryptDecrypt = async (data, encrypt) => {
+    const region = process.env.AWS_KMS_REGION;
+    const accessKey = process.env.AWS_KMS_ACCESS_KEY;
+    const secretKey = process.env.AWS_KMS_SECRET_KEY;
+    const privateDataKey = process.env.AWS_KMS_PRIVATE_DATA_KEY;
+    if (!region)
+        return { status: "FAILED", message: "AWS Region is missing", data: "" };
+    if (!accessKey)
+        return { status: "FAILED", message: "AWS Access Key is missing", data: "" };
+    if (!secretKey)
+        return {
+            status: "FAILED",
+            message: "AWS Access Secret Key is missing",
+            data: "",
+        };
+    if (!privateDataKey)
+        return {
+            status: "FAILED",
+            message: "KMS Private Key is missing",
+            data: "",
+        };
+    const config = {
+        region,
+        accessKeyId: accessKey,
+        secretAccessKey: secretKey,
+    };
+    //Generate Public Key from
+    const plainTextData = await (0, exports.processKMSDecryption)(config, privateDataKey, {});
+    if (plainTextData.status === "FAILED") {
+        return plainTextData;
+    }
+    const publicKey = plainTextData.data;
+    let response = null;
+    if (encrypt) {
+        console.log("Encrypting");
+        response = (0, crypt_1.encryptData)(data, publicKey);
+    }
+    else {
+        console.log("Decrypting");
+        response = (0, crypt_1.decryptData)(data, publicKey);
+    }
+    return { status: "SUCCESS", message: "", data: response };
+};
 exports.drapcodeEncryptDecrypt = drapcodeEncryptDecrypt;
-var cryptFile = function (filePath, encryption, decrypt) { return __awaiter(void 0, void 0, void 0, function () {
-    var data;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, (0, file_1.processFileEncryptionDecryption)(filePath, encryption, decrypt)];
-            case 1:
-                data = _a.sent();
-                return [2 /*return*/, data];
-        }
-    });
-}); };
+const cryptFile = async (filePath, encryption, decrypt) => {
+    const data = await (0, file_1.processFileEncryptionDecryption)(filePath, encryption, decrypt);
+    return data;
+};
 exports.cryptFile = cryptFile;
-var processKMSDecryption = function (config, cipherText, context) { return __awaiter(void 0, void 0, void 0, function () {
-    var accessKeyId, secretAccessKey, region, client, dcipherText, input, command, response, plainText, error_1;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                _a.trys.push([0, 2, , 3]);
-                accessKeyId = config.accessKeyId, secretAccessKey = config.secretAccessKey, region = config.region;
-                client = new client_kms_1.KMSClient({
-                    region: region,
-                    credentials: { accessKeyId: accessKeyId, secretAccessKey: secretAccessKey },
-                });
-                dcipherText = Buffer.from(cipherText, "base64");
-                input = {
-                    CiphertextBlob: dcipherText,
-                    EncryptionContext: context,
-                };
-                command = new client_kms_1.DecryptCommand(input);
-                return [4 /*yield*/, client.send(command)];
-            case 1:
-                response = _a.sent();
-                plainText = Buffer.from(response.Plaintext).toString("base64");
-                return [2 /*return*/, { status: "SUCCESS", data: plainText, message: "" }];
-            case 2:
-                error_1 = _a.sent();
-                return [2 /*return*/, { status: "FAILED", data: "", message: error_1.message }];
-            case 3: return [2 /*return*/];
-        }
-    });
-}); };
+const processKMSDecryption = async (config, cipherText, context) => {
+    try {
+        const { accessKeyId, secretAccessKey, region } = config;
+        const client = new client_kms_1.KMSClient({
+            region,
+            credentials: { accessKeyId, secretAccessKey },
+            maxAttempts: 3,
+        });
+        const dCipherText = Buffer.from(cipherText, "base64");
+        const input = {
+            CiphertextBlob: dCipherText,
+            EncryptionContext: context,
+        };
+        const command = new client_kms_1.DecryptCommand(input);
+        const response = await client.send(command);
+        //@ts-ignore it is important else it will throw error
+        const plainText = Buffer.from(response.Plaintext).toString("base64");
+        return { status: "SUCCESS", data: plainText, message: "" };
+    }
+    catch (error) {
+        return { status: "FAILED", data: "", message: error.message };
+    }
+};
 exports.processKMSDecryption = processKMSDecryption;

package/build/encryption/utility.js

@@ -1,19 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEncryptedReferenceFields = void 0;
-var drapcode_constant_1 = require("drapcode-constant");
-var getEncryptedReferenceFields = function (collectionFields) {
-    var collectionsNamesArr = [];
-    collectionFields = collectionFields.filter(function (field) {
-        return drapcode_constant_1.BelongsCreatedByRefField.includes(field.type);
-    });
-    collectionFields.forEach(function (field) {
-        if (!field.refCollection &&
-            [drapcode_constant_1.FieldTypes.createdBy.id, drapcode_constant_1.FieldTypes.updatedBy.id].includes(field.type)) {
+const drapcode_constant_1 = require("drapcode-constant");
+const getEncryptedReferenceFields = (collectionFields) => {
+    let collectionsNamesArr = [];
+    collectionFields = collectionFields.filter((field) => drapcode_constant_1.BelongsCreatedByRefField.includes(field.type));
+    collectionFields.forEach((field) => {
+        if (!field.refCollection && drapcode_constant_1.byFields.has(field.type)) {
             collectionsNamesArr.push("user");
         }
         else {
-            var collectionName = field.refCollection.collectionName;
+            const { collectionName } = field.refCollection;
             collectionsNamesArr.push(collectionName);
         }
     });

package/build/errors/app-error.js

@@ -1,32 +1,14 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppError = void 0;
-var AppError = /** @class */ (function (_super) {
-    __extends(AppError, _super);
-    function AppError(message, statusCode) {
-        var _this = _super.call(this, message) || this;
-        _this.message = message;
-        _this.statusCode = statusCode;
-        _this.statusCode = statusCode;
-        _this.isOperational = true;
-        Object.setPrototypeOf(_this, AppError.prototype);
-        return _this;
+class AppError extends Error {
+    constructor(message, statusCode) {
+        super(message);
+        this.message = message;
+        this.statusCode = statusCode;
+        this.statusCode = statusCode;
+        this.isOperational = true;
+        Object.setPrototypeOf(this, AppError.prototype);
     }
-    return AppError;
-}(Error));
+}
 exports.AppError = AppError;

package/build/errors/axios-error.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAxiosError = void 0;
-var parseAxiosError = function (error) {
+const parseAxiosError = (error) => {
     if (!error) {
         return {};
     }
-    var response = error.response, request = error.request, message = error.message;
-    var errData = "", errStatus = 400;
+    const { response, request, message } = error;
+    let errData = "", errStatus = 400;
     if (response) {
         console.error("err.response.data: ", response.data);
         console.error("err.response.status: ", response.status);