@protontech/drive-sdk 0.9.9 → 0.10.0

package/src/internal/upload/interface.ts

@@ -8,7 +8,7 @@ export type NodeRevisionDraft = {
     nodeRevisionUid: string;
     nodeKeys: NodeRevisionDraftKeys;
     parentNodeKeys?: {
-        hashKey: Uint8Array;
+        hashKey: Uint8Array<ArrayBuffer>;
     };
     // newNodeInfo is set only when revision is created with the new node.
     newNodeInfo?: {
@@ -64,19 +64,19 @@ export type NodeCryptoSigningKeys = {
 export type EncryptedBlockMetadata = {
     encryptedSize: number;
     originalSize: number;
-    hash: Uint8Array;
+    hash: Uint8Array<ArrayBuffer>;
 };
 
 export type EncryptedBlock = EncryptedBlockMetadata & {
     index: number;
-    encryptedData: Uint8Array;
+    encryptedData: Uint8Array<ArrayBuffer>;
     armoredSignature: string;
-    verificationToken: Uint8Array;
+    verificationToken: Uint8Array<ArrayBuffer>;
 };
 
 export type EncryptedThumbnail = EncryptedBlockMetadata & {
     type: ThumbnailType;
-    encryptedData: Uint8Array;
+    encryptedData: Uint8Array<ArrayBuffer>;
 };
 
 export type UploadTokens = {
@@ -101,7 +101,7 @@ export interface NodesService {
         key: PrivateKey;
         passphraseSessionKey: SessionKey;
         contentKeyPacketSessionKey?: SessionKey;
-        hashKey?: Uint8Array;
+        hashKey?: Uint8Array<ArrayBuffer>;
     }>;
     getNodeSigningKeys(
         uids: { nodeUid: string; parentNodeUid?: string } | { nodeUid?: string; parentNodeUid: string },

package/src/internal/upload/manager.ts

@@ -73,7 +73,7 @@ export class UploadManager {
 
     private async createDraftOnAPI(
         parentFolderUid: string,
-        parentHashKey: Uint8Array,
+        parentHashKey: Uint8Array<ArrayBuffer>,
         name: string,
         metadata: UploadMetadata,
         generatedNodeCrypto: NodeCrypto,
@@ -226,7 +226,7 @@ export class UploadManager {
 
     async commitDraft(
         nodeRevisionDraft: NodeRevisionDraft,
-        manifest: Uint8Array,
+        manifest: Uint8Array<ArrayBuffer>,
         extendedAttributes: {
             modificationTime?: Date;
             size: number;

package/src/internal/upload/streamUploader.ts

@@ -655,7 +655,7 @@ export class StreamUploader {
         return uploadedBlocks.map((block) => block.originalSize);
     }
 
-    protected get manifest(): Uint8Array {
+    protected get manifest(): Uint8Array<ArrayBuffer> {
         this.uploadedThumbnails.sort((a, b) => a.type - b.type);
         this.uploadedBlocks.sort((a, b) => a.index - b.index);
         const hashes = [

package/src/protonDriveClient.ts

@@ -223,12 +223,12 @@ export class ProtonDriveClient {
                 return keys.contentKeyPacketSessionKey;
             },
             getPublicLinkInfo: async (url: string) => {
-                const { token } = getTokenAndPasswordFromUrl(url)
+                const { token } = getTokenAndPasswordFromUrl(url);
                 this.logger.info(`Getting info for public link token ${token}`);
                 return this.publicSessionManager.getInfo(token);
             },
             authPublicLink: async (url: string, customPassword?: string, isAnonymousContext: boolean = false) => {
-                const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url)
+                const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
                 this.logger.info(`Authenticating public link token ${token}`);
 
                 const { httpClient, shareKey, rootUid, publicRole } = await this.publicSessionManager.auth(
@@ -681,7 +681,7 @@ export class ProtonDriveClient {
      * @param customPassword - The optional custom password.
      */
     async createBookmark(url: string, customPassword?: string): Promise<void> {
-        const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url)
+        const { token, password: urlPassword } = getTokenAndPasswordFromUrl(url);
         this.logger.info(`Creating bookmark for token ${token}`);
         await this.sharing.access.createBookmark(token, urlPassword, customPassword);
     }
@@ -912,6 +912,18 @@ export class ProtonDriveClient {
         yield* this.devices.iterateDevices(signal);
     }
 
+    /**
+     * Get the device entity by its UID.
+     *
+     * @param deviceOrUid - Device entity or its UID string.
+     * @returns The device entity.
+     * @throws {@link ValidationError} If the device is not found.
+     */
+    async getDevice(deviceOrUid: DeviceOrUid): Promise<Device> {
+        this.logger.info(`Getting device ${getUid(deviceOrUid)}`);
+        return this.devices.getDevice(getUid(deviceOrUid));
+    }
+
     /**
      * Creates a new device.
      *

package/src/protonDrivePhotosClient.ts

@@ -17,6 +17,7 @@ import {
     NonProtonInvitationOrUid,
     ProtonInvitationWithNode,
     NodeResult,
+    NodeResultWithError,
 } from './interface';
 import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
@@ -120,13 +121,7 @@ export class ProtonDrivePhotosClient {
             this.photoShares,
             fullConfig.clientUid,
         );
-        this.photos = initPhotosModule(
-            telemetry,
-            apiService,
-            cryptoModule,
-            this.photoShares,
-            this.nodes.access,
-        );
+        this.photos = initPhotosModule(telemetry, apiService, cryptoModule, this.photoShares, this.nodes.access);
         this.sharing = initSharingModule(
             telemetry,
             apiService,
@@ -238,7 +233,7 @@ export class ProtonDrivePhotosClient {
      */
     async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating trashed nodes');
-        yield * convertInternalPhotoNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+        yield* convertInternalPhotoNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
     }
 
     /**
@@ -249,7 +244,7 @@ export class ProtonDrivePhotosClient {
     async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingPhotoNode> {
         this.logger.info(`Iterating ${nodeUids.length} nodes`);
         // TODO: expose photo type
-        yield * convertInternalMissingPhotoNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
+        yield* convertInternalMissingPhotoNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
     }
 
     /**
@@ -299,7 +294,7 @@ export class ProtonDrivePhotosClient {
      */
     async *deleteNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<NodeResult> {
         this.logger.info(`Deleting ${nodeUids.length} nodes`);
-        yield * this.nodes.management.deleteTrashedNodes(getUids(nodeUids), signal);
+        yield* this.nodes.management.deleteTrashedNodes(getUids(nodeUids), signal);
     }
 
     /**
@@ -317,7 +312,7 @@ export class ProtonDrivePhotosClient {
      */
     async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating shared nodes by me');
-        yield * convertInternalPhotoNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+        yield* convertInternalPhotoNodeIterator(this.sharing.access.iterateSharedNodes(signal));
     }
 
     /**
@@ -484,7 +479,9 @@ export class ProtonDrivePhotosClient {
      */
     async isDuplicatePhoto(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<boolean> {
         this.logger.info(`Checking if photo is a duplicate`);
-        return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal).then(nodeUids => nodeUids.length !== 0);
+        return this.photos.timeline
+            .findPhotoDuplicates(name, generateSha1, signal)
+            .then((nodeUids) => nodeUids.length !== 0);
     }
 
     /**
@@ -505,7 +502,11 @@ export class ProtonDrivePhotosClient {
      * @param signal - An optional abort signal to cancel the operation.
      * @returns An array of node UIDs of duplicate photos. Empty array if no duplicates found.
      */
-    async findPhotoDuplicates(name: string, generateSha1: () => Promise<string>, signal?: AbortSignal): Promise<string[]> {
+    async findPhotoDuplicates(
+        name: string,
+        generateSha1: () => Promise<string>,
+        signal?: AbortSignal,
+    ): Promise<string[]> {
         this.logger.info(`Checking if photo have duplicates`);
         return this.photos.timeline.findPhotoDuplicates(name, generateSha1, signal);
     }
@@ -575,7 +576,7 @@ export class ProtonDrivePhotosClient {
     async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating albums');
         // TODO: expose album type
-        yield * convertInternalPhotoNodeIterator(this.photos.albums.iterateAlbums(signal));
+        yield* convertInternalPhotoNodeIterator(this.photos.albums.iterateAlbums(signal));
     }
 
     /**
@@ -592,6 +593,29 @@ export class ProtonDrivePhotosClient {
         yield* this.photos.albums.iterateAlbum(getUid(albumNodeUid), signal);
     }
 
+    /**
+     * Adds photos to an album.
+     *
+     * Photos are added in batches. Each photo's related photos (e.g., live
+     * photo components) are always included with the main photo.
+     *
+     * The album has a limit of 10,000 photos. If the limit is reached,
+     * a `ValidationError` is thrown.
+     *
+     * @param albumNodeUid - The UID of the album to add photos to.
+     * @param photoNodeUids - The UIDs of the photos to add to the album.
+     * @param signal - An optional abort signal to cancel the operation.
+     * @returns An async generator of the added photo results.
+     */
+    async *addPhotosToAlbum(
+        albumNodeUid: NodeOrUid,
+        photoNodeUids: NodeOrUid[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithError> {
+        this.logger.info(`Adding ${photoNodeUids.length} photos to album ${getUid(albumNodeUid)}`);
+        yield* this.photos.albums.addPhotos(getUid(albumNodeUid), getUids(photoNodeUids), signal);
+    }
+
     /**
      * Removes photos from an album.
      *
@@ -608,7 +632,7 @@ export class ProtonDrivePhotosClient {
         albumNodeUid: NodeOrUid,
         photoNodeUids: NodeOrUid[],
         signal?: AbortSignal,
-    ): AsyncGenerator<NodeResult> {
+    ): AsyncGenerator<NodeResultWithError> {
         this.logger.info(`Removing ${photoNodeUids.length} photos from album ${getUid(albumNodeUid)}`);
         yield* this.photos.albums.removePhotos(getUid(albumNodeUid), getUids(photoNodeUids), signal);
     }

package/src/transformers.ts

@@ -160,11 +160,13 @@ export function convertInternalPhotoNode(photoNode: InternalPartialPhotoNode): P
         return resultOk({
             ...node.value,
             photo: photoNode.photo,
+            album: photoNode.album,
         } as PublicPhotoNode);
     }
     return resultError({
         ...node.error,
         photo: photoNode.photo,
+        album: photoNode.album,
     } as PublicDegradedPhotoNode);
 }