@protontech/drive-sdk 0.1.0 → 0.1.2

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

@@ -1,5 +1,12 @@
-import { getMockLogger } from "../../tests/logger";
-import { FolderExtendedAttributes, FileExtendedAttributesParsed, generateFolderExtendedAttributes, generateFileExtendedAttributes, parseFolderExtendedAttributes, parseFileExtendedAttributes } from './extendedAttributes';
+import { getMockLogger } from '../../tests/logger';
+import {
+    FolderExtendedAttributes,
+    FileExtendedAttributesParsed,
+    generateFolderExtendedAttributes,
+    generateFileExtendedAttributes,
+    parseFolderExtendedAttributes,
+    parseFileExtendedAttributes,
+} from './extendedAttributes';
 
 describe('extended attrbiutes', () => {
     describe('should generate folder attributes', () => {
@@ -11,7 +18,7 @@ describe('extended attrbiutes', () => {
             it(`should generate ${input}`, () => {
                 const output = generateFolderExtendedAttributes(input);
                 expect(output).toBe(expectedAttributes);
-            })
+            });
         });
     });
 
@@ -26,46 +33,43 @@ describe('extended attrbiutes', () => {
                     claimedModificationTime: new Date(1234567890000),
                 },
             ],
-            [
-                '{"Common": {"ModificationTime": "aa"}}',
-                {},
-            ],
+            ['{"Common": {"ModificationTime": "aa"}}', {}],
             [
                 '{"Common": {"ModificationTime": "2009-02-13T23:31:30+0000", "Size": 123}}',
                 {
                     claimedModificationTime: new Date(1234567890000),
                 },
             ],
-            [
-                '{"Common": {"Whatever": 123}}',
-                {},
-            ],
+            ['{"Common": {"Whatever": 123}}', {}],
         ];
         testCases.forEach(([input, expectedAttributes]) => {
             it(`should parse ${input}`, () => {
                 const output = parseFolderExtendedAttributes(getMockLogger(), input);
                 expect(output).toMatchObject(expectedAttributes);
-            })
+            });
         });
     });
 
     describe('should generate file attributes', () => {
         const testCases: [object, string | undefined][] = [
             [{}, undefined],
-            [{modificationTime: new Date(1234567890000)}, '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}'],
-            [{size: undefined}, undefined],
-            [{size: 0}, '{"Common":{"Size":0}}'],
-            [{size: 1234}, '{"Common":{"Size":1234}}'],
-            [{blockSizes: []}, undefined],
-            [{blockSizes: [4,4,4,2]}, '{"Common":{"BlockSizes":[4,4,4,2]}}'],
-            [{digests: {}}, undefined],
-            [{digests: {sha1: 'abcdef'}}, '{"Common":{"Digests":{"SHA1":"abcdef"}}}'],
+            [
+                { modificationTime: new Date(1234567890000) },
+                '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z"}}',
+            ],
+            [{ size: undefined }, undefined],
+            [{ size: 0 }, '{"Common":{"Size":0}}'],
+            [{ size: 1234 }, '{"Common":{"Size":1234}}'],
+            [{ blockSizes: [] }, undefined],
+            [{ blockSizes: [4, 4, 4, 2] }, '{"Common":{"BlockSizes":[4,4,4,2]}}'],
+            [{ digests: {} }, undefined],
+            [{ digests: { sha1: 'abcdef' } }, '{"Common":{"Digests":{"SHA1":"abcdef"}}}'],
             [
                 {
                     modificationTime: new Date(1234567890000),
                     size: 1234,
                     blockSizes: [4, 4, 4, 2],
-                    digests: {sha1: 'abcdef'},
+                    digests: { sha1: 'abcdef' },
                 },
                 '{"Common":{"ModificationTime":"2009-02-13T23:31:30.000Z","Size":1234,"BlockSizes":[4,4,4,2],"Digests":{"SHA1":"abcdef"}}}',
             ],
@@ -74,7 +78,7 @@ describe('extended attrbiutes', () => {
             it(`should generate ${input}`, () => {
                 const output = generateFileExtendedAttributes(input);
                 expect(output).toBe(expectedAttributes);
-            })
+            });
         });
     });
 
@@ -151,7 +155,7 @@ describe('extended attrbiutes', () => {
                 {
                     claimedModificationTime: undefined,
                     claimedSize: undefined,
-                    claimedDigests: {sha1: "abcdef"},
+                    claimedDigests: { sha1: 'abcdef' },
                     claimedAdditionalMetadata: undefined,
                 },
             ],
@@ -171,7 +175,7 @@ describe('extended attrbiutes', () => {
             it(`should parse ${input}`, () => {
                 const output = parseFileExtendedAttributes(getMockLogger(), input);
                 expect(output).toMatchObject(expectedAttributes);
-            })
+            });
         });
     });
 });

package/src/internal/nodes/extendedAttributes.ts

@@ -1,4 +1,4 @@
-import { Logger } from "../../interface";
+import { Logger } from '../../interface';
 
 interface FolderExtendedAttributesSchema {
     Common?: {
@@ -38,16 +38,16 @@ interface FileExtendedAttributesSchema {
 }
 
 export interface FolderExtendedAttributes {
-    claimedModificationTime?: Date,
+    claimedModificationTime?: Date;
 }
 
 export interface FileExtendedAttributesParsed {
-    claimedSize?: number,
-    claimedModificationTime?: Date,
+    claimedSize?: number;
+    claimedModificationTime?: Date;
     claimedDigests?: {
-        sha1?: string,
-    },
-    claimedAdditionalMetadata?: object,
+        sha1?: string;
+    };
+    claimedAdditionalMetadata?: object;
 }
 
 export function generateFolderExtendedAttributes(claimedModificationTime?: Date): string | undefined {
@@ -83,12 +83,12 @@ export function parseFolderExtendedAttributes(logger: Logger, extendedAttributes
 }
 
 export function generateFileExtendedAttributes(options: {
-    modificationTime?: Date,
-    size?: number,
-    blockSizes?: number[],
+    modificationTime?: Date;
+    size?: number;
+    blockSizes?: number[];
     digests?: {
-        sha1?: string,
-    },
+        sha1?: string;
+    };
 }): string | undefined {
     const commonAttributes: FileExtendedAttributesSchema['Common'] = {};
     if (options.modificationTime) {
@@ -115,7 +115,7 @@ export function generateFileExtendedAttributes(options: {
 
 export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?: string): FileExtendedAttributesParsed {
     if (!extendedAttributes) {
-        return {}
+        return {};
     }
 
     try {
@@ -128,7 +128,9 @@ export function parseFileExtendedAttributes(logger: Logger, extendedAttributes?:
             claimedSize: parseSize(logger, parsed),
             claimedModificationTime: parseModificationTime(logger, parsed),
             claimedDigests: parseDigests(logger, parsed),
-            claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length ? claimedAdditionalMetadata : undefined,
+            claimedAdditionalMetadata: Object.keys(claimedAdditionalMetadata).length
+                ? claimedAdditionalMetadata
+                : undefined,
         };
     } catch (error: unknown) {
         logger.error(`Failed to parse extended attributes`, error);
@@ -148,7 +150,10 @@ function parseSize(logger: Logger, xattr?: FileExtendedAttributesSchema): number
     return size;
 }
 
-function parseModificationTime(logger: Logger, xattr?: FolderExtendedAttributesSchema | FolderExtendedAttributesSchema): Date | undefined {
+function parseModificationTime(
+    logger: Logger,
+    xattr?: FolderExtendedAttributesSchema | FolderExtendedAttributesSchema,
+): Date | undefined {
     const modificationTime = xattr?.Common?.ModificationTime;
     if (modificationTime === undefined) {
         return undefined;

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

@@ -0,0 +1,133 @@
+import {
+    ProtonDriveEntitiesCache,
+    ProtonDriveCryptoCache,
+    ProtonDriveAccount,
+    MemberRole,
+    NodeType,
+} from '../../interface';
+import { DriveCrypto } from '../../crypto';
+import { MemoryCache } from '../../cache';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { DriveAPIService } from '../apiService';
+import { DriveEventType } from '../events';
+import { makeNodeUid } from '../uids';
+import { SharesService, DecryptedNode } from './interface';
+import { initNodesModule } from './index';
+import { NodesCache } from './cache';
+import { getMockLogger } from '../../tests/logger';
+
+function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): DecryptedNode {
+    return {
+        uid,
+        parentUid,
+        directMemberRole: MemberRole.Admin,
+        type: NodeType.File,
+        mediaType: 'text',
+        isShared: false,
+        creationTime: new Date(),
+        trashTime: undefined,
+        isStale: false,
+        ...params,
+    } as DecryptedNode;
+}
+
+describe('nodesModules integration tests', () => {
+    let apiService: DriveAPIService;
+    let driveEntitiesCache: ProtonDriveEntitiesCache;
+    let driveCryptoCache: ProtonDriveCryptoCache;
+    let account: ProtonDriveAccount;
+    let driveCrypto: DriveCrypto;
+    let sharesService: SharesService;
+    let nodesModule: ReturnType<typeof initNodesModule>;
+    let nodesCache: NodesCache;
+
+    beforeEach(() => {
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {};
+        driveEntitiesCache = new MemoryCache();
+        driveCryptoCache = new MemoryCache();
+        // @ts-expect-error No need to implement all methods for mocking
+        account = {};
+        // @ts-expect-error No need to implement all methods for mocking
+        driveCrypto = {};
+        // @ts-expect-error No need to implement all methods for mocking
+        sharesService = {
+            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+        };
+
+        nodesModule = initNodesModule(
+            getMockTelemetry(),
+            apiService,
+            driveEntitiesCache,
+            driveCryptoCache,
+            account,
+            driveCrypto,
+            sharesService,
+        );
+
+        nodesCache = new NodesCache(getMockLogger(), driveEntitiesCache);
+    });
+
+    test('should move node from one folder to another after move event', async () => {
+        // Prepare two folders (original and target) and a node in the original folder.
+        const originalFolderUid = makeNodeUid('volumeId', 'originalFolder');
+        const targetFolderUid = makeNodeUid('volumeId', 'targetFolder');
+        const nodeUid = makeNodeUid('volumeId', 'node1');
+
+        await nodesCache.setNode(generateNode(originalFolderUid));
+        await nodesCache.setFolderChildrenLoaded(originalFolderUid);
+        await nodesCache.setNode(generateNode(targetFolderUid));
+        await nodesCache.setFolderChildrenLoaded(targetFolderUid);
+        await nodesCache.setNode(generateNode(nodeUid, originalFolderUid));
+
+        // Mock the API services to return the moved node.
+        // This is called when listing the children of the target folder after
+        // move event (when node marked as stale).
+        apiService.post = jest.fn().mockImplementation(async (url, body) => {
+            expect(url).toBe(`drive/v2/volumes/volumeId/links`);
+            return {
+                Links: [
+                    {
+                        Link: {
+                            LinkID: 'node1',
+                            ParentLinkID: 'targetFolder',
+                            NameHash: 'hash',
+                            Type: 2,
+                        },
+                        File: {
+                            ActiveRevision: {},
+                        },
+                    },
+                ],
+            };
+        });
+        jest.spyOn(nodesModule.access, 'getParentKeys').mockResolvedValue({ key: { _idx: 32131 } } as any);
+
+        // Verify the inital state before move event is sent.
+        const originalBeforeMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(originalFolderUid));
+        expect(originalBeforeMove).toMatchObject([{ uid: nodeUid, parentUid: originalFolderUid }]);
+
+        const targetBeforeMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(targetFolderUid));
+        expect(targetBeforeMove).toMatchObject([]);
+
+        // Send the move event that updates the cache.
+        await nodesModule.eventHandler.updateNodesCacheOnEvent({
+            type: DriveEventType.NodeUpdated,
+            nodeUid,
+            parentNodeUid: targetFolderUid,
+            isTrashed: false,
+            isShared: false,
+            treeEventScopeId: 'volumeId',
+            eventId: '1',
+        });
+
+        // Verify the state after the move event, including when API service is called.
+        const originalAfterMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(originalFolderUid));
+        expect(originalAfterMove).toMatchObject([]);
+        expect(apiService.post).not.toHaveBeenCalled();
+
+        const targetAfterMove = await Array.fromAsync(nodesModule.access.iterateFolderChildren(targetFolderUid));
+        expect(targetAfterMove).toMatchObject([{ uid: nodeUid, parentUid: targetFolderUid }]);
+        expect(apiService.post).toHaveBeenCalledTimes(1);
+    });
+});

package/src/internal/nodes/index.ts

@@ -1,18 +1,23 @@
-import { DriveAPIService } from "../apiService";
-import { DriveCrypto } from "../../crypto";
-import { ProtonDriveEntitiesCache, ProtonDriveCryptoCache, ProtonDriveAccount, ProtonDriveTelemetry } from "../../interface";
-import { NodeAPIService } from "./apiService";
-import { NodesCache } from "./cache";
-import { NodesCryptoCache } from "./cryptoCache";
-import { NodesCryptoService } from "./cryptoService";
-import { SharesService } from "./interface";
-import { NodesAccess } from "./nodesAccess";
-import { NodesManagement } from "./nodesManagement";
-import { NodesRevisons } from "./nodesRevisions";
-import { NodesEventsHandler } from "./events";
+import { DriveAPIService } from '../apiService';
+import { DriveCrypto } from '../../crypto';
+import {
+    ProtonDriveEntitiesCache,
+    ProtonDriveCryptoCache,
+    ProtonDriveAccount,
+    ProtonDriveTelemetry,
+} from '../../interface';
+import { NodeAPIService } from './apiService';
+import { NodesCache } from './cache';
+import { NodesCryptoCache } from './cryptoCache';
+import { NodesCryptoService } from './cryptoService';
+import { SharesService } from './interface';
+import { NodesAccess } from './nodesAccess';
+import { NodesManagement } from './nodesManagement';
+import { NodesRevisons } from './nodesRevisions';
+import { NodesEventsHandler } from './events';
 
-export type { DecryptedNode, DecryptedRevision } from "./interface";
-export { generateFileExtendedAttributes } from "./extendedAttributes";
+export type { DecryptedNode, DecryptedRevision } from './interface';
+export { generateFileExtendedAttributes } from './extendedAttributes';
 
 /**
  * Provides facade for the whole nodes module.
@@ -36,7 +41,14 @@ export function initNodesModule(
     const cache = new NodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
     const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
     const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
-    const nodesAccess = new NodesAccess(telemetry.getLogger('nodes'), api, cache, cryptoCache, cryptoService, sharesService);
+    const nodesAccess = new NodesAccess(
+        telemetry.getLogger('nodes'),
+        api,
+        cache,
+        cryptoCache,
+        cryptoService,
+        sharesService,
+    );
     const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
     const nodesManagement = new NodesManagement(api, cryptoCache, cryptoService, nodesAccess);
     const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);

package/src/internal/nodes/interface.ts

@@ -1,5 +1,16 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { NodeEntity, Result, InvalidNameError, Author, MemberRole, NodeType, ThumbnailType, MetricVolumeType, Revision, RevisionState } from "../../interface";
+import { PrivateKey, SessionKey } from '../../crypto';
+import {
+    NodeEntity,
+    Result,
+    InvalidNameError,
+    Author,
+    MemberRole,
+    NodeType,
+    ThumbnailType,
+    MetricVolumeType,
+    Revision,
+    RevisionState,
+} from '../../interface';
 
 /**
  * Internal common node interface for both encrypted or decrypted node.
@@ -20,8 +31,8 @@ interface BaseNode {
 
     // Share node metadata
     shareId?: string;
-    isShared: boolean,
-    directMemberRole: MemberRole,
+    isShared: boolean;
+    directMemberRole: MemberRole;
 }
 
 /**
@@ -68,28 +79,30 @@ export interface EncryptedNodeAlbumCrypto extends EncryptedNodeCrypto {}
  * such as extended attributes.
  */
 export interface DecryptedUnparsedNode extends BaseNode {
-    keyAuthor: Author,
-    nameAuthor: Author,
-    name: Result<string, Error>,
-    activeRevision?: Result<DecryptedUnparsedRevision, Error>,
+    keyAuthor: Author;
+    nameAuthor: Author;
+    name: Result<string, Error>;
+    activeRevision?: Result<DecryptedUnparsedRevision, Error>;
     folder?: {
-        extendedAttributes?: string,
-    },
-    errors?: unknown[],
+        extendedAttributes?: string;
+    };
+    errors?: unknown[];
 }
 
 /**
  * Interface holding decrypted node metadata.
  */
-export interface DecryptedNode extends Omit<DecryptedUnparsedNode, 'name' | 'activeRevision' | 'folder'>, Omit<NodeEntity, 'name' | 'activeRevision'> {
+export interface DecryptedNode
+    extends Omit<DecryptedUnparsedNode, 'name' | 'activeRevision' | 'folder'>,
+        Omit<NodeEntity, 'name' | 'activeRevision'> {
     // Internal metadata
     isStale: boolean;
-    name: Result<string, Error | InvalidNameError>,
+    name: Result<string, Error | InvalidNameError>;
 
-    activeRevision?: Result<DecryptedRevision, Error>,
+    activeRevision?: Result<DecryptedRevision, Error>;
     folder?: {
-        claimedModificationTime?: Date,
-    },
+        claimedModificationTime?: Date;
+    };
 }
 
 /**
@@ -120,7 +133,7 @@ interface BaseRevision {
 export type Thumbnail = {
     uid: string;
     type: ThumbnailType;
-}
+};
 
 export interface EncryptedRevision extends BaseRevision {
     signatureEmail?: string;
@@ -128,8 +141,8 @@ export interface EncryptedRevision extends BaseRevision {
 }
 
 export interface DecryptedUnparsedRevision extends BaseRevision {
-    contentAuthor: Author,
-    extendedAttributes?: string,
+    contentAuthor: Author;
+    extendedAttributes?: string;
 }
 
 export interface DecryptedRevision extends Revision {
@@ -140,16 +153,16 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string, rootNodeId: string }>,
-    getSharePrivateKey(shareId: string): Promise<PrivateKey>,
+    getMyFilesIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
-        email: string,
-    }>,
+        email: string;
+    }>;
     getContextShareMemberEmailKey(shareId: string): Promise<{
-        email: string,
-        addressId: string,
-        addressKey: PrivateKey,
-        addressKeyId: string,
-    }>,
-    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>,
+        email: string;
+        addressId: string;
+        addressKey: PrivateKey;
+        addressKeyId: string;
+    }>;
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }