drapcode-utility 2.7.3 → 2.7.4-sandbox.1

package/build/utils/s3-util.js

@@ -1,275 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processAndRemoveScriptFromSVG = exports.processAndRemoveExifDataFromImg = exports.fileUploadToS3 = exports.createS3Client = void 0;
-const drapcode_constant_1 = require("drapcode-constant");
-const client_s3_1 = require("@aws-sdk/client-s3");
-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 uuid_1 = require("uuid");
-const gm_1 = __importDefault(require("gm"));
-const svgo_1 = require("svgo");
-const promises_1 = __importDefault(require("fs/promises"));
-const exiftool_vendored_1 = require("exiftool-vendored");
-const exiftool = new exiftool_vendored_1.ExifTool({});
-const createS3Client = (awsConfig) => {
-    if (!awsConfig) {
-        return null;
-    }
-    const { region, accessKey, accessSecret } = awsConfig;
-    const s3client = new client_s3_1.S3Client({
-        region,
-        credentials: {
-            accessKeyId: accessKey,
-            secretAccessKey: accessSecret,
-        },
-    });
-    return s3client;
-};
-exports.createS3Client = createS3Client;
-const fileUploadToS3 = async (files, s3Client, s3Config, publicS3Client, publicS3Config, isGenerateIcons, encryption, options = {}, encrypted = false) => {
-    if (Array.isArray(files)) {
-        console.log("Multiple file");
-        const fileOptions = [];
-        const s3Key = s3Config.key;
-        for (const file of files) {
-            const fileSlug = slugifyFileName(file.originalname);
-            if (s3Config.append) {
-                s3Config.key = `${s3Key}/${(0, uuid_1.v4)()}/${fileSlug}`;
-            }
-            const fileObj = await processFileUploadToS3(file, s3Client, s3Config, publicS3Client, publicS3Config, isGenerateIcons, encryption, options, encrypted);
-            if (fileObj) {
-                fileOptions.push(fileObj);
-            }
-        }
-        return fileOptions;
-    }
-    else {
-        console.log("Single file");
-        const fileSlug = slugifyFileName(files.originalname);
-        if (s3Config.append) {
-            s3Config.key = `${s3Config.key}/${(0, uuid_1.v4)()}/${fileSlug}`;
-        }
-        console.log("encryption :>> ", encryption);
-        return await processFileUploadToS3(files, s3Client, s3Config, publicS3Client, publicS3Config, isGenerateIcons, encryption, options, encrypted);
-    }
-};
-exports.fileUploadToS3 = fileUploadToS3;
-const processFileUploadToS3 = async (file, s3Client, s3Config, publicS3Client, publicS3Config, isGenerateIcons, encryption, options = {}, encrypt = false) => {
-    try {
-        console.log("encrypt :>> ", encrypt);
-        const contentType = mime_types_1.default.lookup(file.originalname) || "";
-        console.log("s3Config :>> ", s3Config);
-        const { acl, key, bucket } = s3Config;
-        let params = null;
-        let encryptedFilePath = null;
-        if (encrypt) {
-            encryptedFilePath = await (0, encryption_1.cryptFile)(file.path, encryption, false);
-            params = {
-                Bucket: bucket,
-                ACL: acl,
-                Key: key,
-                Body: fs_1.default.createReadStream(encryptedFilePath),
-                ContentType: contentType,
-                ...options,
-            };
-        }
-        else {
-            params = {
-                Bucket: bucket,
-                ACL: acl,
-                Key: key,
-                Body: fs_1.default.createReadStream(file.path),
-                ContentType: contentType,
-                ...options,
-            };
-        }
-        console.log("encryptedFilePath :>> ", encryptedFilePath);
-        console.log("params :>> ", params);
-        const parallelUploads3 = new lib_storage_1.Upload({ client: s3Client, params });
-        const data = await parallelUploads3.done();
-        const { smallIcon, mediumIcon, largeIcon } = await handleIconUpload(file, contentType, publicS3Client, publicS3Config, isGenerateIcons, key, options);
-        if (data) {
-            if (encryptedFilePath) {
-                fs_1.default.unlinkSync(encryptedFilePath);
-            }
-            fs_1.default.unlinkSync(file.path);
-        }
-        const { originalname, mimetype, size } = file;
-        return {
-            originalname,
-            mimetype,
-            size,
-            key: data.Key,
-            contentType,
-            smallIcon,
-            mediumIcon,
-            largeIcon,
-        };
-    }
-    catch (error) {
-        console.error("Error uploading file to S3:", error);
-        return null;
-    }
-};
-const imageTypeFiles = [...drapcode_constant_1.imageMimeTypes, "image/jpg"];
-const processAndRemoveExifDataFromImg = async (files) => {
-    try {
-        files = Array.isArray(files) ? files : [files];
-        files = files.filter((file) => imageTypeFiles.includes(file.mimetype));
-        let promises = [];
-        if (files.length) {
-            promises = files.map(async (file) => {
-                // Remove EXIF data using exiftool
-                return await exiftool
-                    .write(file.path, {}, { writeArgs: ["-all=", "-overwrite_original"] })
-                    .catch((err) => {
-                    console.error("Error processing image:", err);
-                    throw err;
-                });
-            });
-            await Promise.all(promises);
-        }
-        return promises;
-    }
-    catch (error) {
-        console.error("\n error :>> ", error);
-    }
-};
-exports.processAndRemoveExifDataFromImg = processAndRemoveExifDataFromImg;
-const processAndRemoveScriptFromSVG = async (files) => {
-    if (!files || !files.length) {
-        return;
-    }
-    try {
-        files = Array.isArray(files) ? files : [files];
-        files = files.filter((file) => file.mimetype === "image/svg+xml");
-        if (!files || !files.length) {
-            return;
-        }
-        let promises = files.map(async (file) => {
-            const fileContent = await promises_1.default.readFile(file.path, "utf-8");
-            const sanitizedContent = (0, svgo_1.optimize)(fileContent, {
-                plugins: [
-                    "removeScriptElement", // Remove <script>,
-                    "removeDesc",
-                    "removeTitle",
-                    "removeMetadata",
-                    "removeComments",
-                    "removeXMLProcInst",
-                    "removeDoctype",
-                    "cleanupAttrs",
-                    {
-                        name: "removeAttrs", // Plugin to remove event handlers (e.g., onclick)
-                        params: {
-                            attrs: "(on.*)", // Matches attributes starting with "on" (e.g., onclick, onmouseover)
-                        },
-                    },
-                    {
-                        name: "removeForeignObject", // Custom plugin to remove <foreignObject>
-                        fn: (item) => {
-                            if (item.name === "foreignObject") {
-                                return null; // Remove this element
-                            }
-                            else
-                                return item;
-                        },
-                    },
-                ],
-            });
-            await promises_1.default.writeFile(file.path, sanitizedContent.data, "utf-8");
-        });
-        await Promise.all(promises);
-    }
-    catch (error) {
-        console.error("\n error :>> ", error);
-    }
-};
-exports.processAndRemoveScriptFromSVG = processAndRemoveScriptFromSVG;
-const handleIconUpload = async (file, contentType, publicS3Client, publicS3Config, isGenerateIcons, key, options = {}) => {
-    const { path: filePath, size: fileSize } = file;
-    const iconSizes = [200, 300, 500];
-    const iconLabels = ["small", "medium", "large"];
-    try {
-        if (isGenerateIcons &&
-            fileSize < 157286400 && //150mb
-            [...drapcode_constant_1.imageMimeTypes, "application/pdf", "image/gif"].includes(contentType)) {
-            const iconFiles = await generateDynamicIcons(filePath, iconSizes, contentType);
-            const { bucket, acl } = publicS3Config;
-            const iconUploads = iconFiles.map(async (iconFilePath, index) => {
-                const iconLabel = iconLabels[index];
-                const iconKey = `${key}/icons/${(0, uuid_1.v4)()}_${iconLabel}.png`;
-                const iconParams = {
-                    Bucket: bucket,
-                    ACL: acl,
-                    Key: iconKey,
-                    Body: fs_1.default.createReadStream(iconFilePath),
-                    ContentType: "image/png",
-                    ...options,
-                };
-                const iconUpload = new lib_storage_1.Upload({
-                    client: publicS3Client,
-                    params: iconParams,
-                });
-                const iconData = await iconUpload.done();
-                fs_1.default.unlinkSync(iconFilePath);
-                return iconData.Key;
-            });
-            const [smallKey, mediumKey, largeKey] = await Promise.all(iconUploads);
-            return {
-                smallIcon: generateS3IconUrl(bucket, smallKey),
-                mediumIcon: generateS3IconUrl(bucket, mediumKey),
-                largeIcon: generateS3IconUrl(bucket, largeKey),
-            };
-        }
-        else {
-            return generateStaticIcons(contentType);
-        }
-    }
-    catch (iconError) {
-        console.error("Error generating or uploading icons:", iconError);
-        return generateStaticIcons(contentType);
-    }
-};
-const generateS3IconUrl = (bucket, key) => {
-    if (!key)
-        return null;
-    return `https://${bucket}.s3.amazonaws.com/${key}`;
-};
-const generateDynamicIcons = (filePath, sizes, contentType) => {
-    return Promise.all(sizes.map((size) => {
-        const outputFilePath = `${filePath}_${size}.png`;
-        return new Promise((resolve, reject) => {
-            let gmInstance = (0, gm_1.default)(filePath);
-            if (contentType === "application/pdf") {
-                gmInstance = gmInstance.selectFrame(0);
-            }
-            gmInstance.resize(size, size).write(outputFilePath, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(outputFilePath);
-                }
-            });
-        });
-    }));
-};
-const generateStaticIcons = (type) => {
-    const icon = drapcode_constant_1.iconMaps[type] || drapcode_constant_1.defaultIcon;
-    return {
-        smallIcon: icon,
-        mediumIcon: icon,
-        largeIcon: icon,
-    };
-};
-const slugifyFileName = (fileName) => {
-    return fileName
-        .replace(/\s+/g, "_") // Replace spaces with underscores
-        .replace(/[^a-zA-Z0-9._]/g, "") // Remove anything that's not a letter, number, dot, or underscore
-        .toLowerCase(); // Convert to lowercase
-};