@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/shares/cache.ts

@@ -1,14 +1,19 @@
-import { ProtonDriveEntitiesCache, Logger } from "../../interface";
-import { getErrorMessage } from "../errors";
-import { Volume } from "./interface";
+import { ProtonDriveEntitiesCache, Logger } from '../../interface';
+import { getErrorMessage } from '../errors';
+import { Volume } from './interface';
 
 /**
  * Provides caching for shares and volume metadata.
- * 
+ *
  * The cache is responsible for serialising and deserialising volume metadata.
+ *
+ * This is only intended for the owner's main volume. There is no cache invalidation.
  */
 export class SharesCache {
-    constructor(private logger: Logger, private driveCache: ProtonDriveEntitiesCache) {
+    constructor(
+        private logger: Logger,
+        private driveCache: ProtonDriveEntitiesCache,
+    ) {
         this.logger = logger;
         this.driveCache = driveCache;
     }
@@ -49,16 +54,22 @@ function serializeVolume(volume: Volume) {
 }
 
 function deserializeVolume(shareData: string): Volume {
-     const volume = JSON.parse(shareData);
-     if (
-        !volume || typeof volume !== 'object' ||
-        !volume.volumeId || typeof volume.volumeId !== 'string' ||
-        !volume.shareId || typeof volume.shareId !== 'string' ||
-        !volume.rootNodeId || typeof volume.rootNodeId !== 'string' ||
-        !volume.creatorEmail || typeof volume.creatorEmail !== 'string' ||
-        !volume.addressId || typeof volume.addressId !== 'string'
+    const volume = JSON.parse(shareData);
+    if (
+        !volume ||
+        typeof volume !== 'object' ||
+        !volume.volumeId ||
+        typeof volume.volumeId !== 'string' ||
+        !volume.shareId ||
+        typeof volume.shareId !== 'string' ||
+        !volume.rootNodeId ||
+        typeof volume.rootNodeId !== 'string' ||
+        !volume.creatorEmail ||
+        typeof volume.creatorEmail !== 'string' ||
+        !volume.addressId ||
+        typeof volume.addressId !== 'string'
     ) {
         throw new Error('Invalid volume data');
     }
     return volume;
-}
+}

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

@@ -1,19 +1,19 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { MemoryCache } from "../../cache";
-import { CachedCryptoMaterial } from "../../interface";
-import { SharesCryptoCache } from "./cryptoCache";
+import { PrivateKey, SessionKey } from '../../crypto';
+import { MemoryCache } from '../../cache';
+import { CachedCryptoMaterial } from '../../interface';
+import { SharesCryptoCache } from './cryptoCache';
 
 describe('sharesCryptoCache', () => {
     let memoryCache: MemoryCache<CachedCryptoMaterial>;
     let cache: SharesCryptoCache;
 
     const generatePrivateKey = (name: string) => {
-        return name as unknown as PrivateKey
-    }
+        return name as unknown as PrivateKey;
+    };
 
     const generateSessionKey = (name: string) => {
-        return name as unknown as SessionKey
-    }
+        return name as unknown as SessionKey;
+    };
 
     beforeEach(() => {
         memoryCache = new MemoryCache();
@@ -32,8 +32,14 @@ describe('sharesCryptoCache', () => {
 
     it('should replace and retrieve new keys', async () => {
         const shareId = 'newShareId';
-        const keys1 = { key: generatePrivateKey('privateKey1'), passphraseSessionKey: generateSessionKey('sessionKey1') };
-        const keys2 = { key: generatePrivateKey('privateKey2'), passphraseSessionKey: generateSessionKey('sessionKey2') };
+        const keys1 = {
+            key: generatePrivateKey('privateKey1'),
+            passphraseSessionKey: generateSessionKey('sessionKey1'),
+        };
+        const keys2 = {
+            key: generatePrivateKey('privateKey2'),
+            passphraseSessionKey: generateSessionKey('sessionKey2'),
+        };
 
         await cache.setShareKey(shareId, keys1);
         await cache.setShareKey(shareId, keys2);
@@ -67,4 +73,4 @@ describe('sharesCryptoCache', () => {
             expect(`${error}`).toBe('Error: Entity not found');
         }
     });
-});
+});

package/src/internal/shares/cryptoCache.ts

@@ -1,12 +1,12 @@
-import { ProtonDriveCryptoCache } from "../../interface";
-import { DecryptedShareKey } from "./interface";
+import { ProtonDriveCryptoCache } from '../../interface';
+import { DecryptedShareKey } from './interface';
 
 /**
  * Provides caching for share crypto material.
- * 
+ *
  * The cache is responsible for serialising and deserialising share
  * crypto material.
- * 
+ *
  * The share crypto materials are cached so the updates to the root
  * nodes can be decrypted without the need to fetch the share keys
  * from the server again. Otherwise the rest of the tree requires

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

@@ -1,10 +1,10 @@
-import { DriveCrypto, PrivateKey, SessionKey, VERIFICATION_STATUS } from "../../crypto";
-import { ProtonDriveAccount, ProtonDriveTelemetry } from "../../interface";
-import { getMockTelemetry } from "../../tests/telemetry";
-import { EncryptedRootShare, ShareType } from "./interface";
-import { SharesCryptoService } from "./cryptoService";
+import { DriveCrypto, PrivateKey, SessionKey, VERIFICATION_STATUS } from '../../crypto';
+import { ProtonDriveAccount, ProtonDriveTelemetry } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { EncryptedRootShare, ShareType } from './interface';
+import { SharesCryptoService } from './cryptoService';
 
-describe("SharesCryptoService", () => {
+describe('SharesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;
     let driveCrypto: DriveCrypto;
     let account: ProtonDriveAccount;
@@ -14,89 +14,89 @@ describe("SharesCryptoService", () => {
         telemetry = getMockTelemetry();
         // @ts-expect-error No need to implement all methods for mocking
         driveCrypto = {
-            decryptKey: jest.fn(async () => Promise.resolve({
-                passphrase: "pass",
-                key: "decryptedKey" as unknown as PrivateKey,
-                passphraseSessionKey: "sessionKey" as unknown as SessionKey,
-                verified: VERIFICATION_STATUS.SIGNED_AND_VALID,
-            })),
+            decryptKey: jest.fn(async () =>
+                Promise.resolve({
+                    passphrase: 'pass',
+                    key: 'decryptedKey' as unknown as PrivateKey,
+                    passphraseSessionKey: 'sessionKey' as unknown as SessionKey,
+                    verified: VERIFICATION_STATUS.SIGNED_AND_VALID,
+                }),
+            ),
         };
         account = {
             // @ts-expect-error No need to implement full response for mocking
             getOwnAddress: jest.fn(async () => ({
-                keys: [{ key: "addressKey" as unknown as PrivateKey }],
+                keys: [{ key: 'addressKey' as unknown as PrivateKey }],
             })),
             getPublicKeys: jest.fn(async () => []),
         };
         cryptoService = new SharesCryptoService(telemetry, driveCrypto, account);
     });
 
-    it("should decrypt root share", async () => {
-        const result = await cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
-        );
+    it('should decrypt root share', async () => {
+        const result = await cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
 
         expect(result).toMatchObject({
             share: {
-                shareId: "shareId",
-                author: { ok: true, value: "signatureEmail" },
+                shareId: 'shareId',
+                author: { ok: true, value: 'signatureEmail' },
             },
             key: {
-                key: "decryptedKey",
-                passphraseSessionKey: "sessionKey",
+                key: 'decryptedKey',
+                passphraseSessionKey: 'sessionKey',
             },
         });
 
-        expect(account.getOwnAddress).toHaveBeenCalledWith("addressId");
-        expect(account.getPublicKeys).toHaveBeenCalledWith("signatureEmail");
+        expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
+        expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
         expect(telemetry.logEvent).not.toHaveBeenCalled();
     });
 
-    it("should decrypt root share with signiture verification error", async () => {
-        driveCrypto.decryptKey = jest.fn(async () => Promise.resolve({
-            passphrase: "pass",
-            key: "decryptedKey" as unknown as PrivateKey,
-            passphraseSessionKey: "sessionKey" as unknown as SessionKey,
-            verified: VERIFICATION_STATUS.NOT_SIGNED,
-        }));
-
-        const result = await cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
+    it('should decrypt root share with signiture verification error', async () => {
+        driveCrypto.decryptKey = jest.fn(async () =>
+            Promise.resolve({
+                passphrase: 'pass',
+                key: 'decryptedKey' as unknown as PrivateKey,
+                passphraseSessionKey: 'sessionKey' as unknown as SessionKey,
+                verified: VERIFICATION_STATUS.NOT_SIGNED,
+            }),
         );
 
+        const result = await cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
+
         expect(result).toMatchObject({
             share: {
-                shareId: "shareId",
-                author: { ok: false, error: { claimedAuthor: "signatureEmail", error: "Missing signature" } },
+                shareId: 'shareId',
+                author: { ok: false, error: { claimedAuthor: 'signatureEmail', error: 'Missing signature' } },
             },
             key: {
-                key: "decryptedKey",
-                passphraseSessionKey: "sessionKey",
+                key: 'decryptedKey',
+                passphraseSessionKey: 'sessionKey',
             },
         });
 
-        expect(account.getOwnAddress).toHaveBeenCalledWith("addressId");
-        expect(account.getPublicKeys).toHaveBeenCalledWith("signatureEmail");
+        expect(account.getOwnAddress).toHaveBeenCalledWith('addressId');
+        expect(account.getPublicKeys).toHaveBeenCalledWith('signatureEmail');
         expect(telemetry.logEvent).toHaveBeenCalledWith({
             eventName: 'verificationError',
             volumeType: 'own_volume',
@@ -106,23 +106,21 @@ describe("SharesCryptoService", () => {
         });
     });
 
-    it("should handle decrypt issue of root share", async () => {
-        const error = new Error("Decryption error");
+    it('should handle decrypt issue of root share', async () => {
+        const error = new Error('Decryption error');
         driveCrypto.decryptKey = jest.fn(async () => Promise.reject(error));
 
-        const result = cryptoService.decryptRootShare(
-            {
-                shareId: "shareId",
-                addressId: "addressId",
-                creatorEmail: "signatureEmail",
-                encryptedCrypto: {
-                    armoredKey: "armoredKey",
-                    armoredPassphrase: "armoredPassphrase",
-                    armoredPassphraseSignature: "armoredPassphraseSignature",
-                },
-                type: ShareType.Main,
-            } as EncryptedRootShare,
-        );
+        const result = cryptoService.decryptRootShare({
+            shareId: 'shareId',
+            addressId: 'addressId',
+            creatorEmail: 'signatureEmail',
+            encryptedCrypto: {
+                armoredKey: 'armoredKey',
+                armoredPassphrase: 'armoredPassphrase',
+                armoredPassphraseSignature: 'armoredPassphraseSignature',
+            },
+            type: ShareType.Main,
+        } as EncryptedRootShare);
 
         await expect(result).rejects.toThrow(error);
 

package/src/internal/shares/cryptoService.ts

@@ -1,16 +1,31 @@
-import { ProtonDriveAccount, resultOk, resultError, Result, UnverifiedAuthorError, ProtonDriveTelemetry, Logger, MetricVolumeType } from "../../interface";
-import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from "../../crypto";
-import { getVerificationMessage } from "../errors";
-import { EncryptedRootShare, DecryptedRootShare, EncryptedShareCrypto, DecryptedShareKey, ShareType } from "./interface";
+import {
+    ProtonDriveAccount,
+    resultOk,
+    resultError,
+    Result,
+    UnverifiedAuthorError,
+    ProtonDriveTelemetry,
+    Logger,
+    MetricVolumeType,
+} from '../../interface';
+import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
+import { getVerificationMessage } from '../errors';
+import {
+    EncryptedRootShare,
+    DecryptedRootShare,
+    EncryptedShareCrypto,
+    DecryptedShareKey,
+    ShareType,
+} from './interface';
 
 /**
  * Provides crypto operations for share keys.
- * 
+ *
  * The share crypto service is responsible for encrypting and decrypting share
  * keys. It should export high-level actions only, such as "decrypt share"
  * instead of low-level operations like "decrypt share passphrase". Low-level
  * operations should be kept private to the module.
- * 
+ *
  * The service owns the logic to switch between old and new crypto model.
  */
 export class SharesCryptoService {
@@ -19,7 +34,11 @@ export class SharesCryptoService {
     private reportedDecryptionErrors = new Set<string>();
     private reportedVerificationErrors = new Set<string>();
 
-    constructor(private telemetry: ProtonDriveTelemetry, private driveCrypto: DriveCrypto, private account: ProtonDriveAccount) {
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private driveCrypto: DriveCrypto,
+        private account: ProtonDriveAccount,
+    ) {
         this.telemetry = telemetry;
         this.logger = telemetry.getLogger('shares-crypto');
         this.driveCrypto = driveCrypto;
@@ -27,16 +46,21 @@ export class SharesCryptoService {
     }
 
     async generateVolumeBootstrap(addressKey: PrivateKey): Promise<{
-        shareKey: { encrypted: EncryptedShareCrypto, decrypted: DecryptedShareKey },
+        shareKey: { encrypted: EncryptedShareCrypto; decrypted: DecryptedShareKey };
         rootNode: {
-            key: { encrypted: EncryptedShareCrypto, decrypted: DecryptedShareKey },
-            encryptedName: string,
-            armoredHashKey: string,
-        }
+            key: { encrypted: EncryptedShareCrypto; decrypted: DecryptedShareKey };
+            encryptedName: string;
+            armoredHashKey: string;
+        };
     }> {
         const shareKey = await this.driveCrypto.generateKey([addressKey], addressKey);
         const rootNodeKey = await this.driveCrypto.generateKey([shareKey.decrypted.key], addressKey);
-        const { armoredNodeName } = await this.driveCrypto.encryptNodeName('root', undefined, shareKey.decrypted.key, addressKey);
+        const { armoredNodeName } = await this.driveCrypto.encryptNodeName(
+            'root',
+            undefined,
+            shareKey.decrypted.key,
+            addressKey,
+        );
         const { armoredHashKey } = await this.driveCrypto.generateHashKey(rootNodeKey.decrypted.key);
         return {
             shareKey,
@@ -45,10 +69,10 @@ export class SharesCryptoService {
                 encryptedName: armoredNodeName,
                 armoredHashKey,
             },
-        }
+        };
     }
 
-    async decryptRootShare(share: EncryptedRootShare): Promise<{ share: DecryptedRootShare, key: DecryptedShareKey }> {
+    async decryptRootShare(share: EncryptedRootShare): Promise<{ share: DecryptedRootShare; key: DecryptedShareKey }> {
         const { keys: addressKeys } = await this.account.getOwnAddress(share.addressId);
         const addressPublicKeys = await this.account.getPublicKeys(share.creatorEmail);
 
@@ -60,7 +84,7 @@ export class SharesCryptoService {
                 share.encryptedCrypto.armoredPassphraseSignature,
                 addressKeys.map(({ key }) => key),
                 addressPublicKeys,
-            )
+            );
             key = result.key;
             passphraseSessionKey = result.passphraseSessionKey;
             verified = result.verified;
@@ -69,12 +93,13 @@ export class SharesCryptoService {
             throw error;
         }
 
-        const author: Result<string, UnverifiedAuthorError> = verified === VERIFICATION_STATUS.SIGNED_AND_VALID
-            ? resultOk(share.creatorEmail)
-            : resultError({
-                claimedAuthor: share.creatorEmail,
-                error: getVerificationMessage(verified),
-            });
+        const author: Result<string, UnverifiedAuthorError> =
+            verified === VERIFICATION_STATUS.SIGNED_AND_VALID
+                ? resultOk(share.creatorEmail)
+                : resultError({
+                      claimedAuthor: share.creatorEmail,
+                      error: getVerificationMessage(verified),
+                  });
 
         if (!author.ok) {
             await this.reportVerificationError(share);
@@ -89,7 +114,7 @@ export class SharesCryptoService {
                 key,
                 passphraseSessionKey,
             },
-        }
+        };
     }
 
     private reportDecryptionError(share: EncryptedRootShare, error?: unknown) {

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 {