reservease.consumer/lib/FileUpload.js

This package allows you to create an amqplib consumer and producer.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FilUploadService = void 0;
const storage_1 = require("@google-cloud/storage");
const multer_1 = __importDefault(require("multer"));
const stream_1 = __importDefault(require("stream"));
class FilUploadService {
    constructor(params) {
        this.hostingProvider = 'gcp-storage-v3';
        this.fileLimit = 10;
        this.isRequired = false;
        this._storage = storage_1.Storage;
        this._multer = multer_1.default;
        this._stream = stream_1.default;
        this.getPublicUrl = (bucketName, fileName, hostUrl = '') => this.publicUrl === ''
            ? `https://storage.googleapis.com/${bucketName}/${fileName}`
            : `${hostUrl}${this.publicUrl}/${fileName}`;
        this.UploadToGCS = (req, res, next) => {
            try {
                if (!req.files) {
                    return next();
                }
                const bucketName = this.storageBucket;
                const gcsBucket = this.gcStorage.bucket(bucketName);
                const promises = [];
                const hostUrl = 'https://' + req.get('host');
                req.files.forEach((_file, index) => {
                    const fileName = _file.originalname.toLowerCase().split(' ').join('-');
                    const gcsFileName = `${this.storageFolder}/${Date.now()}-${fileName}`;
                    const file = gcsBucket.file(gcsFileName);
                    const size = _file.size;
                    const promise = new Promise((resolve, reject) => {
                        const Stream = file.createWriteStream({
                            metadata: {
                                contentType: _file.mimetype,
                            },
                        });
                        Stream.on('error', (err) => {
                            req.files[index].cloudStorageError = err;
                            reject(err);
                        });
                        Stream.on('finish', async () => {
                            try {
                                req.files[index].cloudStorageObject = gcsFileName;
                                await file.makePublic();
                                const newFile = {
                                    fileName: _file?.cloudStorageObject?.split(`${this.storageFolder}/`)?.[1],
                                    fileUrl: this.getPublicUrl(bucketName, _file?.cloudStorageObject, hostUrl),
                                    hostingProvider: this.hostingProvider,
                                    fileType: _file.mimetype,
                                    fileSize: size,
                                };
                                req.files[index] = newFile;
                                resolve(req.files[index]);
                            }
                            catch (error) {
                                reject(error);
                            }
                        });
                        Stream.end(_file.buffer);
                    });
                    promises.push(promise);
                });
                Promise.all(promises)
                    .then((_) => {
                    next();
                })
                    .catch(next);
            }
            catch (err) {
                next(err);
            }
        };
        this.uploadMiddleware = (0, multer_1.default)({
            storage: multer_1.default.memoryStorage(),
            limits: {
                fileSize: (this.fileLimit ? this.fileLimit : 10) * 1024 * 1024,
            },
        });
        this.UploadBufferToGCSNew = async (data) => new Promise((res, rej) => {
            try {
                if (!data) {
                    throw new Error('No data found');
                }
                const bucketName = this.storageBucket;
                const gcsBucket = this.gcStorage.bucket(bucketName);
                const promises = [];
                data.forEach((_file, index) => {
                    const fileName = _file.FileName.toLowerCase().split(' ').join('-');
                    const gcsFileName = `documents/${Date.now()}-${fileName}`;
                    const file = gcsBucket.file(gcsFileName);
                    const promise = new Promise((resolve, reject) => {
                        const bufferStream = new stream_1.default.PassThrough();
                        bufferStream.end(Buffer.from(_file?.Base64Image, 'base64'));
                        bufferStream
                            .pipe(file.createWriteStream({
                            metadata: {
                                contentType: _file.FileType,
                            },
                        }))
                            .on('error', (err) => {
                            data[index].cloudStorageError = err;
                            reject(err);
                        })
                            .on('finish', async () => {
                            try {
                                data[index].cloudStorageObject = gcsFileName;
                                await file.makePublic();
                                const newFile = {
                                    fileName: _file?.cloudStorageObject?.split(`${this.storageFolder}/`)?.[1],
                                    fileUrl: this.getPublicUrl(bucketName, _file?.cloudStorageObject),
                                    hostingProvider: this.hostingProvider,
                                    fileType: '',
                                    fileSize: 0,
                                };
                                data[index] = newFile;
                                resolve(data[index]);
                            }
                            catch (error) {
                                reject(error);
                            }
                        });
                    });
                    promises.push(promise);
                });
                Promise.all(promises)
                    .then((_) => {
                    res(data);
                })
                    .catch();
            }
            catch (err) {
                throw err;
            }
        });
        this.projectId = params.projectId;
        this.storageBucket = params.storageBucket;
        this.privateKey = params.privateKey;
        this.storageFolder = params.storageFolder;
        this.fileLimit = params.fileLimit;
        this.publicUrl = params.publicUrl;
        this.gcStorage = new storage_1.Storage({
            projectId: this.projectId,
            credentials: JSON.parse(this.privateKey ?? ''),
        });
    }
}
exports.FilUploadService = FilUploadService;