@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/internal/shares/index.ts

@@ -1,20 +1,25 @@
-import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, ProtonDriveTelemetry } from "../../interface";
+import {
+    ProtonDriveEntitiesCache,
+    ProtonDriveCryptoCache,
+    ProtonDriveAccount,
+    ProtonDriveTelemetry,
+} from '../../interface';
 import { DriveCrypto } from '../../crypto';
-import { DriveAPIService } from "../apiService";
-import { SharesAPIService } from "./apiService";
-import { SharesCryptoCache } from "./cryptoCache";
-import { SharesCache } from "./cache";
-import { SharesCryptoService } from "./cryptoService";
-import { SharesManager } from "./manager";
+import { DriveAPIService } from '../apiService';
+import { SharesAPIService } from './apiService';
+import { SharesCryptoCache } from './cryptoCache';
+import { SharesCache } from './cache';
+import { SharesCryptoService } from './cryptoService';
+import { SharesManager } from './manager';
 
-export type { EncryptedShare } from "./interface";
+export type { EncryptedShare } from './interface';
 
 /**
  * Provides facade for the whole shares module.
- * 
+ *
  * The shares module is responsible for handling shares metadata, including
  * API communication, encryption, decryption, caching, and event handling.
- * 
+ *
  * This facade provides internal interface that other modules can use to
  * interact with the shares.
  */
@@ -30,6 +35,13 @@ export function initSharesModule(
     const cache = new SharesCache(telemetry.getLogger('shares-cache'), driveEntitiesCache);
     const cryptoCache = new SharesCryptoCache(driveCryptoCache);
     const cryptoService = new SharesCryptoService(telemetry, crypto, account);
-    const sharesManager = new SharesManager(telemetry.getLogger('shares'), api, cache, cryptoCache, cryptoService, account);
+    const sharesManager = new SharesManager(
+        telemetry.getLogger('shares'),
+        api,
+        cache,
+        cryptoCache,
+        cryptoService,
+        account,
+    );
     return sharesManager;
 }

package/src/internal/shares/interface.ts

@@ -1,13 +1,13 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { Result, UnverifiedAuthorError } from "../../interface";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { Result, UnverifiedAuthorError } from '../../interface';
 
 /**
  * Internal interface providing basic identification of volume and its root
  * share and node.
- * 
+ *
  * No interface should inherit from this, this is only for composition to
  * create basic volume or share interfaces.
- * 
+ *
  * Volumes do not have necessarily share or node, but we want to always
  * know what is the root share or node, thus we want to keep this for both
  * volumes or any type of share.
@@ -21,7 +21,7 @@ export interface VolumeShareNodeIDs {
 export type Volume = {
     /**
      * Creator email and address ID come from the default share.
-     * 
+     *
      * The idea is to keep this information synced, so whenever we check
      * cached volume information, we have creator details at hand for any
      * verification checks or creation needs.
@@ -62,7 +62,7 @@ interface BaseRootShare extends BaseShare {
 
 /**
  * Interface used only internaly in the shares module.
- * 
+ *
  * Outside of the module, the decrypted share interface should be used.
  */
 export interface EncryptedShare extends BaseShare {
@@ -77,7 +77,7 @@ interface ShareMembership {
 
 /**
  * Interface used only internaly in the shares module.
- * 
+ *
  * Outside of the module, the decrypted share interface should be used.
  */
 export interface EncryptedRootShare extends BaseRootShare {
@@ -89,7 +89,7 @@ export interface EncryptedRootShare extends BaseRootShare {
  * Interface holding decrypted share metadata.
  */
 export interface DecryptedRootShare extends BaseRootShare {
-    author: Result<string, UnverifiedAuthorError>,
+    author: Result<string, UnverifiedAuthorError>;
 }
 
 export interface EncryptedShareCrypto {

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.
@@ -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,7 +195,7 @@ export class SharesManager {
         };
     }
 
-    async isOwnVolume(volumeId: string): Promise<boolean>{
+    async isOwnVolume(volumeId: string): Promise<boolean> {
         return (await this.getMyFilesIDs()).volumeId === volumeId;
     }