@protontech/drive-sdk 0.14.0 → 0.14.2

package/src/internal/sharing/events.ts

@@ -1,13 +1,14 @@
 import { Logger } from '../../interface';
 import { DriveEvent, DriveEventType } from '../events';
 import { SharingCache } from './cache';
-import { SharesService } from './interface';
+import { NodesService, SharesService } from './interface';
 
 export class SharingEventHandler {
     constructor(
         private logger: Logger,
         private cache: SharingCache,
         private shares: SharesService,
+        private nodesService: NodesService,
     ) {}
 
     /**
@@ -26,23 +27,59 @@ export class SharingEventHandler {
      */
     async handleDriveEvent(event: DriveEvent) {
         try {
-            if (event.type === DriveEventType.SharedWithMeUpdated) {
-                await this.cache.setSharedWithMeNodeUids(undefined);
-                return;
-            }
+            await this.handleSharedWithMeNodeUidsLoaded(event);
             await this.handleSharedByMeNodeUidsLoaded(event);
         } catch (error: unknown) {
-            this.logger.error(`Skipping shared by me node cache update`, error);
+            this.logger.error(`Skipping sharing cache update`, error);
         }
     }
 
-    private async handleSharedByMeNodeUidsLoaded(event: DriveEvent) {
-        if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
-            await this.cache.setSharedWithMeNodeUids(undefined);
+    private async handleSharedWithMeNodeUidsLoaded(event: DriveEvent) {
+        if (
+            ![DriveEventType.SharedWithMeUpdated, DriveEventType.TreeRefresh, DriveEventType.TreeRemove].includes(
+                event.type,
+            )
+        ) {
             return;
         }
 
-        if (![DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeDeleted].includes(event.type)) {
+        // When user changes the membership (permissions) for a user, the
+        // backend emits both NodeUpdated and SharedWithMeUpdated events.
+        // Ideally, the SDK doesn't have to refresh all the shared nodes,
+        // only those that were changed via the NodeUpdated event. However,
+        // the client very likely will not be subscribed to all shared volumes.
+        // When the client only lists the list itself and not the trees, it
+        // is still required to refresh all the nodes to be sure to have the
+        // latest state.
+        // The sharing module doesn't have access to the nodes cache, thus
+        // it notifies the nodes via the service. If this fails, we need to
+        // log it, but it should not block the event handling. The node might
+        // be wrong at the "shared with me" listing, but it will be eventually
+        // updated once the user opens the volume tree and client processes
+        // the events for that volume.
+        // Ideally, in the future, the Drive API provides a custom event with
+        // indication of what node was added or removed or updated, instead
+        // of emitting destructive SharedWithMeUpdated event.
+        const hasSharedWithMeLoaded = await this.cache.hasSharedWithMeNodeUidsLoaded();
+        if (event.type === DriveEventType.SharedWithMeUpdated && hasSharedWithMeLoaded) {
+            try {
+                const sharedWithMeNodeUids = await this.cache.getSharedWithMeNodeUids();
+                this.logger.debug(`Shared with me updated, notifying ${sharedWithMeNodeUids.length} nodes`);
+                for (const nodeUid of sharedWithMeNodeUids) {
+                    await this.nodesService.notifyNodeChanged(nodeUid);
+                }
+            } catch (error: unknown) {
+                this.logger.error(`Skipping shared with me node cache update`, error);
+            }
+        }
+
+        await this.cache.setSharedWithMeNodeUids(undefined);
+    }
+
+    private async handleSharedByMeNodeUidsLoaded(event: DriveEvent) {
+        if (
+            ![DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeDeleted].includes(event.type)
+        ) {
             return;
         }
 

package/src/internal/sharing/index.ts

@@ -48,6 +48,7 @@ export function initSharingModule(
         telemetry.getLogger('sharing-event-handler'),
         cache,
         sharesService,
+        nodesService,
     );
 
     return {

package/src/internal/sharingPublic/session/index.ts

@@ -1 +1,2 @@
 export { SharingPublicSessionManager } from './manager';
+export { SharingPublicLinkSession } from './session';

package/src/internal/sharingPublic/session/manager.ts

@@ -87,6 +87,7 @@ export class SharingPublicSessionManager {
         shareKey: PrivateKey;
         rootUid: string;
         publicRole: MemberRole;
+        session: SharingPublicLinkSession;
     }> {
         let info = this.infosPerToken.get(token);
         if (!info) {
@@ -105,6 +106,7 @@ export class SharingPublicSessionManager {
             shareKey,
             rootUid,
             publicRole: permissionsToMemberRole(this.logger, encryptedShare.publicPermissions),
+            session,
         };
     }
 

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

@@ -129,6 +129,7 @@ describe('FileUploader', () => {
             'name',
             metadata,
             onFinish,
+            () => Promise.resolve(false),
             abortController.signal,
         );
 

package/src/internal/upload/fileUploader.ts

@@ -5,6 +5,7 @@ import { UploadController } from './controller';
 import { UploadCryptoService } from './cryptoService';
 import { NodeRevisionDraft } from './interface';
 import { UploadManager } from './manager';
+import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
 import { StreamUploader } from './streamUploader';
 import { UploadTelemetry } from './telemetry';
 
@@ -26,6 +27,7 @@ export abstract class Uploader {
         protected manager: UploadManager,
         protected metadata: UploadMetadata,
         protected onFinish: () => void,
+        protected shouldUseSmallFileUpload: (expectedSize: number) => Promise<boolean>,
         protected signal?: AbortSignal,
     ) {
         this.telemetry = telemetry;
@@ -34,6 +36,7 @@ export abstract class Uploader {
         this.manager = manager;
         this.metadata = metadata;
         this.onFinish = onFinish;
+        this.shouldUseSmallFileUpload = shouldUseSmallFileUpload;
 
         this.signal = signal;
         this.abortController = new AbortController();
@@ -97,10 +100,28 @@ export abstract class Uploader {
         thumbnails: Thumbnail[],
         onProgress?: (uploadedBytes: number) => void,
     ): Promise<{ nodeRevisionUid: string; nodeUid: string }> {
+        const expectedEncryptedTotalSize = this.getExpectedEncryptedTotalSize(thumbnails);
+        if (await this.shouldUseSmallFileUpload(expectedEncryptedTotalSize)) {
+            return this.initSmallFileUploader(stream, thumbnails, onProgress);
+        }
+
         const uploader = await this.initStreamUploader();
         return uploader.start(stream, thumbnails, onProgress);
     }
 
+    private getExpectedEncryptedTotalSize(thumbnails: Thumbnail[]): number {
+        const thumbnailSize = thumbnails.reduce((acc, thumbnail) => acc + thumbnail.thumbnail.length, 0);
+        const totalSize = this.metadata.expectedSize + thumbnailSize;
+        const expectedEncryptedTotalSize = totalSize * 1.1; // 10% margin for encryption overhead
+        return expectedEncryptedTotalSize;
+    }
+
+    protected abstract initSmallFileUploader(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<{ nodeRevisionUid: string; nodeUid: string }>;
+
     protected async initStreamUploader(): Promise<StreamUploader> {
         const { revisionDraft, blockVerifier } = await this.createRevisionDraft();
 
@@ -154,9 +175,10 @@ export class FileUploader extends Uploader {
         private name: string,
         metadata: UploadMetadata,
         onFinish: () => void,
+        protected shouldUseSmallFileUpload: (expectedSize: number) => Promise<boolean>,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, shouldUseSmallFileUpload, signal);
 
         this.parentFolderUid = parentFolderUid;
         this.name = name;
@@ -192,6 +214,24 @@ export class FileUploader extends Uploader {
     protected async deleteRevisionDraft(revisionDraft: NodeRevisionDraft): Promise<void> {
         await this.manager.deleteDraftNode(revisionDraft.nodeUid);
     }
+
+    protected async initSmallFileUploader(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<{ nodeRevisionUid: string; nodeUid: string }> {
+        const uploader = new SmallFileUploader(
+            this.telemetry,
+            this.cryptoService,
+            this.manager,
+            this.metadata,
+            this.onFinish,
+            this.signal,
+            this.parentFolderUid,
+            this.name,
+        );
+        return uploader.upload(stream, thumbnails, onProgress);
+    }
 }
 
 /**
@@ -206,9 +246,10 @@ export class FileRevisionUploader extends Uploader {
         private nodeUid: string,
         metadata: UploadMetadata,
         onFinish: () => void,
+        protected shouldUseSmallFileUpload: (expectedSize: number) => Promise<boolean>,
         signal?: AbortSignal,
     ) {
-        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, signal);
+        super(telemetry, apiService, cryptoService, manager, metadata, onFinish, shouldUseSmallFileUpload, signal);
 
         this.nodeUid = nodeUid;
     }
@@ -243,4 +284,21 @@ export class FileRevisionUploader extends Uploader {
     protected async deleteRevisionDraft(revisionDraft: NodeRevisionDraft): Promise<void> {
         await this.manager.deleteDraftRevision(revisionDraft.nodeRevisionUid);
     }
+
+    protected async initSmallFileUploader(
+        stream: ReadableStream,
+        thumbnails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<{ nodeRevisionUid: string; nodeUid: string }> {
+        const uploader = new SmallFileRevisionUploader(
+            this.telemetry,
+            this.cryptoService,
+            this.manager,
+            this.metadata,
+            this.onFinish,
+            this.signal,
+            this.nodeUid,
+        );
+        return uploader.upload(stream, thumbnails, onProgress);
+    }
 }

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

@@ -1,18 +1,23 @@
-import { FeatureFlagProvider, FeatureFlags, UploadMetadata } from '../../interface';
+import { FeatureFlagProvider, ThumbnailType, UploadMetadata } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
-import { FileRevisionUploader, FileUploader } from './fileUploader';
+import { FileRevisionUploader, FileUploader, Uploader } from './fileUploader';
 import { initUploadModule } from './index';
-import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
 
-const SMALL_FILE_SIZE_LIMIT = 128 * 1024; // 128 KiB, must match index.ts
+const RAW_SMALL_FILE_SIZE_LIMIT = (128 * 1024) / 1.1; // 128 KiB, must match index.ts
 
-describe('initUploadModule - uploader selection', () => {
+describe('initUploadModule', () => {
     const parentFolderUid = 'parent-folder-uid';
     const name = 'test-file.txt';
     const nodeUid = 'node-uid';
 
     let featureFlagProvider: jest.Mocked<FeatureFlagProvider>;
     let uploadModule: ReturnType<typeof initUploadModule>;
+    let initSmallFileSpy: jest.SpyInstance;
+    let initSmallRevisionSpy: jest.SpyInstance;
+    let initStreamSpy: jest.SpyInstance;
+
+    let stream: ReadableStream;
+    const thumbnail100k = { type: ThumbnailType.Type1, thumbnail: new Uint8Array(100_000) };
 
     beforeEach(() => {
         const apiService = {};
@@ -31,69 +36,122 @@ describe('initUploadModule - uploader selection', () => {
             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);
+        initSmallFileSpy = jest.spyOn(FileUploader.prototype as any, 'initSmallFileUploader').mockResolvedValue({
+            nodeRevisionUid: 'revision-uid',
+            nodeUid: 'node-uid',
         });
-
-        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);
+        initSmallRevisionSpy = jest
+            .spyOn(FileRevisionUploader.prototype as any, 'initSmallFileUploader')
+            .mockResolvedValue({
+                nodeRevisionUid: 'revision-uid',
+                nodeUid: 'node-uid',
+            });
+        initStreamSpy = jest.spyOn(Uploader.prototype as any, 'initStreamUploader').mockResolvedValue({
+            start: jest.fn().mockResolvedValue({
+                nodeRevisionUid: 'revision-uid',
+                nodeUid: 'node-uid',
+            }),
+        } as any);
+
+        stream = new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
         });
     });
 
-    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);
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
 
-            expect(uploader).toBeInstanceOf(FileRevisionUploader);
+    async function drainUpload(controller: { completion(): Promise<unknown> }) {
+        await controller.completion();
+    }
+
+    const suites = [
+        {
+            method: 'getFileUploader',
+            getUploader: (metadata: UploadMetadata) => uploadModule.getFileUploader(parentFolderUid, name, metadata),
+            expect: (option: 'small' | 'stream') => {
+                if (option === 'stream') {
+                    expect(initStreamSpy).toHaveBeenCalled();
+                    expect(initSmallFileSpy).not.toHaveBeenCalled();
+                    expect(initSmallRevisionSpy).not.toHaveBeenCalled();
+                } else {
+                    expect(initSmallFileSpy).toHaveBeenCalled();
+                    expect(initStreamSpy).not.toHaveBeenCalled();
+                    expect(initSmallRevisionSpy).not.toHaveBeenCalled();
+                }
+            },
+        },
+        {
+            method: 'getFileRevisionUploader',
+            getUploader: (metadata: UploadMetadata) => uploadModule.getFileRevisionUploader(nodeUid, metadata),
+            expect: (option: 'small' | 'stream') => {
+                if (option === 'stream') {
+                    expect(initStreamSpy).toHaveBeenCalled();
+                    expect(initSmallFileSpy).not.toHaveBeenCalled();
+                    expect(initSmallRevisionSpy).not.toHaveBeenCalled();
+                } else {
+                    expect(initSmallRevisionSpy).toHaveBeenCalled();
+                    expect(initSmallFileSpy).not.toHaveBeenCalled();
+                    expect(initStreamSpy).not.toHaveBeenCalled();
+                }
+            },
+        },
+    ];
+    for (const suite of suites) {
+        describe(suite.method, () => {
+            it('uses stream path 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 suite.getUploader(metadata);
+                await drainUpload(await uploader.uploadFromStream(stream, []));
+
+                suite.expect('stream');
+            });
+
+            it('uses small-file path when flag is on and encrypted total size is below cap', async () => {
+                featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+                const metadata: UploadMetadata = { expectedSize: 100, mediaType: 'text/plain' };
+                const uploader = await suite.getUploader(metadata);
+                await drainUpload(await uploader.uploadFromStream(stream, []));
+
+                suite.expect('small');
+            });
+
+            it('uses small-file path when flag is on and encrypted total size with thumbnails is below cap', async () => {
+                featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+                const metadata: UploadMetadata = { expectedSize: 100, mediaType: 'image/jpeg' };
+                const uploader = await suite.getUploader(metadata);
+                await drainUpload(await uploader.uploadFromStream(stream, [thumbnail100k]));
+
+                suite.expect('small');
+            });
+
+            it('uses stream path when feature flag is enabled but raw file size exceeds limit', async () => {
+                featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+                const metadata: UploadMetadata = { expectedSize: RAW_SMALL_FILE_SIZE_LIMIT, mediaType: 'text/plain' };
+                const uploader = await suite.getUploader(metadata);
+                await drainUpload(await uploader.uploadFromStream(stream, []));
+
+                suite.expect('stream');
+            });
+
+            it('uses stream path when thumbnail bytes push encrypted total size with thumbnail exceeds limit', async () => {
+                featureFlagProvider.isEnabled.mockResolvedValue(true);
+
+                const metadata: UploadMetadata = { expectedSize: 100_000, mediaType: 'image/jpeg' };
+                const uploader = await suite.getUploader(metadata);
+                await drainUpload(await uploader.uploadFromStream(stream, [thumbnail100k]));
+
+                suite.expect('stream');
+            });
         });
-    });
+    }
 });

package/src/internal/upload/index.ts

@@ -8,7 +8,6 @@ import { FileUploader as FileUploaderClass, FileRevisionUploader } from './fileU
 import { NodesService, SharesService } from './interface';
 import { UploadManager } from './manager';
 import { UploadQueue } from './queue';
-import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
 import { UploadTelemetry } from './telemetry';
 
 const SMALL_FILE_SIZE_LIMIT = 128 * 1024; // 128 KiB
@@ -38,13 +37,13 @@ export function initUploadModule(
 
     const queue = new UploadQueue();
 
-    async function useSmallFileUpload(metadata: UploadMetadata): Promise<boolean> {
+    async function shouldUseSmallFileUpload(expectedSize: number): Promise<boolean> {
         const isEnabled =
             allowSmallFileUpload && (await featureFlagProvider.isEnabled(FeatureFlags.DriveSmallFileUpload));
         if (!isEnabled) {
             return false;
         }
-        return metadata.expectedSize < SMALL_FILE_SIZE_LIMIT;
+        return expectedSize < SMALL_FILE_SIZE_LIMIT;
     }
 
     /**
@@ -66,20 +65,6 @@ export function initUploadModule(
             queue.releaseCapacity(metadata.expectedSize);
         };
 
-        if (await useSmallFileUpload(metadata)) {
-            return new SmallFileUploader(
-                uploadTelemetry,
-                api,
-                cryptoService,
-                manager,
-                metadata,
-                onFinish,
-                signal,
-                parentFolderUid,
-                name,
-            );
-        }
-
         return new FileUploaderClass(
             uploadTelemetry,
             api,
@@ -89,6 +74,7 @@ export function initUploadModule(
             name,
             metadata,
             onFinish,
+            shouldUseSmallFileUpload,
             signal,
         );
     }
@@ -111,19 +97,6 @@ export function initUploadModule(
             queue.releaseCapacity(metadata.expectedSize);
         };
 
-        if (await useSmallFileUpload(metadata)) {
-            return new SmallFileRevisionUploader(
-                uploadTelemetry,
-                api,
-                cryptoService,
-                manager,
-                metadata,
-                onFinish,
-                signal,
-                nodeUid,
-            );
-        }
-
         return new FileRevisionUploader(
             uploadTelemetry,
             api,
@@ -132,6 +105,7 @@ export function initUploadModule(
             nodeUid,
             metadata,
             onFinish,
+            shouldUseSmallFileUpload,
             signal,
         );
     }