@protontech/drive-sdk 0.0.13 → 0.1.1

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

@@ -1,14 +1,14 @@
-import { ProtonDriveAccount } from "../../interface";
-import { getMockLogger } from "../../tests/logger";
-import { NotFoundAPIError } from "../apiService";
-import { SharesAPIService } from "./apiService";
-import { SharesCache } from "./cache";
-import { SharesCryptoCache } from "./cryptoCache";
-import { SharesCryptoService } from "./cryptoService";
-import { VolumeShareNodeIDs } from "./interface";
-import { SharesManager } from "./manager";
-
-describe("SharesManager", () => {
+import { ProtonDriveAccount } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { NotFoundAPIError } from '../apiService';
+import { SharesAPIService } from './apiService';
+import { SharesCache } from './cache';
+import { SharesCryptoCache } from './cryptoCache';
+import { SharesCryptoService } from './cryptoService';
+import { VolumeShareNodeIDs } from './interface';
+import { SharesManager } from './manager';
+
+describe('SharesManager', () => {
     let apiService: SharesAPIService;
     let cache: SharesCache;
     let cryptoCache: SharesCryptoCache;
@@ -25,46 +25,46 @@ describe("SharesManager", () => {
             getShare: jest.fn(),
             getVolume: jest.fn(),
             createVolume: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
             setVolume: jest.fn(),
             getVolume: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
             setShareKey: jest.fn(),
             getShareKey: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             generateVolumeBootstrap: jest.fn(),
             decryptRootShare: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         account = {
             getOwnPrimaryAddress: jest.fn(),
             getOwnAddress: jest.fn(),
-        }
+        };
 
         manager = new SharesManager(getMockLogger(), apiService, cache, cryptoCache, cryptoService, account);
     });
 
-    describe("getMyFilesIDs", () => {
+    describe('getMyFilesIDs', () => {
         const myFilesShare = {
-            shareId: "myFilesShareId",
-            volumeId: "myFilesVolumeId",
-            rootNodeId: "myFilesRootNodeId",
+            shareId: 'myFilesShareId',
+            volumeId: 'myFilesVolumeId',
+            rootNodeId: 'myFilesRootNodeId',
         };
 
-        it("should load My files IDs once", async () => {
+        it('should load My files IDs once', async () => {
             const encryptedShare = {
                 share: myFilesShare,
-                creatorEmail: "email",
+                creatorEmail: 'email',
             };
             const key = {
-                key: "privateKey",
-                sessionKey: "sessionKey",
+                key: 'privateKey',
+                sessionKey: 'sessionKey',
             };
 
             apiService.getMyFiles = jest.fn().mockResolvedValue(encryptedShare);
@@ -86,18 +86,20 @@ describe("SharesManager", () => {
         });
 
         it("should create volume when My files section doesn't exist", async () => {
-            apiService.getMyFiles = jest.fn().mockRejectedValue(new NotFoundAPIError("no active volume", 0));
-            account.getOwnPrimaryAddress = jest.fn().mockResolvedValue({ primaryKeyIndex: 0, keys: [{ key: "addressKey" }] });
+            apiService.getMyFiles = jest.fn().mockRejectedValue(new NotFoundAPIError('no active volume', 0));
+            account.getOwnPrimaryAddress = jest
+                .fn()
+                .mockResolvedValue({ primaryKeyIndex: 0, keys: [{ key: 'addressKey' }] });
             cryptoService.generateVolumeBootstrap = jest.fn().mockResolvedValue({
                 shareKey: {
-                    encrypted: "encrypted share key",
-                    decrypted: "decrypted share key",
+                    encrypted: 'encrypted share key',
+                    decrypted: 'decrypted share key',
                 },
                 rootNode: {
                     key: {
-                        encrypted: "encrypted root key",
+                        encrypted: 'encrypted root key',
                     },
-                }
+                },
             });
             apiService.createVolume = jest.fn().mockResolvedValue(myFilesShare);
 
@@ -105,102 +107,108 @@ describe("SharesManager", () => {
 
             expect(result).toStrictEqual(myFilesShare);
             expect(cryptoService.decryptRootShare).not.toHaveBeenCalled();
-            expect(cryptoCache.setShareKey).toHaveBeenCalledWith("myFilesShareId", "decrypted share key");
+            expect(cryptoCache.setShareKey).toHaveBeenCalledWith('myFilesShareId', 'decrypted share key');
         });
 
-        it("should throw on unknown error", async () => {
-            apiService.getMyFiles = jest.fn().mockRejectedValue(new Error("Some error"));
+        it('should throw on unknown error', async () => {
+            apiService.getMyFiles = jest.fn().mockRejectedValue(new Error('Some error'));
 
-            await expect(manager.getMyFilesIDs()).rejects.toThrow("Some error");
+            await expect(manager.getMyFilesIDs()).rejects.toThrow('Some error');
             expect(cryptoService.decryptRootShare).not.toHaveBeenCalled();
             expect(apiService.createVolume).not.toHaveBeenCalled();
         });
     });
 
-    describe("getSharePrivateKey", () => {
-        it("should return cached private key", async () => {
-            cryptoCache.getShareKey = jest.fn().mockResolvedValue({ key: "cachedPrivateKey" });
+    describe('getSharePrivateKey', () => {
+        it('should return cached private key', async () => {
+            cryptoCache.getShareKey = jest.fn().mockResolvedValue({ key: 'cachedPrivateKey' });
 
-            const result = await manager.getSharePrivateKey("shareId");
+            const result = await manager.getSharePrivateKey('shareId');
 
-            expect(result).toBe("cachedPrivateKey");
+            expect(result).toBe('cachedPrivateKey');
         });
 
-        it("should load private key if not in cache", async () => {
+        it('should load private key if not in cache', async () => {
             cryptoCache.getShareKey = jest.fn().mockRejectedValue(new Error('not found'));
-            apiService.getRootShare = jest.fn().mockResolvedValue({ shareId: "shareId" });
-            cryptoService.decryptRootShare = jest.fn().mockResolvedValue({ key: { key: "privateKey" } });
+            apiService.getRootShare = jest.fn().mockResolvedValue({ shareId: 'shareId' });
+            cryptoService.decryptRootShare = jest.fn().mockResolvedValue({ key: { key: 'privateKey' } });
 
-            const result = await manager.getSharePrivateKey("shareId");
+            const result = await manager.getSharePrivateKey('shareId');
 
-            expect(result).toBe("privateKey");
-            expect(cryptoCache.setShareKey).toHaveBeenCalledWith("shareId", { key: "privateKey" });
+            expect(result).toBe('privateKey');
+            expect(cryptoCache.setShareKey).toHaveBeenCalledWith('shareId', { key: 'privateKey' });
         });
     });
 
-    describe("getMyFilesShareMemberEmailKey", () => {
-        it("should return cached volume email key", async () => {
-            jest.spyOn(manager, 'getMyFilesIDs').mockResolvedValue({ volumeId: "volumeId" } as VolumeShareNodeIDs);
-            cache.getVolume = jest.fn().mockResolvedValue({ addressId: "addressId" });
-            account.getOwnAddress = jest.fn().mockResolvedValue({ email: "email", primaryKeyIndex: 0, keys: [{ key: "addressKey" }] });
+    describe('getMyFilesShareMemberEmailKey', () => {
+        it('should return cached volume email key', async () => {
+            jest.spyOn(manager, 'getMyFilesIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
+            cache.getVolume = jest.fn().mockResolvedValue({ addressId: 'addressId' });
+            account.getOwnAddress = jest
+                .fn()
+                .mockResolvedValue({ email: 'email', primaryKeyIndex: 0, keys: [{ key: 'addressKey' }] });
 
             const result = await manager.getMyFilesShareMemberEmailKey();
 
             expect(result).toEqual({
-                addressId: "addressId",
-                email: "email",
-                addressKey: "addressKey",
+                addressId: 'addressId',
+                email: 'email',
+                addressKey: 'addressKey',
             });
         });
 
-        it("should load volume email key if not in cache", async () => {
-            jest.spyOn(manager, 'getMyFilesIDs').mockResolvedValue({ volumeId: "volumeId" } as VolumeShareNodeIDs);
+        it('should load volume email key if not in cache', async () => {
+            jest.spyOn(manager, 'getMyFilesIDs').mockResolvedValue({ volumeId: 'volumeId' } as VolumeShareNodeIDs);
             const share = {
-                volumeId: "volumeId",
-                shareId: "shareId",
-                rootNodeId: "rootNodeId",
-                creatorEmail: "email",
-                addressId: "addressId",
-            }
+                volumeId: 'volumeId',
+                shareId: 'shareId',
+                rootNodeId: 'rootNodeId',
+                creatorEmail: 'email',
+                addressId: 'addressId',
+            };
             cache.getVolume = jest.fn().mockRejectedValue(new Error('not found'));
-            apiService.getVolume = jest.fn().mockResolvedValue({ shareId: "shareId" });
+            apiService.getVolume = jest.fn().mockResolvedValue({ shareId: 'shareId' });
             apiService.getRootShare = jest.fn().mockResolvedValue(share);
-            account.getOwnAddress = jest.fn().mockResolvedValue({ email: "email", primaryKeyIndex: 0, keys: [{ key: "addressKey" }] });
+            account.getOwnAddress = jest
+                .fn()
+                .mockResolvedValue({ email: 'email', primaryKeyIndex: 0, keys: [{ key: 'addressKey' }] });
 
             const result = await manager.getMyFilesShareMemberEmailKey();
 
             expect(result).toEqual({
-                addressId: "addressId",
-                email: "email",
-                addressKey: "addressKey",
+                addressId: 'addressId',
+                email: 'email',
+                addressKey: 'addressKey',
             });
             expect(cache.setVolume).toHaveBeenCalledWith(share);
         });
     });
 
-    describe("getContextShareMemberEmailKey", () => {
-        it("should load share email key only once", async () => {
+    describe('getContextShareMemberEmailKey', () => {
+        it('should load share email key only once', async () => {
             const share = {
-                volumeId: "volumeId",
-                shareId: "shareId",
-                rootNodeId: "rootNodeId",
-                creatorEmail: "creatorEmail",
-                addressId: "addressId",
-            }
+                volumeId: 'volumeId',
+                shareId: 'shareId',
+                rootNodeId: 'rootNodeId',
+                creatorEmail: 'creatorEmail',
+                addressId: 'addressId',
+            };
             apiService.getRootShare = jest.fn().mockResolvedValue(share);
-            account.getOwnAddress = jest.fn().mockResolvedValue({ email: "email", primaryKeyIndex: 0, keys: [{ key: "addressKey" }] });
+            account.getOwnAddress = jest
+                .fn()
+                .mockResolvedValue({ email: 'email', primaryKeyIndex: 0, keys: [{ key: 'addressKey' }] });
 
-            const result = await manager.getContextShareMemberEmailKey("shareId");
+            const result = await manager.getContextShareMemberEmailKey('shareId');
 
             expect(result).toEqual({
-                addressId: "addressId",
-                email: "email",
-                addressKey: "addressKey",
+                addressId: 'addressId',
+                email: 'email',
+                addressKey: 'addressKey',
             });
             expect(apiService.getRootShare).toHaveBeenCalledTimes(1);
             expect(account.getOwnAddress).toHaveBeenCalledTimes(1);
 
-            const result2 = await manager.getContextShareMemberEmailKey("shareId");
+            const result2 = await manager.getContextShareMemberEmailKey('shareId');
 
             expect(result2).toEqual(result);
             expect(apiService.getRootShare).toHaveBeenCalledTimes(1);

package/src/internal/shares/manager.ts

@@ -1,11 +1,11 @@
-import { Logger, MetricVolumeType, ProtonDriveAccount } from "../../interface";
-import { PrivateKey } from "../../crypto";
-import { NotFoundAPIError } from "../apiService";
-import { SharesAPIService } from "./apiService";
-import { SharesCache } from "./cache";
-import { SharesCryptoCache } from "./cryptoCache";
-import { SharesCryptoService } from "./cryptoService";
-import { VolumeShareNodeIDs, EncryptedShare, EncryptedRootShare } from "./interface";
+import { Logger, MetricVolumeType, ProtonDriveAccount } from '../../interface';
+import { PrivateKey } from '../../crypto';
+import { NotFoundAPIError } from '../apiService';
+import { SharesAPIService } from './apiService';
+import { SharesCache } from './cache';
+import { SharesCryptoCache } from './cryptoCache';
+import { SharesCryptoService } from './cryptoService';
+import { VolumeShareNodeIDs, EncryptedShare, EncryptedRootShare } from './interface';
 
 /**
  * Provides high-level actions for managing shares.
@@ -43,7 +43,7 @@ export class SharesManager {
 
     /**
      * It returns the IDs of the My files section.
-     * 
+     *
      * If the default volume or My files section doesn't exist, it creates it.
      */
     async getMyFilesIDs(): Promise<VolumeShareNodeIDs> {
@@ -85,12 +85,12 @@ export class SharesManager {
 
     /**
      * Creates new default volume for the user.
-     * 
+     *
      * It generates the volume bootstrap, creates the volume on the server,
      * and caches the volume metadata.
-     * 
+     *
      * User can have only one default volume.
-     * 
+     *
      * @throws If the volume cannot be created (e.g., one already exists).
      */
     private async createVolume(): Promise<VolumeShareNodeIDs> {
@@ -117,7 +117,7 @@ export class SharesManager {
      * It is a high-level action that retrieves the private key for a share.
      * If prefers to use the cache, but if the key is not there, it fetches
      * the share from the API, decrypts it, and caches it.
-     * 
+     *
      * @param shareId - The ID of the share.
      * @returns The private key for the share.
      * @throws If the share is not found or cannot be decrypted, or cached.
@@ -126,7 +126,7 @@ export class SharesManager {
         try {
             const { key } = await this.cryptoCache.getShareKey(shareId);
             return key;
-        } catch { }
+        } catch {}
 
         const encryptedShare = await this.apiService.getRootShare(shareId);
         const { key } = await this.cryptoService.decryptRootShare(encryptedShare);
@@ -135,10 +135,10 @@ export class SharesManager {
     }
 
     async getMyFilesShareMemberEmailKey(): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
     }> {
         const { volumeId } = await this.getMyFilesIDs();
 
@@ -151,7 +151,7 @@ export class SharesManager {
                 addressKey: address.keys[address.primaryKeyIndex].key,
                 addressKeyId: address.keys[address.primaryKeyIndex].id,
             };
-        } catch { }
+        } catch {}
 
         const { shareId } = await this.apiService.getVolume(volumeId);
         const share = await this.apiService.getRootShare(shareId);
@@ -174,10 +174,10 @@ export class SharesManager {
     }
 
     async getContextShareMemberEmailKey(shareId: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
     }> {
         let encryptedShare = this.rootShares.get(shareId);
         if (!encryptedShare) {
@@ -195,6 +195,10 @@ export class SharesManager {
         };
     }
 
+    async isOwnVolume(volumeId: string): Promise<boolean> {
+        return (await this.getMyFilesIDs()).volumeId === volumeId;
+    }
+
     async getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType> {
         const { volumeId: myVolumeId } = await this.getMyFilesIDs();