@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/nodes/nodesManagement.ts

@@ -1,16 +1,16 @@
 import { c } from 'ttag';
 
-import { MemberRole, NodeType, NodeResult, resultOk } from "../../interface";
-import { AbortError, ValidationError } from "../../errors";
+import { MemberRole, NodeType, NodeResult, resultOk } from '../../interface';
+import { AbortError, ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
-import { NodeAPIService } from "./apiService";
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
-import { NodesEvents } from './events';
-import { DecryptedNode } from "./interface";
-import { NodesAccess } from "./nodesAccess";
-import { validateNodeName } from "./validations";
-import { generateFolderExtendedAttributes } from "./extendedAttributes";
+import { NodeAPIService } from './apiService';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
+import { DecryptedNode } from './interface';
+import { NodesAccess } from './nodesAccess';
+import { validateNodeName } from './validations';
+import { generateFolderExtendedAttributes } from './extendedAttributes';
+import { splitNodeUid } from '../uids';
 
 /**
  * Provides high-level actions for managing nodes.
@@ -27,16 +27,18 @@ export class NodesManagement {
         private cryptoCache: NodesCryptoCache,
         private cryptoService: NodesCryptoService,
         private nodesAccess: NodesAccess,
-        private nodesEvents: NodesEvents,
     ) {
         this.apiService = apiService;
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.nodesAccess = nodesAccess;
-        this.nodesEvents = nodesEvents;
     }
 
-    async renameNode(nodeUid: string, newName: string, options = { allowRenameRootNode: false }): Promise<DecryptedNode> {
+    async renameNode(
+        nodeUid: string,
+        newName: string,
+        options = { allowRenameRootNode: false },
+    ): Promise<DecryptedNode> {
         validateNodeName(newName);
 
         const node = await this.nodesAccess.getNode(nodeUid);
@@ -45,19 +47,20 @@ export class NodesManagement {
         const address = await this.nodesAccess.getRootNodeEmailKey(nodeUid);
 
         if (!options.allowRenameRootNode && (!node.hash || !parentKeys.hashKey)) {
-            throw new ValidationError(c('Error').t`Renaming root item is not allowed`)
+            throw new ValidationError(c('Error').t`Renaming root item is not allowed`);
         }
 
-        const {
-            signatureEmail,
-            armoredNodeName,
-            hash,
-        } = await this.cryptoService.encryptNewName(parentKeys, nodeNameSessionKey, address, newName);
+        const { signatureEmail, armoredNodeName, hash } = await this.cryptoService.encryptNewName(
+            parentKeys,
+            nodeNameSessionKey,
+            address,
+            newName,
+        );
 
         // Because hash is optional, lets ensure we have it unless explicitely
         // allowed to rename root node.
         if (!options.allowRenameRootNode && !hash) {
-            throw new Error("Node hash not generated");
+            throw new Error('Node hash not generated');
         }
 
         await this.apiService.renameNode(
@@ -69,20 +72,21 @@ export class NodesManagement {
                 encryptedName: armoredNodeName,
                 nameSignatureEmail: signatureEmail,
                 hash: hash,
-            }
+            },
         );
+        await this.nodesAccess.notifyNodeChanged(nodeUid);
         const newNode: DecryptedNode = {
             ...node,
             name: resultOk(newName),
+            encryptedName: armoredNodeName,
             nameAuthor: resultOk(signatureEmail),
             hash,
-        }
-        await this.nodesEvents.nodeUpdated(newNode);
+        };
         return newNode;
     }
 
     // Improvement requested: move nodes in parallel
-    async* moveNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *moveNodes(nodeUids: string[], newParentNodeUid: string, signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for (const nodeUid of nodeUids) {
             if (signal?.aborted) {
                 throw new AbortError(c('Error').t`Move operation aborted`);
@@ -92,13 +96,13 @@ export class NodesManagement {
                 yield {
                     uid: nodeUid,
                     ok: true,
-                }
+                };
             } catch (error: unknown) {
                 yield {
                     uid: nodeUid,
                     ok: false,
                     error: getErrorMessage(error),
-                }
+                };
             }
         }
     }
@@ -133,10 +137,12 @@ export class NodesManagement {
         // Node passphrase and signature email must be passed if and only if
         // the the signatures are missing (key author is null).
         const anonymousKey = node.keyAuthor.ok && node.keyAuthor.value === null;
-        const keySignatureProperties = !anonymousKey ? {} : {
-            signatureEmail: encryptedCrypto.signatureEmail,
-            armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
-        }
+        const keySignatureProperties = !anonymousKey
+            ? {}
+            : {
+                  signatureEmail: encryptedCrypto.signatureEmail,
+                  armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
+              };
         await this.apiService.moveNode(
             nodeUid,
             {
@@ -150,70 +156,51 @@ export class NodesManagement {
                 nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
                 hash: encryptedCrypto.hash,
                 // TODO: When moving photos, we need to pass content hash.
-            }
+            },
         );
         const newNode: DecryptedNode = {
             ...node,
+            encryptedName: encryptedCrypto.encryptedName,
             parentUid: newParentUid,
             hash: encryptedCrypto.hash,
             keyAuthor: resultOk(encryptedCrypto.signatureEmail),
             nameAuthor: resultOk(encryptedCrypto.nameSignatureEmail),
         };
-        await this.nodesEvents.nodeUpdated(newNode);
+        await this.nodesAccess.notifyNodeChanged(node.uid, newParentUid);
         return newNode;
     }
 
-    async* trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const nodesOrMissing = await Array.fromAsync(this.nodesAccess.iterateNodes(nodeUids, signal));
-        const nodes = nodesOrMissing.filter(node => !('missingUid' in node)) as DecryptedNode[];
-
+    async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.trashNodes(nodeUids, signal)) {
             if (result.ok) {
-                const node = nodes.find(node => node.uid === result.uid);
-                if (node) {
-                    await this.nodesEvents.nodeUpdated({
-                        ...node,
-                        trashTime: new Date(),
-                    });
-                }
+                await this.nodesAccess.notifyNodeChanged(result.uid);
             }
-
             yield result;
         }
     }
 
-    async* restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
-        const nodesOrMissing = await Array.fromAsync(this.nodesAccess.iterateNodes(nodeUids, signal));
-        const nodes = nodesOrMissing.filter(node => !('missingUid' in node)) as DecryptedNode[];
-
+    async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.restoreNodes(nodeUids, signal)) {
             if (result.ok) {
-                const node = nodes.find(node => node.uid === result.uid);
-                if (node) {
-                    await this.nodesEvents.nodeUpdated({
-                        ...node,
-                        trashTime: undefined,
-                    });
-                }
+                await this.nodesAccess.notifyNodeChanged(result.uid);
             }
-
             yield result;
         }
     }
 
-    async* deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *deleteNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const deletedNodeUids = [];
 
         for await (const result of this.apiService.deleteNodes(nodeUids, signal)) {
             if (result.ok) {
                 deletedNodeUids.push(result.uid);
+                await this.nodesAccess.notifyNodeDeleted(result.uid);
             }
             yield result;
         }
-
-        await this.nodesEvents.nodesDeleted(deletedNodeUids);
     }
 
+    // FIXME create test for create folder
     async createFolder(parentNodeUid: string, folderName: string, modificationTime?: Date): Promise<DecryptedNode> {
         validateNodeName(folderName);
 
@@ -242,6 +229,8 @@ export class NodesManagement {
             armoredExtendedAttributes: encryptedCrypto.folder.armoredExtendedAttributes,
         });
 
+        await this.nodesAccess.notifyChildCreated(parentNodeUid);
+
         const node: DecryptedNode = {
             // Internal metadata
             hash: encryptedCrypto.hash,
@@ -251,7 +240,7 @@ export class NodesManagement {
             uid: nodeUid,
             parentUid: parentNodeUid,
             type: NodeType.Folder,
-            mediaType: "Folder",
+            mediaType: 'Folder',
             creationTime: new Date(),
 
             // Share node metadata
@@ -263,9 +252,9 @@ export class NodesManagement {
             keyAuthor: resultOk(encryptedCrypto.signatureEmail),
             nameAuthor: resultOk(encryptedCrypto.signatureEmail),
             name: resultOk(folderName),
-        }
+            treeEventScopeId: splitNodeUid(nodeUid).volumeId,
+        };
 
-        await this.nodesEvents.nodeCreated(node);
         await this.cryptoCache.setNodeKeys(nodeUid, keys);
         return node;
     }

package/src/internal/nodes/nodesRevisions.ts

@@ -1,9 +1,9 @@
-import { Logger, Revision } from "../../interface";
-import { makeNodeUidFromRevisionUid } from "../uids";
-import { NodeAPIService } from "./apiService";
-import { NodesCryptoService } from "./cryptoService";
-import { NodesAccess } from "./nodesAccess";
-import { parseFileExtendedAttributes } from "./extendedAttributes";
+import { Logger, Revision } from '../../interface';
+import { makeNodeUidFromRevisionUid } from '../uids';
+import { NodeAPIService } from './apiService';
+import { NodesCryptoService } from './cryptoService';
+import { NodesAccess } from './nodesAccess';
+import { parseFileExtendedAttributes } from './extendedAttributes';
 
 /**
  * Provides access to revisions metadata.
@@ -34,7 +34,7 @@ export class NodesRevisons {
         };
     }
 
-    async* iterateRevisions(nodeUid: string, signal?: AbortSignal): AsyncGenerator<Revision> {
+    async *iterateRevisions(nodeUid: string, signal?: AbortSignal): AsyncGenerator<Revision> {
         const { key } = await this.nodesAccess.getNodeKeys(nodeUid);
 
         const encryptedRevisions = await this.apiService.getRevisions(nodeUid, signal);

package/src/internal/nodes/validations.ts

@@ -16,8 +16,8 @@ export function validateNodeName(name: string): void {
             c('Error').ngettext(
                 msgid`Name must be ${MAX_NODE_NAME_LENGTH} character long at most`,
                 `Name must be ${MAX_NODE_NAME_LENGTH} characters long at most`,
-                MAX_NODE_NAME_LENGTH
-            )
+                MAX_NODE_NAME_LENGTH,
+            ),
         );
     }
     if (name.includes('/')) {

package/src/internal/photos/albums.ts

@@ -1,6 +1,6 @@
-import { PhotosAPIService } from "./apiService";
-import { PhotosCache } from "./cache";
-import { NodesService } from "./interface";
+import { PhotosAPIService } from './apiService';
+import { PhotosCache } from './cache';
+import { NodesService } from './interface';
 
 export class Albums {
     constructor(
@@ -13,12 +13,12 @@ export class Albums {
         this.nodesService = nodesService;
     }
 
-    async* iterateAlbums() {
+    async *iterateAlbums() {
         for await (const album of this.apiService.iterateAlbums()) {
             const node = await this.nodesService.getNode(album.uid);
             yield {
                 node,
-            }
+            };
         }
     }
 

package/src/internal/photos/apiService.ts

@@ -1,16 +1,13 @@
-import { DriveAPIService } from "../apiService";
+import { DriveAPIService } from '../apiService';
 
 export class PhotosAPIService {
     constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
     }
 
-    async* iterateTimeline(): AsyncGenerator<any> {
-    }
+    async *iterateTimeline(): AsyncGenerator<any> {}
 
-    async* iterateAlbums(): AsyncGenerator<any> {
-    }
+    async *iterateAlbums(): AsyncGenerator<any> {}
 
-    async createAlbum(object: any): Promise<any> {
-    }
+    async createAlbum(object: any): Promise<any> {}
 }

package/src/internal/photos/cache.ts

@@ -1,4 +1,4 @@
-import { ProtonDriveEntitiesCache } from "../../interface";
+import { ProtonDriveEntitiesCache } from '../../interface';
 
 export class PhotosCache {
     constructor(private driveCache: ProtonDriveEntitiesCache) {

package/src/internal/photos/index.ts

@@ -1,10 +1,10 @@
-import { DriveAPIService } from "../apiService";
-import { ProtonDriveEntitiesCache } from "../../interface";
-import { PhotosAPIService } from "./apiService";
-import { PhotosCache } from "./cache";
-import { PhotosTimeline } from "./photosTimeline";
-import { Albums } from "./albums";
-import { NodesService } from "./interface";
+import { DriveAPIService } from '../apiService';
+import { ProtonDriveEntitiesCache } from '../../interface';
+import { PhotosAPIService } from './apiService';
+import { PhotosCache } from './cache';
+import { PhotosTimeline } from './photosTimeline';
+import { Albums } from './albums';
+import { NodesService } from './interface';
 
 export function initPhotosModule(
     apiService: DriveAPIService,
@@ -19,5 +19,5 @@ export function initPhotosModule(
     return {
         timeline,
         albums,
-    }
+    };
 }

package/src/internal/photos/interface.ts

@@ -1,5 +1,5 @@
-import { MissingNode } from "../../interface";
-import { DecryptedNode } from "../nodes";
+import { MissingNode } from '../../interface';
+import { DecryptedNode } from '../nodes';
 
 export interface NodesService {
     getNode(nodeUid: string): Promise<DecryptedNode>;

package/src/internal/photos/photosTimeline.ts

@@ -1,6 +1,6 @@
-import { PhotosAPIService } from "./apiService";
-import { PhotosCache } from "./cache";
-import { NodesService } from "./interface";
+import { PhotosAPIService } from './apiService';
+import { PhotosCache } from './cache';
+import { NodesService } from './interface';
 
 export class PhotosTimeline {
     constructor(
@@ -13,6 +13,5 @@ export class PhotosTimeline {
         this.nodesService = nodesService;
     }
 
-    async getTimelineStructure() {
-    }
+    async getTimelineStructure() {}
 }

package/src/internal/sdkEvents.test.ts

@@ -1,7 +1,7 @@
-import { SDKEvent } from "../interface";
-import { SDKEvents } from "./sdkEvents";
+import { SDKEvent } from '../interface';
+import { SDKEvents } from './sdkEvents';
 
-describe("SDKEvents", () => {
+describe('SDKEvents', () => {
     let sdkEvents: SDKEvents;
     let logger: { debug: jest.Mock };
 
@@ -10,13 +10,13 @@ describe("SDKEvents", () => {
         sdkEvents = new SDKEvents({ getLogger: () => logger } as any);
     });
 
-    it("should log when no listeners are present for an event", () => {
+    it('should log when no listeners are present for an event', () => {
         sdkEvents.requestsThrottled();
 
-        expect(logger.debug).toHaveBeenCalledWith("No listeners for event: requestsThrottled");
+        expect(logger.debug).toHaveBeenCalledWith('No listeners for event: requestsThrottled');
     });
 
-    it("should emit an event to its listeners", () => {
+    it('should emit an event to its listeners', () => {
         const requestsThrottledListener = jest.fn();
         sdkEvents.addListener(SDKEvent.RequestsThrottled, requestsThrottledListener);
         const requestsUnthrottledListener = jest.fn();
@@ -26,10 +26,10 @@ describe("SDKEvents", () => {
 
         expect(requestsThrottledListener).toHaveBeenCalled();
         expect(requestsUnthrottledListener).not.toHaveBeenCalled();
-        expect(logger.debug).toHaveBeenCalledWith("Emitting event: requestsThrottled");
+        expect(logger.debug).toHaveBeenCalledWith('Emitting event: requestsThrottled');
     });
 
-    it("should emit an event to multiple listeners", () => {
+    it('should emit an event to multiple listeners', () => {
         const requestsThrottledListener1 = jest.fn();
         const requestsThrottledListener2 = jest.fn();
         sdkEvents.addListener(SDKEvent.RequestsThrottled, requestsThrottledListener1);
@@ -39,10 +39,10 @@ describe("SDKEvents", () => {
 
         expect(requestsThrottledListener1).toHaveBeenCalled();
         expect(requestsThrottledListener2).toHaveBeenCalled();
-        expect(logger.debug).toHaveBeenCalledWith("Emitting event: requestsThrottled");
+        expect(logger.debug).toHaveBeenCalledWith('Emitting event: requestsThrottled');
     });
 
-    it("should not emit after unsubsribe", () => {
+    it('should not emit after unsubsribe', () => {
         const callback = jest.fn();
         const unsubscribe = sdkEvents.addListener(SDKEvent.RequestsThrottled, callback);
 

package/src/internal/sdkEvents.ts

@@ -1,4 +1,4 @@
-import { ProtonDriveTelemetry, Logger, SDKEvent } from "../interface";
+import { ProtonDriveTelemetry, Logger, SDKEvent } from '../interface';
 
 export class SDKEvents {
     private logger: Logger;
@@ -9,17 +9,11 @@ export class SDKEvents {
     }
 
     addListener(eventName: SDKEvent, callback: () => void): () => void {
-        this.listeners.set(eventName, [
-            ...(this.listeners.get(eventName) || []),
-            callback,
-        ]);
+        this.listeners.set(eventName, [...(this.listeners.get(eventName) || []), callback]);
 
         return () => {
-            this.listeners.set(
-                eventName,
-                this.listeners.get(eventName)?.filter((cb) => cb !== callback) || []
-            );
-        }
+            this.listeners.set(eventName, this.listeners.get(eventName)?.filter((cb) => cb !== callback) || []);
+        };
     }
 
     transfersPaused(): void {
@@ -45,8 +39,6 @@ export class SDKEvents {
         }
 
         this.logger.debug(`Emitting event: ${eventName}`);
-        this.listeners
-            .get(eventName)
-            ?.forEach((callback) => callback());
+        this.listeners.get(eventName)?.forEach((callback) => callback());
     }
 }

package/src/internal/shares/apiService.ts

@@ -1,20 +1,29 @@
-import { DriveAPIService, drivePaths } from "../apiService";
-import { makeMemberUid } from "../uids";
-import { EncryptedShare, EncryptedRootShare, EncryptedShareCrypto, ShareType } from "./interface";
-
-type PostCreateVolumeRequest = Extract<drivePaths['/drive/volumes']['post']['requestBody'], { 'content': object }>['content']['application/json'];
+import { DriveAPIService, drivePaths } from '../apiService';
+import { makeMemberUid } from '../uids';
+import { EncryptedShare, EncryptedRootShare, EncryptedShareCrypto, ShareType } from './interface';
+
+type PostCreateVolumeRequest = Extract<
+    drivePaths['/drive/volumes']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
 type PostCreateVolumeResponse = drivePaths['/drive/volumes']['post']['responses']['200']['content']['application/json'];
 
-type PostCreateShareRequest = Extract<drivePaths['/drive/volumes/{volumeID}/shares']['post']['requestBody'], { 'content': object }>['content']['application/json'];
-type PostCreateShareResponse = drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
-
-type GetMyFilesResponse = drivePaths['/drive/v2/shares/my-files']['get']['responses']['200']['content']['application/json'];
-type GetVolumeResponse = drivePaths['/drive/volumes/{volumeID}']['get']['responses']['200']['content']['application/json'];
+type PostCreateShareRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/shares']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCreateShareResponse =
+    drivePaths['/drive/volumes/{volumeID}/shares']['post']['responses']['200']['content']['application/json'];
+
+type GetMyFilesResponse =
+    drivePaths['/drive/v2/shares/my-files']['get']['responses']['200']['content']['application/json'];
+type GetVolumeResponse =
+    drivePaths['/drive/volumes/{volumeID}']['get']['responses']['200']['content']['application/json'];
 type GetShareResponse = drivePaths['/drive/shares/{shareID}']['get']['responses']['200']['content']['application/json'];
 
 /**
  * Provides API communication for fetching shares and creating volumes.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
@@ -44,7 +53,7 @@ export class SharesAPIService {
         const response = await this.apiService.get<GetVolumeResponse>(`drive/volumes/${volumeId}`);
         return {
             shareId: response.Volume.Share.ShareID,
-        }
+        };
     }
 
     async getShare(shareId: string): Promise<EncryptedShare> {
@@ -54,11 +63,11 @@ export class SharesAPIService {
 
     /**
      * Returns root share with address key.
-     * 
+     *
      * This function provides access to root shares that provides access
      * to node tree via address key. For this reason, caller must use this
      * only when it is clear the shareId is root share.
-     * 
+     *
      * @throws Error when share is not root share.
      */
     async getRootShare(shareId: string): Promise<EncryptedRootShare> {
@@ -76,17 +85,17 @@ export class SharesAPIService {
 
     async createVolume(
         share: {
-            addressId: string,
-            addressKeyId: string,
+            addressId: string;
+            addressKeyId: string;
         } & EncryptedShareCrypto,
         node: {
-            encryptedName: string,
-            armoredKey: string,
-            armoredPassphrase: string,
-            armoredPassphraseSignature: string,
-            armoredHashKey: string,
+            encryptedName: string;
+            armoredKey: string;
+            armoredPassphrase: string;
+            armoredPassphraseSignature: string;
+            armoredHashKey: string;
         },
-    ): Promise<{ volumeId: string, shareId: string, rootNodeId: string }> {
+    ): Promise<{ volumeId: string; shareId: string; rootNodeId: string }> {
         const response = await this.apiService.post<
             // Volume & share names are deprecated.
             Omit<PostCreateVolumeRequest, 'VolumeName' | 'ShareName'>,
@@ -108,19 +117,19 @@ export class SharesAPIService {
             volumeId: response.Volume.ID,
             shareId: response.Volume.Share.ShareID,
             rootNodeId: response.Volume.Share.LinkID,
-        }
+        };
     }
 
     async createShare(
         volumeId: string,
         share: {
-            addressId: string,
+            addressId: string;
         } & EncryptedShareCrypto,
         node: {
-            nodeId: string,
-            encryptedName: string,
-            nameKeyPacket: string,
-            passphraseKeyPacket: string,
+            nodeId: string;
+            encryptedName: string;
+            nameKeyPacket: string;
+            passphraseKeyPacket: string;
         },
     ): Promise<{ shareId: string }> {
         const response = await this.apiService.post<
@@ -139,7 +148,7 @@ export class SharesAPIService {
 
         return {
             shareId: response.Share.ID,
-        }
+        };
     }
 }
 
@@ -149,15 +158,17 @@ function convertSharePayload(response: GetShareResponse): EncryptedShare {
         shareId: response.ShareID,
         rootNodeId: response.LinkID,
         creatorEmail: response.Creator,
-        creationTime: response.CreateTime ? new Date(response.CreateTime*1000) : undefined,
+        creationTime: response.CreateTime ? new Date(response.CreateTime * 1000) : undefined,
         encryptedCrypto: {
             armoredKey: response.Key,
             armoredPassphrase: response.Passphrase,
             armoredPassphraseSignature: response.PassphraseSignature,
         },
-        membership: response.Memberships?.[0] ? {
-            memberUid: makeMemberUid(response.ShareID, response.Memberships[0].MemberID),
-        } : undefined,
+        membership: response.Memberships?.[0]
+            ? {
+                  memberUid: makeMemberUid(response.ShareID, response.Memberships[0].MemberID),
+              }
+            : undefined,
         type: convertShareTypeNumberToEnum(response.Type),
     };
 }

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

@@ -1,6 +1,6 @@
-import { MemoryCache } from "../../cache";
-import { getMockLogger } from "../../tests/logger";
-import { SharesCache } from "./cache";
+import { MemoryCache } from '../../cache';
+import { getMockLogger } from '../../tests/logger';
+import { SharesCache } from './cache';
 
 describe('sharesCache', () => {
     let memoryCache: MemoryCache<string>;
@@ -45,7 +45,9 @@ describe('sharesCache', () => {
             await cache.getVolume('badObject');
             fail('Should have thrown an error');
         } catch (error) {
-            expect(`${error}`).toBe('Error: Failed to deserialize volume: Unexpected token \'a\', \"aaa\" is not valid JSON');
+            expect(`${error}`).toBe(
+                'Error: Failed to deserialize volume: Unexpected token \'a\', \"aaa\" is not valid JSON',
+            );
         }
 
         try {