@sastatesla/payment-gateway-sdk/dist/src/providers/gcsProvider.js

A unified interface for integrating multiple payment providers (e.g., Razorpay, Cashfree) in your Node.js application.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GCSProvider = void 0;
const storage_1 = require("@google-cloud/storage");
const storageProvider_1 = require("./storageProvider");
const error_1 = require("../utils/error");
const helpers_1 = __importDefault(require("../helpers/helpers"));
const path_1 = __importDefault(require("path"));
const inputParser_1 = require("../utils/inputParser");
const crypto_1 = __importDefault(require("crypto"));
class GCSProvider extends storageProvider_1.StorageProvider {
    async uploadBulkBuffer(files, options) {
        return Promise.all(files.map((file) => this.uploadBuffer(file, options)));
    }
    constructor(gcsConfig, cloudStorageConfig) {
        super();
        this.gcsConfig = gcsConfig;
        this.cloudStorageConfig = cloudStorageConfig;
        this.bucketName = gcsConfig.bucketName;
        this.allowedFileTypes = cloudStorageConfig.allowedFileTypes;
        this.storage = new storage_1.Storage({ credentials: gcsConfig.credentials });
    }
    // Upload a file from a file path (for existing files on disk)
    async upload(filePath, options) {
        const parsedOptions = (0, inputParser_1.parseFileUploadOptions)(options);
        try {
            if (this.allowedFileTypes) {
                const mimeType = (0, helpers_1.default)(filePath);
                if (!mimeType || !this.allowedFileTypes.includes(mimeType)) {
                    throw new error_1.StorageError(`Invalid file type: ${mimeType}`);
                }
            }
            const destination = options?.destination || path_1.default.basename(filePath);
            const [file] = await this.storage
                .bucket(this.bucketName)
                .upload(filePath, {
                destination,
                metadata: options?.metadata
            });
            return {
                id: file.name,
                url: `https://storage.googleapis.com/${this.bucketName}/${file.name}`,
                provider: "gcs",
                metadata: file.metadata
            };
        }
        catch (err) {
            throw new error_1.StorageError(`GCS upload failed: ${err.message}`, "GCS_UPLOAD_ERROR", err);
        }
    }
    // NEW: Upload a file buffer (e.g., from multer memory storage)
    async uploadBuffer(file, options) {
        try {
            if (this.allowedFileTypes &&
                (!file.mimetype ||
                    !this.allowedFileTypes.includes(file.mimetype))) {
                throw new error_1.StorageError(`Invalid file type: ${file.mimetype}`);
            }
            const extension = path_1.default.extname(file.originalname);
            const randomName = crypto_1.default.randomBytes(16).toString("hex") + extension;
            const destination = options?.destination || randomName;
            const bucketFile = this.storage
                .bucket(this.bucketName)
                .file(destination);
            await new Promise((resolve, reject) => {
                const stream = bucketFile.createWriteStream({
                    resumable: false,
                    contentType: file.mimetype,
                    metadata: options?.metadata
                });
                stream.on("error", reject);
                stream.on("finish", resolve);
                stream.end(file.buffer);
            });
            return {
                id: bucketFile.name,
                url: `https://storage.googleapis.com/${this.bucketName}/${bucketFile.name}`,
                provider: "gcs",
                metadata: (await bucketFile.getMetadata())[0]
            };
        }
        catch (err) {
            throw new error_1.StorageError(`GCS uploadBuffer failed: ${err.message}`, "GCS_UPLOAD_BUFFER_ERROR", err);
        }
    }
    async uploadBulk(filePaths, options) {
        return Promise.all(filePaths.map((filePath) => this.upload(filePath, options)));
    }
    async delete(fileId) {
        try {
            await this.storage.bucket(this.bucketName).file(fileId).delete();
        }
        catch (err) {
            throw new error_1.StorageError(`GCS delete failed: ${err.message}`, "GCS_DELETE_ERROR", err);
        }
    }
    async deleteBulk(fileIds) {
        return Promise.all(fileIds.map((id) => this.delete(id)));
    }
    async createFolder(folderName) {
        try {
            await this.storage
                .bucket(this.bucketName)
                .file(`${folderName.replace(/\/$/, "")}/.placeholder`)
                .save("");
        }
        catch (err) {
            throw new error_1.StorageError(`GCS createFolder failed: ${err.message}`, "GCS_CREATEFOLDER_ERROR", err);
        }
    }
    async uploadToFolder(folderName, filePath, options) {
        const fileName = path_1.default.basename(options?.destination ?? filePath);
        const destination = `${folderName.replace(/\/$/, "")}/${fileName}`;
        return this.upload(filePath, { ...options, destination });
    }
    async uploadBufferToFolder(folderName, file, options) {
        const fileName = options?.destination ?? file.originalname;
        const destination = `${folderName.replace(/\/$/, "")}/${fileName}`;
        return this.uploadBuffer(file, { ...options, destination });
    }
}
exports.GCSProvider = GCSProvider;
//# sourceMappingURL=gcsProvider.js.map