@protontech/drive-sdk 0.0.13 → 0.1.0

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

@@ -2,16 +2,15 @@ import { NodeAPIService } from "./apiService";
 import { NodesCryptoCache } from "./cryptoCache";
 import { NodesCryptoService } from "./cryptoService";
 import { NodesAccess } from './nodesAccess';
-import { NodesEvents } from './events';
 import { DecryptedNode } from './interface';
 import { NodesManagement } from './nodesManagement';
+import { NodeResult } from "../../interface";
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;
     let cryptoCache: NodesCryptoCache;
     let cryptoService: NodesCryptoService;
     let nodesAccess: NodesAccess;
-    let nodesEvents: NodesEvents;
     let management: NodesManagement;
 
     let nodes: { [uid: string]: DecryptedNode };
@@ -50,9 +49,15 @@ describe('NodesManagement', () => {
         apiService = {
             renameNode: jest.fn(),
             moveNode: jest.fn(),
-            trashNodes: jest.fn(),
-            restoreNodes: jest.fn(),
-            deleteNodes: jest.fn(),
+            trashNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+            }),
+            restoreNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+            }),
+            deleteNodes: jest.fn(async function* (uids) {
+                yield* uids.map((uid) => ({ok: true, uid} as NodeResult))
+            }),
             createFolder: jest.fn(),
         }
         // @ts-expect-error No need to implement all methods for mocking
@@ -91,15 +96,11 @@ describe('NodesManagement', () => {
                 nameSessionKey: `${uid}-nameSessionKey`,
             })),
             getRootNodeEmailKey: jest.fn().mockResolvedValue({ email: "root-email", addressKey: "root-key" }),
-        }
-        // @ts-expect-error No need to implement all methods for mocking
-        nodesEvents = {
-            nodeCreated: jest.fn(),
-            nodeUpdated: jest.fn(),
-            nodesDeleted: jest.fn(),
+            notifyNodeChanged: jest.fn(),
+            notifyNodeDeleted: jest.fn(),
         }
 
-        management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess, nodesEvents);
+        management = new NodesManagement(apiService, cryptoCache, cryptoService, nodesAccess);
     });
 
     it('renameNode manages rename and updates cache', async () => {
@@ -108,6 +109,7 @@ describe('NodesManagement', () => {
         expect(newNode).toEqual({
             ...nodes.nodeUid,
             name: { ok: true, value: 'new name' },
+            encryptedName: 'newArmoredNodeName',
             nameAuthor: { ok: true, value: 'newSignatureEmail' },
             hash: 'newHash',
         });
@@ -123,7 +125,7 @@ describe('NodesManagement', () => {
             { hash: nodes.nodeUid.hash },
             { encryptedName: 'newArmoredNodeName', nameSignatureEmail: 'newSignatureEmail', hash: 'newHash' }
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid');
     });
 
     it('moveNode manages move and updates cache', async () => {
@@ -142,6 +144,7 @@ describe('NodesManagement', () => {
         expect(newNode).toEqual({
             ...nodes.nodeUid,
             parentUid: 'newParentNodeUid',
+            encryptedName: 'movedArmoredNodeName',
             hash: 'movedHash',
             keyAuthor: { ok: true, value: 'movedSignatureEmail' },
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
@@ -171,7 +174,7 @@ describe('NodesManagement', () => {
                 signatureEmail: undefined,
             },
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledWith('nodeUid', 'newParentNodeUid');
     });
 
     it('moveNode manages move of anonymous node', async () => {
@@ -202,6 +205,7 @@ describe('NodesManagement', () => {
         expect(newNode).toEqual({
             ...nodes.anonymousNodeUid,
             parentUid: 'newParentNodeUid',
+            encryptedName: 'movedArmoredNodeName',
             hash: 'movedHash',
             keyAuthor: { ok: true, value: 'movedSignatureEmail' },
             nameAuthor: { ok: true, value: 'movedNameSignatureEmail' },
@@ -216,6 +220,26 @@ describe('NodesManagement', () => {
                 ...encryptedCrypto
             },
         );
-        expect(nodesEvents.nodeUpdated).toHaveBeenCalledWith(newNode);
     });
+
+    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)) {
+            trashed.add(node.uid);
+        }
+        expect(trashed).toEqual(new Set(uids));
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
+    });
+
+    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)) {
+            restored.add(node.uid);
+        }
+        expect(restored).toEqual(new Set(uids));
+        expect(nodesAccess.notifyNodeChanged).toHaveBeenCalledTimes(2);
+    });
+
 });

package/src/internal/nodes/nodesManagement.ts

@@ -6,11 +6,11 @@ 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 { splitNodeUid } from '../uids';
 
 /**
  * Provides high-level actions for managing nodes.
@@ -27,13 +27,11 @@ 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> {
@@ -71,13 +69,14 @@ export class NodesManagement {
                 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;
     }
 
@@ -154,49 +153,30 @@ export class NodesManagement {
         );
         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[];
-
         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[];
-
         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;
         }
     }
@@ -207,13 +187,13 @@ export class NodesManagement {
         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 +222,8 @@ export class NodesManagement {
             armoredExtendedAttributes: encryptedCrypto.folder.armoredExtendedAttributes,
         });
 
+        await this.nodesAccess.notifyChildCreated(parentNodeUid);
+
         const node: DecryptedNode = {
             // Internal metadata
             hash: encryptedCrypto.hash,
@@ -263,9 +245,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/shares/cache.ts

@@ -4,8 +4,10 @@ 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) {
@@ -61,4 +63,4 @@ function deserializeVolume(shareData: string): Volume {
         throw new Error('Invalid volume data');
     }
     return volume;
-}
+}

package/src/internal/shares/manager.ts

@@ -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.
@@ -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();
 

package/src/internal/sharing/apiService.ts

@@ -391,6 +391,7 @@ export class SharingAPIService {
             flags: shareUrl.Flags,
             creatorEmail: shareUrl.CreatorEmail,
             publicUrl: shareUrl.PublicUrl,
+            numberOfInitializedDownloads: shareUrl.NumAccesses,
             armoredUrlPassword: shareUrl.Password,
             urlPasswordSalt: shareUrl.UrlPasswordSalt,
             base64SharePassphraseKeyPacket: shareUrl.SharePassphraseKeyPacket,

package/src/internal/sharing/cache.ts

@@ -3,7 +3,7 @@ import { SharingType } from "./interface";
 
 /**
  * Provides caching for shared by me and with me listings.
- * 
+ *
  * The cache is responsible for serialising and deserialising the node
  * UIDs for each sharing type. Also, ensuring that only full lists are
  * cached.

package/src/internal/sharing/cryptoService.ts

@@ -347,6 +347,7 @@ export class SharingCryptoService {
             url: `${encryptedPublicLink.publicUrl}#${password}`,
             customPassword,
             creatorEmail: encryptedPublicLink.creatorEmail,
+            numberOfInitializedDownloads: encryptedPublicLink.numberOfInitializedDownloads
         }
     }