@protontech/drive-sdk 0.3.2 → 0.4.1

package/src/internal/nodes/apiService.ts

@@ -6,6 +6,7 @@ import { MemberRole, RevisionState } from '../../interface/nodes';
 import {
     DriveAPIService,
     drivePaths,
+    InvalidRequirementsAPIError,
     isCodeOk,
     nodeTypeNumberToNodeType,
     permissionsToMemberRole,
@@ -13,7 +14,8 @@ import {
 import { asyncIteratorRace } from '../asyncIteratorRace';
 import { batch } from '../batch';
 import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from '../uids';
-import { EncryptedNode, EncryptedRevision, Thumbnail } from './interface';
+import { NodeOutOfSyncError } from './errors';
+import { EncryptedNode, EncryptedRevision, FilterOptions, Thumbnail } from './interface';
 
 // This is the number of calls to the API that are made in parallel.
 const API_CONCURRENCY = 15;
@@ -48,6 +50,13 @@ type PutMoveNodeRequest = Extract<
 type PutMoveNodeResponse =
     drivePaths['/drive/v2/volumes/{volumeID}/links/{linkID}/move']['put']['responses']['200']['content']['application/json'];
 
+type PostCopyNodeRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCopyNodeResponse =
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['responses']['200']['content']['application/json'];
+
 type PostTrashNodesRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/trash_multiple']['post']['requestBody'],
     { content: object }
@@ -108,7 +117,7 @@ export class NodeAPIService {
     }
 
     async getNode(nodeUid: string, ownVolumeId: string, signal?: AbortSignal): Promise<EncryptedNode> {
-        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, signal);
+        const nodesGenerator = this.iterateNodes([nodeUid], ownVolumeId, undefined, signal);
         const result = await nodesGenerator.next();
         if (!result.value) {
             throw new ValidationError(c('Error').t`Node not found`);
@@ -117,7 +126,12 @@ export class NodeAPIService {
         return result.value;
     }
 
-    async *iterateNodes(nodeUids: string[], ownVolumeId: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
+    async *iterateNodes(
+        nodeUids: string[],
+        ownVolumeId: string,
+        filterOptions?: FilterOptions,
+        signal?: AbortSignal,
+    ): AsyncGenerator<EncryptedNode> {
         const allNodeIds = nodeUids.map(splitNodeUid);
 
         const nodeIdsByVolumeId = new Map<string, string[]>();
@@ -139,7 +153,13 @@ export class NodeAPIService {
                 const isAdmin = volumeId === ownVolumeId;
 
                 yield (async function* () {
-                    const errorsPerVolume = yield* iterateNodesPerVolume(volumeId, nodeIds, isAdmin, signal);
+                    const errorsPerVolume = yield* iterateNodesPerVolume(
+                        volumeId,
+                        nodeIds,
+                        isAdmin,
+                        filterOptions,
+                        signal,
+                    );
                     if (errorsPerVolume.length) {
                         errors.push(...errorsPerVolume);
                     }
@@ -159,6 +179,7 @@ export class NodeAPIService {
         volumeId: string,
         nodeIds: string[],
         isOwnVolumeId: boolean,
+        filterOptions?: FilterOptions,
         signal?: AbortSignal,
     ): AsyncGenerator<EncryptedNode, unknown[]> {
         const errors: unknown[] = [];
@@ -174,7 +195,11 @@ export class NodeAPIService {
 
             for (const link of response.Links) {
                 try {
-                    yield linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    const encryptedNode = linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+                    if (filterOptions?.type && encryptedNode.type !== filterOptions.type) {
+                        continue;
+                    }
+                    yield encryptedNode;
                 } catch (error: unknown) {
                     this.logger.error(`Failed to transform node ${link.Link.LinkID}`, error);
                     errors.push(error);
@@ -186,13 +211,25 @@ export class NodeAPIService {
     }
 
     // Improvement requested: load next page sooner before all IDs are yielded.
-    async *iterateChildrenNodeUids(parentNodeUid: string, signal?: AbortSignal): AsyncGenerator<string> {
+    async *iterateChildrenNodeUids(
+        parentNodeUid: string,
+        onlyFolders: boolean = false,
+        signal?: AbortSignal,
+    ): AsyncGenerator<string> {
         const { volumeId, nodeId } = splitNodeUid(parentNodeUid);
 
         let anchor = '';
         while (true) {
+            const queryParams = new URLSearchParams();
+            if (onlyFolders) {
+                queryParams.set('FoldersOnly', '1');
+            }
+            if (anchor) {
+                queryParams.set('AnchorID', anchor);
+            }
+
             const response = await this.apiService.get<GetChildrenResponse>(
-                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${anchor ? `AnchorID=${anchor}` : ''}`,
+                `drive/v2/volumes/${volumeId}/folders/${nodeId}/children?${queryParams.toString()}`,
                 signal,
             );
             for (const linkID of response.LinkIDs) {
@@ -251,16 +288,28 @@ export class NodeAPIService {
     ): Promise<void> {
         const { volumeId, nodeId } = splitNodeUid(nodeUid);
 
-        await this.apiService.put<Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>, PutRenameNodeResponse>(
-            `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
-            {
-                Name: newNode.encryptedName,
-                NameSignatureEmail: newNode.nameSignatureEmail,
-                Hash: newNode.hash,
-                OriginalHash: originalNode.hash || null,
-            },
-            signal,
-        );
+        try {
+            await this.apiService.put<
+                Omit<PutRenameNodeRequest, 'SignatureAddress' | 'MIMEType'>,
+                PutRenameNodeResponse
+            >(
+                `drive/v2/volumes/${volumeId}/links/${nodeId}/rename`,
+                {
+                    Name: newNode.encryptedName,
+                    NameSignatureEmail: newNode.nameSignatureEmail,
+                    Hash: newNode.hash,
+                    OriginalHash: originalNode.hash || null,
+                },
+                signal,
+            );
+        } catch (error: unknown) {
+            // API returns generic code 2000 when node is out of sync.
+            // We map this to specific error for clarity.
+            if (error instanceof InvalidRequirementsAPIError) {
+                throw new NodeOutOfSyncError(error.message, error.code, { cause: error });
+            }
+            throw error;
+        }
     }
 
     async moveNode(
@@ -303,6 +352,43 @@ export class NodeAPIService {
         );
     }
 
+    async copyNode(
+        nodeUid: string,
+        newNode: {
+            parentUid: string;
+            armoredNodePassphrase: string;
+            armoredNodePassphraseSignature?: string;
+            signatureEmail?: string;
+            encryptedName: string;
+            nameSignatureEmail?: string;
+            hash: string;
+        },
+        signal?: AbortSignal,
+    ): Promise<string> {
+        const { volumeId, nodeId } = splitNodeUid(nodeUid);
+        const { volumeId: parentVolumeId, nodeId: parentNodeId } = splitNodeUid(newNode.parentUid);
+
+        const response = await this.apiService.post<PostCopyNodeRequest, PostCopyNodeResponse>(
+            `drive/volumes/${volumeId}/links/${nodeId}/copy`,
+            {
+                TargetVolumeID: parentVolumeId,
+                TargetParentLinkID: parentNodeId,
+                NodePassphrase: newNode.armoredNodePassphrase,
+                // @ts-expect-error: API accepts NodePassphraseSignature as optional.
+                NodePassphraseSignature: newNode.armoredNodePassphraseSignature,
+                // @ts-expect-error: API accepts SignatureEmail as optional.
+                SignatureEmail: newNode.signatureEmail,
+                Name: newNode.encryptedName,
+                // @ts-expect-error: API accepts NameSignatureEmail as optional.
+                NameSignatureEmail: newNode.nameSignatureEmail,
+                Hash: newNode.hash,
+            },
+            signal,
+        );
+
+        return makeNodeUid(volumeId, response.LinkID);
+    }
+
     // Improvement requested: split into multiple calls for many nodes.
     async *trashNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         const nodeIds = nodeUids.map(splitNodeUid);
@@ -491,6 +577,7 @@ function linkToEncryptedNode(
         // Sharing node metadata
         shareId: link.Sharing?.ShareID || undefined,
         isShared: !!link.Sharing,
+        isSharedPublicly: !!link.Sharing?.ShareURLID,
         directRole: isAdmin ? MemberRole.Admin : membershipRole,
         membership: link.Membership
             ? {

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

@@ -21,6 +21,7 @@ function generateNode(
         type: NodeType.File,
         mediaType: 'text',
         isShared: false,
+        isSharedPublicly: false,
         creationTime: new Date(),
         trashTime: undefined,
         volumeId: 'volumeId',

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

@@ -985,7 +985,7 @@ describe('nodesCryptoService', () => {
         });
     });
 
-    describe('moveNode', () => {
+    describe('encryptNodeWithNewParent', () => {
         it('should encrypt node data for move operation', async () => {
             const node = {
                 name: { ok: true, value: 'testFile.txt' },
@@ -1012,7 +1012,7 @@ describe('nodesCryptoService', () => {
                 armoredPassphraseSignature: 'passphraseSignature',
             });
 
-            const result = await cryptoService.moveNode(node, keys as any, parentKeys, address);
+            const result = await cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address);
 
             expect(result).toEqual({
                 encryptedName: 'encryptedNodeName',
@@ -1056,9 +1056,9 @@ describe('nodesCryptoService', () => {
                 addressKey: 'addressKey' as any,
             };
 
-            await expect(cryptoService.moveNode(node, keys as any, parentKeys, address)).rejects.toThrow(
-                'Moving item to a non-folder is not allowed',
-            );
+            await expect(
+                cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address),
+            ).rejects.toThrow('Moving item to a non-folder is not allowed');
         });
 
         it('should throw error when node has invalid name', async () => {
@@ -1079,9 +1079,9 @@ describe('nodesCryptoService', () => {
                 addressKey: 'addressKey' as any,
             };
 
-            await expect(cryptoService.moveNode(node, keys as any, parentKeys, address)).rejects.toThrow(
-                'Cannot move item without a valid name, please rename the item first',
-            );
+            await expect(
+                cryptoService.encryptNodeWithNewParent(node, keys as any, parentKeys, address),
+            ).rejects.toThrow('Cannot move item without a valid name, please rename the item first');
         });
     });
 });

package/src/internal/nodes/cryptoService.ts

@@ -601,7 +601,7 @@ export class NodesCryptoService {
         };
     }
 
-    async moveNode(
+    async encryptNodeWithNewParent(
         node: Pick<DecryptedNode, 'name'>,
         keys: { passphrase: string; passphraseSessionKey: SessionKey; nameSessionKey: SessionKey },
         parentKeys: { key: PrivateKey; hashKey: Uint8Array },

package/src/internal/nodes/errors.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../errors";
+
+export class NodeOutOfSyncError extends ValidationError {
+    name = 'NodeOutOfSyncError';
+}

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

@@ -50,7 +50,7 @@ describe('extended attrbiutes', () => {
         });
     });
 
-    describe('should generate file attributes', () => {
+    describe('should generate file attributes without additional metadata', () => {
         const testCases: [object, string | undefined][] = [
             [{}, undefined],
             [
@@ -82,6 +82,28 @@ describe('extended attrbiutes', () => {
         });
     });
 
+    describe('should generate file attributes with additional metadata', () => {
+        const testCases: [object, string | undefined][] = [
+            [{}, '{"Media":{"Width":100,"Height":100}}'],
+            [{ size: undefined }, '{"Media":{"Width":100,"Height":100}}'],
+            [{ size: 123 }, '{"Common":{"Size":123},"Media":{"Width":100,"Height":100}}'],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should generate ${input}`, () => {
+                const output = generateFileExtendedAttributes(input, { Media: { Width: 100, Height: 100 } });
+                expect(output).toBe(expectedAttributes);
+            });
+        });
+    });
+
+    describe('should throw an error if additional metadata contains common attributes', () => {
+        it('should throw an error', () => {
+            expect(() => generateFileExtendedAttributes({ size: 123 }, { Common: { Hello: 'World' } })).toThrow(
+                'Common attributes are not allowed in additional metadata',
+            );
+        });
+    });
+
     describe('should parses file attributes', () => {
         const testCases: [Date, string, FileExtendedAttributesParsed][] = [
             [new Date('2025-01-01'), '', {}],

package/src/internal/nodes/extendedAttributes.ts

@@ -83,34 +83,42 @@ export function parseFolderExtendedAttributes(logger: Logger, extendedAttributes
     }
 }
 
-export function generateFileExtendedAttributes(options: {
-    modificationTime?: Date;
-    size?: number;
-    blockSizes?: number[];
-    digests?: {
-        sha1?: string;
-    };
-}): string | undefined {
+export function generateFileExtendedAttributes(
+    common: {
+        modificationTime?: Date;
+        size?: number;
+        blockSizes?: number[];
+        digests?: {
+            sha1?: string;
+        };
+    },
+    additionalMetadata?: object,
+): string | undefined {
+    if (additionalMetadata && 'Common' in additionalMetadata) {
+        throw new Error('Common attributes are not allowed in additional metadata');
+    }
+
     const commonAttributes: FileExtendedAttributesSchema['Common'] = {};
-    if (options.modificationTime) {
-        commonAttributes.ModificationTime = dateToIsoString(options.modificationTime);
+    if (common.modificationTime) {
+        commonAttributes.ModificationTime = dateToIsoString(common.modificationTime);
     }
-    if (options.size !== undefined) {
-        commonAttributes.Size = options.size;
+    if (common.size !== undefined) {
+        commonAttributes.Size = common.size;
     }
-    if (options.blockSizes?.length) {
-        commonAttributes.BlockSizes = options.blockSizes;
+    if (common.blockSizes?.length) {
+        commonAttributes.BlockSizes = common.blockSizes;
     }
-    if (options.digests?.sha1) {
+    if (common.digests?.sha1) {
         commonAttributes.Digests = {
-            SHA1: options.digests.sha1,
+            SHA1: common.digests.sha1,
         };
     }
-    if (!Object.keys(commonAttributes).length) {
+    if (!Object.keys(commonAttributes).length && !additionalMetadata) {
         return undefined;
     }
     return JSON.stringify({
-        Common: commonAttributes,
+        ...(Object.keys(commonAttributes).length ? { Common: commonAttributes } : {}),
+        ...(additionalMetadata ? { ...additionalMetadata } : {}),
     });
 }
 

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

@@ -24,6 +24,7 @@ function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<
         type: NodeType.File,
         mediaType: 'text',
         isShared: false,
+        isSharedPublicly: false,
         creationTime: new Date(),
         trashTime: undefined,
         isStale: false,
@@ -52,7 +53,7 @@ describe('nodesModules integration tests', () => {
         driveCrypto = {};
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
         };
 
         nodesModule = initNodesModule(

package/src/internal/nodes/interface.ts

@@ -12,6 +12,10 @@ import {
     RevisionState,
 } from '../../interface';
 
+export type FilterOptions = {
+    type?: NodeType;
+};
+
 /**
  * Internal common node interface for both encrypted or decrypted node.
  */
@@ -34,6 +38,7 @@ interface BaseNode {
     // Share node metadata
     shareId?: string;
     isShared: boolean;
+    isSharedPublicly: boolean;
     directRole: MemberRole;
     membership?: {
         role: MemberRole;
@@ -172,7 +177,7 @@ export interface DecryptedRevision extends Revision {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getMyFilesIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
+    getOwnVolumeIDs(): Promise<{ volumeId: string; rootNodeId: string }>;
     getSharePrivateKey(shareId: string): Promise<PrivateKey>;
     getMyFilesShareMemberEmailKey(): Promise<{
         email: string;

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

@@ -46,7 +46,7 @@ describe('nodesAccess', () => {
         };
         // @ts-expect-error No need to implement all methods for mocking
         shareService = {
-            getMyFilesIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
+            getOwnVolumeIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId' }),
             getSharePrivateKey: jest.fn(),
         };
 
@@ -209,7 +209,12 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node4, node2, node3]);
-                expect(apiService.iterateNodes).toHaveBeenCalledWith([node2.uid, node3.uid], 'volumeId', undefined);
+                expect(apiService.iterateNodes).toHaveBeenCalledWith(
+                    [node2.uid, node3.uid],
+                    'volumeId',
+                    undefined, // filterOptions
+                    undefined, // signal
+                );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(2);
                 expect(cache.setNode).toHaveBeenCalledTimes(2);
                 expect(cryptoCache.setNodeKeys).toHaveBeenCalledTimes(2);
@@ -226,7 +231,11 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith(
+                    'volumeId~parentNodeid',
+                    false, // onlyFolders
+                    undefined, // signal
+                );
                 expect(apiService.iterateNodes).not.toHaveBeenCalled();
                 expect(cache.setFolderChildrenLoaded).toHaveBeenCalledWith('volumeId~parentNodeid');
             });
@@ -247,11 +256,16 @@ describe('nodesAccess', () => {
 
                 const result = await Array.fromAsync(access.iterateFolderChildren('volumeId~parentNodeid'));
                 expect(result).toMatchObject([node1, node2, node3, node4]);
-                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith('volumeId~parentNodeid', undefined);
+                expect(apiService.iterateChildrenNodeUids).toHaveBeenCalledWith(
+                    'volumeId~parentNodeid',
+                    false, // onlyFolders
+                    undefined, // signal
+                );
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
                     'volumeId',
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
@@ -320,6 +334,50 @@ describe('nodesAccess', () => {
                     expect(error.cause).toEqual([new DecryptionError('Decryption failed')]);
                 }
             });
+
+            it('should return only filtered nodes from cache', async () => {
+                cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(true);
+                cache.iterateChildren = jest.fn().mockImplementation(async function* () {
+                    yield { ok: true, node: { ...node1, type: NodeType.Folder } };
+                    yield { ok: true, node: { ...node2, type: NodeType.Folder } };
+                    yield { ok: true, node: { ...node3, type: NodeType.File } };
+                    yield { ok: true, node: { ...node4, type: NodeType.File } };
+                });
+
+                const result = await Array.fromAsync(
+                    access.iterateFolderChildren('volumeId~parentNodeid', { type: NodeType.Folder }),
+                );
+
+                expect(result).toMatchObject([node1, node2]);
+                expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
+            });
+
+            it.only('should return only filtered nodes from API', async () => {
+                cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(false);
+                cache.getNode = jest.fn().mockImplementation((uid: string) => {
+                    if (uid === parentNode.uid) {
+                        return parentNode;
+                    }
+                    throw new Error('Entity not found');
+                });
+                apiService.iterateChildrenNodeUids = jest.fn().mockImplementation(async function* () {
+                    yield 'volumeId~node1';
+                    yield 'volumeId~node2';
+                    yield 'volumeId~node3';
+                    yield 'volumeId~node4';
+                });
+                apiService.iterateNodes = jest.fn().mockImplementation(async function* () {
+                    yield { ...node1, parentUid: 'volumeId~parentNodeId', type: NodeType.Folder };
+                    yield { ...node2, parentUid: 'volumeId~parentNodeId', type: NodeType.Folder };
+                });
+
+                const result = await Array.fromAsync(
+                    access.iterateFolderChildren('volumeId~parentNodeid', { type: NodeType.Folder }),
+                );
+
+                expect(result).toMatchObject([node1, node2]);
+                expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
+            });
         });
 
         describe('iterateTrashedNodes', () => {
@@ -330,7 +388,7 @@ describe('nodesAccess', () => {
             const node4 = { uid: 'volumeId~node4', isStale: false } as DecryptedNode;
 
             beforeEach(() => {
-                shareService.getMyFilesIDs = jest.fn().mockResolvedValue({ volumeId });
+                shareService.getOwnVolumeIDs = jest.fn().mockResolvedValue({ volumeId });
                 apiService.iterateTrashedNodeUids = jest.fn().mockImplementation(async function* () {
                     yield node1.uid;
                     yield node2.uid;
@@ -359,7 +417,8 @@ describe('nodesAccess', () => {
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node1', 'volumeId~node2', 'volumeId~node3', 'volumeId~node4'],
                     volumeId,
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
                 expect(cryptoService.decryptNode).toHaveBeenCalledTimes(4);
                 expect(cache.setNode).toHaveBeenCalledTimes(4);
@@ -417,7 +476,8 @@ describe('nodesAccess', () => {
                 expect(apiService.iterateNodes).toHaveBeenCalledWith(
                     ['volumeId~node2', 'volumeId~node3'],
                     'volumeId',
-                    undefined,
+                    undefined, // filterOptions
+                    undefined, // signal
                 );
             });