@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/internal/sharing/events.ts

@@ -1,11 +1,14 @@
-import { Logger } from "../../interface";
-import { DriveEvent, DriveEventType } from "../events";
-import { SharingCache } from "./cache";
-import { SharesService } from "./interface";
+import { Logger } from '../../interface';
+import { DriveEvent, DriveEventType } from '../events';
+import { SharingCache } from './cache';
+import { SharesService } from './interface';
 
 export class SharingEventHandler {
-    constructor(private logger: Logger, private cache: SharingCache, private shares: SharesService) {
-    };
+    constructor(
+        private logger: Logger,
+        private cache: SharingCache,
+        private shares: SharesService,
+    ) {}
 
     /**
      * Update cache and notify listeners accordingly for any updates
@@ -27,26 +30,41 @@ export class SharingEventHandler {
                 await this.cache.setSharedWithMeNodeUids(undefined);
                 return;
             }
-            if (!(await this.shares.isOwnVolume(event.treeEventScopeId))) {
-                return;
-            }
-            if (event.type === DriveEventType.NodeCreated || event.type == DriveEventType.NodeUpdated) {
-                if (event.isShared && !event.isTrashed) {
-                    await this.cache.addSharedByMeNodeUid(event.nodeUid);
-                } else {
-                    await this.cache.removeSharedByMeNodeUid(event.nodeUid);
-                }
-                return;
-            }
-            if (event.type === DriveEventType.NodeDeleted) {
-                await this.cache.removeSharedByMeNodeUid(event.nodeUid);
-                return;
-            }
-            if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
-                await this.cache.setSharedWithMeNodeUids(undefined);
-            }
+            await this.handleSharedByMeNodeUidsLoaded(event);
         } catch (error: unknown) {
             this.logger.error(`Skipping shared by me node cache update`, error);
         }
     }
+
+    private async handleSharedByMeNodeUidsLoaded(event: DriveEvent) {
+        if (event.type === DriveEventType.TreeRefresh || event.type === DriveEventType.TreeRemove) {
+            await this.cache.setSharedWithMeNodeUids(undefined);
+            return;
+        }
+
+        if (![DriveEventType.NodeCreated, DriveEventType.NodeUpdated, DriveEventType.NodeDeleted].includes(event.type)) {
+            return;
+        }
+
+        const hasSharedByMeLoaded = await this.cache.hasSharedByMeNodeUidsLoaded();
+        if (!hasSharedByMeLoaded) {
+            return;
+        }
+
+        const isOwnVolume = await this.shares.isOwnVolume(event.treeEventScopeId);
+        if (!isOwnVolume) {
+            return;
+        }
+
+        if (event.type === DriveEventType.NodeCreated || event.type == DriveEventType.NodeUpdated) {
+            if (event.isShared && !event.isTrashed) {
+                await this.cache.addSharedByMeNodeUid(event.nodeUid);
+            } else {
+                await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+            }
+        }
+        if (event.type === DriveEventType.NodeDeleted) {
+            await this.cache.removeSharedByMeNodeUid(event.nodeUid);
+        }
+    }
 }

package/src/internal/sharing/index.ts

@@ -1,13 +1,13 @@
-import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from "../../interface";
+import { ProtonDriveAccount, ProtonDriveEntitiesCache, ProtonDriveTelemetry } from '../../interface';
 import { DriveCrypto } from '../../crypto';
-import { DriveAPIService } from "../apiService";
-import { SharingAPIService } from "./apiService";
-import { SharingCache } from "./cache";
-import { SharingCryptoService } from "./cryptoService";
-import { SharingAccess } from "./sharingAccess";
-import { SharingManagement } from "./sharingManagement";
-import { SharesService, NodesService } from "./interface";
-import { SharingEventHandler } from "./events";
+import { DriveAPIService } from '../apiService';
+import { SharingAPIService } from './apiService';
+import { SharingCache } from './cache';
+import { SharingCryptoService } from './cryptoService';
+import { SharingAccess } from './sharingAccess';
+import { SharingManagement } from './sharingManagement';
+import { SharesService, NodesService } from './interface';
+import { SharingEventHandler } from './events';
 
 /**
  * Provides facade for the whole sharing module.
@@ -29,8 +29,19 @@ export function initSharingModule(
     const cache = new SharingCache(driveEntitiesCache);
     const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);
-    const sharingManagement = new SharingManagement(telemetry.getLogger('sharing'), api, cryptoService, account, sharesService, nodesService);
-    const sharingEventHandler = new SharingEventHandler(telemetry.getLogger('sharing-event-handler'), cache, sharesService);
+    const sharingManagement = new SharingManagement(
+        telemetry.getLogger('sharing'),
+        api,
+        cryptoService,
+        account,
+        sharesService,
+        nodesService,
+    );
+    const sharingEventHandler = new SharingEventHandler(
+        telemetry.getLogger('sharing-event-handler'),
+        cache,
+        sharesService,
+    );
 
     return {
         access: sharingAccess,

package/src/internal/sharing/interface.ts

@@ -1,7 +1,7 @@
-import { NodeType, MemberRole, NonProtonInvitationState, MissingNode, ShareResult, PublicLink } from "../../interface";
-import { PrivateKey, SessionKey } from "../../crypto";
-import { EncryptedShare } from "../shares";
-import { DecryptedNode } from "../nodes";
+import { NodeType, MemberRole, NonProtonInvitationState, MissingNode, ShareResult, PublicLink } from '../../interface';
+import { PrivateKey, SessionKey } from '../../crypto';
+import { EncryptedShare } from '../shares';
+import { DecryptedNode } from '../nodes';
 
 export enum SharingType {
     SharedByMe = 'sharedByMe',
@@ -43,10 +43,11 @@ export interface EncryptedInvitationWithNode extends EncryptedInvitation {
         creatorEmail: string;
     };
     node: {
+        uid: string;
         type: NodeType;
         mediaType?: string;
         encryptedName: string;
-    }
+    };
 }
 
 /**
@@ -109,24 +110,24 @@ export interface EncryptedBookmark {
 }
 
 export interface EncryptedPublicLink {
-    uid: string,
-    creationTime: Date,
-    expirationTime?: Date,
-    role: MemberRole,
-    flags: number,
-    creatorEmail: string,
-    publicUrl: string,
+    uid: string;
+    creationTime: Date;
+    expirationTime?: Date;
+    role: MemberRole;
+    flags: number;
+    creatorEmail: string;
+    publicUrl: string;
     numberOfInitializedDownloads: number;
-    armoredUrlPassword: string,
-    urlPasswordSalt: string,
-    base64SharePassphraseKeyPacket: string,
-    sharePassphraseSalt: string,
+    armoredUrlPassword: string;
+    urlPasswordSalt: string;
+    base64SharePassphraseKeyPacket: string;
+    sharePassphraseSalt: string;
 }
 
 export interface EncryptedPublicLinkCrypto {
-    base64SharePasswordSalt: string,
-    base64SharePassphraseKeyPacket: string,
-    armoredPassword: string,
+    base64SharePasswordSalt: string;
+    base64SharePassphraseKeyPacket: string;
+    armoredPassword: string;
 }
 
 export interface ShareResultWithCreatorEmail extends ShareResult {
@@ -137,22 +138,21 @@ export interface PublicLinkWithCreatorEmail extends PublicLink {
     creatorEmail: string;
 }
 
-
 /**
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string }>,
-    loadEncryptedShare(shareId: string): Promise<EncryptedShare>,
+    getMyFilesIDs(): Promise<{ volumeId: string }>;
+    loadEncryptedShare(shareId: string): Promise<EncryptedShare>;
     getMyFilesShareMemberEmailKey(): Promise<{
-        addressId: string,
-        addressKey: PrivateKey,
-    }>,
+        addressId: string;
+        addressKey: PrivateKey;
+    }>;
     getContextShareMemberEmailKey(shareId: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-    }>,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+    }>;
     isOwnVolume(volumeId: string): Promise<boolean>;
 }
 
@@ -160,18 +160,18 @@ export interface SharesService {
  * Interface describing the dependencies to the nodes module.
  */
 export interface NodesService {
-    getNode(nodeUid: string): Promise<DecryptedNode>,
-    getNodeKeys(nodeUid: string): Promise<{ key: PrivateKey }>,
+    getNode(nodeUid: string): Promise<DecryptedNode>;
+    getNodeKeys(nodeUid: string): Promise<{ key: PrivateKey }>;
     getNodePrivateAndSessionKeys(nodeUid: string): Promise<{
-        key: PrivateKey,
-        passphraseSessionKey: SessionKey,
-        nameSessionKey: SessionKey,
-    }>,
+        key: PrivateKey;
+        passphraseSessionKey: SessionKey;
+        nameSessionKey: SessionKey;
+    }>;
     getRootNodeEmailKey(nodeUid: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-    }>,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+    }>;
     iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
     notifyNodeChanged(nodeUid: string): Promise<void>;
 }
@@ -181,5 +181,5 @@ export interface NodesService {
  * Interface describing the dependencies to the nodes module.
  */
 export interface NodesEvents {
-    nodeUpdated(partialNode: { uid: string, shareId: string | undefined, isShared: boolean }): Promise<void>,
+    nodeUpdated(partialNode: { uid: string; shareId: string | undefined; isShared: boolean }): Promise<void>;
 }

package/src/internal/sharing/sharingAccess.test.ts

@@ -1,11 +1,11 @@
-import { NodeType, resultError, resultOk } from "../../interface";
-import { SharingAPIService } from "./apiService";
-import { SharingCache } from "./cache";
-import { SharingCryptoService } from "./cryptoService";
-import { SharesService, NodesService } from "./interface";
-import { SharingAccess } from "./sharingAccess";
-
-describe("SharingAccess", () => {
+import { NodeType, resultError, resultOk } from '../../interface';
+import { SharingAPIService } from './apiService';
+import { SharingCache } from './cache';
+import { SharingCryptoService } from './cryptoService';
+import { SharesService, NodesService } from './interface';
+import { SharingAccess } from './sharingAccess';
+
+describe('SharingAccess', () => {
     let apiService: SharingAPIService;
     let cache: SharingCache;
     let cryptoService: SharingCryptoService;
@@ -20,7 +20,7 @@ describe("SharingAccess", () => {
         for (const nodeUid of nodeUids) {
             yield nodeUid;
         }
-    }
+    };
 
     beforeEach(() => {
         // @ts-expect-error No need to implement all methods for mocking
@@ -29,29 +29,29 @@ describe("SharingAccess", () => {
             iterateSharedWithMeNodeUids: jest.fn().mockImplementation(() => nodeUidsIterator()),
             iterateBookmarks: jest.fn().mockImplementation(async function* () {
                 yield {
-                    tokenId: "tokenId",
+                    tokenId: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     node: {
                         type: NodeType.File,
-                        mediaType: "mediaType",
+                        mediaType: 'mediaType',
                     },
-                }
+                };
             }),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
             setSharedByMeNodeUids: jest.fn(),
             setSharedWithMeNodeUids: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             decryptInvitation: jest.fn(),
             decryptBookmark: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: "volumeId" }),
-        }
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+        };
         // @ts-expect-error No need to implement all methods for mocking
         nodesService = {
             iterateNodes: jest.fn().mockImplementation(async function* (nodeUids) {
@@ -61,13 +61,13 @@ describe("SharingAccess", () => {
                     }
                 }
             }),
-        }
+        };
 
         sharingAccess = new SharingAccess(apiService, cache, cryptoService, sharesService, nodesService);
     });
 
-    describe("iterateSharedNodes", () => {
-        it("should iterate from cache", async () => {
+    describe('iterateSharedNodes', () => {
+        it('should iterate from cache', async () => {
             cache.getSharedByMeNodeUids = jest.fn().mockResolvedValue(nodeUids);
 
             const result = await Array.fromAsync(sharingAccess.iterateSharedNodes());
@@ -77,20 +77,20 @@ describe("SharingAccess", () => {
             expect(cache.setSharedByMeNodeUids).not.toHaveBeenCalled();
         });
 
-        it("should iterate from API", async () => {
+        it('should iterate from API', async () => {
             cache.getSharedByMeNodeUids = jest.fn().mockRejectedValue(new Error('Not cached'));
 
             const result = await Array.fromAsync(sharingAccess.iterateSharedNodes());
 
             expect(result).toEqual(nodes);
-            expect(apiService.iterateSharedNodeUids).toHaveBeenCalledWith("volumeId", undefined);
+            expect(apiService.iterateSharedNodeUids).toHaveBeenCalledWith('volumeId', undefined);
             expect(nodesService.iterateNodes).toHaveBeenCalledTimes(2); // 15 / 10 per batch
             expect(cache.setSharedByMeNodeUids).toHaveBeenCalledWith(nodeUids);
         });
     });
 
-    describe("iterateSharedNodesWithMe", () => {
-        it("should iterate from cache", async () => {
+    describe('iterateSharedNodesWithMe', () => {
+        it('should iterate from cache', async () => {
             cache.getSharedWithMeNodeUids = jest.fn().mockResolvedValue(nodeUids);
 
             const result = await Array.fromAsync(sharingAccess.iterateSharedNodesWithMe());
@@ -100,7 +100,7 @@ describe("SharingAccess", () => {
             expect(cache.setSharedWithMeNodeUids).not.toHaveBeenCalled();
         });
 
-        it("should iterate from API", async () => {
+        it('should iterate from API', async () => {
             cache.getSharedWithMeNodeUids = jest.fn().mockRejectedValue(new Error('Not cached'));
 
             const result = await Array.fromAsync(sharingAccess.iterateSharedNodesWithMe());
@@ -112,65 +112,71 @@ describe("SharingAccess", () => {
         });
     });
 
-    describe("iterateBookmarks", () => {
-        it("should return decrypted bookmark", async () => {
+    describe('iterateBookmarks', () => {
+        it('should return decrypted bookmark', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
-                url: resultOk("url"),
-                nodeName: resultOk("nodeName"),
+                url: resultOk('url'),
+                nodeName: resultOk('nodeName'),
             });
 
             const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
 
-            expect(result).toEqual([resultOk({
-                uid: "tokenId",
-                creationTime: new Date('2025-01-01'),
-                url: "url",
-                node: {
-                    name: "nodeName",
-                    type: NodeType.File,
-                    mediaType: "mediaType",
-                },
-            })]);
+            expect(result).toEqual([
+                resultOk({
+                    uid: 'tokenId',
+                    creationTime: new Date('2025-01-01'),
+                    url: 'url',
+                    node: {
+                        name: 'nodeName',
+                        type: NodeType.File,
+                        mediaType: 'mediaType',
+                    },
+                }),
+            ]);
         });
 
-        it("should return degraded bookmark if URL password cannot be decrypted", async () => {
+        it('should return degraded bookmark if URL password cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
-                url: resultError("url cannot be decrypted"),
-                nodeName: resultError("url cannot be decrypted"),
+                url: resultError('url cannot be decrypted'),
+                nodeName: resultError('url cannot be decrypted'),
             });
 
             const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
 
-            expect(result).toEqual([resultError({
-                uid: "tokenId",
-                creationTime: new Date('2025-01-01'),
-                url: resultError("url cannot be decrypted"),
-                node: {
-                    name: resultError("url cannot be decrypted"),
-                    type: NodeType.File,
-                    mediaType: "mediaType",
-                },
-            })]);
+            expect(result).toEqual([
+                resultError({
+                    uid: 'tokenId',
+                    creationTime: new Date('2025-01-01'),
+                    url: resultError('url cannot be decrypted'),
+                    node: {
+                        name: resultError('url cannot be decrypted'),
+                        type: NodeType.File,
+                        mediaType: 'mediaType',
+                    },
+                }),
+            ]);
         });
 
-        it("should return degraded bookmark if node name cannot be decrypted", async () => {
+        it('should return degraded bookmark if node name cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
-                url: resultOk("url"),
-                nodeName: resultError("node name cannot be decrypted"),
+                url: resultOk('url'),
+                nodeName: resultError('node name cannot be decrypted'),
             });
 
             const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
 
-            expect(result).toEqual([resultError({
-                uid: "tokenId",
-                creationTime: new Date('2025-01-01'),
-                url: resultOk("url"),
-                node: {
-                    name: resultError("node name cannot be decrypted"),
-                    type: NodeType.File,
-                    mediaType: "mediaType",
-                },
-            })]);
+            expect(result).toEqual([
+                resultError({
+                    uid: 'tokenId',
+                    creationTime: new Date('2025-01-01'),
+                    url: resultOk('url'),
+                    node: {
+                        name: resultError('node name cannot be decrypted'),
+                        type: NodeType.File,
+                        mediaType: 'mediaType',
+                    },
+                }),
+            ]);
         });
     });
 });

package/src/internal/sharing/sharingAccess.ts

@@ -1,13 +1,13 @@
 import { c } from 'ttag';
 
-import { MaybeBookmark, ProtonInvitationWithNode, resultError, resultOk } from "../../interface";
-import { ValidationError } from "../../errors";
-import { DecryptedNode } from "../nodes";
-import { BatchLoading } from "../batchLoading";
-import { SharingAPIService } from "./apiService";
-import { SharingCache } from "./cache";
-import { SharingCryptoService } from "./cryptoService";
-import { SharesService, NodesService } from "./interface";
+import { MaybeBookmark, ProtonInvitationWithNode, resultError, resultOk } from '../../interface';
+import { ValidationError } from '../../errors';
+import { DecryptedNode } from '../nodes';
+import { BatchLoading } from '../batchLoading';
+import { SharingAPIService } from './apiService';
+import { SharingCache } from './cache';
+import { SharingCryptoService } from './cryptoService';
+import { SharesService, NodesService } from './interface';
 
 /**
  * Provides high-level actions for access shared nodes.
@@ -31,42 +31,57 @@ export class SharingAccess {
         this.nodesService = nodesService;
     }
 
-    async* iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         try {
             const nodeUids = await this.cache.getSharedByMeNodeUids();
             yield* this.iterateSharedNodesFromCache(nodeUids, signal);
         } catch {
             const { volumeId } = await this.sharesService.getMyFilesIDs();
             const nodeUidsIterator = this.apiService.iterateSharedNodeUids(volumeId, signal);
-            yield* this.iterateSharedNodesFromAPI(nodeUidsIterator, (nodeUids) => this.cache.setSharedByMeNodeUids(nodeUids), signal);
+            yield* this.iterateSharedNodesFromAPI(
+                nodeUidsIterator,
+                (nodeUids) => this.cache.setSharedByMeNodeUids(nodeUids),
+                signal,
+            );
         }
     }
 
-    async* iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         try {
             const nodeUids = await this.cache.getSharedWithMeNodeUids();
             yield* this.iterateSharedNodesFromCache(nodeUids, signal);
         } catch {
             const nodeUidsIterator = this.apiService.iterateSharedWithMeNodeUids(signal);
-            yield* this.iterateSharedNodesFromAPI(nodeUidsIterator, (nodeUids) => this.cache.setSharedWithMeNodeUids(nodeUids), signal);
+            yield* this.iterateSharedNodesFromAPI(
+                nodeUidsIterator,
+                (nodeUids) => this.cache.setSharedWithMeNodeUids(nodeUids),
+                signal,
+            );
         }
     }
 
-    private async* iterateSharedNodesFromCache(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal) });
+    private async *iterateSharedNodesFromCache(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+        });
         for (const nodeUid of nodeUids) {
             yield* batchLoading.load(nodeUid);
         }
         yield* batchLoading.loadRest();
     }
 
-    private async* iterateSharedNodesFromAPI(
+    private async *iterateSharedNodesFromAPI(
         nodeUidsIterator: AsyncGenerator<string>,
         setCache: (nodeUids: string[]) => Promise<void>,
         signal?: AbortSignal,
     ): AsyncGenerator<DecryptedNode> {
         const loadedNodeUids = [];
-        const batchLoading = new BatchLoading<string, DecryptedNode>({ iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal) });
+        const batchLoading = new BatchLoading<string, DecryptedNode>({
+            iterateItems: (nodeUids) => this.iterateNodesAndIgnoreMissingOnes(nodeUids, signal),
+        });
         for await (const nodeUid of nodeUidsIterator) {
             loadedNodeUids.push(nodeUid);
             yield* batchLoading.load(nodeUid);
@@ -77,7 +92,10 @@ export class SharingAccess {
         await setCache(loadedNodeUids);
     }
 
-    private async* iterateNodesAndIgnoreMissingOnes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
+    private async *iterateNodesAndIgnoreMissingOnes(
+        nodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<DecryptedNode> {
         const nodeGenerator = this.nodesService.iterateNodes(nodeUids, signal);
         for await (const node of nodeGenerator) {
             if ('missingUid' in node) {
@@ -102,7 +120,7 @@ export class SharingAccess {
         await this.apiService.removeMember(memberUid);
     }
 
-    async* iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
+    async *iterateInvitations(signal?: AbortSignal): AsyncGenerator<ProtonInvitationWithNode> {
         for await (const invitationUid of this.apiService.iterateInvitationUids(signal)) {
             const encryptedInvitation = await this.apiService.getInvitation(invitationUid);
             const invitation = await this.cryptoService.decryptInvitationWithNode(encryptedInvitation);
@@ -120,7 +138,7 @@ export class SharingAccess {
         await this.apiService.rejectInvitation(invitationUid);
     }
 
-    async* iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
+    async *iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
         for await (const bookmark of this.apiService.iterateBookmarks(signal)) {
             const { url, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
 
@@ -133,7 +151,7 @@ export class SharingAccess {
                         name: nodeName,
                         type: bookmark.node.type,
                         mediaType: bookmark.node.mediaType,
-                    }
+                    },
                 });
             } else {
                 yield resultOk({
@@ -144,7 +162,7 @@ export class SharingAccess {
                         name: nodeName.value,
                         type: bookmark.node.type,
                         mediaType: bookmark.node.mediaType,
-                    }
+                    },
                 });
             }
         }