gb_utils/spaceUtils.js

All utils file for beta

/* eslint-disable no-async-promise-executor */
const { S3Client, PutObjectCommand, DeleteObjectCommand } = require("@aws-sdk/client-s3");
const QRCode = require("qrcode");
const sharp = require("sharp");

const constantUtils = require("./constantUtils");
const redisUtils = require("./redisUtils");
const helperUtils = require("./helperUtils");
const logger = require("./loggerUtils");

const langJson = require("gb_json/en.json");

const utils = {};

const createS3Client = (spaces) =>
	new S3Client({
		region: "ap-south-1", // or set from config
		credentials: {
			accessKeyId: spaces.spacesKey,
			secretAccessKey: spaces.spacesSecret,
		},
		forcePathStyle: false,
	});

/** Delete a single file */
utils.delete = (config, fileName) => {
	return new Promise(async (resolve) => {
		const configData = await redisUtils.read(config, constantUtils.GENERALSETTING);
		const spaces = configData?.data?.spaces;
		if (!spaces) {
			logger.error(langJson.SPACEKEYMISSING);
			return resolve("");
		}

		if (!fileName.includes(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}`)) return resolve("");

		const key = fileName.replace(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/`, "");
		const s3 = createS3Client(spaces);

		try {
			await s3.send(new DeleteObjectCommand({
				Bucket: spaces.spacesBucketName,
				Key: `${spaces.spacesObjectName}/${key}`,
			}));
			resolve(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/${key}`);
		} catch (err) {
			logger.error(err);
			resolve(err);
		}
	});
};

/** Delete multiple files */
utils.deleteMulti = (config, filenames) => {
	return new Promise(async (resolve) => {
		const configData = await redisUtils.read(config, constantUtils.GENERALSETTING);
		const spaces = configData?.data?.spaces;
		if (!spaces) {
			logger.error(langJson.SPACEKEYMISSING);
			return resolve("");
		}

		const s3 = createS3Client(spaces);

		try {
			await Promise.all(filenames.map(async (fileName) => {
				if (!fileName.includes(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}`)) return;
				const key = fileName.replace(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/`, "");
				await s3.send(new DeleteObjectCommand({
					Bucket: spaces.spacesBucketName,
					Key: `${spaces.spacesObjectName}/${key}`,
				}));
			}));

			resolve("done");
		} catch (err) {
			logger.error(err);
			resolve(err);
		}
	});
};

/** Upload a single file */
utils.uploadSingle = async (config, file) => {
	if (!file) {
		logger.error(langJson.FILEMISSING);
		return "";
	}

	const configData = await redisUtils.read(config, constantUtils.GENERALSETTING);
	const spaces = configData?.data?.spaces;
	if (!spaces) {
		logger.error(langJson.SPACEKEYMISSING);
		return "";
	}

	const s3 = createS3Client(spaces);
	let format = (file.originalname.split(".").pop() || "jpg").toLowerCase();
	let mime = file.mimetype;
	const fileName = `${constantUtils.GAMERSBACK}.${await helperUtils.randomString({ length: 12, type: "# A a" })}`;
	let bufferToUpload = file.buffer;
	let finalFormat = format;

	try {
		if (mime.startsWith("image/")) {
			// Convert image to webp
			bufferToUpload = await sharp(file.buffer).webp({ quality: 70 }).toBuffer();
			finalFormat = "webp";

		} 

		const finalFileName = `${fileName}.${finalFormat}`;

		await s3.send(new PutObjectCommand({
			Bucket: spaces.spacesBucketName,
			Key: `${spaces.spacesObjectName}/${finalFileName}`,
			Body: bufferToUpload,
			ACL: "public-read",
		}));

		return `${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/${finalFileName}`;
	} catch (err) {
		logger.error(err);
		return "";
	}
};

/** Upload multiple files */
utils.uploadMulti = (config, files) => {
	return new Promise(async (resolve) => {
		if (!files || files.length === 0) {
			logger.error(langJson.FILEMISSING);
			return resolve("");
		}

		const configData = await redisUtils.read(config, constantUtils.GENERALSETTING);
		const spaces = configData?.data?.spaces;
		if (!spaces) {
			logger.error(langJson.SPACEKEYMISSING);
			return resolve("");
		}

		const s3 = createS3Client(spaces);
		const imageArray = [];

		try {
			await Promise.all(files.map(async (file) => {
				let format = file.originalname.split(".").pop().toLowerCase() || "jpg";
				let mime = file.mimetype;
				const baseFileName = `${constantUtils.GAMERSBACK}.${await helperUtils.randomString({ length: 12, type: "# A a" })}`;

				let bufferToUpload = file.buffer;
				let finalFormat = format;

				if (mime.startsWith("image/")) {
					bufferToUpload = await sharp(file.buffer).webp({ quality: 75 }).toBuffer();
					finalFormat = "webp";
				}

				const finalFileName = `${baseFileName}.${finalFormat}`;

				await s3.send(new PutObjectCommand({
					Bucket: spaces.spacesBucketName,
					Key: `${spaces.spacesObjectName}/${finalFileName}`,
					Body: bufferToUpload,
					ACL: "public-read",
				}));

				imageArray.push({
					imageUrl: `${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/${finalFileName}`,
				});
			}));

			resolve(imageArray);
		} catch (err) {
			logger.error(err);
			resolve("");
		}
	});
};

/** Upload QR Code */
utils.uploadQrCode = async (config, text, imageName) => {
	const options = {
		errorCorrectionLevel: "L",
		type: "image/png",
		quality: 0.92,
	};

	return new Promise((resolve) => {
		QRCode.toBuffer(text, options, async (err, bufferData) => {
			if (err) return resolve("");

			const file = {
				originalname: imageName,
				buffer: bufferData,
			};

			const configData = await redisUtils.read(config, constantUtils.GENERALSETTING);
			const spaces = configData?.data?.spaces;
			if (!spaces) {
				logger.error(langJson.SPACEKEYMISSING);
				return resolve("");
			}

			const s3 = createS3Client(spaces);
			let fileNameBase = `${constantUtils.GAMERSBACK}.${imageName}`;

			try {
				const compressedBuffer = await sharp(file.buffer).webp({ quality: 70 }).toBuffer();
				const finalFileName = `${fileNameBase}.webp`;

				await s3.send(new PutObjectCommand({
					Bucket: spaces.spacesBucketName,
					Key: `${spaces.spacesObjectName}/${finalFileName}`,
					Body: compressedBuffer,
					ACL: "public-read",
				}));

				resolve(`${spaces.spacesBaseUrl}/${spaces.spacesObjectName}/${finalFileName}`);
			} catch (err) {
				logger.error(err);
				resolve("");
			}
		});
	});
};

module.exports = utils;