@duvdu-v1/duvdu 1.1.203 → 1.1.204

package/build/utils/bucket.d.ts

@@ -2,8 +2,17 @@
 export declare class Bucket {
     private s3;
     private bucketName;
+    private rekognition;
     constructor();
     saveBucketFiles(folder: string, ...files: Express.Multer.File[]): Promise<void>;
+    private uploadSmallFile;
     removeBucketFiles(...filePaths: string[]): Promise<void>;
     private getContentType;
+    validateFace(imageKey: string): Promise<{
+        isValid: boolean;
+        error?: {
+            en: string;
+            ar: string;
+        };
+    }>;
 }

package/build/utils/bucket.js

@@ -8,6 +8,13 @@ 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 };
 };
@@ -24,12 +31,120 @@ class Bucket {
             region: process.env.BUCKET_REGION,
         });
         this.bucketName = process.env.BUCKET_NAME;
+        this.rekognition = new aws_sdk_1.default.Rekognition({
+            accessKeyId: process.env.BUCKET_ACESS_KEY,
+            secretAccessKey: process.env.BUCKET_SECRET_KEY,
+            region: process.env.BUCKET_REGION,
+        });
     }
     saveBucketFiles(folder, ...files) {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const file of files) {
-                const fileStream = fs_1.default.createReadStream(path_1.default.resolve(`media/${folder}/${file.filename}`));
+            const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB chunks (AWS minimum)
+            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);
+                // Use regular upload for small files (less than 15MB)
+                if (fileSize < CHUNK_SIZE * 3) {
+                    return this.uploadSmallFile(folder, file, contentType);
+                }
+                // Use multipart upload for large files
+                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, { highWaterMark: CHUNK_SIZE });
+                    let partNumber = 1;
+                    let buffer = 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;
+                            buffer = Buffer.concat([buffer, chunk]);
+                            // Upload when buffer reaches CHUNK_SIZE or it's the last chunk
+                            if (buffer.length >= CHUNK_SIZE || partNumber * CHUNK_SIZE >= fileSize) {
+                                const partData = yield new Promise((resolve, reject) => {
+                                    this.s3.uploadPart({
+                                        Bucket: this.bucketName,
+                                        Key: `${folder}/${file.filename}`,
+                                        PartNumber: partNumber,
+                                        UploadId: uploadId,
+                                        Body: buffer,
+                                    }, (err, data) => {
+                                        if (err)
+                                            reject(err);
+                                        else
+                                            resolve(data);
+                                    });
+                                });
+                                parts.push({
+                                    PartNumber: partNumber,
+                                    ETag: partData.ETag
+                                });
+                                buffer = Buffer.alloc(0);
+                                partNumber++;
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = fileStream_1.return)) yield _b.call(fileStream_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    // 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({
+                                Bucket: this.bucketName,
+                                Key: `${folder}/${file.filename}`,
+                                UploadId: multipartUpload.UploadId // Add non-null assertion here
+                            }, () => 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,
@@ -37,27 +152,39 @@ class Bucket {
                         Body: fileStream,
                         ContentDisposition: 'inline',
                         ContentType: contentType,
+                        ServerSideEncryption: 'AES256',
                     }, (err, data) => {
+                        fileStream.destroy();
                         if (err)
                             reject(err);
                         else
                             resolve(data);
                     });
                 });
-                fileStream.close();
+            }
+            catch (error) {
+                fileStream.destroy();
+                throw error;
             }
         });
     }
     removeBucketFiles(...filePaths) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield new Promise((resolve, reject) => {
-                this.s3.deleteObjects({ Bucket: this.bucketName, Delete: { Objects: filePaths.map((el) => ({ Key: el })) } }, (err, data) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(data);
+            const BATCH_SIZE = 1000; // AWS limit is 1000 objects per delete operation
+            for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
+                const batch = filePaths.slice(i, i + BATCH_SIZE);
+                yield new Promise((resolve, reject) => {
+                    this.s3.deleteObjects({
+                        Bucket: this.bucketName,
+                        Delete: { Objects: batch.map((el) => ({ Key: el })) }
+                    }, (err, data) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve(data);
+                    });
                 });
-            });
+            }
         });
     }
     getContentType(filename) {
@@ -118,5 +245,71 @@ class Bucket {
                 return 'application/octet-stream'; // Fallback for unknown types
         }
     }
+    validateFace(imageKey) {
+        var _a, _b, _c, _d, _e, _f;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const params = {
+                    Image: {
+                        S3Object: {
+                            Bucket: this.bucketName,
+                            Name: imageKey
+                        }
+                    },
+                    Attributes: ['ALL']
+                };
+                const result = yield this.rekognition.detectFaces(params).promise();
+                // Check if exactly one face is detected
+                if (!result.FaceDetails || result.FaceDetails.length === 0) {
+                    return {
+                        isValid: false,
+                        error: { en: 'No face detected in the image', ar: 'لا يوجد وجه مكتشف في الصورة' }
+                    };
+                }
+                if (result.FaceDetails.length > 1) {
+                    return {
+                        isValid: false,
+                        error: { en: 'Multiple faces detected in the image', ar: 'تم الكشف عن أكثر من وجه في الصورة' }
+                    };
+                }
+                const face = result.FaceDetails[0];
+                // Validate if it's a real human face (confidence check)
+                if (!face.Confidence || face.Confidence < 90) {
+                    return {
+                        isValid: false,
+                        error: { en: 'Low confidence in face detection', ar: 'الثقة في الكشف عن الوجه منخفضة' }
+                    };
+                }
+                // Check if eyes are open
+                const leftEyeOpen = ((_a = face.EyesOpen) === null || _a === void 0 ? void 0 : _a.Value) && ((_c = (_b = face.EyesOpen) === null || _b === void 0 ? void 0 : _b.Confidence) !== null && _c !== void 0 ? _c : 0) > 90;
+                const rightEyeOpen = ((_d = face.EyesOpen) === null || _d === void 0 ? void 0 : _d.Value) && ((_f = (_e = face.EyesOpen) === null || _e === void 0 ? void 0 : _e.Confidence) !== null && _f !== void 0 ? _f : 0) > 90;
+                if (!leftEyeOpen || !rightEyeOpen) {
+                    return {
+                        isValid: false,
+                        error: { en: 'Eyes must be open and clearly visible', ar: 'يجب أن تكون العينين مفتوحة وواضحة بشكل مباشر' }
+                    };
+                }
+                // Check face orientation (looking straight ahead)
+                const pose = face.Pose;
+                const poseThreshold = 20; // degrees
+                if (Math.abs((pose === null || pose === void 0 ? void 0 : pose.Pitch) || 0) > poseThreshold ||
+                    Math.abs((pose === null || pose === void 0 ? void 0 : pose.Roll) || 0) > poseThreshold ||
+                    Math.abs((pose === null || pose === void 0 ? void 0 : pose.Yaw) || 0) > poseThreshold) {
+                    return {
+                        isValid: false,
+                        error: { en: 'Face must be looking straight ahead', ar: 'يجب أن يكون الوجه منظراً مباشراً' }
+                    };
+                }
+                return { isValid: true };
+            }
+            catch (error) {
+                console.error('Error validating face:', error);
+                return {
+                    isValid: false,
+                    error: { en: 'Error processing image', ar: 'خطأ في معالجة الصورة' }
+                };
+            }
+        });
+    }
 }
 exports.Bucket = Bucket;

package/package.json

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