@protontech/drive-sdk 0.14.7 → 0.14.8

package/src/internal/nodes/apiService.ts

@@ -851,6 +851,7 @@ function transformRevisionResponse(
         signatureEmail: revision.SignatureEmail || undefined,
         armoredExtendedAttributes: revision.XAttr || undefined,
         thumbnails: revision.Thumbnails?.map((thumbnail) => transformThumbnail(volumeId, nodeId, thumbnail)) || [],
+        sha1Verified: revision.ChecksumVerified,
     };
 }
 

package/src/internal/nodes/cache.test.ts

@@ -123,6 +123,7 @@ describe('nodesCache', () => {
             claimedSize: 100,
             claimedDigests: {
                 sha1: 'hash',
+                sha1Verified: true,
             },
             claimedBlockSizes: [100],
             claimedAdditionalMetadata: {

package/src/internal/nodes/cryptoService.ts

@@ -509,6 +509,7 @@ export class NodesCryptoService {
             contentAuthor,
             extendedAttributes,
             thumbnails: encryptedRevision.thumbnails,
+            sha1Verified: encryptedRevision.sha1Verified,
         };
     }
 

package/src/internal/nodes/interface.ts

@@ -181,11 +181,13 @@ export type Thumbnail = {
 export interface EncryptedRevision extends BaseRevision {
     signatureEmail?: string;
     armoredExtendedAttributes?: string;
+    sha1Verified?: boolean;
 }
 
 export interface DecryptedUnparsedRevision extends BaseRevision {
     contentAuthor: Author;
     extendedAttributes?: string;
+    sha1Verified?: boolean;
 }
 
 export interface DecryptedRevision extends Revision {

package/src/internal/nodes/nodesAccess.ts

@@ -549,6 +549,10 @@ export function parseNode(logger: Logger, unparsedNode: DecryptedUnparsedNode):
                       contentAuthor: unparsedNode.activeRevision.value.contentAuthor,
                       thumbnails: unparsedNode.activeRevision.value.thumbnails,
                       ...extendedAttributes,
+                      claimedDigests: {
+                          ...extendedAttributes?.claimedDigests,
+                          sha1Verified: unparsedNode.activeRevision.value.sha1Verified || false,
+                      },
                   }),
             folder: undefined,
             treeEventScopeId,

package/src/internal/nodes/nodesRevisions.ts

@@ -36,6 +36,10 @@ export class NodesRevisons {
         return {
             ...revision,
             ...extendedAttributes,
+            claimedDigests: {
+                ...extendedAttributes?.claimedDigests,
+                sha1Verified: revision.sha1Verified || false,
+            },
         };
     }
 
@@ -53,6 +57,10 @@ export class NodesRevisons {
             yield {
                 ...revision,
                 ...extendedAttributes,
+                claimedDigests: {
+                    ...extendedAttributes?.claimedDigests,
+                    sha1Verified: revision.sha1Verified || false,
+                },
             };
         }
     }

package/src/internal/photos/albumsManager.test.ts

@@ -293,6 +293,47 @@ describe('Albums', () => {
         });
     });
 
+    describe('iterateAlbumUids', () => {
+        it('yields album uids and patches metadata into cache', async () => {
+            const album1 = {
+                albumUid: 'volumeId~album1',
+                photoCount: 3,
+                coverNodeUid: 'volumeId~cover1',
+                lastActivityTime: new Date('2024-01-01T00:00:00.000Z'),
+            };
+            const album2 = {
+                albumUid: 'volumeId~album2',
+                photoCount: 0,
+                coverNodeUid: undefined,
+                lastActivityTime: new Date('2024-02-01T00:00:00.000Z'),
+            };
+
+            apiService.iterateAlbums = jest.fn().mockImplementation(async function* () {
+                yield album1;
+                yield album2;
+            });
+            nodesService.updateAlbumMetadataCache = jest.fn().mockResolvedValue(undefined);
+
+            const uids: string[] = [];
+            for await (const uid of albums.iterateAlbumUids()) {
+                uids.push(uid);
+            }
+
+            expect(uids).toEqual(['volumeId~album1', 'volumeId~album2']);
+            expect(nodesService.updateAlbumMetadataCache).toHaveBeenCalledTimes(2);
+            expect(nodesService.updateAlbumMetadataCache).toHaveBeenCalledWith('volumeId~album1', {
+                photoCount: 3,
+                coverNodeUid: 'volumeId~cover1',
+                lastActivityTime: album1.lastActivityTime,
+            });
+            expect(nodesService.updateAlbumMetadataCache).toHaveBeenCalledWith('volumeId~album2', {
+                photoCount: 0,
+                coverNodeUid: undefined,
+                lastActivityTime: album2.lastActivityTime,
+            });
+        });
+    });
+
     describe('removePhotos', () => {
         it('notifies nodes service only for successfully removed photos', async () => {
             apiService.removePhotosFromAlbum = jest.fn().mockImplementation(async function* () {

package/src/internal/photos/albumsManager.ts

@@ -53,6 +53,15 @@ export class AlbumsManager {
         const { volumeId } = await this.photoShares.getRootIDs();
 
         for await (const album of this.apiService.iterateAlbums(volumeId, signal)) {
+            // Patch fresh album metadata into the node cache so that the subsequent
+            // iterateNodes call returns up-to-date photoCount/coverNodeUid without
+            // an extra API round-trip. The fresh data comes from the /albums endpoint
+            // which always reflects the current state.
+            void this.nodesService.updateAlbumMetadataCache(album.albumUid, {
+                photoCount: album.photoCount,
+                coverNodeUid: album.coverNodeUid,
+                lastActivityTime: album.lastActivityTime,
+            });
             yield album.albumUid;
         }
     }

package/src/internal/photos/apiService.ts

@@ -264,7 +264,12 @@ export class PhotosAPIService {
         );
 
         return response.DuplicateHashes.map((duplicate) => {
-            if (!duplicate.Hash || !duplicate.ContentHash || duplicate.LinkState !== 1 /* Active */) {
+            if (
+                !duplicate.Hash ||
+                !duplicate.ContentHash ||
+                !duplicate.LinkID ||
+                duplicate.LinkState !== 1 /* Active */
+            ) {
                 return undefined;
             }
             return {

package/src/internal/photos/nodes.test.ts

@@ -3,6 +3,7 @@ import { NodeType, MemberRole } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { getMockTelemetry } from '../../tests/telemetry';
 import { DriveAPIService } from '../apiService';
+import { DecryptedPhotoNode } from './interface';
 import { PhotosNodesAPIService, PhotosNodesCache, PhotosNodesAccess, PhotosNodesCryptoService } from './nodes';
 
 function generateAPINode() {
@@ -266,6 +267,47 @@ describe('PhotosNodesAccess', () => {
         });
     });
 
+    describe('updateAlbumMetadataCache', () => {
+        let access: PhotosNodesAccess;
+        let mockCache: { getNode: jest.Mock; setNode: jest.Mock };
+
+        beforeEach(() => {
+            mockCache = { getNode: jest.fn(), setNode: jest.fn() };
+            access = new PhotosNodesAccess(
+                getMockTelemetry(),
+                // @ts-expect-error Mocking for testing purposes
+                {},
+                mockCache,
+                { getNodeKeys: jest.fn().mockRejectedValue(new Error()) },
+                {},
+                {},
+            );
+        });
+
+        it('updates album metadata in cache', async () => {
+            const existing = { uid: 'v~album1', type: NodeType.Album, album: { photoCount: 1, coverPhotoNodeUid: 'v~old', lastActivityTime: new Date('2024-01-01') } } as DecryptedPhotoNode;
+            mockCache.getNode.mockResolvedValue(existing);
+
+            await access.updateAlbumMetadataCache('v~album1', { photoCount: 5, coverNodeUid: 'v~new', lastActivityTime: new Date('2024-06-01') });
+
+            expect(mockCache.setNode).toHaveBeenCalledWith(expect.objectContaining({
+                album: { photoCount: 5, coverPhotoNodeUid: 'v~new', lastActivityTime: new Date('2024-06-01') },
+            }));
+        });
+
+        it('does nothing when node is not in cache', async () => {
+            mockCache.getNode.mockRejectedValue(new Error('Entity not found'));
+            await expect(access.updateAlbumMetadataCache('v~missing', { photoCount: 3, coverNodeUid: undefined, lastActivityTime: new Date() })).resolves.toBeUndefined();
+            expect(mockCache.setNode).not.toHaveBeenCalled();
+        });
+
+        it('does nothing when cached node has no album field', async () => {
+            mockCache.getNode.mockResolvedValue({ uid: 'v~folder1', type: NodeType.Folder } as DecryptedPhotoNode);
+            await access.updateAlbumMetadataCache('v~folder1', { photoCount: 2, coverNodeUid: undefined, lastActivityTime: new Date() });
+            expect(mockCache.setNode).not.toHaveBeenCalled();
+        });
+    });
+
     describe('parseNode', () => {
         it('should keep photo type and add photo object', async () => {
             const telemetry = getMockTelemetry();

package/src/internal/photos/nodes.ts

@@ -237,6 +237,35 @@ export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, Decry
 
         return parseNodeBase(this.logger, unparsedNode);
     }
+
+    /**
+     * Update album metadata fields in the cache without invalidating the node.
+     * Used by iterateAlbumUids to patch fresh API data (photoCount, coverNodeUid,
+     * lastActivityTime) into already-cached nodes so iterateNodes doesn't re-fetch
+     * the full node just to get up-to-date album attributes.
+     */
+    async updateAlbumMetadataCache(
+        albumUid: string,
+        metadata: { photoCount: number; coverNodeUid?: string; lastActivityTime: Date },
+    ): Promise<void> {
+        try {
+            const cached = await this.cache.getNode(albumUid);
+            if (!cached?.album) {
+                return;
+            }
+            await this.cache.setNode({
+                ...cached,
+                album: {
+                    ...cached.album,
+                    photoCount: metadata.photoCount,
+                    coverPhotoNodeUid: metadata.coverNodeUid,
+                    lastActivityTime: metadata.lastActivityTime,
+                },
+            });
+        } catch {
+            // Cache miss is fine — node will be fetched fresh by iterateNodes anyway.
+        }
+    }
 }
 
 export class PhotosNodesCryptoService extends NodesCryptoService {

package/src/internal/photos/upload.ts

@@ -128,7 +128,7 @@ export class PhotoStreamUploader extends StreamUploader {
 
     async commitFile(thumbnails: Thumbnail[]) {
         const digests = this.digests.digests();
-        this.verifyIntegrity(thumbnails, digests);
+        const integrityInfo = this.verifyIntegrity(thumbnails, digests);
 
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
@@ -142,6 +142,7 @@ export class PhotoStreamUploader extends StreamUploader {
             await this.getManifest(),
             extendedAttributes,
             this.photoMetadata,
+            integrityInfo,
         );
     }
 }
@@ -174,6 +175,7 @@ export class PhotoUploadManager extends UploadManager {
             };
         },
         uploadMetadata: PhotoUploadMetadata,
+        integrityInfo: { checksumVerified: boolean },
     ): Promise<void> {
         if (!nodeRevisionDraft.parentNodeKeys) {
             throw new Error('Parent node keys are required for photo upload');
@@ -201,7 +203,14 @@ export class PhotoUploadManager extends UploadManager {
             mainPhotoNodeUid: uploadMetadata.mainPhotoNodeUid,
             tags: uploadMetadata.tags,
         };
-        await this.photoApiService.commitDraftPhoto(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto, photo);
+        await this.photoApiService.commitDraftPhoto(
+            nodeRevisionDraft.nodeRevisionUid,
+            {
+                ...nodeCommitCrypto,
+                ...integrityInfo,
+            },
+            photo,
+        );
         await this.notifyNodeUploaded(nodeRevisionDraft);
     }
 }
@@ -232,6 +241,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             armoredManifestSignature: string;
             signatureEmail: string | AnonymousUser;
             armoredExtendedAttributes?: string;
+            checksumVerified?: boolean;
         },
         photo: {
             contentHash: string;
@@ -257,6 +267,7 @@ export class PhotoUploadAPIService extends UploadAPIService {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
             XAttr: options.armoredExtendedAttributes || null,
+            ChecksumVerified: options.checksumVerified || false,
             Photo: {
                 ContentHash: photo.contentHash,
                 CaptureTime: photo.captureTime ? Math.floor(photo.captureTime?.getTime() / 1000) : 0,

package/src/internal/upload/apiService.ts

@@ -239,6 +239,7 @@ export class UploadAPIService {
             armoredManifestSignature: string;
             signatureEmail: string | AnonymousUser;
             armoredExtendedAttributes: string;
+            checksumVerified?: boolean;
         },
     ): Promise<void> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
@@ -250,6 +251,7 @@ export class UploadAPIService {
             ManifestSignature: options.armoredManifestSignature,
             SignatureAddress: options.signatureEmail,
             XAttr: options.armoredExtendedAttributes,
+            ChecksumVerified: options.checksumVerified || false,
             Photo: null, // Only used for photos in the Photo volume.
         });
     }
@@ -322,6 +324,7 @@ export class UploadAPIService {
         },
         content: {
             armoredManifestSignature: string;
+            checksumVerified?: boolean;
             block:
                 | {
                       encryptedData: Uint8Array<ArrayBuffer>;
@@ -355,6 +358,7 @@ export class UploadAPIService {
                 ? uint8ArrayToBase64String(content.block.verificationToken)
                 : null,
             XAttr: metadata.armoredExtendedAttributes,
+            ChecksumVerified: content.checksumVerified || false,
             Photo: null, // TODO
         };
 
@@ -395,6 +399,7 @@ export class UploadAPIService {
         },
         content: {
             armoredManifestSignature: string;
+            checksumVerified?: boolean;
             block:
                 | {
                       encryptedData: Uint8Array<ArrayBuffer>;
@@ -421,6 +426,7 @@ export class UploadAPIService {
                 ? uint8ArrayToBase64String(content.block.verificationToken)
                 : null,
             XAttr: metadata.armoredExtendedAttributes,
+            ChecksumVerified: content.checksumVerified || false,
         };
 
         const formData = new FormData();

package/src/internal/upload/manager.ts

@@ -154,6 +154,7 @@ export class UploadManager {
         commitPayload: {
             armoredManifestSignature: string;
             armoredExtendedAttributes: string;
+            checksumVerified?: boolean;
         },
         encryptedBlock:
             | {
@@ -182,6 +183,7 @@ export class UploadManager {
                 },
                 {
                     armoredManifestSignature: commitPayload.armoredManifestSignature,
+                    checksumVerified: commitPayload.checksumVerified,
                     block: encryptedBlock
                         ? {
                               encryptedData: encryptedBlock.encryptedData,
@@ -387,6 +389,7 @@ export class UploadManager {
             };
         },
         additionalExtendedAttributes?: object,
+        integrityInfo?: { checksumVerified: boolean },
     ): Promise<void> {
         const generatedExtendedAttributes = generateFileExtendedAttributes(
             extendedAttributes,
@@ -398,7 +401,10 @@ export class UploadManager {
             generatedExtendedAttributes,
         );
         try {
-            await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto);
+            await this.apiService.commitDraftRevision(nodeRevisionDraft.nodeRevisionUid, {
+                ...nodeCommitCrypto,
+                ...integrityInfo,
+            });
         } catch (error: unknown) {
             // Commit might be sent but due to network error no response is
             // received. In this case, API service automatically retries the

package/src/internal/upload/smallFileUploader.ts

@@ -77,6 +77,7 @@ abstract class SmallUploader {
         commitPayload: {
             armoredManifestSignature: string;
             armoredExtendedAttributes: string;
+            checksumVerified?: boolean;
         };
         encryptedBlock:
             | {
@@ -253,6 +254,7 @@ abstract class SmallUploader {
     ): Promise<{
         armoredManifestSignature: string;
         armoredExtendedAttributes: string;
+        checksumVerified?: boolean;
     }> {
         this.logger.debug(`Preparing commit payload`);
 
@@ -269,6 +271,7 @@ abstract class SmallUploader {
         return {
             armoredManifestSignature: commitCrypto.armoredManifestSignature,
             armoredExtendedAttributes: commitCrypto.armoredExtendedAttributes,
+            checksumVerified: !!(this.metadata.expectedSha1 && contentSha1 === this.metadata.expectedSha1),
         };
     }
 }

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

@@ -172,6 +172,9 @@ describe('StreamUploader', () => {
                     },
                 },
                 metadata.additionalMetadata,
+                {
+                    checksumVerified: !!metadata.expectedSha1,
+                },
             );
             expect(telemetry.uploadFinished).toHaveBeenCalledTimes(1);
             expect(telemetry.uploadFinished).toHaveBeenCalledWith('revisionUid', metadata.expectedSize + thumbnailSize);

package/src/internal/upload/streamUploader.ts

@@ -22,6 +22,39 @@ import { UploadManager } from './manager';
  */
 export const FILE_CHUNK_SIZE = 4 * 1024 * 1024;
 
+/**
+ * Creates an upload progress callback isolated from the caller's scope.
+ *
+ * When a closure is defined inside a function, the JS engine attaches it to
+ * the entire lexical environment of that function — all variables in scope,
+ * whether the closure uses them or not. This means an inline `onProgress`
+ * lambda defined inside `uploadBlockData` would keep `encryptedData` (the
+ * 4 MB buffer) alive for as long as the HTTP client holds the callback,
+ * even though the lambda never references `encryptedData`.
+ *
+ * By defining this factory at module level, the returned closures only see
+ * `reported` and `onProgress`. The encrypted data is invisible to them and
+ * can be garbage collected as soon as the upload completes.
+ */
+function createProgressCallback(onProgress?: (n: number) => void): {
+    callback: (uploadedBytes: number) => void;
+    rollback: () => void;
+} {
+    let reported = 0;
+    return {
+        callback: (uploadedBytes: number) => {
+            reported += uploadedBytes;
+            onProgress?.(uploadedBytes);
+        },
+        rollback: () => {
+            if (reported !== 0) {
+                onProgress?.(-reported);
+                reported = 0;
+            }
+        },
+    };
+}
+
 /**
  * Maximum number of blocks that can be buffered before upload.
  * This is to prevent using too much memory.
@@ -71,7 +104,6 @@ export class StreamUploader {
         {
             index?: number;
             uploadPromise: Promise<void>;
-            encryptedBlock: EncryptedBlock | EncryptedThumbnail;
         }
     >();
     protected uploadedThumbnails: ({ type: ThumbnailType } & EncryptedBlockMetadata)[] = [];
@@ -222,7 +254,7 @@ export class StreamUploader {
 
     protected async commitFile(thumbnails: Thumbnail[]) {
         const digests = this.digests.digests();
-        this.verifyIntegrity(thumbnails, digests);
+        const integrityInfo = this.verifyIntegrity(thumbnails, digests);
 
         const extendedAttributes = {
             modificationTime: this.metadata.modificationTime,
@@ -235,6 +267,7 @@ export class StreamUploader {
             await this.getManifest(),
             extendedAttributes,
             this.metadata.additionalMetadata,
+            integrityInfo,
         );
     }
 
@@ -364,7 +397,6 @@ export class StreamUploader {
                     // Help the garbage collector to clean up the memory.
                     encryptedThumbnail = undefined;
                 }),
-                encryptedBlock: encryptedThumbnail,
             });
         }
 
@@ -385,7 +417,6 @@ export class StreamUploader {
                     // Help the garbage collector to clean up the memory.
                     encryptedBlock = undefined;
                 }),
-                encryptedBlock,
             });
         }
     }
@@ -401,8 +432,8 @@ export class StreamUploader {
         );
         logger.info(`Upload started`);
 
-        let blockProgress = 0;
         let attempt = 0;
+        const { callback: progressCallback, rollback: rollbackProgress } = createProgressCallback(onProgress);
 
         while (true) {
             attempt++;
@@ -412,10 +443,7 @@ export class StreamUploader {
                     uploadToken.bareUrl,
                     uploadToken.token,
                     encryptedThumbnail.encryptedData,
-                    (uploadedBytes) => {
-                        blockProgress += uploadedBytes;
-                        onProgress?.(uploadedBytes);
-                    },
+                    progressCallback,
                     this.abortController.signal,
                 );
                 this.uploadedThumbnails.push({
@@ -431,10 +459,7 @@ export class StreamUploader {
                     throw error;
                 }
 
-                if (blockProgress !== 0) {
-                    onProgress?.(-blockProgress);
-                    blockProgress = 0;
-                }
+                rollbackProgress();
 
                 // Note: We don't handle token expiration for thumbnails, because
                 // the API requires the thumbnails to be requested with the first
@@ -468,8 +493,8 @@ export class StreamUploader {
         const logger = new LoggerWithPrefix(this.logger, `block ${uploadToken.index}:${uploadToken.token}`);
         logger.info(`Upload started`);
 
-        let blockProgress = 0;
         let attempt = 0;
+        const { callback: progressCallback, rollback: rollbackProgress } = createProgressCallback(onProgress);
 
         while (true) {
             if (this.isUploadAborted) {
@@ -483,10 +508,7 @@ export class StreamUploader {
                     uploadToken.bareUrl,
                     uploadToken.token,
                     encryptedBlock.encryptedData,
-                    (uploadedBytes) => {
-                        blockProgress += uploadedBytes;
-                        onProgress?.(uploadedBytes);
-                    },
+                    progressCallback,
                     this.abortController.signal,
                 );
                 this.uploadedBlocks.push({
@@ -502,10 +524,7 @@ export class StreamUploader {
                     throw error;
                 }
 
-                if (blockProgress !== 0) {
-                    onProgress?.(-blockProgress);
-                    blockProgress = 0;
-                }
+                rollbackProgress();
 
                 if (error instanceof Error && error.name === 'TimeoutError') {
                     logger.warn(`Upload timeout, limiting upload capacity to 1 block`);
@@ -608,7 +627,12 @@ export class StreamUploader {
         }
     }
 
-    protected verifyIntegrity(thumbnails: Thumbnail[], digests: { sha1: string }) {
+    protected verifyIntegrity(
+        thumbnails: Thumbnail[],
+        digests: { sha1: string },
+    ): {
+        checksumVerified: boolean;
+    } {
         const expectedBlockCount =
             Math.ceil(this.metadata.expectedSize / FILE_CHUNK_SIZE) + (thumbnails ? thumbnails?.length : 0);
         if (this.uploadedBlockCount !== expectedBlockCount) {
@@ -629,6 +653,9 @@ export class StreamUploader {
                 expectedSha1: this.metadata.expectedSha1,
             });
         }
+        return {
+            checksumVerified: !!(this.metadata.expectedSha1 && digests.sha1 === this.metadata.expectedSha1),
+        };
     }
 
     /**