@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/internal/nodes/nodesManagement.test.ts

@@ -1,10 +1,10 @@
-import { NodeAPIService } from "./apiService";
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
+import { NodeAPIService } from './apiService';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
 import { NodesAccess } from './nodesAccess';
 import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
-import { NodeResult } from "../../interface";
+import { NodeResult } from '../../interface';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
@@ -50,20 +50,20 @@ describe('NodesManagement', () => {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
             trashNodes: jest.fn(async function* (uids) {
-                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             restoreNodes: jest.fn(async function* (uids) {
-                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             deleteNodes: jest.fn(async function* (uids) {
-                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+                yield* uids.map((uid) => ({ ok: true, uid }) as NodeResult);
             }),
             createFolder: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoCache = {
             setNodeKeys: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             encryptNewName: jest.fn().mockResolvedValue({
@@ -73,7 +73,7 @@ describe('NodesManagement', () => {
             }),
             moveNode: jest.fn(),
             createFolder: jest.fn(),
-        }
+        };
         // @ts-expect-error No need to implement all methods for mocking
         nodesAccess = {
             getNode: jest.fn().mockImplementation((uid: string) => nodes[uid]),
@@ -88,17 +88,19 @@ describe('NodesManagement', () => {
                 hashKey: `${nodes[uid].parentUid}-hashKey`,
             })),
             iterateNodes: jest.fn(),
-            getNodePrivateAndSessionKeys: jest.fn().mockImplementation((uid) => Promise.resolve({
-                key: `${uid}-key`,
-                passphrase: `${uid}-passphrase`,
-                passphraseSessionKey: `${uid}-passphraseSessionKey`,
-                contentKeyPacketSessionKey: `${uid}-contentKeyPacketSessionKey`,
-                nameSessionKey: `${uid}-nameSessionKey`,
-            })),
-            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "root-email", addressKey: "root-key" }),
+            getNodePrivateAndSessionKeys: jest.fn().mockImplementation((uid) =>
+                Promise.resolve({
+                    key: `${uid}-key`,
+                    passphrase: `${uid}-passphrase`,
+                    passphraseSessionKey: `${uid}-passphraseSessionKey`,
+                    contentKeyPacketSessionKey: `${uid}-contentKeyPacketSessionKey`,
+                    nameSessionKey: `${uid}-nameSessionKey`,
+                }),
+            ),
+            getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: 'root-email', addressKey: 'root-key' }),
             notifyNodeChanged: jest.fn(),
             notifyNodeDeleted: jest.fn(),
-        }
+        };
 
         management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess);
     });
@@ -117,13 +119,13 @@ describe('NodesManagement', () => {
         expect(cryptoService.encryptNewName).toHaveBeenCalledWith(
             { key: 'parentUid-key', hashKey: 'parentUid-hashKey' },
             'nodeUid-nameSessionKey',
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
             'new name',
         );
         expect(apiService.renameNode).toHaveBeenCalledWith(
             nodes.nodeUid.uid,
             { hash: nodes.nodeUid.hash },
-            { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' }
+            { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' },
         );
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
     });
@@ -136,7 +138,7 @@ describe('NodesManagement', () => {
             armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
-        }
+        };
         cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('nodeUid', 'newParentNodeUid');
@@ -157,10 +159,10 @@ describe('NodesManagement', () => {
                 passphrase: 'nodeUid-passphrase',
                 passphraseSessionKey: 'nodeUid-passphraseSessionKey',
                 contentKeyPacketSessionKey: 'nodeUid-contentKeyPacketSessionKey',
-                nameSessionKey: 'nodeUid-nameSessionKey'
+                nameSessionKey: 'nodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
         );
         expect(apiService.moveNode).toHaveBeenCalledWith(
             'nodeUid',
@@ -185,7 +187,7 @@ describe('NodesManagement', () => {
             armoredNodePassphraseSignature: 'movedArmoredNodePassphraseSignature',
             signatureEmail: 'movedSignatureEmail',
             nameSignatureEmail: 'movedNameSignatureEmail',
-        }
+        };
         cryptoService.moveNode = jest.fn().mockResolvedValue(encryptedCrypto);
 
         const newNode = await management.moveNode('anonymousNodeUid', 'newParentNodeUid');
@@ -197,10 +199,10 @@ describe('NodesManagement', () => {
                 passphrase: 'anonymousNodeUid-passphrase',
                 passphraseSessionKey: 'anonymousNodeUid-passphraseSessionKey',
                 contentKeyPacketSessionKey: 'anonymousNodeUid-contentKeyPacketSessionKey',
-                nameSessionKey: 'anonymousNodeUid-nameSessionKey'
+                nameSessionKey: 'anonymousNodeUid-nameSessionKey',
             }),
             expect.objectContaining({ key: 'newParentNodeUid-key', hashKey: 'newParentNodeUid-hashKey' }),
-            { email: "root-email", addressKey: "root-key" },
+            { email: 'root-email', addressKey: 'root-key' },
         );
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
@@ -217,12 +219,12 @@ describe('NodesManagement', () => {
             },
             {
                 parentUid: 'newParentNodeUid',
-                ...encryptedCrypto
+                ...encryptedCrypto,
             },
         );
     });
 
-    it("trashes node and updates cache", async () => {
+    it('trashes node and updates cache', async () => {
         const uids = ['v1~n1', 'v1~n2'];
         const trashed = new Set();
         for await (const node of management.trashNodes(uids)) {
@@ -232,7 +234,7 @@ describe('NodesManagement', () => {
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
     });
 
-    it("restores node and updates cache", async () => {
+    it('restores node and updates cache', async () => {
         const uids = ['v1~n1', 'v1~n2'];
         const restored = new Set();
         for await (const node of management.restoreNodes(uids)) {
@@ -241,5 +243,4 @@ describe('NodesManagement', () => {
         expect(restored).toEqual(new Set(uids));
         expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
     });
-
 });

package/src/internal/nodes/nodesManagement.ts

@@ -1,15 +1,15 @@
 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 { 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';
 
 /**
@@ -34,7 +34,11 @@ export class NodesManagement {
         this.nodesAccess = nodesAccess;
     }
 
-    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);
@@ -43,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(
@@ -67,7 +72,7 @@ export class NodesManagement {
                 encryptedName: armoredNodeName,
                 nameSignatureEmail: signatureEmail,
                 hash: hash,
-            }
+            },
         );
         await this.nodesAccess.notifyNodeChanged(nodeUid);
         const newNode: DecryptedNode = {
@@ -76,12 +81,12 @@ export class NodesManagement {
             encryptedName: armoredNodeName,
             nameAuthor: resultOk(signatureEmail),
             hash,
-        }
+        };
         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`);
@@ -91,13 +96,13 @@ export class NodesManagement {
                 yield {
                     uid: nodeUid,
                     ok: true,
-                }
+                };
             } catch (error: unknown) {
                 yield {
                     uid: nodeUid,
                     ok: false,
                     error: getErrorMessage(error),
-                }
+                };
             }
         }
     }
@@ -132,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,
             {
@@ -149,7 +156,7 @@ export class NodesManagement {
                 nameSignatureEmail: encryptedCrypto.nameSignatureEmail,
                 hash: encryptedCrypto.hash,
                 // TODO: When moving photos, we need to pass content hash.
-            }
+            },
         );
         const newNode: DecryptedNode = {
             ...node,
@@ -163,7 +170,7 @@ export class NodesManagement {
         return newNode;
     }
 
-    async* trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.trashNodes(nodeUids, signal)) {
             if (result.ok) {
                 await this.nodesAccess.notifyNodeChanged(result.uid);
@@ -172,7 +179,7 @@ export class NodesManagement {
         }
     }
 
-    async* restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
+    async *restoreNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         for await (const result of this.apiService.restoreNodes(nodeUids, signal)) {
             if (result.ok) {
                 await this.nodesAccess.notifyNodeChanged(result.uid);
@@ -181,7 +188,7 @@ export class NodesManagement {
         }
     }
 
-    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)) {
@@ -233,7 +240,7 @@ export class NodesManagement {
             uid: nodeUid,
             parentUid: parentNodeUid,
             type: NodeType.Folder,
-            mediaType: "Folder",
+            mediaType: 'Folder',
             creationTime: new Date(),
 
             // Share node metadata
@@ -246,7 +253,7 @@ export class NodesManagement {
             nameAuthor: resultOk(encryptedCrypto.signatureEmail),
             name: resultOk(folderName),
             treeEventScopeId: splitNodeUid(nodeUid).volumeId,
-        }
+        };
 
         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());
     }
 }