sky-buckets/lib/MinioService.js

NPM package to redirect file uploads from Multer to MinIO with TypeScript support.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MinioService = void 0;
const stream_1 = require("stream");
class MinioService {
    constructor(minioClient) {
        this.minioClient = minioClient;
    }
    async ensureBucketExists(bucketName) {
        const bucketExists = await this.minioClient.bucketExists(bucketName);
        if (!bucketExists) {
            await this.minioClient.makeBucket(bucketName, "us-east-1");
        }
    }
    async uploadFromBuffer(bucketName, objectName, buffer, metaData) {
        try {
            await this.ensureBucketExists(bucketName);
            const uploadInfo = await this.minioClient.putObject(bucketName, objectName, buffer, buffer.length, metaData);
            return { etag: uploadInfo.etag, bucket: bucketName, name: objectName };
        }
        catch (error) {
            console.error("Error uploading from buffer:", error);
            throw error;
        }
    }
    async uploadFromPath(bucketName, objectName, filePath, metaData) {
        try {
            await this.ensureBucketExists(bucketName);
            const uploadInfo = await this.minioClient.fPutObject(bucketName, objectName, filePath, metaData);
            return { etag: uploadInfo.etag, bucket: bucketName, name: objectName };
        }
        catch (error) {
            console.error("Error uploading from path:", error);
            throw error;
        }
    }
    async uploadFromBase64(bucketName, objectName, base64String, metaData) {
        try {
            const base64Data = base64String.replace(/^data:([A-Za-z-+\/]+);base64,/, "");
            const buffer = Buffer.from(base64Data, "base64");
            return this.uploadFromBuffer(bucketName, objectName, buffer, metaData);
        }
        catch (error) {
            console.error("Error uploading from base64:", error);
            throw error;
        }
    }
    async uploadFromBlob(bucketName, objectName, blob, metaData) {
        try {
            await this.ensureBucketExists(bucketName);
            const stream = stream_1.Readable.from(blob.stream());
            const uploadInfo = await this.minioClient.putObject(bucketName, objectName, stream, blob.size, metaData);
            return { etag: uploadInfo.etag, bucket: bucketName, name: objectName };
        }
        catch (error) {
            console.error("Error uploading from blob:", error);
            throw error;
        }
    }
    async uploadMultipleFiles(bucketName, files) {
        const uploadPromises = files.map(async (fileData) => {
            var _a;
            await this.ensureBucketExists(bucketName);
            switch (fileData.type) {
                case "buffer":
                    return this.uploadFromBuffer(bucketName, fileData.objectName, fileData.data, fileData.metaData);
                case "path":
                    return this.uploadFromPath(bucketName, fileData.objectName, fileData.data, fileData.metaData);
                case "base64":
                    return this.uploadFromBase64(bucketName, fileData.objectName, fileData.data, fileData.metaData);
                case "blob":
                    return this.uploadFromBlob(bucketName, fileData.objectName, fileData.data, fileData.metaData);
                case "stream":
                    const streamSize = (_a = fileData.size) !== null && _a !== void 0 ? _a : -1;
                    const uploadInfo = await this.minioClient.putObject(bucketName, fileData.objectName, fileData.data, streamSize, fileData.metaData);
                    return {
                        etag: uploadInfo.etag,
                        bucket: bucketName,
                        name: fileData.objectName,
                    };
                default:
                    throw new Error(`Unsupported file data type: ${fileData.type}`);
            }
        });
        try {
            return await Promise.all(uploadPromises);
        }
        catch (error) {
            console.error("Error uploading multiple files:", error);
            throw error;
        }
    }
    async downloadFile(bucketName, objectName, res) {
        try {
            const stream = await this.minioClient.getObject(bucketName, objectName);
            stream.pipe(res);
        }
        catch (error) {
            console.error("Error downloading file:", error);
            throw error;
        }
    }
    async downloadFileToPath(bucketName, objectName, destinationPath) {
        try {
            await this.minioClient.fGetObject(bucketName, objectName, destinationPath);
        }
        catch (error) {
            console.error("Error downloading file to path:", error);
            throw error;
        }
    }
    async deleteFile(bucketName, objectName) {
        try {
            await this.minioClient.removeObject(bucketName, objectName);
            console.log(`File ${objectName} berhasil dihapus dari bucket ${bucketName}`);
        }
        catch (error) {
            console.error("Error menghapus file:", error);
            throw error;
        }
    }
    async deleteMultipleFiles(bucketName, objectNames) {
        try {
            await this.minioClient.removeObjects(bucketName, objectNames);
            console.log(`${objectNames.length} file berhasil dihapus dari bucket ${bucketName}`);
        }
        catch (error) {
            console.error("Error menghapus multiple files:", error);
            throw error;
        }
    }
    async fileExists(bucketName, objectName) {
        try {
            await this.minioClient.statObject(bucketName, objectName);
            return true;
        }
        catch (error) {
            if (error.code === "NotFound") {
                return false;
            }
            console.error("Error checking file existence:", error);
            throw error;
        }
    }
    async safeDeleteFile(bucketName, objectName) {
        try {
            const exists = await this.fileExists(bucketName, objectName);
            if (exists) {
                await this.deleteFile(bucketName, objectName);
                return true;
            }
            else {
                console.log(`File ${objectName} tidak ditemukan di bucket ${bucketName}`);
                return false;
            }
        }
        catch (error) {
            console.error("Error dalam safe delete file:", error);
            throw error;
        }
    }
}
exports.MinioService = MinioService;