refactor: Improve and simplify attachment and file validation

src/CONST/index.ts

@@ -2271,16 +2271,24 @@ const CONST = {
     },
 
     FILE_VALIDATION_ERRORS: {
-        WRONG_FILE_TYPE: 'wrongFileType',
-        WRONG_FILE_TYPE_MULTIPLE: 'wrongFileTypeMultiple',
-        FILE_TOO_LARGE: 'fileTooLarge',
-        FILE_TOO_LARGE_MULTIPLE: 'fileTooLargeMultiple',
-        FILE_TOO_SMALL: 'fileTooSmall',
-        FILE_CORRUPTED: 'fileCorrupted',
-        FOLDER_NOT_ALLOWED: 'folderNotAllowed',
-        MAX_FILE_LIMIT_EXCEEDED: 'fileLimitExceeded',
-        PROTECTED_FILE: 'protectedFile',
-        IMAGE_DIMENSIONS_TOO_LARGE: 'imageDimensionsTooLarge',
+        SINGLE_FILE: {
+            NO_FILE_PROVIDED: 'noFileProvided',
+            FILE_INVALID: 'fileInvalid',
+            WRONG_FILE_TYPE: 'wrongFileType',
+            FILE_TOO_LARGE: 'fileTooLarge',
+            FILE_TOO_SMALL: 'fileTooSmall',
+            FILE_CORRUPTED: 'fileCorrupted',
+            PROTECTED_FILE: 'protectedFile',
+            FOLDER_NOT_ALLOWED: 'folderNotAllowed',
+            HEIC_OR_HEIF_IMAGE: 'heicOrHeifImage',
+            IMAGE_DIMENSIONS_TOO_LARGE: 'imageDimensionsTooLarge',
+        },
+        MULTIPLE_FILES: {
+            WRONG_FILE_TYPE: 'multipleAttachmentsWrongFileType',
+            FILE_TOO_LARGE: 'multipleAttachmentsFileTooLarge',
+            FOLDER_NOT_ALLOWED: 'multipleAttachmentsFolderNotAllowed',
+            MAX_FILE_LIMIT_EXCEEDED: 'multipleAttachmentsMaxFileLimitExceeded',
+        },
     },
 
     IOS_CAMERA_ROLL_ACCESS_ERROR: 'Access to photo library was denied',

src/components/AttachmentPicker/index.native.tsx

@@ -321,7 +321,7 @@ function AttachmentPicker({
         (error: unknown) => {
             const errorMessage = error instanceof Error ? error.message : undefined;
 
-            if (errorMessage === CONST.FILE_VALIDATION_ERRORS.IMAGE_DIMENSIONS_TOO_LARGE) {
+            if (errorMessage === CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.IMAGE_DIMENSIONS_TOO_LARGE) {
                 showGeneralAlert(translate('attachmentPicker.imageDimensionsTooLarge'));
             } else if (errorMessage) {
                 showGeneralAlert(errorMessage);

src/hooks/useReceiptScanDrop.tsx

@@ -39,7 +39,7 @@ function useReceiptScanDrop() {
 
     const hasOnlyPersonalPolicies = useMemo(() => hasOnlyPersonalPoliciesUtil(policies), [policies]);
 
-    const saveFileAndInitMoneyRequest = (files: FileObject[]) => {
+    const saveFileAndInitMoneyRequest = (files: FileObject | FileObject[]) => {
         const initialTransaction = initMoneyRequest({
             isFromGlobalCreate: true,
             isFromFloatingActionButton: true,
@@ -56,7 +56,9 @@ function useReceiptScanDrop() {
 
         const newReceiptFiles: ReceiptFile[] = [];
 
-        for (const [index, file] of files.entries()) {
+        const fileItems = Array.isArray(files) ? files : [files];
+
+        for (const [index, file] of fileItems.entries()) {
             const source = URL.createObjectURL(file as Blob);
             const transaction =
                 index === 0

src/libs/AttachmentValidation.ts

@@ -0,0 +1,206 @@
+import {Str} from 'expensify-common';
+import type {ValueOf} from 'type-fest';
+import CONST from '@src/CONST';
+import type {FileObject} from '@src/types/utils/Attachment';
+import {cleanFileName, hasHeicOrHeifExtension, isValidReceiptExtension, normalizeFileObject, validateImageForCorruption} from './fileDownload/FileUtils';
+
+type ValidatedFile = {
+    fileType: 'file' | 'uri';
+    source: string;
+    file: FileObject;
+};
+
+type SingleAttachmentValidResult = {
+    isValid: true;
+    validatedFile: ValidatedFile;
+};
+
+type SingleAttachmentValidationError = ValueOf<typeof CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE>;
+type SingleAttachmentInvalidResult = {
+    isValid: false;
+    error: SingleAttachmentValidationError;
+    file: FileObject;
+};
+
+type SingleAttachmentValidationResult = SingleAttachmentValidResult | SingleAttachmentInvalidResult;
+
+function isSingleAttachmentValidationResult(result: unknown): result is SingleAttachmentValidationResult {
+    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFile' in result || 'error' in result);
+}
+
+function validateAttachmentFile(file: FileObject, item?: DataTransferItem, isValidatingReceipts = false): Promise<SingleAttachmentValidationResult> {
+    if (!file) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.NO_FILE_PROVIDED, file});
+    }
+
+    const maxFileSize = isValidatingReceipts ? CONST.API_ATTACHMENT_VALIDATIONS.RECEIPT_MAX_SIZE : CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE;
+
+    const isImage = Str.isImage(file.name ?? '');
+
+    if (isImage && hasHeicOrHeifExtension(file)) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.HEIC_OR_HEIF_IMAGE, file});
+    }
+
+    if (!isImage && !hasHeicOrHeifExtension(file) && (file?.size ?? 0) > maxFileSize) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE, file});
+    }
+
+    if (isValidatingReceipts && (file?.size ?? 0) < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL, file});
+    }
+
+    if (isValidatingReceipts && !isValidReceiptExtension(file)) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.WRONG_FILE_TYPE, file});
+    }
+
+    let fileObject = file;
+    const fileConverted = file.getAsFile?.();
+    if (fileConverted) {
+        fileObject = fileConverted;
+    }
+
+    if (!fileObject) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID, file});
+    }
+
+    if (item && item.kind === 'file' && 'webkitGetAsEntry' in item) {
+        const entry = item.webkitGetAsEntry();
+
+        if (entry?.isDirectory) {
+            return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FOLDER_NOT_ALLOWED, file});
+        }
+    }
+
+    return isFileCorrupted(fileObject).then((corruptionResult) => {
+        if (!corruptionResult.isValid) {
+            return corruptionResult;
+        }
+
+        let validatedFile: ValidatedFile;
+
+        if (fileObject instanceof File) {
+            /**
+             * Cleaning file name, done here so that it covers all cases:
+             * upload, drag and drop, copy-paste
+             */
+            let updatedFile = fileObject;
+            const cleanName = cleanFileName(updatedFile.name);
+            if (updatedFile.name !== cleanName) {
+                updatedFile = new File([updatedFile], cleanName, {type: updatedFile.type});
+            }
+            const inputSource = URL.createObjectURL(updatedFile);
+            updatedFile.uri = inputSource;
+
+            validatedFile = {
+                fileType: 'file',
+                source: inputSource,
+                file: updatedFile,
+            };
+
+            return {isValid: true, validatedFile};
+        }
+
+        validatedFile = {
+            fileType: 'uri',
+            source: fileObject.uri ?? '',
+            file: fileObject,
+        };
+
+        return {isValid: true, validatedFile};
+    });
+}
+
+type MultipleAttachmentsValidResult = {
+    isValid: true;
+    validatedFiles: ValidatedFile[];
+};
+
+type MultipleAttachmentsValidationError = ValueOf<typeof CONST.FILE_VALIDATION_ERRORS.MULTIPLE_FILES>;
+type MultipleAttachmentsInvalidResult = {
+    isValid: false;
+    error: MultipleAttachmentsValidationError;
+    fileResults: SingleAttachmentValidationResult[];
+    files: FileObject[];
+};
+type MultipleAttachmentsValidationResult = MultipleAttachmentsValidResult | MultipleAttachmentsInvalidResult;
+
+function isMultipleAttachmentsValidationResult(result: unknown): result is MultipleAttachmentsValidationResult {
+    return typeof result === 'object' && result !== null && 'isValid' in result && typeof result.isValid === 'boolean' && ('validatedFiles' in result || 'fileResults' in result);
+}
+
+function validateMultipleAttachmentFiles(files: FileObject[], items?: DataTransferItem[], isValidatingReceipts = false): Promise<MultipleAttachmentsValidationResult> {
+    if (!files?.length || files.some((f) => isDirectory(f))) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.MULTIPLE_FILES.FOLDER_NOT_ALLOWED, fileResults: [], files});
+    }
+
+    if (files.length > CONST.API_ATTACHMENT_VALIDATIONS.MAX_FILE_LIMIT) {
+        return Promise.resolve({isValid: false, error: CONST.FILE_VALIDATION_ERRORS.MULTIPLE_FILES.MAX_FILE_LIMIT_EXCEEDED, fileResults: [], files});
+    }
+
+    return Promise.all(files.map((f, index) => validateAttachmentFile(f, items?.at(index), isValidatingReceipts))).then((results) => {
+        if (results.every((result) => result.isValid)) {
+            return {
+                isValid: true,
+                validatedFiles: results.map((result) => result.validatedFile),
+            };
+        }
+
+        return {
+            isValid: false,
+            error: CONST.FILE_VALIDATION_ERRORS.MULTIPLE_FILES.WRONG_FILE_TYPE,
+            fileResults: results,
+            files,
+        };
+    });
+}
+
+function isFileCorrupted(fileObject: FileObject): Promise<SingleAttachmentValidationResult> {
+    return normalizeFileObject(fileObject).then((normalizedFile) => {
+        return validateImageForCorruption(normalizedFile)
+            .then(() => {
+                if (normalizedFile.size && normalizedFile.size > CONST.API_ATTACHMENT_VALIDATIONS.MAX_SIZE) {
+                    return {
+                        isValid: false,
+                        error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_LARGE,
+                    } as SingleAttachmentInvalidResult;
+                }
+
+                if (normalizedFile.size && normalizedFile.size < CONST.API_ATTACHMENT_VALIDATIONS.MIN_SIZE) {
+                    return {
+                        isValid: false,
+                        error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_TOO_SMALL,
+                    } as SingleAttachmentInvalidResult;
+                }
+
+                return {
+                    isValid: true,
+                } as SingleAttachmentValidResult;
+            })
+            .catch(() => {
+                return {
+                    isValid: false,
+                    error: CONST.FILE_VALIDATION_ERRORS.SINGLE_FILE.FILE_INVALID,
+                } as SingleAttachmentInvalidResult;
+            });
+    });
+}
+
+function isDirectory(data: FileObject) {
+    if ('webkitGetAsEntry' in data && (data as DataTransferItem).webkitGetAsEntry()?.isDirectory) {
+        return true;
+    }
+
+    return false;
+}
+
+export {validateAttachmentFile, validateMultipleAttachmentFiles, isSingleAttachmentValidationResult, isMultipleAttachmentsValidationResult};
+export type {
+    SingleAttachmentValidationResult,
+    SingleAttachmentValidResult,
+    SingleAttachmentInvalidResult,
+    SingleAttachmentValidationError,
+    MultipleAttachmentsValidationResult,
+    MultipleAttachmentsValidResult,
+    MultipleAttachmentsInvalidResult,
+    MultipleAttachmentsValidationError,
+};

src/libs/actions/Share.ts

@@ -29,8 +29,9 @@ function addTempShareFile(file: ShareTempFile) {
  *
  * @param file Array of validated file objects to be saved
  */
-function addValidatedShareFile(file: FileObject[]) {
-    Onyx.set(ONYXKEYS.VALIDATED_FILE_OBJECT, file.at(0));
+function addValidatedShareFile(file: FileObject | FileObject[]) {
+    const fileItems = Array.isArray(file) ? file : [file];
+    Onyx.set(ONYXKEYS.VALIDATED_FILE_OBJECT, fileItems.at(0));
 }
 
 /**