hrms-shared/utils/s3.js

HRMS shared code: models, middleware, utils

const {
    S3Client,
    PutObjectCommand,
    GetObjectCommand,
    DeleteObjectCommand,
    HeadObjectCommand,
} = require("@aws-sdk/client-s3");
const multer = require("multer");
const path = require("path");
const crypto = require("crypto");
const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");

const s3 = new S3Client({
    region: process.env.AWS_REGION,
    credentials: {
        accessKeyId: process.env.AWS_ACCESS_KEY,
        secretAccessKey: process.env.AWS_SECRET_KEY,
    },
});

const upload = multer({ storage: multer.memoryStorage() });

const uploadImageToS3 = async (file, folderName) => {
    const baseFolder = "Sparkup_HRMS";
    const targetFolder = `${baseFolder}/${folderName}`;

    const ext = path.extname(file.originalname);
    const fileName = `${crypto.randomUUID()}${ext}`;
    const key = `${targetFolder}/${fileName}`;

    await s3.send(
        new PutObjectCommand({
            Bucket: process.env.S3_BUCKET_NAME,
            Key: key,
            Body: file.buffer,
            ContentType: file.mimetype,
            ACL: "public-read",
        })
    );

    const fileUrl = `https://${process.env.S3_BUCKET_NAME}.s3.${process.env.AWS_REGION}.amazonaws.com/${key}`;

    return { fileName, key, fileUrl };
};

async function generatePresignedUrl(key, contentType) {
    const command = new PutObjectCommand({
        Bucket: process.env.S3_BUCKET_NAME,
        Key: key,
        ContentType: contentType,
    });
    const url = await getSignedUrl(s3, command, { expiresIn: 3600 });
    return url;
};

const getSingleUploadUrl = async (userId, docType) => {
    const baseFolder = "Sparkup_HRMS";
    const userFolder = `${baseFolder}/${userId}`;
    const fileName = `${docType}.jpg`;
    const key = `${userFolder}/${fileName}`;
    const url = await generatePresignedUrl(key, "image/jpeg", 300);
    return { userId, fileName, key, url };
};

const getDownloadUrl = async (docKey) => {
    try {
        await s3.send(
            new HeadObjectCommand({
                Bucket: process.env.S3_BUCKET_NAME,
                Key: docKey,
            })
        );

        const command = new GetObjectCommand({
            Bucket: process.env.S3_BUCKET_NAME,
            Key: docKey,
        });

        const url = await getSignedUrl(s3, command, { expiresIn: 300 }); // 5 min

        return url;

    } catch (error) {
        if (
            error.name === "NotFound" ||
            error.$metadata?.httpStatusCode === 404
        ) {
            return null; // Or throw a custom error
        } else {
            throw error;
        }
    }
};

const deleteDocObject = async (s3_key) => {
    s3.send(
        new DeleteObjectCommand({
            Bucket: process.env.AWS_S3_BUCKET,
            Key: s3_key,
        })
    );
};

const uploadFile = async (docname, docType) => {
    const baseFolder = "Sparkup_HRMS";
    const iconsFolder = `${baseFolder}/Icons`;
    const fileName = `${docname}.${docType}`;
    const key = `${iconsFolder}/${fileName}`;

    const command = new PutObjectCommand({
        Bucket: process.env.S3_BUCKET_NAME,
        Key: key,
        ContentType: "image/jpeg",
    });

    const url = await getSignedUrl(s3, command, {
        expiresIn: 300, // 5 minutes
    });

    return {
        fileName,
        key,
        url,
    };
};

module.exports = {
    generatePresignedUrl,
    getSingleUploadUrl,
    getDownloadUrl,
    deleteDocObject,
    uploadFile,
    upload,
    uploadImageToS3
};