@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/devices/apiService.ts

@@ -1,19 +1,26 @@
-import { DeviceType } from "../../interface";
-import { DriveAPIService, drivePaths } from "../apiService";
-import { makeDeviceUid, makeNodeUid, splitDeviceUid } from "../uids";
-import { DeviceMetadata } from "./interface";
+import { DeviceType } from '../../interface';
+import { DriveAPIService, drivePaths } from '../apiService';
+import { makeDeviceUid, makeNodeUid, splitDeviceUid } from '../uids';
+import { DeviceMetadata } from './interface';
 
 type GetDevicesResponse = drivePaths['/drive/devices']['get']['responses']['200']['content']['application/json'];
 
-type PostCreateDeviceRequest = Extract<drivePaths['/drive/devices']['post']['requestBody'], { 'content': object }>['content']['application/json'];
+type PostCreateDeviceRequest = Extract<
+    drivePaths['/drive/devices']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
 type PostCreateDeviceResponse = drivePaths['/drive/devices']['post']['responses']['200']['content']['application/json'];
 
-type PutUpdateDeviceRequest = Extract<drivePaths['/drive/devices/{deviceID}']['put']['requestBody'], { 'content': object }>['content']['application/json'];
-type PutUpdateDeviceResponse = drivePaths['/drive/devices/{deviceID}']['put']['responses']['200']['content']['application/json'];
+type PutUpdateDeviceRequest = Extract<
+    drivePaths['/drive/devices/{deviceID}']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PutUpdateDeviceResponse =
+    drivePaths['/drive/devices/{deviceID}']['put']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for managing devices.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
@@ -28,8 +35,8 @@ export class DevicesAPIService {
             uid: makeDeviceUid(device.Device.VolumeID, device.Device.DeviceID),
             type: deviceTypeNumberToEnum(device.Device.Type),
             rootFolderUid: makeNodeUid(device.Device.VolumeID, device.Share.LinkID),
-            creationTime: new Date(device.Device.CreateTime*1000),
-            lastSyncTime: device.Device.LastSyncTime ? new Date(device.Device.LastSyncTime*1000) : undefined,
+            creationTime: new Date(device.Device.CreateTime * 1000),
+            lastSyncTime: device.Device.LastSyncTime ? new Date(device.Device.LastSyncTime * 1000) : undefined,
             hasDeprecatedName: !!device.Share.Name,
             /** @deprecated to be removed once Volume-based navigation is implemented in web */
             shareId: device.Share.ShareID,
@@ -48,56 +55,56 @@ export class DevicesAPIService {
             // Web clients do not update Device fields, that is only for desktop clients.
             Omit<PutUpdateDeviceRequest, 'Device'>,
             PutUpdateDeviceResponse
-        >(
-            `drive/devices/${deviceId}`,
-            {
-                Share: { Name: "" },
-            },
-        );
+        >(`drive/devices/${deviceId}`, {
+            Share: { Name: '' },
+        });
     }
 
     async createDevice(
         device: {
-            volumeId: string,
-            type: DeviceType,
+            volumeId: string;
+            type: DeviceType;
         },
         share: {
-            addressId: string,
-            addressKeyId: string,
-            armoredKey: string,
-            armoredSharePassphrase: string,
-            armoredSharePassphraseSignature: string,
+            addressId: string;
+            addressKeyId: string;
+            armoredKey: string;
+            armoredSharePassphrase: string;
+            armoredSharePassphraseSignature: string;
         },
         node: {
-            encryptedName: string,
-            armoredKey: string,
-            armoredNodePassphrase: string,
-            armoredNodePassphraseSignature: string,
-            armoredHashKey: string,
-        }
+            encryptedName: string;
+            armoredKey: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature: string;
+            armoredHashKey: string;
+        },
     ): Promise<DeviceMetadata> {
-        const response = await this.apiService.post<PostCreateDeviceRequest, PostCreateDeviceResponse>('drive/devices', {
-            // @ts-expect-error VolumeID is deprecated.
-            Device: {
-                Type: deviceTypeEnumToNumber(device.type),
-                SyncState: 0,
-            },
-            // @ts-expect-error Name is deprecated.
-            Share: {
-                AddressID: share.addressId,
-                AddressKeyID: share.addressKeyId,
-                Key: share.armoredKey,
-                Passphrase: share.armoredSharePassphrase,
-                PassphraseSignature: share.armoredSharePassphraseSignature,
+        const response = await this.apiService.post<PostCreateDeviceRequest, PostCreateDeviceResponse>(
+            'drive/devices',
+            {
+                // @ts-expect-error VolumeID is deprecated.
+                Device: {
+                    Type: deviceTypeEnumToNumber(device.type),
+                    SyncState: 0,
+                },
+                // @ts-expect-error Name is deprecated.
+                Share: {
+                    AddressID: share.addressId,
+                    AddressKeyID: share.addressKeyId,
+                    Key: share.armoredKey,
+                    Passphrase: share.armoredSharePassphrase,
+                    PassphraseSignature: share.armoredSharePassphraseSignature,
+                },
+                Link: {
+                    Name: node.encryptedName,
+                    NodeKey: node.armoredKey,
+                    NodePassphrase: node.armoredNodePassphrase,
+                    NodePassphraseSignature: node.armoredNodePassphraseSignature,
+                    NodeHashKey: node.armoredHashKey,
+                },
             },
-            Link: {
-                Name: node.encryptedName,
-                NodeKey: node.armoredKey,
-                NodePassphrase: node.armoredNodePassphrase,
-                NodePassphraseSignature: node.armoredNodePassphraseSignature,
-                NodeHashKey: node.armoredHashKey,
-            }
-        });
+        );
 
         return {
             uid: makeDeviceUid(device.volumeId, response.Device.DeviceID),
@@ -106,7 +113,7 @@ export class DevicesAPIService {
             creationTime: new Date(),
             hasDeprecatedName: false,
             shareId: response.Device.ShareID,
-        }
+        };
     }
 
     async deleteDevice(deviceUid: string): Promise<void> {

package/src/internal/devices/cryptoService.ts

@@ -15,30 +15,35 @@ export class DevicesCryptoService {
 
     async createDevice(deviceName: string): Promise<{
         address: {
-            addressId: string,
-            addressKeyId: string,
-        },
+            addressId: string;
+            addressKeyId: string;
+        };
         shareKey: {
-            armoredKey: string,
-            armoredPassphrase: string,
-            armoredPassphraseSignature: string,
-        },
+            armoredKey: string;
+            armoredPassphrase: string;
+            armoredPassphraseSignature: string;
+        };
         node: {
             key: {
-                armoredKey: string,
-                armoredPassphrase: string,
-                armoredPassphraseSignature: string,
-            },
-            encryptedName: string,
-            armoredHashKey: string,
-        }
+                armoredKey: string;
+                armoredPassphrase: string;
+                armoredPassphraseSignature: string;
+            };
+            encryptedName: string;
+            armoredHashKey: string;
+        };
     }> {
         const address = await this.sharesService.getMyFilesShareMemberEmailKey();
         const addressKey = address.addressKey;
 
         const shareKey = await this.driveCrypto.generateKey([addressKey], addressKey);
         const rootNodeKey = await this.driveCrypto.generateKey([shareKey.decrypted.key], addressKey);
-        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(deviceName, undefined, shareKey.decrypted.key, addressKey);
+        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(
+            deviceName,
+            undefined,
+            shareKey.decrypted.key,
+            addressKey,
+        );
         const { armoredHashKey } = await this.driveCrypto.generateHashKey(rootNodeKey.decrypted.key);
 
         return {
@@ -59,7 +64,7 @@ export class DevicesCryptoService {
                 },
                 encryptedName: armoredNodeName,
                 armoredHashKey,
-            }
+            },
         };
-    };
+    }
 }

package/src/internal/devices/index.ts

@@ -1,17 +1,17 @@
-import { DriveCrypto } from "../../crypto";
-import { ProtonDriveTelemetry } from "../../interface";
-import { DriveAPIService } from "../apiService";
-import { DevicesAPIService } from "./apiService";
-import { DevicesCryptoService } from "./cryptoService";
-import { SharesService, NodesService, NodesManagementService } from "./interface";
-import { DevicesManager } from "./manager";
+import { DriveCrypto } from '../../crypto';
+import { ProtonDriveTelemetry } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { DevicesAPIService } from './apiService';
+import { DevicesCryptoService } from './cryptoService';
+import { SharesService, NodesService, NodesManagementService } from './interface';
+import { DevicesManager } from './manager';
 
 /**
  * Provides facade for the whole devices module.
- * 
+ *
  * The devices module is responsible for handling devices metadata, including
  * API communication, encryption, decryption, caching, and event handling.
- * 
+ *
  * This facade provides internal interface that other modules can use to
  * interact with the devices.
  */
@@ -25,7 +25,14 @@ export function initDevicesModule(
 ) {
     const api = new DevicesAPIService(apiService);
     const cryptoService = new DevicesCryptoService(driveCrypto, sharesService);
-    const manager = new DevicesManager(telemetry.getLogger('devices'), api, cryptoService, sharesService, nodesService, nodesManagementService);
+    const manager = new DevicesManager(
+        telemetry.getLogger('devices'),
+        api,
+        cryptoService,
+        sharesService,
+        nodesService,
+        nodesManagementService,
+    );
 
     return manager;
 }

package/src/internal/devices/interface.ts

@@ -1,20 +1,25 @@
-import { PrivateKey } from "../../crypto";
-import { DeviceType, MissingNode } from "../../interface";
-import { DecryptedNode } from "../nodes";
+import { PrivateKey } from '../../crypto';
+import { DeviceType, MissingNode } from '../../interface';
+import { DecryptedNode } from '../nodes';
 
 export type DeviceMetadata = {
-    uid: string,
-    type: DeviceType
-    rootFolderUid: string,
-    creationTime: Date,
+    uid: string;
+    type: DeviceType;
+    rootFolderUid: string;
+    creationTime: Date;
     lastSyncTime?: Date;
     hasDeprecatedName: boolean;
     shareId: string;
-}
+};
 
 export interface SharesService {
     getMyFilesIDs(): Promise<{ volumeId: string }>;
-    getMyFilesShareMemberEmailKey(): Promise<{ addressId: string, email: string, addressKey: PrivateKey, addressKeyId: string }>,
+    getMyFilesShareMemberEmailKey(): Promise<{
+        addressId: string;
+        email: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
 }
 
 export interface NodesService {
@@ -22,7 +27,11 @@ export interface NodesService {
 }
 
 export interface NodesManagementService {
-    renameNode(nodeUid: string, newName: string, options: {
-        allowRenameRootNode: boolean,
-    }): Promise<DecryptedNode>;
+    renameNode(
+        nodeUid: string,
+        newName: string,
+        options: {
+            allowRenameRootNode: boolean;
+        },
+    ): Promise<DecryptedNode>;
 }

package/src/internal/devices/manager.test.ts

@@ -53,9 +53,26 @@ describe('DevicesManager', () => {
         const name = 'Test Device';
         const deviceType = DeviceType.Linux;
         const address = { addressId: 'address123', addressKeyId: 'key123' };
-        const shareKey = { armoredKey: 'armoredKey', armoredPassphrase: 'passphrase', armoredPassphraseSignature: 'signature' };
-        const node = { encryptedName: 'encryptedName', key: { armoredKey: 'nodeKey', armoredPassphrase: 'nodePassphrase', armoredPassphraseSignature: 'nodeSignature' }, armoredHashKey: 'hashKey' };
-        const createdDevice = { uid: 'device123', rootFolderUid: 'rootFolder123', type: deviceType, shareId: 'shareid' } as DeviceMetadata;
+        const shareKey = {
+            armoredKey: 'armoredKey',
+            armoredPassphrase: 'passphrase',
+            armoredPassphraseSignature: 'signature',
+        };
+        const node = {
+            encryptedName: 'encryptedName',
+            key: {
+                armoredKey: 'nodeKey',
+                armoredPassphrase: 'nodePassphrase',
+                armoredPassphraseSignature: 'nodeSignature',
+            },
+            armoredHashKey: 'hashKey',
+        };
+        const createdDevice = {
+            uid: 'device123',
+            rootFolderUid: 'rootFolder123',
+            type: deviceType,
+            shareId: 'shareid',
+        } as DeviceMetadata;
 
         sharesService.getMyFilesIDs.mockResolvedValue({ volumeId });
         cryptoService.createDevice.mockResolvedValue({ address, shareKey, node });
@@ -80,7 +97,7 @@ describe('DevicesManager', () => {
                 armoredNodePassphrase: node.key.armoredPassphrase,
                 armoredNodePassphraseSignature: node.key.armoredPassphraseSignature,
                 armoredHashKey: node.armoredHashKey,
-            }
+            },
         );
         expect(result).toEqual({ ...createdDevice, name: { ok: true, value: name } });
     });
@@ -88,7 +105,12 @@ describe('DevicesManager', () => {
     it('renames device with deprecated name', async () => {
         const deviceUid = 'device123';
         const name = 'New Device Name';
-        const device = { uid: deviceUid, rootFolderUid: 'rootFolder123', hasDeprecatedName: true, shareId: 'shareid' } as DeviceMetadata;
+        const device = {
+            uid: deviceUid,
+            rootFolderUid: 'rootFolder123',
+            hasDeprecatedName: true,
+            shareId: 'shareid',
+        } as DeviceMetadata;
 
         apiService.getDevices.mockResolvedValue([device]);
 
@@ -96,14 +118,21 @@ describe('DevicesManager', () => {
 
         expect(apiService.getDevices).toHaveBeenCalled();
         expect(apiService.removeNameFromDevice).toHaveBeenCalledWith(deviceUid);
-        expect(nodesManagementService.renameNode).toHaveBeenCalledWith(device.rootFolderUid, name, { allowRenameRootNode: true });
+        expect(nodesManagementService.renameNode).toHaveBeenCalledWith(device.rootFolderUid, name, {
+            allowRenameRootNode: true,
+        });
         expect(result).toEqual({ ...device, name: { ok: true, value: name } });
     });
 
     it('renames device without deprecated name', async () => {
         const deviceUid = 'device123';
         const name = 'New Device Name';
-        const device = { uid: deviceUid, rootFolderUid: 'rootFolder123', hasDeprecatedName: false, shareId: 'shareid' } as DeviceMetadata;
+        const device = {
+            uid: deviceUid,
+            rootFolderUid: 'rootFolder123',
+            hasDeprecatedName: false,
+            shareId: 'shareid',
+        } as DeviceMetadata;
 
         apiService.getDevices.mockResolvedValue([device]);
 
@@ -111,7 +140,9 @@ describe('DevicesManager', () => {
 
         expect(apiService.getDevices).toHaveBeenCalled();
         expect(apiService.removeNameFromDevice).not.toHaveBeenCalled();
-        expect(nodesManagementService.renameNode).toHaveBeenCalledWith(device.rootFolderUid, name, { allowRenameRootNode: true });
+        expect(nodesManagementService.renameNode).toHaveBeenCalledWith(device.rootFolderUid, name, {
+            allowRenameRootNode: true,
+        });
         expect(result).toEqual({ ...device, name: { ok: true, value: name } });
     });
 
@@ -126,4 +157,4 @@ describe('DevicesManager', () => {
         expect(apiService.removeNameFromDevice).not.toHaveBeenCalled();
         expect(nodesManagementService.renameNode).not.toHaveBeenCalled();
     });
-});
+});

package/src/internal/devices/manager.ts

@@ -80,7 +80,7 @@ export class DevicesManager {
         const device = await this.getDeviceMetadata(deviceUid);
 
         if (device.hasDeprecatedName) {
-            this.logger.info("Removing deprecated name from device");
+            this.logger.info('Removing deprecated name from device');
             try {
                 await this.apiService.removeNameFromDevice(deviceUid);
             } catch (error: unknown) {
@@ -95,12 +95,12 @@ export class DevicesManager {
         return {
             ...device,
             name: resultOk(name),
-        }
+        };
     }
 
     private async getDeviceMetadata(deviceUid: string): Promise<DeviceMetadata> {
         const devices = await this.apiService.getDevices();
-        const device = devices.find(device => device.uid === deviceUid);
+        const device = devices.find((device) => device.uid === deviceUid);
         if (!device) {
             throw new ValidationError(c('Error').t`Device not found`);
         }

package/src/internal/download/apiService.ts

@@ -1,25 +1,32 @@
-import { c } from "ttag";
-import { ValidationError } from "../../errors";
-import { DriveAPIService, drivePaths, ObserverStream } from "../apiService";
-import { makeNodeThumbnailUid, splitNodeRevisionUid, splitNodeThumbnailUid } from "../uids";
-import { BlockMetadata } from "./interface";
+import { DriveAPIService, drivePaths, ObserverStream } from '../apiService';
+import { makeNodeThumbnailUid, splitNodeRevisionUid, splitNodeThumbnailUid } from '../uids';
+import { BlockMetadata } from './interface';
 
 const BLOCKS_PAGE_SIZE = 20;
 
-type GetRevisionResponse = drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['get']['responses']['200']['content']['application/json'];
+type GetRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['get']['responses']['200']['content']['application/json'];
 
-type PostGetThumbnailsRequest = Extract<drivePaths['/drive/volumes/{volumeID}/thumbnails']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostGetThumbnailsResponse = drivePaths['/drive/volumes/{volumeID}/thumbnails']['post']['responses']['200']['content']['application/json'];
+type PostGetThumbnailsRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/thumbnails']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostGetThumbnailsResponse =
+    drivePaths['/drive/volumes/{volumeID}/thumbnails']['post']['responses']['200']['content']['application/json'];
 
 export class DownloadAPIService {
     constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async* iterateRevisionBlocks(nodeRevisionUid: string, signal?: AbortSignal, fromBlockIndex = 1): AsyncGenerator<
-        { type: 'manifestSignature', armoredManifestSignature?: string } |
-        { type: 'thumbnail', base64sha256Hash: string } |
-        { type: 'block' } & BlockMetadata
+    async *iterateRevisionBlocks(
+        nodeRevisionUid: string,
+        signal?: AbortSignal,
+        fromBlockIndex = 1,
+    ): AsyncGenerator<
+        | { type: 'manifestSignature'; armoredManifestSignature?: string }
+        | { type: 'thumbnail'; base64sha256Hash: string }
+        | ({ type: 'block' } & BlockMetadata)
     > {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
@@ -44,7 +51,7 @@ export class DownloadAPIService {
                         yield {
                             type: 'thumbnail',
                             base64sha256Hash: block.Hash,
-                        }
+                        };
                     }
                 }
             }
@@ -63,7 +70,11 @@ export class DownloadAPIService {
         }
     }
 
-    async getRevisionBlockToken(nodeRevisionUid: string, blockIndex: number, signal?: AbortSignal): Promise<BlockMetadata> {
+    async getRevisionBlockToken(
+        nodeRevisionUid: string,
+        blockIndex: number,
+        signal?: AbortSignal,
+    ): Promise<BlockMetadata> {
         const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(nodeRevisionUid);
 
         const result = await this.apiService.get<GetRevisionResponse>(
@@ -75,7 +86,12 @@ export class DownloadAPIService {
         return transformBlock(block);
     }
 
-    async downloadBlock(baseUrl: string, token: string, onProgress?: (downloadedBytes: number) => void, signal?: AbortSignal): Promise<Uint8Array> {
+    async downloadBlock(
+        baseUrl: string,
+        token: string,
+        onProgress?: (downloadedBytes: number) => void,
+        signal?: AbortSignal,
+    ): Promise<Uint8Array> {
         const rawBlockStream = await this.apiService.getBlockStream(baseUrl, token, signal);
         const progressStream = new ObserverStream((value) => {
             onProgress?.(value.length);
@@ -85,50 +101,55 @@ export class DownloadAPIService {
         return encryptedBlock;
     }
 
-    // Improvement requested: support multiple volumes.
-    async* iterateThumbnails(thumbnailUids: string[], signal?: AbortSignal): AsyncGenerator<
-        { uid: string, ok: true, bareUrl: string, token: string } |
-        { uid: string, ok: false, error: string }
+    async *iterateThumbnails(
+        thumbnailUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<
+        { uid: string; ok: true; bareUrl: string; token: string } | { uid: string; ok: false; error: string }
     > {
-        const thumbnailIds = thumbnailUids.map(splitNodeThumbnailUid);
+        const splitedThumbnailsIds = thumbnailUids.map(splitNodeThumbnailUid);
 
-        const uniqueVolumeIds = new Set(thumbnailIds.map(({ volumeId }) => volumeId));
-        if (uniqueVolumeIds.size !== 1) {
-            throw new ValidationError(c('Error').t`Loading thumbnails from multiple sections is not allowed`);
+        const thumbnailIdsByVolumeId = new Map<string, { volumeId: string; thumbnailId: string; nodeId: string }[]>();
+        for (const { volumeId, thumbnailId, nodeId } of splitedThumbnailsIds) {
+            if (!thumbnailIdsByVolumeId.has(volumeId)) {
+                thumbnailIdsByVolumeId.set(volumeId, []);
+            }
+            thumbnailIdsByVolumeId.get(volumeId)?.push({ volumeId, thumbnailId, nodeId });
         }
-        const volumeId = thumbnailIds[0].volumeId;
 
-        const result = await this.apiService.post<PostGetThumbnailsRequest, PostGetThumbnailsResponse>(
-            `drive/volumes/${volumeId}/thumbnails`,
-            {
-                ThumbnailIDs: thumbnailIds.map(({ thumbnailId }) => thumbnailId),
-            },
-            signal,
-        );
+        for (const [volumeId, thumbnailIds] of thumbnailIdsByVolumeId.entries()) {
+            const result = await this.apiService.post<PostGetThumbnailsRequest, PostGetThumbnailsResponse>(
+                `drive/volumes/${volumeId}/thumbnails`,
+                {
+                    ThumbnailIDs: thumbnailIds.map(({ thumbnailId }) => thumbnailId),
+                },
+                signal,
+            );
 
-        for (const thumbnail of result.Thumbnails) {
-            const id = thumbnailIds.find(({ thumbnailId }) => thumbnailId === thumbnail.ThumbnailID);
-            if (!id) {
-                continue;
+            for (const thumbnail of result.Thumbnails) {
+                const id = thumbnailIds.find(({ thumbnailId }) => thumbnailId === thumbnail.ThumbnailID);
+                if (!id) {
+                    continue;
+                }
+                yield {
+                    uid: makeNodeThumbnailUid(id.volumeId, id.nodeId, thumbnail.ThumbnailID),
+                    ok: true,
+                    bareUrl: thumbnail.BareURL,
+                    token: thumbnail.Token,
+                };
             }
-            yield {
-                uid: makeNodeThumbnailUid(id.volumeId, id.nodeId, thumbnail.ThumbnailID),
-                ok: true,
-                bareUrl: thumbnail.BareURL,
-                token: thumbnail.Token,
-            };
-        }
 
-        for (const error of result.Errors) {
-            const id = thumbnailIds.find(({ thumbnailId }) => thumbnailId === error.ThumbnailID);
-            if (!id) {
-                continue;
+            for (const error of result.Errors) {
+                const id = thumbnailIds.find(({ thumbnailId }) => thumbnailId === error.ThumbnailID);
+                if (!id) {
+                    continue;
+                }
+                yield {
+                    uid: makeNodeThumbnailUid(id.volumeId, id.nodeId, error.ThumbnailID),
+                    ok: false,
+                    error: error.Error,
+                };
             }
-            yield {
-                uid: makeNodeThumbnailUid(id.volumeId, id.nodeId, error.ThumbnailID),
-                ok: false,
-                error: error.Error,
-            };
         }
     }
 }
@@ -140,6 +161,5 @@ function transformBlock(block: GetRevisionResponse['Revision']['Blocks'][0]): Bl
         token: block.Token as string,
         base64sha256Hash: block.Hash,
         signatureEmail: block.SignatureEmail || undefined,
-        armoredSignature: block.EncSignature || undefined,
     };
 }