@duvdu-v1/duvdu 1.1.212 → 1.1.214

package/build/middlewares/global-upload.middleware.d.ts

@@ -1,8 +1,8 @@
 import multer from 'multer';
-interface uploadOptions {
+interface UploadOptions {
     fileTypes?: string[];
     maxSize?: number;
     fileFilter?(req: Request, file: Express.Multer.File, callback: multer.FileFilterCallback): void;
 }
-export declare const globalUploadMiddleware: (folder: string, options?: uploadOptions) => multer.Multer;
+export declare const globalUploadMiddleware: (folder: string, options?: UploadOptions) => multer.Multer;
 export {};

package/build/middlewares/global-upload.middleware.js

@@ -1,21 +1,45 @@
 "use strict";
+// /* eslint-disable indent */
+// import path from 'path';
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalUploadMiddleware = void 0;
-/* eslint-disable indent */
-const path_1 = __importDefault(require("path"));
+// import multer from 'multer';
+// import { v4 } from 'uuid';
+// import { BadRequestError } from '../errors/bad-request-error';
+// interface uploadOptions {
+//   fileTypes?: string[];
+//   maxSize?: number;
+//   fileFilter?(req: Request, file: Express.Multer.File, callback: multer.FileFilterCallback): void;
+// }
+// export const globalUploadMiddleware = (folder: string, options?: uploadOptions) =>
+//   multer({
+//     storage: multer.diskStorage({
+//       destination: path.resolve(`media/${folder}`),
+//       filename(req, file, callback) {
+//         callback(null, `${v4()}.${file.originalname.split('.').at(-1)}`);
+//       },
+//     }),
+//     limits: { fileSize: options?.maxSize || 3 * 1024 * 1024 }, // 3MB
+//     fileFilter: options?.fileFilter
+//       ? (options.fileFilter as any)
+//       : function fileFilter(req, file, callback) {
+//           if (!options?.fileTypes) {
+//             if (!file.mimetype.startsWith('image'))
+//               return callback(new BadRequestError('invalid file format'));
+//             return callback(null, true);
+//           }
+//           if (options?.fileTypes?.some((type) => file.mimetype.startsWith(type)))
+//             return callback(null, true);
+//           else return callback(new BadRequestError('invalid file format'));
+//         },
+//   });
 const multer_1 = __importDefault(require("multer"));
-const uuid_1 = require("uuid");
 const bad_request_error_1 = require("../errors/bad-request-error");
 const globalUploadMiddleware = (folder, options) => (0, multer_1.default)({
-    storage: multer_1.default.diskStorage({
-        destination: path_1.default.resolve(`media/${folder}`),
-        filename(req, file, callback) {
-            callback(null, `${(0, uuid_1.v4)()}.${file.originalname.split('.').at(-1)}`);
-        },
-    }),
+    storage: multer_1.default.memoryStorage(),
     limits: { fileSize: (options === null || options === void 0 ? void 0 : options.maxSize) || 3 * 1024 * 1024 }, // 3MB
     fileFilter: (options === null || options === void 0 ? void 0 : options.fileFilter)
         ? options.fileFilter

package/build/utils/bucket.js

@@ -8,19 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bucket = void 0;
-const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const aws_sdk_1 = __importDefault(require("aws-sdk"));
 class Bucket {
@@ -39,143 +31,130 @@ class Bucket {
     }
     saveBucketFiles(folder, ...files) {
         return __awaiter(this, void 0, void 0, function* () {
-            const CHUNK_SIZE = 20 * 1024 * 1024; // 20MB chunks for better performance
-            const MAX_PARALLEL_CHUNKS = 4; // Control parallel uploads
-            yield Promise.all(files.map((file) => __awaiter(this, void 0, void 0, function* () {
-                var _a, e_1, _b, _c;
-                const filePath = path_1.default.resolve(`media/${folder}/${file.filename}`);
-                const fileSize = fs_1.default.statSync(filePath).size;
-                const contentType = this.getContentType(file.filename);
-                if (fileSize < CHUNK_SIZE) {
-                    return this.uploadSmallFile(folder, file, contentType);
-                }
-                let multipartUpload;
-                try {
-                    // Initiate multipart upload
-                    multipartUpload = yield new Promise((resolve, reject) => {
-                        this.s3.createMultipartUpload({
-                            Bucket: this.bucketName,
-                            Key: `${folder}/${file.filename}`,
-                            ContentType: contentType,
-                            ContentDisposition: 'inline',
-                            ServerSideEncryption: 'AES256',
-                        }, (err, data) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve(data);
-                        });
-                    });
-                    const uploadId = multipartUpload.UploadId;
-                    const parts = [];
-                    const fileStream = fs_1.default.createReadStream(filePath);
-                    // Prepare chunks for parallel upload
-                    const chunks = [];
-                    let currentChunk = Buffer.alloc(0);
-                    try {
-                        for (var _d = true, fileStream_1 = __asyncValues(fileStream), fileStream_1_1; fileStream_1_1 = yield fileStream_1.next(), _a = fileStream_1_1.done, !_a; _d = true) {
-                            _c = fileStream_1_1.value;
-                            _d = false;
-                            const chunk = _c;
-                            currentChunk = Buffer.concat([currentChunk, chunk]);
-                            if (currentChunk.length >= CHUNK_SIZE) {
-                                chunks.push(Buffer.from(currentChunk));
-                                currentChunk = Buffer.alloc(0);
-                            }
-                        }
+            const CHUNK_SIZE = 20 * 1024 * 1024;
+            const MAX_PARALLEL_FILES = 30;
+            const MAX_RETRIES = 3;
+            // Process files in parallel batches
+            for (let i = 0; i < files.length; i += MAX_PARALLEL_FILES) {
+                const fileBatch = files.slice(i, i + MAX_PARALLEL_FILES);
+                yield Promise.all(fileBatch.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const contentType = this.getContentType(file.filename);
+                    const fileSize = file.size;
+                    if (fileSize < CHUNK_SIZE) {
+                        return this.uploadSmallFile(folder, file, contentType);
                     }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (!_d && !_a && (_b = fileStream_1.return)) yield _b.call(fileStream_1);
+                    let multipartUpload;
+                    try {
+                        // Initiate multipart upload
+                        multipartUpload = yield new Promise((resolve, reject) => {
+                            this.s3.createMultipartUpload({
+                                Bucket: this.bucketName,
+                                Key: `${folder}/${file.filename}`,
+                                ContentType: contentType,
+                                ContentDisposition: 'inline',
+                                ServerSideEncryption: 'AES256',
+                            }, (err, data) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve(data);
+                            });
+                        });
+                        const uploadId = multipartUpload.UploadId;
+                        const parts = [];
+                        // Split buffer into chunks
+                        const buffer = file.buffer;
+                        const chunks = [];
+                        for (let i = 0; i < buffer.length; i += CHUNK_SIZE) {
+                            chunks.push(buffer.slice(i, i + CHUNK_SIZE));
                         }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    if (currentChunk.length > 0) {
-                        chunks.push(Buffer.from(currentChunk));
-                    }
-                    // Upload chunks in parallel batches
-                    for (let i = 0; i < chunks.length; i += MAX_PARALLEL_CHUNKS) {
-                        const batch = chunks.slice(i, i + MAX_PARALLEL_CHUNKS);
-                        const partUploads = batch.map((chunkBuffer, index) => {
-                            const partNumber = i + index + 1;
-                            return new Promise((resolve, reject) => {
-                                this.s3.uploadPart({
-                                    Bucket: this.bucketName,
-                                    Key: `${folder}/${file.filename}`,
-                                    PartNumber: partNumber,
-                                    UploadId: uploadId,
-                                    Body: chunkBuffer,
-                                }, (err, data) => {
-                                    if (err)
-                                        reject(err);
-                                    else
-                                        resolve({
+                        // Upload chunks
+                        const partUploads = chunks.map((chunk, index) => {
+                            const partNumber = index + 1;
+                            const uploadChunkWithRetry = (retryCount = 0) => __awaiter(this, void 0, void 0, function* () {
+                                try {
+                                    const uploadPromise = new Promise((resolve, reject) => {
+                                        this.s3.uploadPart({
+                                            Bucket: this.bucketName,
+                                            Key: `${folder}/${file.filename}`,
                                             PartNumber: partNumber,
-                                            ETag: data.ETag
+                                            UploadId: uploadId,
+                                            Body: chunk,
+                                        }, (err, data) => {
+                                            if (err)
+                                                reject(err);
+                                            else
+                                                resolve({
+                                                    PartNumber: partNumber,
+                                                    ETag: data.ETag
+                                                });
                                         });
-                                });
+                                    });
+                                    const timeoutPromise = new Promise((_, reject) => {
+                                        setTimeout(() => reject(new Error('Upload timeout')), 30000);
+                                    });
+                                    return yield Promise.race([uploadPromise, timeoutPromise]);
+                                }
+                                catch (error) {
+                                    if (retryCount < MAX_RETRIES) {
+                                        yield new Promise(resolve => setTimeout(resolve, Math.pow(2, retryCount) * 1000));
+                                        return uploadChunkWithRetry(retryCount + 1);
+                                    }
+                                    throw error;
+                                }
                             });
+                            return uploadChunkWithRetry();
                         });
                         const completedParts = yield Promise.all(partUploads);
                         parts.push(...completedParts.sort((a, b) => { var _a, _b; return ((_a = a.PartNumber) !== null && _a !== void 0 ? _a : 0) - ((_b = b.PartNumber) !== null && _b !== void 0 ? _b : 0); }));
-                    }
-                    // Complete multipart upload
-                    yield new Promise((resolve, reject) => {
-                        this.s3.completeMultipartUpload({
-                            Bucket: this.bucketName,
-                            Key: `${folder}/${file.filename}`,
-                            UploadId: uploadId,
-                            MultipartUpload: { Parts: parts }
-                        }, (err, data) => {
-                            if (err)
-                                reject(err);
-                            else
-                                resolve(data);
-                        });
-                    });
-                }
-                catch (error) {
-                    // Attempt to abort multipart upload if it fails
-                    if (multipartUpload === null || multipartUpload === void 0 ? void 0 : multipartUpload.UploadId) {
-                        yield new Promise((resolve) => {
-                            this.s3.abortMultipartUpload({
+                        // Complete multipart upload
+                        yield new Promise((resolve, reject) => {
+                            this.s3.completeMultipartUpload({
                                 Bucket: this.bucketName,
                                 Key: `${folder}/${file.filename}`,
-                                UploadId: multipartUpload.UploadId
-                            }, () => resolve(null));
+                                UploadId: uploadId,
+                                MultipartUpload: { Parts: parts }
+                            }, (err, data) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve(data);
+                            });
                         });
                     }
-                    throw error;
-                }
-            })));
+                    catch (error) {
+                        if (multipartUpload === null || multipartUpload === void 0 ? void 0 : multipartUpload.UploadId) {
+                            yield new Promise((resolve) => {
+                                this.s3.abortMultipartUpload({
+                                    Bucket: this.bucketName,
+                                    Key: `${folder}/${file.filename}`,
+                                    UploadId: multipartUpload.UploadId
+                                }, () => resolve(null));
+                            });
+                        }
+                        throw error;
+                    }
+                })));
+            }
         });
     }
     uploadSmallFile(folder, file, contentType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fileStream = fs_1.default.createReadStream(path_1.default.resolve(`media/${folder}/${file.filename}`));
-            try {
-                yield new Promise((resolve, reject) => {
-                    this.s3.putObject({
-                        Bucket: this.bucketName,
-                        Key: `${folder}/${file.filename}`,
-                        Body: fileStream,
-                        ContentDisposition: 'inline',
-                        ContentType: contentType,
-                        ServerSideEncryption: 'AES256',
-                    }, (err, data) => {
-                        fileStream.destroy();
-                        if (err)
-                            reject(err);
-                        else
-                            resolve(data);
-                    });
+            yield new Promise((resolve, reject) => {
+                this.s3.putObject({
+                    Bucket: this.bucketName,
+                    Key: `${folder}/${file.filename}`,
+                    Body: file.buffer,
+                    ContentDisposition: 'inline',
+                    ContentType: contentType,
+                    ServerSideEncryption: 'AES256',
+                }, (err, data) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(data);
                 });
-            }
-            catch (error) {
-                fileStream.destroy();
-                throw error;
-            }
+            });
         });
     }
     removeBucketFiles(...filePaths) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duvdu-v1/duvdu",
-  "version": "1.1.212",
+  "version": "1.1.214",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [