drapcode-utility 2.1.4 → 2.2.1

package/build/encryption/KMS.d.ts

@@ -1,9 +1,6 @@
-import { AwsConfig } from "./model";
-export declare const processKMSEncryption: (config: AwsConfig, arn: string, plainText: string, context: any) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-}>;
+import { AwsConfig, DecryptResponse, Encryption } from "./model";
+export declare const processKey: (encryption: Encryption, encryptionType: string) => Promise<Encryption>;
+export declare const processKMSDecryption: (config: AwsConfig, cipherText: string, context: any) => Promise<DecryptResponse>;
 export declare const processKMSGenerateDataKey: (config: AwsConfig, arn: string) => Promise<{
     status: string;
     dataKey: string;

package/build/encryption/KMS.js

@@ -1,36 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processKMSGenerateDataKey = exports.processKMSEncryption = void 0;
+exports.processKMSGenerateDataKey = exports.processKMSDecryption = exports.processKey = void 0;
 const client_kms_1 = require("@aws-sdk/client-kms");
-const processKMSEncryption = async (config, arn, plainText, context) => {
+const processKey = async (encryption, encryptionType) => {
+    if (encryptionType !== "KMS") {
+        return encryption;
+    }
+    const plainTextData = await (0, exports.processKMSDecryption)(encryption.awsConfig, encryption.dataKey, {});
+    if (plainTextData.status === "SUCCESS") {
+        return { ...encryption, dataKey: plainTextData.data };
+    }
+    return encryption;
+};
+exports.processKey = processKey;
+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 = {
-            KeyId: arn,
-            Plaintext: Buffer.from(plainText),
+            CiphertextBlob: dCipherText,
             EncryptionContext: context,
         };
-        const command = new client_kms_1.EncryptCommand(input);
+        const command = new client_kms_1.DecryptCommand(input);
         const response = await client.send(command);
-        // Encrypted text will be in uint8array
-        // To save it in database, we need string representation
-        //@ts-ignore it is important else it will throw error
-        const cipherText = Buffer.from(response.CiphertextBlob).toString("base64");
-        return { status: "SUCCESS", data: cipherText, message: "" };
+        if (!response.Plaintext) {
+            throw new Error("Missing plaintext in KMS response.");
+        }
+        const plainText = Buffer.from(response.Plaintext).toString("base64");
+        return { status: "SUCCESS", data: plainText, message: "" };
     }
     catch (error) {
-        return {
-            status: "FAILED",
-            data: "",
-            message: error.message,
-        };
+        return { status: "FAILED", data: "", message: error.message };
     }
 };
-exports.processKMSEncryption = processKMSEncryption;
+exports.processKMSDecryption = processKMSDecryption;
 const processKMSGenerateDataKey = async (config, arn) => {
     try {
         const { accessKeyId, secretAccessKey, region } = config;

package/build/encryption/crypt.d.ts

@@ -1,4 +1,4 @@
-export declare const encryptData: (data: string, key: string) => string;
-export declare const decryptData: (data: string, key: string) => string;
-export declare const encryptFile: (filePath: string, key: string) => Promise<string>;
-export declare const decryptFile: (encryptedFilePath: string, key: string) => Promise<string>;
+export declare const encryptData: (data: string, key: string, iv?: string) => string;
+export declare const decryptData: (data: string, key: string, iv?: string) => string;
+export declare const encryptFile: (filePath: string, key: string, iv: string) => Promise<string>;
+export declare const decryptFile: (encryptedFilePath: string, key: string, iv: string) => Promise<string>;

package/build/encryption/crypt.js

@@ -7,14 +7,19 @@ exports.decryptFile = exports.encryptFile = exports.decryptData = exports.encryp
 const fs_1 = __importDefault(require("fs"));
 const crypto_1 = __importDefault(require("crypto"));
 const defaultAlgorithm = "aes-256-cbc";
-const fixedIv = Buffer.from("i4mboZDwaNEC38YCzi77lw==", "base64"); // Must be 16 bytes
-const encryptData = (data, key) => {
+const fixedIv = "i4mboZDwaNEC38YCzi77lw==";
+const toBuffer = (base64) => Buffer.from(base64, "base64");
+const createCipher = (key, iv) => crypto_1.default.createCipheriv(defaultAlgorithm, toBuffer(key), toBuffer(iv));
+const createDecipher = (key, iv) => crypto_1.default.createDecipheriv(defaultAlgorithm, toBuffer(key), toBuffer(iv));
+const encryptData = (data, key, iv) => {
     try {
-        const keyBuffer = Buffer.from(key, "base64");
-        const cipher = crypto_1.default.createCipheriv(defaultAlgorithm, keyBuffer, fixedIv);
+        console.log("encryptData: key :>> ", key);
+        console.log("encryptData: iv :>> ", iv);
+        if (!iv)
+            iv = fixedIv;
+        const cipher = createCipher(key, iv);
         const encrypted = Buffer.concat([cipher.update(`${data}`), cipher.final()]);
-        const base64Encrypted = encrypted.toString("base64");
-        return handleExtraString(base64Encrypted, true);
+        return handleExtraString(encrypted.toString("base64"), true);
     }
     catch (error) {
         console.error("\n Error: ", error);
@@ -22,12 +27,15 @@ const encryptData = (data, key) => {
     }
 };
 exports.encryptData = encryptData;
-const decryptData = (data, key) => {
+const decryptData = (data, key, iv) => {
     try {
+        console.log("decryptData: key :>> ", key);
+        console.log("decryptData: iv :>> ", iv);
         const cleaned = handleExtraString(data, false);
-        const encryptedData = Buffer.from(cleaned, "base64");
-        const keyBuffer = Buffer.from(key, "base64");
-        const decipher = crypto_1.default.createDecipheriv(defaultAlgorithm, keyBuffer, fixedIv);
+        const encryptedData = toBuffer(cleaned);
+        if (!iv)
+            iv = fixedIv;
+        const decipher = createDecipher(key, iv);
         const decrypted = Buffer.concat([
             decipher.update(encryptedData),
             decipher.final(),
@@ -40,40 +48,70 @@ const decryptData = (data, key) => {
     }
 };
 exports.decryptData = decryptData;
-const encryptFile = async (filePath, key) => {
-    try {
-        const keyBuffer = Buffer.from(key, "base64");
-        const fileContent = await fs_1.default.promises.readFile(filePath);
-        const cipher = crypto_1.default.createCipheriv(defaultAlgorithm, keyBuffer, fixedIv);
-        let encryptedDataBuffer = cipher.update(fileContent);
-        encryptedDataBuffer = Buffer.concat([encryptedDataBuffer, cipher.final()]);
-        const encryptedFilePath = filePath + ".enc";
-        await fs_1.default.promises.writeFile(encryptedFilePath, encryptedDataBuffer);
-        console.log("File encrypted successfully.");
-        return encryptedFilePath;
-    }
-    catch (error) {
-        console.error("\n Error: ", error);
-        throw error;
-    }
+const encryptFile = async (filePath, key, iv) => {
+    return new Promise((resolve, reject) => {
+        try {
+            console.log("encryptFile: key :>> ", key);
+            console.log("encryptFile: iv :>> ", iv);
+            if (!iv)
+                iv = fixedIv;
+            const cipher = createCipher(key, iv);
+            const encryptedFilePath = filePath.endsWith(".enc")
+                ? filePath
+                : `${filePath}.enc`;
+            const readStream = fs_1.default.createReadStream(filePath);
+            const writeStream = fs_1.default.createWriteStream(encryptedFilePath);
+            readStream
+                .pipe(cipher)
+                .pipe(writeStream)
+                .on("finish", () => {
+                console.log("File encrypted successfully (stream).");
+                resolve(encryptedFilePath);
+            })
+                .on("error", (err) => {
+                console.error("encryptFileStream error:", err);
+                reject(err);
+            });
+        }
+        catch (error) {
+            console.error("\n Error: ", error);
+            reject(error);
+        }
+    });
 };
 exports.encryptFile = encryptFile;
-const decryptFile = async (encryptedFilePath, key) => {
-    try {
-        const keyBuffer = Buffer.from(key, "base64");
-        const encryptedData = await fs_1.default.promises.readFile(encryptedFilePath);
-        const decipher = crypto_1.default.createDecipheriv(defaultAlgorithm, keyBuffer, fixedIv);
-        let decryptedBuffer = decipher.update(encryptedData);
-        decryptedBuffer = Buffer.concat([decryptedBuffer, decipher.final()]);
-        const decryptedFilePath = `${encryptedFilePath.slice(0, -4)}.dec`;
-        await fs_1.default.promises.writeFile(decryptedFilePath, decryptedBuffer);
-        console.log("File decrypted successfully.");
-        return decryptedFilePath;
-    }
-    catch (error) {
-        console.error("Error:", error);
-        throw error;
-    }
+const decryptFile = async (encryptedFilePath, key, iv) => {
+    return new Promise((resolve, reject) => {
+        try {
+            console.log("decryptFile: key :>> ", key);
+            console.log("decryptFile: iv :>> ", iv);
+            if (!iv)
+                iv = fixedIv;
+            const decipher = createDecipher(key, iv);
+            const readStream = fs_1.default.createReadStream(encryptedFilePath);
+            const decryptedFilePath = encryptedFilePath.endsWith(".enc")
+                ? `${encryptedFilePath.slice(0, -4)}.dec`
+                : `${encryptedFilePath}.dec`;
+            const writeStream = fs_1.default.createWriteStream(decryptedFilePath);
+            readStream
+                .pipe(decipher)
+                .pipe(writeStream)
+                .on("finish", () => {
+                console.log("File decrypted successfully (stream).");
+                resolve(decryptedFilePath);
+            })
+                .on("error", (err) => {
+                console.error("decryptFileStream error:", err);
+                reject(err);
+            });
+            console.log("File decrypted successfully.");
+            return decryptedFilePath;
+        }
+        catch (error) {
+            console.error("Error:", error);
+            reject(error);
+        }
+    });
 };
 exports.decryptFile = decryptFile;
 const handleExtraString = (key, append = true) => {

package/build/encryption/file.js

@@ -3,16 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processFileEncryptionDecryption = void 0;
 const crypt_1 = require("./crypt");
 const processFileEncryptionDecryption = async (data, encryption, decrypt) => {
-    const { encryptionType, dataKey } = encryption;
+    const { dataKey, iv } = encryption;
     if (!data)
         return data;
-    switch (encryptionType) {
-        case "KMS":
-            return decrypt
-                ? await (0, crypt_1.decryptFile)(data, dataKey)
-                : await (0, crypt_1.encryptFile)(data, dataKey);
-        default:
-            return data;
-    }
+    return decrypt
+        ? await (0, crypt_1.decryptFile)(data, dataKey, iv)
+        : await (0, crypt_1.encryptFile)(data, dataKey, iv);
 };
 exports.processFileEncryptionDecryption = processFileEncryptionDecryption;

package/build/encryption/index.d.ts

@@ -14,41 +14,5 @@ export declare const createKMSDataKey: (config: AwsConfig, arn: string) => Promi
     dataKey: string;
     message: string;
 }>;
-/**
- * This method is used to encrypt plaintext upto 4KB
- * It requires KMS config and ARN
- * @param config AWS Config
- * @param arn KMS Key
- * @param plainText Text to be encrypted
- * @param context Extra setting for extra security
- * @returns {status: string, message: string, cipherText: string}
- */
-export declare const encryptDataWithKMS: (config: AwsConfig, arn: string, plainText: string, context: any) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-}>;
-/**
- * This method is used to decrypt secure text
- * It requires KMS config
- * @param config AWS Config
- * @param cipherText Encrypted Text
- * @param context Extra setting which given for extra security
- * @returns {status: string, message: string, plainText: string}
- */
-export declare const decryptDataWithKMS: (config: AwsConfig, cipherText: string, context: any) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-}>;
-export declare const drapcodeEncryptDecrypt: (data: string, encrypt: boolean) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-}>;
+export declare const drapcodeEncryptDecrypt: (data: string, encrypt: boolean) => Promise<import("./model").DecryptResponse>;
 export declare const cryptFile: (filePath: any, encryption: Encryption, decrypt: boolean) => Promise<string>;
-export declare const processKMSDecryption: (config: AwsConfig, cipherText: string, context: any) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-}>;

package/build/encryption/index.js

@@ -1,25 +1,11 @@
 "use strict";
 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;
-const client_kms_1 = require("@aws-sdk/client-kms");
+exports.cryptFile = exports.drapcodeEncryptDecrypt = exports.createKMSDataKey = exports.processDataEncryptionDecryption = exports.processItemEncryptDecrypt = exports.crypt = void 0;
 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);
@@ -63,15 +49,12 @@ const processItemEncryptDecrypt = async (item, fields, encryption, decrypt, encr
 };
 exports.processItemEncryptDecrypt = processItemEncryptDecrypt;
 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;
-    }
+    const { dataKey, iv } = encryption;
+    return decrypt
+        ? (0, crypt_1.decryptData)(data, dataKey, iv)
+        : (0, crypt_1.encryptData)(data, dataKey, iv);
 };
 exports.processDataEncryptionDecryption = processDataEncryptionDecryption;
 const processReferenceItemDecrypt = async (data, encryption, decrypt, refField, encryptedRefCollections) => {
@@ -104,33 +87,6 @@ const createKMSDataKey = async (config, arn) => {
     return dataKeyRes;
 };
 exports.createKMSDataKey = createKMSDataKey;
-/**
- * This method is used to encrypt plaintext upto 4KB
- * It requires KMS config and ARN
- * @param config AWS Config
- * @param arn KMS Key
- * @param plainText Text to be encrypted
- * @param context Extra setting for extra security
- * @returns {status: string, message: string, cipherText: string}
- */
-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
- * It requires KMS config
- * @param config AWS Config
- * @param cipherText Encrypted Text
- * @param context Extra setting which given for extra security
- * @returns {status: string, message: string, plainText: string}
- */
-const decryptDataWithKMS = async (config, cipherText, context) => {
-    const plainTextData = await (0, exports.processKMSDecryption)(config, cipherText, context);
-    return plainTextData;
-};
-exports.decryptDataWithKMS = decryptDataWithKMS;
 const drapcodeEncryptDecrypt = async (data, encrypt) => {
     const region = process.env.AWS_KMS_REGION;
     const accessKey = process.env.AWS_KMS_ACCESS_KEY;
@@ -158,7 +114,7 @@ const drapcodeEncryptDecrypt = async (data, encrypt) => {
         secretAccessKey: secretKey,
     };
     //Generate Public Key from
-    const plainTextData = await (0, exports.processKMSDecryption)(config, privateDataKey, {});
+    const plainTextData = await (0, KMS_1.processKMSDecryption)(config, privateDataKey, {});
     if (plainTextData.status === "FAILED") {
         return plainTextData;
     }
@@ -180,27 +136,3 @@ const cryptFile = async (filePath, encryption, decrypt) => {
     return data;
 };
 exports.cryptFile = cryptFile;
-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/model.d.ts

@@ -8,4 +8,10 @@ export type Encryption = {
     algorithm: string;
     dataKey: string;
     awsConfig: AwsConfig;
+    iv: string;
+};
+export type DecryptResponse = {
+    status: string;
+    data: string;
+    message: string;
 };

package/build/index.d.ts

@@ -16,5 +16,6 @@ export * from "./utils/common-util";
 export * from "./utils/rest-client";
 export * from "./encryption/index";
 export * from "./encryption/utility";
+export * from "./encryption/KMS";
 export * from "./format-fields/index";
 export * from "./utils/token";

package/build/index.js

@@ -32,5 +32,6 @@ __exportStar(require("./utils/common-util"), exports);
 __exportStar(require("./utils/rest-client"), exports);
 __exportStar(require("./encryption/index"), exports);
 __exportStar(require("./encryption/utility"), exports);
+__exportStar(require("./encryption/KMS"), exports);
 __exportStar(require("./format-fields/index"), exports);
 __exportStar(require("./utils/token"), exports);

package/build/utils/s3-util.d.ts

@@ -13,10 +13,6 @@ interface S3Config {
 }
 export declare const createS3Client: (awsConfig: AWSConfig) => S3Client | null;
 export declare const fileUploadToS3: (files: any, s3Client: S3Client, s3Config: S3Config, publicS3Client: S3Client, publicS3Config: S3Config, isGenerateIcons: boolean, encryption: Encryption, options?: {}) => Promise<{
-    status: string;
-    data: string;
-    message: string;
-} | {
     originalname: any;
     mimetype: any;
     size: any;

package/build/utils/s3-util.js

@@ -10,7 +10,6 @@ const fs_1 = __importDefault(require("fs"));
 const mime_types_1 = __importDefault(require("mime-types"));
 const lib_storage_1 = require("@aws-sdk/lib-storage");
 const encryption_1 = require("../encryption");
-const encryption_2 = require("../encryption");
 const uuid_1 = require("uuid");
 const gm_1 = __importDefault(require("gm"));
 const svgo_1 = require("svgo");
@@ -33,22 +32,6 @@ const createS3Client = (awsConfig) => {
 };
 exports.createS3Client = createS3Client;
 const fileUploadToS3 = async (files, s3Client, s3Config, publicS3Client, publicS3Config, isGenerateIcons, encryption, options = {}) => {
-    if (encryption) {
-        const { awsConfig, encryptionType, dataKey } = encryption;
-        if (encryptionType === "KMS") {
-            const { accessKeyId, secretAccessKey, region } = awsConfig;
-            const config = {
-                region,
-                accessKeyId,
-                secretAccessKey,
-            };
-            const plainTextData = await (0, encryption_2.processKMSDecryption)(config, dataKey, {});
-            if (plainTextData.status === "FAILED") {
-                return plainTextData;
-            }
-            encryption.dataKey = plainTextData.data;
-        }
-    }
     if (Array.isArray(files)) {
         const fileOptions = [];
         const s3Key = s3Config.key;

package/build/utils/util.js

@@ -890,7 +890,7 @@ const addition = function (formatType, { numbers }) {
         }
         numbers = numbers.map((number) => (isNaN(number) ? 0 : number));
         const allNumbers = (0, exports.validateNumbers)(numbers);
-        return (0, numeral_1.default)(mathjs_1.default.add(...allNumbers)).format(formatType ? formatType : "00.00");
+        return (0, numeral_1.default)(mathjs_1.default.sum(allNumbers)).format(formatType ? formatType : "00.00");
     }
     catch (err) {
         console.log("🚀 ~ file: util.js:89 ~ addition ~ error:", err);
@@ -901,10 +901,10 @@ exports.addition = addition;
 const substraction = function (formatType, { numbers1, numbers2 }) {
     try {
         const actNumber1 = Array.isArray(numbers1)
-            ? mathjs_1.default.add(...numbers1)
+            ? mathjs_1.default.sum(...numbers1)
             : numbers1;
         const actNumber2 = Array.isArray(numbers2)
-            ? mathjs_1.default.add(...numbers2)
+            ? mathjs_1.default.sum(...numbers2)
             : numbers2;
         return (0, numeral_1.default)(mathjs_1.default.subtract(actNumber1, actNumber2)).format(formatType ? formatType : "00.00");
     }
@@ -936,7 +936,7 @@ const multiply = function (formatType, { numbers }) {
         }
         numbers = numbers.map((number) => (isNaN(number) ? 1 : number));
         const allNumbers = (0, exports.validateNumbers)(numbers);
-        return (0, numeral_1.default)(mathjs_1.default.multiply(...allNumbers)).format(formatType ? formatType : "00.00");
+        return (0, numeral_1.default)(mathjs_1.default.prod(...allNumbers)).format(formatType ? formatType : "00.00");
     }
     catch (err) {
         console.log("🚀 ~ file: util.js:106 ~ multiply ~ error:", err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drapcode-utility",
-  "version": "2.1.4",
+  "version": "2.2.1",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,9 +42,9 @@
     "axios": "^1.1.2",
     "date-fns": "^4.1.0",
     "dompurify": "^3.1.7",
-    "drapcode-constant": "^1.8.4",
+    "drapcode-constant": "^1.9.1",
     "drapcode-logger": "^1.3.5",
-    "drapcode-redis": "^1.3.9",
+    "drapcode-redis": "^1.3.6",
     "exiftool-vendored": "^28.2.1",
     "express": "^4.17.1",
     "gm": "^1.25.0",