@protontech/drive-sdk 0.12.1 → 0.13.1

package/src/internal/nodes/nodesManagement.ts

@@ -312,6 +312,7 @@ export abstract class NodesManagementBase<
     async createFolder(parentNodeUid: string, folderName: string, modificationTime?: Date): Promise<TDecryptedNode> {
         validateNodeName(folderName);
 
+        const parentNode = await this.nodesAccess.getNode(parentNodeUid);
         const parentKeys = await this.nodesAccess.getNodeKeys(parentNodeUid);
         if (!parentKeys.hashKey) {
             throw new ValidationError(c('Error').t`Creating folders in non-folders is not allowed`);
@@ -338,14 +339,14 @@ export abstract class NodesManagementBase<
         });
 
         await this.nodesAccess.notifyChildCreated(parentNodeUid);
-        const node = this.generateNodeFolder(nodeUid, parentNodeUid, folderName, encryptedCrypto);
+        const node = this.generateNodeFolder(parentNode, nodeUid, folderName, encryptedCrypto);
         await this.cryptoCache.setNodeKeys(nodeUid, keys);
         return node;
     }
 
     protected abstract generateNodeFolder(
+        parentNode: TDecryptedNode,
         nodeUid: string,
-        parentUid: string,
         name: string,
         encryptedCrypto: {
             hash: string;
@@ -355,8 +356,8 @@ export abstract class NodesManagementBase<
     ): TDecryptedNode;
 
     protected generateNodeFolderBase(
+        parentNode: TDecryptedNode,
         nodeUid: string,
-        parentNodeUid: string,
         name: string,
         encryptedCrypto: {
             hash: string;
@@ -371,7 +372,7 @@ export abstract class NodesManagementBase<
 
             // Basic node metadata
             uid: nodeUid,
-            parentUid: parentNodeUid,
+            parentUid: parentNode.uid,
             type: NodeType.Folder,
             mediaType: FOLDER_MEDIA_TYPE,
             creationTime: new Date(),
@@ -381,6 +382,7 @@ export abstract class NodesManagementBase<
             isShared: false,
             isSharedPublicly: false,
             directRole: MemberRole.Inherited,
+            ownedBy: parentNode.ownedBy,
 
             // Decrypted metadata
             isStale: false,
@@ -432,8 +434,8 @@ export abstract class NodesManagementBase<
 
 export class NodesManagement extends NodesManagementBase {
     protected generateNodeFolder(
+        parentNode: DecryptedNode,
         nodeUid: string,
-        parentNodeUid: string,
         name: string,
         encryptedCrypto: {
             hash: string;
@@ -441,6 +443,6 @@ export class NodesManagement extends NodesManagementBase {
             signatureEmail: string | null;
         },
     ): DecryptedNode {
-        return this.generateNodeFolderBase(nodeUid, parentNodeUid, name, encryptedCrypto);
+        return this.generateNodeFolderBase(parentNode, nodeUid, name, encryptedCrypto);
     }
 }

package/src/internal/photos/albumsManager.ts

@@ -95,6 +95,7 @@ export class AlbumsManager {
             isShared: false,
             isSharedPublicly: false,
             directRole: MemberRole.Inherited,
+            ownedBy: rootNode.ownedBy,
 
             // Decrypted metadata
             isStale: false,

package/src/internal/photos/nodes.ts

@@ -252,8 +252,8 @@ export class PhotosNodesManagement extends NodesManagementBase<
     PhotosNodesCryptoService
 > {
     protected generateNodeFolder(
+        parentNode: DecryptedPhotoNode,
         nodeUid: string,
-        parentNodeUid: string,
         name: string,
         encryptedCrypto: {
             hash: string;
@@ -261,6 +261,6 @@ export class PhotosNodesManagement extends NodesManagementBase<
             signatureEmail: string | null;
         },
     ): DecryptedPhotoNode {
-        return this.generateNodeFolderBase(nodeUid, parentNodeUid, name, encryptedCrypto);
+        return this.generateNodeFolderBase(parentNode, nodeUid, name, encryptedCrypto);
     }
 }

package/src/internal/photos/upload.ts

@@ -1,8 +1,15 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveTelemetry, UploadMetadata, Thumbnail, AnonymousUser, FeatureFlagProvider } from '../../interface';
+import {
+    ProtonDriveTelemetry,
+    UploadMetadata,
+    Thumbnail,
+    AnonymousUser,
+    FeatureFlagProvider,
+    PhotoTag,
+} from '../../interface';
 import { DriveAPIService, drivePaths } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
-import { splitNodeRevisionUid } from '../uids';
+import { splitNodeRevisionUid, splitNodeUid } from '../uids';
 import { UploadAPIService } from '../upload/apiService';
 import { BlockVerifier } from '../upload/blockVerifier';
 import { UploadController } from '../upload/controller';
@@ -22,9 +29,8 @@ type PostCommitRevisionResponse =
 
 export type PhotoUploadMetadata = UploadMetadata & {
     captureTime?: Date;
-    mainPhotoLinkID?: string;
-    // TODO: handle tags enum in the SDK
-    tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+    mainPhotoNodeUid?: string;
+    tags?: PhotoTag[];
 };
 
 export class PhotoFileUploader extends FileUploader {
@@ -180,7 +186,7 @@ export class PhotoUploadManager extends UploadManager {
         const photo = {
             contentHash,
             captureTime: uploadMetadata.captureTime || extendedAttributes.modificationTime,
-            mainPhotoLinkID: uploadMetadata.mainPhotoLinkID,
+            mainPhotoNodeUid: uploadMetadata.mainPhotoNodeUid,
             tags: uploadMetadata.tags,
         };
         await this.photoApiService.commitDraftPhoto(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto, photo);
@@ -218,12 +224,19 @@ export class PhotoUploadAPIService extends UploadAPIService {
         photo: {
             contentHash: string;
             captureTime?: Date;
-            mainPhotoLinkID?: string;
-            // TODO: handle tags enum in the SDK
-            tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+            mainPhotoNodeUid?: string;
+            tags?: PhotoTag[];
         },
     ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
+        const { volumeId: mainPhotoVolumeId, nodeId: mainPhotoNodeId } = photo.mainPhotoNodeUid
+            ? splitNodeUid(photo.mainPhotoNodeUid)
+            : { volumeId: null, nodeId: null };
+
+        if (mainPhotoVolumeId !== null && mainPhotoVolumeId !== volumeId) {
+            throw new Error('mainPhotoNodeUid must belong to the same volume as the draft');
+        }
+
         await this.apiService.put<
             // TODO: Deprected fields but not properly marked in the types.
             Omit<PostCommitRevisionRequest, 'BlockNumber' | 'BlockList' | 'ThumbnailToken' | 'State'>,
@@ -235,7 +248,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             Photo: {
                 ContentHash: photo.contentHash,
                 CaptureTime: photo.captureTime ? Math.floor(photo.captureTime?.getTime() / 1000) : 0,
-                MainPhotoLinkID: photo.mainPhotoLinkID || null,
+                MainPhotoLinkID: mainPhotoNodeId,
                 Tags: photo.tags || [],
                 Exif: null, // Deprecated field, not used.
             },

package/src/internal/sharing/apiService.ts

@@ -79,12 +79,12 @@ type PostCreateShareResponse =
     drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
 
 type PostChangeSharePropertiesRequest = Extract<
-    drivePaths['/drive/shares/{shareID}/property']['post']['requestBody'],
+    drivePaths['/drive/shares/{shareID}/editors-can-share']['put']['requestBody'],
     { content: object }
 >['content']['application/json'];
 
 type PostChangeSharePropertiesResponse =
-    drivePaths['/drive/shares/{shareID}/property']['post']['responses']['200']['content']['application/json'];
+    drivePaths['/drive/shares/{shareID}/editors-can-share']['put']['responses']['200']['content']['application/json'];
 
 type PostInviteProtonUserRequest = Extract<
     drivePaths['/drive/v2/shares/{shareID}/invitations']['post']['requestBody'],
@@ -423,9 +423,9 @@ export class SharingAPIService {
     }
 
     async changeShareProperties(shareId: string, { editorsCanShare }: { editorsCanShare: boolean }) {
-        await this.apiService.post<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
-            `drive/shares/${shareId}/property`,
-            { EditorsCanShare: editorsCanShare },
+        await this.apiService.put<PostChangeSharePropertiesRequest, PostChangeSharePropertiesResponse>(
+            `drive/shares/${shareId}/editors-can-share`,
+            { Value: editorsCanShare },
         );
     }
 

package/src/internal/upload/apiService.ts

@@ -52,6 +52,26 @@ type PostLoadLinksMetadataRequest = Extract<
 type PostLoadLinksMetadataResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
 
+type PostSmallFileFormData = Extract<
+    Extract<
+        drivePaths['/drive/v2/volumes/{volumeID}/files/small']['post']['requestBody'],
+        { content: object }
+    >['content']['multipart/form-data'],
+    { Metadata: object }
+>;
+type PostSmallFileResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/small']['post']['responses']['200']['content']['application/json'];
+
+type PostSmallRevisionFormData = Extract<
+    Extract<
+        drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/small']['post']['requestBody'],
+        { content: object }
+    >['content']['multipart/form-data'],
+    { Metadata: object }
+>;
+type PostSmallRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/small']['post']['responses']['200']['content']['application/json'];
+
 export class UploadAPIService {
     constructor(
         protected apiService: DriveAPIService,
@@ -218,7 +238,7 @@ export class UploadAPIService {
         options: {
             armoredManifestSignature: string;
             signatureEmail: string | AnonymousUser;
-            armoredExtendedAttributes?: string;
+            armoredExtendedAttributes: string;
         },
     ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
@@ -229,7 +249,7 @@ export class UploadAPIService {
         >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`, {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
-            XAttr: options.armoredExtendedAttributes || null,
+            XAttr: options.armoredExtendedAttributes,
             Photo: null, // Only used for photos in the Photo volume.
         });
     }
@@ -285,4 +305,149 @@ export class UploadAPIService {
             link.File?.ActiveRevision?.RevisionID === revisionId
         );
     }
+
+    async uploadSmallFile(
+        parentFolderUid: string,
+        metadata: {
+            armoredEncryptedName: string;
+            hash: string;
+            mediaType: string;
+            armoredNodeKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            base64ContentKeyPacket: string;
+            armoredContentKeyPacketSignature: string;
+            armoredExtendedAttributes: string;
+            signatureEmail: string | AnonymousUser;
+        },
+        content: {
+            armoredManifestSignature: string;
+            block:
+                | {
+                      encryptedData: Uint8Array<ArrayBuffer>;
+                      armoredSignature: string;
+                      verificationToken: Uint8Array<ArrayBuffer>;
+                  }
+                | undefined;
+            thumbnails: {
+                type: ThumbnailType;
+                encryptedData: Uint8Array<ArrayBuffer>;
+            }[];
+        },
+        signal?: AbortSignal,
+    ): Promise<{ nodeUid: string; nodeRevisionUid: string }> {
+        const { volumeId, nodeId: parentNodeId } = splitNodeUid(parentFolderUid);
+
+        const metadataPayload: PostSmallFileFormData['Metadata'] = {
+            ParentLinkID: parentNodeId,
+            Name: metadata.armoredEncryptedName,
+            NameHash: metadata.hash,
+            NodePassphrase: metadata.armoredNodePassphrase,
+            NodePassphraseSignature: metadata.armoredNodePassphraseSignature,
+            SignatureEmail: metadata.signatureEmail,
+            NodeKey: metadata.armoredNodeKey,
+            MIMEType: metadata.mediaType,
+            ContentKeyPacket: metadata.base64ContentKeyPacket,
+            ContentKeyPacketSignature: metadata.armoredContentKeyPacketSignature,
+            ManifestSignature: content.armoredManifestSignature,
+            ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
+            ContentBlockVerificationToken: content.block
+                ? uint8ArrayToBase64String(content.block.verificationToken)
+                : null,
+            XAttr: metadata.armoredExtendedAttributes,
+            Photo: null, // TODO
+        };
+
+        const formData = new FormData();
+        formData.set('Metadata', new Blob([JSON.stringify(metadataPayload)], { type: 'application/json' }), 'Metadata');
+        if (content.block) {
+            formData.set('ContentBlock', new Blob([content.block.encryptedData]), 'ContentBlock');
+        }
+        for (const thumb of content.thumbnails) {
+            if (formData.get(`ThumbnailBlockType_${thumb.type}`)) {
+                throw new Error('Duplicate thumbnail types');
+            }
+            formData.set(
+                `ThumbnailBlockType_${thumb.type}`,
+                new Blob([thumb.encryptedData]),
+                `ThumbnailBlockType_${thumb.type}`,
+            );
+        }
+
+        const result = await this.apiService.postFormData<PostSmallFileResponse>(
+            `drive/v2/volumes/${volumeId}/files/small`,
+            formData,
+            signal,
+        );
+
+        return {
+            nodeUid: makeNodeUid(volumeId, result.LinkID),
+            nodeRevisionUid: makeNodeRevisionUid(volumeId, result.LinkID, result.RevisionID),
+        };
+    }
+
+    async uploadSmallRevision(
+        nodeUid: string,
+        currentRevisionUid: string,
+        metadata: {
+            signatureEmail: string | AnonymousUser | null;
+            armoredExtendedAttributes: string;
+        },
+        content: {
+            armoredManifestSignature: string;
+            block:
+                | {
+                      encryptedData: Uint8Array<ArrayBuffer>;
+                      armoredSignature: string;
+                      verificationToken: Uint8Array<ArrayBuffer>;
+                  }
+                | undefined;
+            thumbnails: {
+                type: ThumbnailType;
+                encryptedData: Uint8Array<ArrayBuffer>;
+            }[];
+        },
+        signal?: AbortSignal,
+    ): Promise<{ nodeUid: string; nodeRevisionUid: string }> {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        const { revisionId: currentRevisionId } = splitNodeRevisionUid(currentRevisionUid);
+
+        const metadataPayload: PostSmallRevisionFormData['Metadata'] = {
+            CurrentRevisionID: currentRevisionId,
+            SignatureEmail: metadata.signatureEmail,
+            ManifestSignature: content.armoredManifestSignature,
+            ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
+            ContentBlockVerificationToken: content.block
+                ? uint8ArrayToBase64String(content.block.verificationToken)
+                : null,
+            XAttr: metadata.armoredExtendedAttributes,
+        };
+
+        const formData = new FormData();
+        formData.set('Metadata', new Blob([JSON.stringify(metadataPayload)], { type: 'application/json' }), 'Metadata');
+        if (content.block) {
+            formData.set('ContentBlock', new Blob([content.block.encryptedData]), 'ContentBlock');
+        }
+        for (const thumb of content.thumbnails) {
+            if (formData.get(`ThumbnailBlockType_${thumb.type}`)) {
+                throw new Error('Duplicate thumbnail types');
+            }
+            formData.set(
+                `ThumbnailBlockType_${thumb.type}`,
+                new Blob([thumb.encryptedData]),
+                `ThumbnailBlockType_${thumb.type}`,
+            );
+        }
+
+        const result = await this.apiService.postFormData<PostSmallRevisionResponse>(
+            `drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/small`,
+            formData,
+            signal,
+        );
+
+        return {
+            nodeUid: makeNodeUid(volumeId, result.LinkID),
+            nodeRevisionUid: makeNodeRevisionUid(volumeId, result.LinkID, result.RevisionID),
+        };
+    }
 }

package/src/internal/upload/blockVerifier.ts

@@ -2,6 +2,18 @@ import { PrivateKey, SessionKey } from '../../crypto';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
 
+export async function verifyBlockWithContentKey(
+    cryptoService: UploadCryptoService,
+    contentKeyPacket: Uint8Array<ArrayBuffer>,
+    contentKeyPacketSessionKey: SessionKey,
+    encryptedBlock: Uint8Array<ArrayBuffer>,
+): Promise<{
+    verificationToken: Uint8Array<ArrayBuffer>;
+}> {
+    const verificationCode = contentKeyPacket.subarray(-32);
+    return cryptoService.verifyBlock(contentKeyPacketSessionKey, verificationCode, encryptedBlock);
+}
+
 export class BlockVerifier {
     private verificationCode?: Uint8Array<ArrayBuffer>;
     private contentKeyPacketSessionKey?: SessionKey;

package/src/internal/upload/cryptoService.ts

@@ -145,7 +145,9 @@ export class UploadCryptoService {
     }
 
     async encryptBlock(
-        verifyBlock: (encryptedBlock: Uint8Array<ArrayBuffer>) => Promise<{ verificationToken: Uint8Array<ArrayBuffer> }>,
+        verifyBlock: (
+            encryptedBlock: Uint8Array<ArrayBuffer>,
+        ) => Promise<{ verificationToken: Uint8Array<ArrayBuffer> }>,
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         block: Uint8Array<ArrayBuffer>,
         index: number,
@@ -173,24 +175,22 @@ export class UploadCryptoService {
     async commitFile(
         nodeRevisionDraftKeys: NodeRevisionDraftKeys,
         manifest: Uint8Array<ArrayBuffer>,
-        extendedAttributes?: string,
+        extendedAttributes: string,
     ): Promise<{
         armoredManifestSignature: string;
         signatureEmail: string | AnonymousUser;
-        armoredExtendedAttributes?: string;
+        armoredExtendedAttributes: string;
     }> {
         const { armoredManifestSignature } = await this.driveCrypto.signManifest(
             manifest,
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
 
-        const { armoredExtendedAttributes } = extendedAttributes
-            ? await this.driveCrypto.encryptExtendedAttributes(
-                  extendedAttributes,
-                  nodeRevisionDraftKeys.key,
-                  nodeRevisionDraftKeys.signingKeys.contentSigningKey,
-              )
-            : { armoredExtendedAttributes: undefined };
+        const { armoredExtendedAttributes } = await this.driveCrypto.encryptExtendedAttributes(
+            extendedAttributes,
+            nodeRevisionDraftKeys.key,
+            nodeRevisionDraftKeys.signingKeys.contentSigningKey,
+        );
 
         return {
             armoredManifestSignature,

package/src/internal/upload/fileUploader.ts

@@ -13,9 +13,9 @@ import { UploadTelemetry } from './telemetry';
  * and initiate the upload process for a file object or a stream.
  *
  * This class is not meant to be used directly, but rather to be extended
- * by `FileUploader` and `FileRevisionUploader`.
+ * by `FileUploader`, `FileRevisionUploader`, or `SmallFileUploader`.
  */
-abstract class Uploader {
+export abstract class Uploader {
     protected controller: UploadController;
     protected abortController: AbortController;
 
@@ -51,9 +51,9 @@ abstract class Uploader {
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
     ): Promise<UploadController> {
-        if (this.controller.promise) {
-            throw new Error(`Upload already started`);
-        }
+        this.assertNotStartedYet();
+        this.assertUniqueThumbnailTypes(thumbnails);
+
         if (!this.metadata.mediaType) {
             this.metadata.mediaType = fileObject.type;
         }
@@ -72,11 +72,24 @@ abstract class Uploader {
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
     ): Promise<UploadController> {
+        this.assertNotStartedYet();
+        this.assertUniqueThumbnailTypes(thumbnails);
+
+        this.controller.promise = this.startUpload(stream, thumbnails, onProgress);
+        return this.controller;
+    }
+
+    private assertNotStartedYet(): void {
         if (this.controller.promise) {
             throw new Error(`Upload already started`);
         }
-        this.controller.promise = this.startUpload(stream, thumbnails, onProgress);
-        return this.controller;
+    }
+
+    private assertUniqueThumbnailTypes(thumbnails: Thumbnail[]): void {
+        const uniqueThumbnailTypes = new Set(thumbnails.map(({ type }) => type));
+        if (uniqueThumbnailTypes.size !== thumbnails.length) {
+            throw new Error('Duplicate thumbnail types');
+        }
     }
 
     protected async startUpload(

package/src/internal/upload/index.test.ts

@@ -0,0 +1,99 @@
+import { FeatureFlagProvider, FeatureFlags, UploadMetadata } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { FileRevisionUploader, FileUploader } from './fileUploader';
+import { initUploadModule } from './index';
+import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
+
+const SMALL_FILE_SIZE_LIMIT = 128 * 1024; // 128 KiB, must match index.ts
+
+describe('initUploadModule - uploader selection', () => {
+    const parentFolderUid = 'parent-folder-uid';
+    const name = 'test-file.txt';
+    const nodeUid = 'node-uid';
+
+    let featureFlagProvider: jest.Mocked<FeatureFlagProvider>;
+    let uploadModule: ReturnType<typeof initUploadModule>;
+
+    beforeEach(() => {
+        const apiService = {};
+        const driveCrypto = {};
+        const sharesService = {};
+        const nodesService = {};
+        featureFlagProvider = {
+            isEnabled: jest.fn().mockResolvedValue(true),
+        };
+
+        uploadModule = initUploadModule(
+            getMockTelemetry(),
+            apiService as any,
+            driveCrypto as any,
+            sharesService as any,
+            nodesService as any,
+            featureFlagProvider as any,
+        );
+    });
+
+    describe('getFileUploader', () => {
+        it('returns SmallFileUploader when feature flag is enabled and file size is below limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(SmallFileUploader);
+        });
+
+        it('returns FileUploader when feature flag is enabled but file size exceeds limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = {
+                expectedSize: SMALL_FILE_SIZE_LIMIT,
+                mediaType: 'text/plain',
+            };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(FileUploader);
+        });
+
+        it('returns FileUploader when feature flag is disabled even for small file', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(false);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileUploader(parentFolderUid, name, metadata);
+
+            expect(uploader).toBeInstanceOf(FileUploader);
+        });
+    });
+
+    describe('getFileRevisionUploader', () => {
+        it('returns SmallFileRevisionUploader when feature flag is enabled and file size is below limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(SmallFileRevisionUploader);
+        });
+
+        it('returns FileRevisionUploader when feature flag is enabled but file size exceeds limit', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+            const metadata: UploadMetadata = {
+                expectedSize: SMALL_FILE_SIZE_LIMIT + 1,
+                mediaType: 'text/plain',
+            };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(FileRevisionUploader);
+        });
+
+        it('returns FileRevisionUploader when feature flag is disabled even for small file', async () => {
+            featureFlagProvider.isEnabled.mockResolvedValue(false);
+
+            const metadata: UploadMetadata = { expectedSize: 1, mediaType: 'text/plain' };
+            const uploader = await uploadModule.getFileRevisionUploader(nodeUid, metadata);
+
+            expect(uploader).toBeInstanceOf(FileRevisionUploader);
+        });
+    });
+});