@protontech/drive-sdk 0.9.7 → 0.9.9

package/src/internal/photos/albums.test.ts

@@ -0,0 +1,268 @@
+import { NodeType, MemberRole } from '../../interface';
+import { ValidationError } from '../../errors';
+import { Albums } from './albums';
+import { AlbumsCryptoService } from './albumsCrypto';
+import { PhotosAPIService } from './apiService';
+import { DecryptedPhotoNode } from './interface';
+import { PhotosNodesAccess } from './nodes';
+import { PhotoSharesManager } from './shares';
+
+describe('Albums', () => {
+    let apiService: PhotosAPIService;
+    let cryptoService: AlbumsCryptoService;
+    let photoShares: PhotoSharesManager;
+    let nodesService: PhotosNodesAccess;
+    let albums: Albums;
+
+    let nodes: { [uid: string]: DecryptedPhotoNode };
+
+    beforeEach(() => {
+        nodes = {
+            rootNodeUid: {
+                uid: 'rootNodeUid',
+                parentUid: '',
+                hash: 'rootHash',
+            } as DecryptedPhotoNode,
+            albumNodeUid: {
+                uid: 'albumNodeUid',
+                parentUid: 'rootNodeUid',
+                name: { ok: true, value: 'old album name' },
+                hash: 'albumHash',
+                encryptedName: 'encryptedAlbumName',
+            } as DecryptedPhotoNode,
+        };
+
+        // @ts-expect-error No need to implement all methods for mocking
+        apiService = {
+            createAlbum: jest.fn().mockResolvedValue('volumeId~newAlbumNodeId'),
+            updateAlbum: jest.fn(),
+            deleteAlbum: jest.fn(),
+            removePhotosFromAlbum: jest.fn(),
+        };
+
+        // @ts-expect-error No need to implement all methods for mocking
+        cryptoService = {
+            createAlbum: jest.fn().mockResolvedValue({
+                encryptedCrypto: {
+                    encryptedName: 'newEncryptedAlbumName',
+                    hash: 'newAlbumHash',
+                    armoredKey: 'armoredKey',
+                    armoredNodePassphrase: 'armoredNodePassphrase',
+                    armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                    signatureEmail: 'signature@example.com',
+                    armoredHashKey: 'armoredHashKey',
+                },
+                keys: {
+                    passphrase: 'passphrase',
+                    key: 'nodeKey',
+                    passphraseSessionKey: 'passphraseSessionKey',
+                    hashKey: new Uint8Array([1, 2, 3]),
+                },
+            }),
+            renameAlbum: jest.fn().mockResolvedValue({
+                signatureEmail: 'newSignatureEmail',
+                armoredNodeName: 'newArmoredAlbumName',
+                hash: 'newHash',
+            }),
+        };
+
+        // @ts-expect-error No need to implement all methods for mocking
+        photoShares = {
+            getRootIDs: jest.fn().mockResolvedValue({ volumeId: 'volumeId', rootNodeId: 'rootNodeId' }),
+        };
+
+        // @ts-expect-error No need to implement all methods for mocking
+        nodesService = {
+            getVolumeRootFolder: jest.fn().mockResolvedValue(nodes.rootNodeUid),
+            getNode: jest.fn().mockImplementation((uid: string) => nodes[uid]),
+            getNodeKeys: jest.fn().mockImplementation((uid) => ({
+                key: `${uid}-key`,
+                hashKey: `${uid}-hashKey`,
+                passphrase: `${uid}-passphrase`,
+                passphraseSessionKey: `${uid}-passphraseSessionKey`,
+            })),
+            getParentKeys: jest.fn().mockImplementation(({ parentUid }) => ({
+                key: `${parentUid}-key`,
+                hashKey: `${parentUid}-hashKey`,
+            })),
+            getNodeSigningKeys: jest.fn().mockResolvedValue({
+                type: 'userAddress',
+                email: 'user@example.com',
+                addressId: 'addressId',
+                key: 'addressKey',
+            }),
+            notifyNodeChanged: jest.fn(),
+            notifyNodeDeleted: jest.fn(),
+            notifyChildCreated: jest.fn(),
+        };
+
+        albums = new Albums(apiService, cryptoService, photoShares, nodesService);
+    });
+
+    describe('createAlbum', () => {
+        it('creates album and returns decrypted node', async () => {
+            const newAlbum = await albums.createAlbum('My New Album');
+
+            expect(newAlbum).toEqual(
+                expect.objectContaining({
+                    uid: 'volumeId~newAlbumNodeId',
+                    parentUid: 'rootNodeUid',
+                    type: NodeType.Album,
+                    mediaType: 'Album',
+                    name: { ok: true, value: 'My New Album' },
+                    hash: 'newAlbumHash',
+                    encryptedName: 'newEncryptedAlbumName',
+                    keyAuthor: { ok: true, value: 'signature@example.com' },
+                    nameAuthor: { ok: true, value: 'signature@example.com' },
+                }),
+            );
+
+            expect(nodesService.getNodeSigningKeys).toHaveBeenCalledWith({ parentNodeUid: 'rootNodeUid' });
+            expect(cryptoService.createAlbum).toHaveBeenCalledWith(
+                { key: 'rootNodeUid-key', hashKey: 'rootNodeUid-hashKey' },
+                { type: 'userAddress', email: 'user@example.com', addressId: 'addressId', key: 'addressKey' },
+                'My New Album',
+            );
+            expect(apiService.createAlbum).toHaveBeenCalledWith('rootNodeUid', {
+                encryptedName: 'newEncryptedAlbumName',
+                hash: 'newAlbumHash',
+                armoredKey: 'armoredKey',
+                armoredNodePassphrase: 'armoredNodePassphrase',
+                armoredNodePassphraseSignature: 'armoredNodePassphraseSignature',
+                signatureEmail: 'signature@example.com',
+                armoredHashKey: 'armoredHashKey',
+            });
+            expect(nodesService.notifyChildCreated).toHaveBeenCalledWith('rootNodeUid');
+        });
+
+        it('throws validation error for invalid album name', async () => {
+            await expect(albums.createAlbum('invalid/name')).rejects.toThrow(ValidationError);
+        });
+
+        it('throws error when parent hash key is not available', async () => {
+            nodesService.getNodeKeys = jest.fn().mockResolvedValue({
+                key: 'rootNodeUid-key',
+                hashKey: undefined,
+            });
+
+            await expect(albums.createAlbum('My Album')).rejects.toThrow(
+                'Cannot create album: parent folder hash key not available',
+            );
+        });
+    });
+
+    describe('updateAlbum', () => {
+        it('updates album name and notifies cache', async () => {
+            const updatedAlbum = await albums.updateAlbum('albumNodeUid', { name: 'new album name' });
+
+            expect(updatedAlbum).toEqual({
+                ...nodes.albumNodeUid,
+                name: { ok: true, value: 'new album name' },
+                encryptedName: 'newArmoredAlbumName',
+                nameAuthor: { ok: true, value: 'newSignatureEmail' },
+                hash: 'newHash',
+            });
+            expect(nodesService.getNodeSigningKeys).toHaveBeenCalledWith({
+                nodeUid: 'albumNodeUid',
+                parentNodeUid: 'rootNodeUid',
+            });
+            expect(cryptoService.renameAlbum).toHaveBeenCalledWith(
+                { key: 'rootNodeUid-key', hashKey: 'rootNodeUid-hashKey' },
+                'encryptedAlbumName',
+                { type: 'userAddress', email: 'user@example.com', addressId: 'addressId', key: 'addressKey' },
+                'new album name',
+            );
+            expect(apiService.updateAlbum).toHaveBeenCalledWith(
+                'albumNodeUid',
+                undefined,
+                {
+                    encryptedName: 'newArmoredAlbumName',
+                    hash: 'newHash',
+                    originalHash: 'albumHash',
+                    nameSignatureEmail: 'newSignatureEmail',
+                },
+            );
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('albumNodeUid');
+        });
+
+        it('updates album cover photo only', async () => {
+            const updatedAlbum = await albums.updateAlbum('albumNodeUid', { coverPhotoNodeUid: 'photoNodeUid' });
+
+            expect(updatedAlbum).toEqual(nodes.albumNodeUid);
+            expect(cryptoService.renameAlbum).not.toHaveBeenCalled();
+            expect(apiService.updateAlbum).toHaveBeenCalledWith('albumNodeUid', 'photoNodeUid', undefined);
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('albumNodeUid');
+        });
+
+        it('updates album name and cover photo together', async () => {
+            const updatedAlbum = await albums.updateAlbum('albumNodeUid', {
+                name: 'new album name',
+                coverPhotoNodeUid: 'photoNodeUid',
+            });
+
+            expect(updatedAlbum).toEqual({
+                ...nodes.albumNodeUid,
+                name: { ok: true, value: 'new album name' },
+                encryptedName: 'newArmoredAlbumName',
+                nameAuthor: { ok: true, value: 'newSignatureEmail' },
+                hash: 'newHash',
+            });
+            expect(apiService.updateAlbum).toHaveBeenCalledWith(
+                'albumNodeUid',
+                'photoNodeUid',
+                {
+                    encryptedName: 'newArmoredAlbumName',
+                    hash: 'newHash',
+                    originalHash: 'albumHash',
+                    nameSignatureEmail: 'newSignatureEmail',
+                },
+            );
+        });
+
+        it('throws validation error for invalid album name', async () => {
+            await expect(albums.updateAlbum('albumNodeUid', { name: 'invalid/name' })).rejects.toThrow(ValidationError);
+        });
+    });
+
+    describe('deleteAlbum', () => {
+        it('deletes album and notifies cache', async () => {
+            await albums.deleteAlbum('albumNodeUid');
+
+            expect(apiService.deleteAlbum).toHaveBeenCalledWith('albumNodeUid', {});
+            expect(nodesService.notifyNodeDeleted).toHaveBeenCalledWith('albumNodeUid');
+        });
+
+        it('deletes album with force option', async () => {
+            await albums.deleteAlbum('albumNodeUid', { force: true });
+
+            expect(apiService.deleteAlbum).toHaveBeenCalledWith('albumNodeUid', { force: true });
+            expect(nodesService.notifyNodeDeleted).toHaveBeenCalledWith('albumNodeUid');
+        });
+    });
+
+    describe('removePhotos', () => {
+        it('notifies nodes service only for successfully removed photos', async () => {
+            apiService.removePhotosFromAlbum = jest.fn().mockImplementation(async function* () {
+                yield { uid: 'photo1', ok: true };
+                yield { uid: 'photo2', ok: false, error: 'Some error' };
+                yield { uid: 'photo3', ok: true };
+            });
+
+            const results = [];
+            for await (const result of albums.removePhotos('albumNodeUid', ['photo1', 'photo2', 'photo3'])) {
+                results.push(result);
+            }
+
+            expect(results).toEqual([
+                { uid: 'photo1', ok: true },
+                { uid: 'photo2', ok: false, error: 'Some error' },
+                { uid: 'photo3', ok: true },
+            ]);
+            expect(apiService.removePhotosFromAlbum).toHaveBeenCalledWith('albumNodeUid', ['photo1', 'photo2', 'photo3'], undefined);
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledTimes(2);
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('photo1');
+            expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith('photo3');
+            expect(nodesService.notifyNodeChanged).not.toHaveBeenCalledWith('photo2');
+        });
+    });
+});

package/src/internal/photos/albums.ts

@@ -1,6 +1,12 @@
+import { MemberRole, NodeResult, NodeType, resultOk } from '../../interface';
 import { BatchLoading } from '../batchLoading';
 import { DecryptedNode } from '../nodes';
+import { ALBUM_MEDIA_TYPE } from '../nodes/mediaTypes';
+import { validateNodeName } from '../nodes/validations';
+import { splitNodeUid } from '../uids';
+import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
+import { AlbumItem, DecryptedPhotoNode } from './interface';
 import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
@@ -12,10 +18,12 @@ const BATCH_LOADING_SIZE = 10;
 export class Albums {
     constructor(
         private apiService: PhotosAPIService,
+        private cryptoService: AlbumsCryptoService,
         private photoShares: PhotoSharesManager,
         private nodesService: PhotosNodesAccess,
     ) {
         this.apiService = apiService;
+        this.cryptoService = cryptoService;
         this.photoShares = photoShares;
         this.nodesService = nodesService;
     }
@@ -33,6 +41,134 @@ export class Albums {
         yield* batchLoading.loadRest();
     }
 
+    async *iterateAlbum(albumNodeUid: string, signal?: AbortSignal): AsyncGenerator<AlbumItem> {
+        yield* this.apiService.iterateAlbumChildren(albumNodeUid, signal);
+    }
+
+    async createAlbum(name: string): Promise<DecryptedPhotoNode> {
+        validateNodeName(name);
+
+        const rootNode = await this.nodesService.getVolumeRootFolder();
+        const parentKeys = await this.nodesService.getNodeKeys(rootNode.uid);
+        if (!parentKeys.hashKey) {
+            throw new Error('Cannot create album: parent folder hash key not available');
+        }
+
+        const signingKeys = await this.nodesService.getNodeSigningKeys({ parentNodeUid: rootNode.uid });
+        const { encryptedCrypto } = await this.cryptoService.createAlbum(
+            { key: parentKeys.key, hashKey: parentKeys.hashKey },
+            signingKeys,
+            name,
+        );
+
+        const nodeUid = await this.apiService.createAlbum(rootNode.uid, {
+            encryptedName: encryptedCrypto.encryptedName,
+            hash: encryptedCrypto.hash,
+            armoredKey: encryptedCrypto.armoredKey,
+            armoredNodePassphrase: encryptedCrypto.armoredNodePassphrase,
+            armoredNodePassphraseSignature: encryptedCrypto.armoredNodePassphraseSignature,
+            signatureEmail: encryptedCrypto.signatureEmail,
+            armoredHashKey: encryptedCrypto.armoredHashKey,
+        });
+
+        await this.nodesService.notifyChildCreated(rootNode.uid);
+
+        return {
+            // Internal metadata
+            hash: encryptedCrypto.hash,
+            encryptedName: encryptedCrypto.encryptedName,
+
+            // Basic node metadata
+            uid: nodeUid,
+            parentUid: rootNode.uid,
+            type: NodeType.Album,
+            mediaType: ALBUM_MEDIA_TYPE,
+            creationTime: new Date(),
+            modificationTime: new Date(),
+
+            // Share node metadata
+            isShared: false,
+            isSharedPublicly: false,
+            directRole: MemberRole.Inherited,
+
+            // Decrypted metadata
+            isStale: false,
+            keyAuthor: resultOk(encryptedCrypto.signatureEmail),
+            nameAuthor: resultOk(encryptedCrypto.signatureEmail),
+            name: resultOk(name),
+            treeEventScopeId: splitNodeUid(nodeUid).volumeId,
+        };
+    }
+
+    async updateAlbum(
+        nodeUid: string,
+        updates: {
+            name?: string;
+            coverPhotoNodeUid?: string;
+        },
+    ): Promise<DecryptedPhotoNode> {
+        if (updates.name) {
+            validateNodeName(updates.name);
+        }
+
+        const node = await this.nodesService.getNode(nodeUid);
+        const newNode = { ...node };
+
+        let nameUpdate:
+            | {
+                  encryptedName: string;
+                  hash: string;
+                  originalHash: string;
+                  nameSignatureEmail: string;
+              }
+            | undefined;
+
+        if (updates.name) {
+            const parentKeys = await this.nodesService.getParentKeys(node);
+            const signingKeys = await this.nodesService.getNodeSigningKeys({ nodeUid, parentNodeUid: node.parentUid });
+
+            const { signatureEmail, armoredNodeName, hash } = await this.cryptoService.renameAlbum(
+                { key: parentKeys.key, hashKey: parentKeys.hashKey },
+                node.encryptedName,
+                signingKeys,
+                updates.name,
+            );
+
+            nameUpdate = {
+                encryptedName: armoredNodeName,
+                hash,
+                originalHash: node.hash || '',
+                nameSignatureEmail: signatureEmail,
+            };
+            newNode.name = resultOk(updates.name);
+            newNode.encryptedName = nameUpdate.encryptedName;
+            newNode.nameAuthor = resultOk(nameUpdate.nameSignatureEmail);
+            newNode.hash = nameUpdate.hash;
+        }
+
+        await this.apiService.updateAlbum(nodeUid, updates.coverPhotoNodeUid, nameUpdate);
+        await this.nodesService.notifyNodeChanged(nodeUid);
+        return newNode;
+    }
+
+    async deleteAlbum(nodeUid: string, options: { force?: boolean } = {}): Promise<void> {
+        await this.apiService.deleteAlbum(nodeUid, options);
+        await this.nodesService.notifyNodeDeleted(nodeUid);
+    }
+
+    async *removePhotos(
+        albumNodeUid: string,
+        photoNodeUids: string[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
+        for await (const result of this.apiService.removePhotosFromAlbum(albumNodeUid, photoNodeUids, signal)) {
+            if (result.ok) {
+                await this.nodesService.notifyNodeChanged(result.uid);
+            }
+            yield result;
+        }
+    }
+
     private async *iterateNodesAndIgnoreMissingOnes(
         nodeUids: string[],
         signal?: AbortSignal,

package/src/internal/photos/albumsCrypto.test.ts

@@ -0,0 +1,181 @@
+import { DriveCrypto, PrivateKey, SessionKey } from '../../crypto';
+import { NodeSigningKeys } from '../nodes/interface';
+import { AlbumsCryptoService } from './albumsCrypto';
+
+describe('AlbumsCryptoService', () => {
+    let driveCrypto: DriveCrypto;
+    let albumsCryptoService: AlbumsCryptoService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // @ts-expect-error No need to implement all methods for mocking
+        driveCrypto = {};
+
+        albumsCryptoService = new AlbumsCryptoService(driveCrypto);
+    });
+
+    describe('createAlbum', () => {
+        let parentKeys: any;
+
+        beforeEach(() => {
+            parentKeys = {
+                key: 'parentKey' as any,
+                hashKey: new Uint8Array([1, 2, 3]),
+            };
+            driveCrypto.generateKey = jest.fn().mockResolvedValue({
+                encrypted: {
+                    armoredKey: 'encryptedNodeKey',
+                    armoredPassphrase: 'encryptedPassphrase',
+                    armoredPassphraseSignature: 'passphraseSignature',
+                },
+                decrypted: {
+                    key: 'nodeKey' as any,
+                    passphrase: 'nodePassphrase',
+                    passphraseSessionKey: 'passphraseSessionKey' as any,
+                },
+            });
+            driveCrypto.encryptNodeName = jest.fn().mockResolvedValue({
+                armoredNodeName: 'encryptedNodeName',
+            });
+            driveCrypto.generateLookupHash = jest.fn().mockResolvedValue('lookupHash');
+            driveCrypto.generateHashKey = jest.fn().mockResolvedValue({
+                armoredHashKey: 'encryptedHashKey',
+                hashKey: new Uint8Array([4, 5, 6]),
+            });
+        });
+
+        it('should encrypt new album with user address key', async () => {
+            const signingKeys: NodeSigningKeys = {
+                type: 'userAddress',
+                email: 'test@example.com',
+                addressId: 'addressId',
+                key: 'addressKey' as any,
+            };
+
+            const result = await albumsCryptoService.createAlbum(parentKeys, signingKeys, 'My Album');
+
+            expect(result).toEqual({
+                encryptedCrypto: {
+                    encryptedName: 'encryptedNodeName',
+                    hash: 'lookupHash',
+                    armoredKey: 'encryptedNodeKey',
+                    armoredNodePassphrase: 'encryptedPassphrase',
+                    armoredNodePassphraseSignature: 'passphraseSignature',
+                    signatureEmail: 'test@example.com',
+                    armoredHashKey: 'encryptedHashKey',
+                },
+                keys: {
+                    passphrase: 'nodePassphrase',
+                    key: 'nodeKey',
+                    passphraseSessionKey: 'passphraseSessionKey',
+                    hashKey: new Uint8Array([4, 5, 6]),
+                },
+            });
+
+            expect(driveCrypto.generateKey).toHaveBeenCalledWith([parentKeys.key], signingKeys.key);
+            expect(driveCrypto.encryptNodeName).toHaveBeenCalledWith(
+                'My Album',
+                undefined,
+                parentKeys.key,
+                signingKeys.key,
+            );
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledWith('My Album', parentKeys.hashKey);
+            expect(driveCrypto.generateHashKey).toHaveBeenCalledWith('nodeKey');
+        });
+
+        it('should throw error when creating album by anonymous user', async () => {
+            const signingKeys: NodeSigningKeys = {
+                type: 'nodeKey',
+                nodeKey: 'nodeSigningKey' as any,
+                parentNodeKey: 'parentNodeKey' as any,
+            };
+
+            await expect(albumsCryptoService.createAlbum(parentKeys, signingKeys, 'My Album')).rejects.toThrow(
+                'Creating album by anonymous user is not supported',
+            );
+        });
+    });
+
+    describe('renameAlbum', () => {
+        let parentKeys: any;
+        let nodeNameSessionKey: SessionKey;
+
+        beforeEach(() => {
+            parentKeys = {
+                key: 'parentKey' as any,
+                hashKey: new Uint8Array([1, 2, 3]),
+            };
+            nodeNameSessionKey = 'nameSessionKey' as any;
+            driveCrypto.decryptSessionKey = jest.fn().mockResolvedValue(nodeNameSessionKey);
+            driveCrypto.encryptNodeName = jest.fn().mockResolvedValue({
+                armoredNodeName: 'encryptedNewNodeName',
+            });
+            driveCrypto.generateLookupHash = jest.fn().mockResolvedValue('newHash');
+        });
+
+        it('should encrypt new album name with user address key', async () => {
+            const signingKeys: NodeSigningKeys = {
+                type: 'userAddress',
+                email: 'test@example.com',
+                addressId: 'addressId',
+                key: 'addressKey' as any,
+            };
+
+            const result = await albumsCryptoService.renameAlbum(
+                parentKeys,
+                'oldEncryptedName',
+                signingKeys,
+                'Renamed Album',
+            );
+
+            expect(result).toEqual({
+                signatureEmail: 'test@example.com',
+                armoredNodeName: 'encryptedNewNodeName',
+                hash: 'newHash',
+            });
+
+            expect(driveCrypto.decryptSessionKey).toHaveBeenCalledWith('oldEncryptedName', parentKeys.key);
+            expect(driveCrypto.encryptNodeName).toHaveBeenCalledWith(
+                'Renamed Album',
+                nodeNameSessionKey,
+                parentKeys.key,
+                signingKeys.key,
+            );
+            expect(driveCrypto.generateLookupHash).toHaveBeenCalledWith('Renamed Album', parentKeys.hashKey);
+        });
+
+        it('should throw error when renaming album by anonymous user', async () => {
+            const signingKeys: NodeSigningKeys = {
+                type: 'nodeKey',
+                nodeKey: 'nodeSigningKey' as any,
+                parentNodeKey: 'parentNodeKey' as any,
+            };
+
+            await expect(
+                albumsCryptoService.renameAlbum(parentKeys, 'oldEncryptedName', signingKeys, 'Renamed Album'),
+            ).rejects.toThrow('Renaming album by anonymous user is not supported');
+        });
+
+        it('should throw error when parent hash key is not available', async () => {
+            const parentKeysWithoutHashKey = {
+                key: 'parentKey' as any,
+            };
+            const signingKeys: NodeSigningKeys = {
+                type: 'userAddress',
+                email: 'test@example.com',
+                addressId: 'addressId',
+                key: 'addressKey' as any,
+            };
+
+            await expect(
+                albumsCryptoService.renameAlbum(
+                    parentKeysWithoutHashKey,
+                    'oldEncryptedName',
+                    signingKeys,
+                    'Renamed Album',
+                ),
+            ).rejects.toThrow('Cannot rename album: parent folder hash key not available');
+        });
+    });
+});