@protontech/drive-sdk 0.14.9 → 0.15.0

package/src/internal/sharing/sharingManagement.test.ts

@@ -1,4 +1,4 @@
-import { getMockLogger } from '../../tests/logger';
+import { ValidationError } from '../../errors';
 import {
     Logger,
     Member,
@@ -10,13 +10,13 @@ import {
     PublicLink,
     resultOk,
 } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { ErrorCode } from '../apiService';
 import { SharingAPIService } from './apiService';
 import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
-import { SharesService, NodesService } from './interface';
+import { NodesService, SharesService } from './interface';
 import { SharingManagement } from './sharingManagement';
-import { ValidationError } from '../../errors';
-import { ErrorCode } from '../apiService';
 
 const DEFAULT_SHARE_ID = 'shareId';
 

package/src/internal/sharing/sharingManagement.ts

@@ -4,24 +4,24 @@ import { PrivateKey, SessionKey } from '../../crypto';
 import { ValidationError } from '../../errors';
 import {
     Logger,
+    Member,
     MemberRole,
-    ShareNodeSettings,
-    UnshareNodeSettings,
-    ShareResult,
-    ProtonInvitation,
     NonProtonInvitation,
-    Member,
-    resultOk,
     ProtonDriveAccount,
+    ProtonInvitation,
+    resultOk,
+    ShareNodeSettings,
     SharePublicLinkSettingsObject,
+    ShareResult,
+    UnshareNodeSettings,
 } from '../../interface';
 import { ErrorCode } from '../apiService';
-import { splitNodeUid, splitInvitationUid } from '../uids';
 import { getErrorMessage } from '../errors';
+import { splitInvitationUid, splitNodeUid } from '../uids';
 import { SharingAPIService } from './apiService';
-import { PUBLIC_LINK_GENERATED_PASSWORD_LENGTH, SharingCryptoService } from './cryptoService';
-import { SharesService, NodesService, ShareResultWithCreatorEmail, PublicLinkWithCreatorEmail } from './interface';
 import { SharingCache } from './cache';
+import { PUBLIC_LINK_GENERATED_PASSWORD_LENGTH, SharingCryptoService } from './cryptoService';
+import { NodesService, PublicLinkWithCreatorEmail, ShareResultWithCreatorEmail, SharesService } from './interface';
 
 interface InternalShareResult extends ShareResultWithCreatorEmail {
     share: Share;

package/src/internal/sharingPublic/cryptoReporter.ts

@@ -1,18 +1,18 @@
 import { c } from 'ttag';
 
 import { VERIFICATION_STATUS } from '../../crypto';
-import { getVerificationMessage, isNotApplicationError } from '../errors';
 import {
-    resultOk,
-    resultError,
-    Author,
     AnonymousUser,
-    ProtonDriveTelemetry,
+    Author,
+    Logger,
+    MetricsDecryptionErrorField,
     MetricVerificationErrorField,
     MetricVolumeType,
-    MetricsDecryptionErrorField,
-    Logger,
+    ProtonDriveTelemetry,
+    resultError,
+    resultOk,
 } from '../../interface';
+import { getVerificationMessage, isNotApplicationError } from '../errors';
 
 export class SharingPublicCryptoReporter {
     private logger: Logger;

package/src/internal/sharingPublic/index.ts

@@ -1,21 +1,21 @@
 import { DriveCrypto, PrivateKey } from '../../crypto';
 import {
-    ProtonDriveCryptoCache,
-    ProtonDriveTelemetry,
+    MemberRole,
     ProtonDriveAccount,
+    ProtonDriveCryptoCache,
     ProtonDriveEntitiesCache,
-    MemberRole,
+    ProtonDriveTelemetry,
 } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { SharingPublicNodesAPIService, SharingPublicNodesCryptoService } from './nodes';
 import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesRevisons } from '../nodes/nodesRevisions';
+import { SharingPublicAPIService } from './apiService';
 import { SharingPublicCryptoReporter } from './cryptoReporter';
+import { SharingPublicNodesAPIService, SharingPublicNodesCryptoService } from './nodes';
 import { SharingPublicNodesAccess, SharingPublicNodesManagement } from './nodes';
-import { SharingPublicSharesManager } from './shares';
-import { SharingPublicAPIService } from './apiService';
 import { NodesSecurity } from './nodesSecurity';
+import { SharingPublicSharesManager } from './shares';
 
 export { SharingPublicSessionManager } from './session/manager';
 export { getTokenAndPasswordFromUrl } from './session/url';

package/src/internal/sharingPublic/nodes.ts

@@ -4,14 +4,14 @@ import { PrivateKey } from '../../crypto';
 import { ValidationError } from '../../errors';
 import { type Logger, MemberRole, NodeResult, ProtonDriveTelemetry } from '../../interface';
 import { type DriveAPIService, drivePaths } from '../apiService';
-import { NodeAPIService, linkToEncryptedNode } from '../nodes/apiService';
+import { linkToEncryptedNode, NodeAPIService } from '../nodes/apiService';
 import { NodesCache } from '../nodes/cache';
 import { NodesCryptoCache } from '../nodes/cryptoCache';
 import { NodesCryptoService } from '../nodes/cryptoService';
-import { DecryptedNode, DecryptedNodeKeys, NodeSigningKeys, EncryptedNode } from '../nodes/interface';
+import { DecryptedNode, DecryptedNodeKeys, EncryptedNode, NodeSigningKeys } from '../nodes/interface';
+import { isProtonDocument, isProtonSheet } from '../nodes/mediaTypes';
 import { NodesAccess } from '../nodes/nodesAccess';
 import { NodesManagement } from '../nodes/nodesManagement';
-import { isProtonDocument, isProtonSheet } from '../nodes/mediaTypes';
 import { validateNodeName } from '../nodes/validations';
 import { makeNodeUid, splitNodeUid } from '../uids';
 import { SharingPublicSharesManager } from './shares';
@@ -82,9 +82,12 @@ export class SharingPublicNodesAPIService extends NodeAPIService {
         volumeId: string,
         link: PostLoadLinksMetadataResponse['Links'][0],
         isOwnVolumeId: boolean,
-    ): EncryptedNode {
+    ): EncryptedNode | undefined {
         const nodeUid = makeNodeUid(volumeId, link.Link.LinkID);
         const encryptedNode = linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
+        if (!encryptedNode) {
+            return undefined;
+        }
 
         // TODO: This affects the cache. At this moment, the public link is not cached
         // anywhere, thus OK. To avoid issues when public links reuses the same cache,

package/src/internal/sharingPublic/session/apiService.ts

@@ -1,7 +1,7 @@
 import { Logger } from '../../../interface';
 import { DriveAPIService, drivePaths, permissionsToMemberRole } from '../../apiService';
 import { makeNodeUid } from '../../uids';
-import { PublicLinkInfo, PublicLinkSrpAuth, PublicLinkSession, EncryptedShareCrypto } from './interface';
+import { EncryptedShareCrypto, PublicLinkInfo, PublicLinkSession, PublicLinkSrpAuth } from './interface';
 
 type GetPublicLinkInfoResponse =
     drivePaths['/drive/urls/{token}/info']['get']['responses']['200']['content']['application/json'];

package/src/internal/sharingPublic/session/manager.ts

@@ -1,5 +1,5 @@
-import { Logger, MemberRole, ProtonDriveHTTPClient, ProtonDriveTelemetry } from '../../../interface';
 import { DriveCrypto, PrivateKey, SRPModule } from '../../../crypto';
+import { Logger, MemberRole, ProtonDriveHTTPClient, ProtonDriveTelemetry } from '../../../interface';
 import { DriveAPIService, permissionsToMemberRole } from '../../apiService';
 import { SharingPublicSessionAPIService } from './apiService';
 import { SharingPublicSessionHttpClient } from './httpClient';

package/src/internal/upload/apiService.ts

@@ -1,11 +1,10 @@
 import { c } from 'ttag';
 
-import { base64StringToUint8Array, uint8ArrayToBase64String } from '../../crypto';
 import { AnonymousUser } from '../../interface';
+import { ThumbnailType } from '../../interface';
 import { APICodeError, DriveAPIService, drivePaths, isCodeOk } from '../apiService';
-import { splitNodeUid, makeNodeUid, splitNodeRevisionUid, makeNodeRevisionUid } from '../uids';
+import { makeNodeRevisionUid, makeNodeUid, splitNodeRevisionUid, splitNodeUid } from '../uids';
 import { UploadTokens } from './interface';
-import { ThumbnailType } from '../../interface';
 
 type PostCreateDraftRequest = Extract<
     drivePaths['/drive/v2/volumes/{volumeID}/files']['post']['requestBody'],
@@ -171,7 +170,7 @@ export class UploadAPIService {
         );
 
         return {
-            verificationCode: base64StringToUint8Array(result.VerificationCode),
+            verificationCode: Uint8Array.fromBase64(result.VerificationCode),
             base64ContentKeyPacket: result.ContentKeyPacket,
         };
     }
@@ -210,7 +209,7 @@ export class UploadAPIService {
                 Index: block.index,
                 EncSignature: block.armoredSignature,
                 Verifier: {
-                    Token: uint8ArrayToBase64String(block.verificationToken),
+                    Token: block.verificationToken.toBase64(),
                 },
             })),
             ThumbnailList: (blocks.thumbnails || []).map((block) => ({
@@ -287,7 +286,17 @@ export class UploadAPIService {
         const formData = new FormData();
         formData.append('Block', new Blob([block]), 'blob');
 
-        await this.apiService.postBlockStream(url, token, formData, onProgress, signal);
+        let onProgressCalled = false;
+        const onProgressHandler = (uploadedBytes: number) => {
+            onProgressCalled = true;
+            onProgress?.(uploadedBytes);
+        };
+
+        await this.apiService.postBlockStream(url, token, formData, onProgressHandler, signal);
+
+        if (!onProgressCalled) {
+            onProgress?.(block.length);
+        }
     }
 
     async isRevisionUploaded(nodeRevisionUid: string): Promise<boolean> {
@@ -355,7 +364,7 @@ export class UploadAPIService {
             ManifestSignature: content.armoredManifestSignature,
             ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
             ContentBlockVerificationToken: content.block
-                ? uint8ArrayToBase64String(content.block.verificationToken)
+                ? content.block.verificationToken.toBase64()
                 : null,
             XAttr: metadata.armoredExtendedAttributes,
             ChecksumVerified: content.checksumVerified || false,
@@ -423,7 +432,7 @@ export class UploadAPIService {
             ManifestSignature: content.armoredManifestSignature,
             ContentBlockEncSignature: content.block ? content.block.armoredSignature : null,
             ContentBlockVerificationToken: content.block
-                ? uint8ArrayToBase64String(content.block.verificationToken)
+                ? content.block.verificationToken.toBase64()
                 : null,
             XAttr: metadata.armoredExtendedAttributes,
             ChecksumVerified: content.checksumVerified || false,

package/src/internal/upload/cryptoService.ts

@@ -1,14 +1,16 @@
 import { c } from 'ttag';
 
+import { computeSHA256 } from '@protontech/crypto/subtle/hash.ts';
+
 import { DriveCrypto, PrivateKey, SessionKey } from '../../crypto';
 import { IntegrityError } from '../../errors';
 import {
-    Thumbnail,
     AnonymousUser,
     FeatureFlagProvider,
     FeatureFlags,
-    ProtonDriveTelemetry,
     Logger,
+    ProtonDriveTelemetry,
+    Thumbnail,
 } from '../../interface';
 import {
     EncryptedBlock,
@@ -133,14 +135,14 @@ export class UploadCryptoService {
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
 
-        const digestPromise = crypto.subtle.digest('SHA-256', encryptedData);
+        const digestPromise = computeSHA256(encryptedData);
 
         return {
             type: thumbnail.type,
             encryptedData: encryptedData,
             originalSize: thumbnail.thumbnail.length,
             encryptedSize: encryptedData.length,
-            hashPromise: digestPromise.then((digest) => new Uint8Array<ArrayBuffer>(digest)),
+            hashPromise: digestPromise,
         };
     }
 
@@ -158,7 +160,7 @@ export class UploadCryptoService {
             nodeRevisionDraftKeys.contentKeyPacketSessionKey,
             nodeRevisionDraftKeys.signingKeys.contentSigningKey,
         );
-        const digestPromise = crypto.subtle.digest('SHA-256', encryptedData);
+        const digestPromise = computeSHA256(encryptedData);
         const { verificationToken } = await verifyBlock(encryptedData);
 
         return {
@@ -168,7 +170,7 @@ export class UploadCryptoService {
             verificationToken,
             originalSize: block.length,
             encryptedSize: encryptedData.length,
-            hashPromise: digestPromise.then((digest) => new Uint8Array<ArrayBuffer>(digest)),
+            hashPromise: digestPromise,
         };
     }
 

package/src/internal/upload/fileUploader.test.ts

@@ -1,12 +1,12 @@
 import { Thumbnail, UploadMetadata } from '../../interface';
-import { FileUploader } from './fileUploader';
-import { UploadTelemetry } from './telemetry';
 import { UploadAPIService } from './apiService';
-import { UploadCryptoService } from './cryptoService';
-import { UploadController } from './controller';
 import { BlockVerifier } from './blockVerifier';
+import { UploadController } from './controller';
+import { UploadCryptoService } from './cryptoService';
+import { FileUploader } from './fileUploader';
 import { NodeRevisionDraft } from './interface';
 import { UploadManager } from './manager';
+import { UploadTelemetry } from './telemetry';
 
 const BLOCK_ENCRYPTION_OVERHEAD = 10000;
 

package/src/internal/upload/index.ts

@@ -1,10 +1,10 @@
-import { FeatureFlagProvider, FeatureFlags, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
+import { DriveCrypto } from '../../crypto';
 import type { FileUploader } from '../../interface';
+import { FeatureFlagProvider, FeatureFlags, ProtonDriveTelemetry, UploadMetadata } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { DriveCrypto } from '../../crypto';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
-import { FileUploader as FileUploaderClass, FileRevisionUploader } from './fileUploader';
+import { FileRevisionUploader, FileUploader as FileUploaderClass } from './fileUploader';
 import { NodesService, SharesService } from './interface';
 import { UploadManager } from './manager';
 import { UploadQueue } from './queue';

package/src/internal/upload/interface.ts

@@ -1,6 +1,5 @@
 import { PrivateKey, SessionKey } from '../../crypto';
-
-import { MetricVolumeType, ThumbnailType, Result, Revision, AnonymousUser } from '../../interface';
+import { AnonymousUser, MetricVolumeType, Result, Revision, ThumbnailType } from '../../interface';
 import { DecryptedNode } from '../nodes';
 
 export type NodeRevisionDraft = {

package/src/internal/upload/manager.ts

@@ -1,15 +1,15 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey } from '../../crypto';
+import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
 import { Logger, ProtonDriveTelemetry, ThumbnailType, UploadMetadata } from '../../interface';
-import { ValidationError, NodeWithSameNameExistsValidationError } from '../../errors';
+import { reduceSizePrecision } from '../../telemetry';
 import { ErrorCode } from '../apiService';
 import { generateFileExtendedAttributes } from '../nodes';
+import { makeNodeUid, splitNodeUid } from '../uids';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
-import { NodeRevisionDraft, NodesService, NodeCrypto } from './interface';
-import { makeNodeUid, splitNodeUid } from '../uids';
-import { reduceSizePrecision } from '../../telemetry';
+import { NodeCrypto, NodeRevisionDraft, NodesService } from './interface';
 
 /**
  * UploadManager is responsible for creating and deleting draft nodes

package/src/internal/upload/smallFileUploader.test.ts

@@ -1,12 +1,12 @@
 import { IntegrityError } from '../../errors';
 import { Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
-import { SmallFileUploader, SmallFileRevisionUploader } from './smallFileUploader';
-import { UploadTelemetry } from './telemetry';
+import { mergeUint8Arrays } from '../utils';
 import { UploadAPIService } from './apiService';
 import { UploadCryptoService } from './cryptoService';
-import { UploadManager } from './manager';
 import { NodeCrypto } from './interface';
-import { mergeUint8Arrays } from '../utils';
+import { UploadManager } from './manager';
+import { SmallFileRevisionUploader, SmallFileUploader } from './smallFileUploader';
+import { UploadTelemetry } from './telemetry';
 
 const MOCK_BLOCK_HASH = new Uint8Array(32).fill(4);
 const MOCK_VERIFICATION_TOKEN = new Uint8Array(16).fill(5);

package/src/internal/upload/streamUploader.test.ts

@@ -1,15 +1,15 @@
-import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
 import { IntegrityError } from '../../errors';
+import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { APIHTTPError, HTTPErrorCode } from '../apiService';
-import { FILE_CHUNK_SIZE, StreamUploader } from './streamUploader';
-import { UploadTelemetry } from './telemetry';
 import { UploadAPIService } from './apiService';
-import { UploadCryptoService } from './cryptoService';
-import { UploadController } from './controller';
 import { BlockVerifier } from './blockVerifier';
+import { UploadController } from './controller';
+import { UploadCryptoService } from './cryptoService';
 import { NodeRevisionDraft } from './interface';
 import { UploadManager } from './manager';
+import { FILE_CHUNK_SIZE, StreamUploader } from './streamUploader';
+import { UploadTelemetry } from './telemetry';
 
 const BLOCK_ENCRYPTION_OVERHEAD = 10000;
 

package/src/internal/upload/streamUploader.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
-import { Thumbnail, Logger, ThumbnailType, UploadMetadata } from '../../interface';
 import { AbortError, IntegrityError } from '../../errors';
+import { Logger, Thumbnail, ThumbnailType, UploadMetadata } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
 import { APIHTTPError, HTTPErrorCode, NotFoundAPIError } from '../apiService';
 import { getErrorMessage } from '../errors';
@@ -9,13 +9,13 @@ import { mergeUint8Arrays } from '../utils';
 import { waitForCondition } from '../wait';
 import { UploadAPIService } from './apiService';
 import { BlockVerifier } from './blockVerifier';
+import { ChunkStreamReader } from './chunkStreamReader';
 import { UploadController } from './controller';
 import { UploadCryptoService } from './cryptoService';
 import { UploadDigests } from './digests';
-import { NodeRevisionDraft, EncryptedBlock, EncryptedThumbnail, EncryptedBlockMetadata } from './interface';
-import { UploadTelemetry } from './telemetry';
-import { ChunkStreamReader } from './chunkStreamReader';
+import { EncryptedBlock, EncryptedBlockMetadata, EncryptedThumbnail, NodeRevisionDraft } from './interface';
 import { UploadManager } from './manager';
+import { UploadTelemetry } from './telemetry';
 
 /**
  * File chunk size in bytes representing the size of each block.

package/src/internal/upload/telemetry.test.ts

@@ -1,4 +1,4 @@
-import { RateLimitedError, ValidationError, IntegrityError } from '../../errors';
+import { IntegrityError, RateLimitedError, ValidationError } from '../../errors';
 import { ProtonDriveTelemetry } from '../../interface';
 import { APIHTTPError } from '../apiService';
 import { SharesService } from './interface';
@@ -135,5 +135,11 @@ describe('UploadTelemetry', () => {
             await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
             verifyErrorCategory('network_error');
         });
+
+        it('should detect "network_error" for TypeError', async () => {
+            const error = new TypeError('Failed to fetch');
+            await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
+            verifyErrorCategory('network_error');
+        });
     });
 });

package/src/internal/upload/telemetry.ts

@@ -1,8 +1,9 @@
-import { RateLimitedError, ValidationError, IntegrityError } from '../../errors';
-import { ProtonDriveTelemetry, MetricsUploadErrorType, Logger, MetricVolumeType } from '../../interface';
+import { IntegrityError, RateLimitedError, ValidationError } from '../../errors';
+import { Logger, MetricsUploadErrorType, MetricVolumeType, ProtonDriveTelemetry } from '../../interface';
 import { LoggerWithPrefix, reduceSizePrecision } from '../../telemetry';
 import { APIHTTPError } from '../apiService';
-import { splitNodeUid, splitNodeRevisionUid } from '../uids';
+import { isNetworkError } from '../errors';
+import { splitNodeRevisionUid, splitNodeUid } from '../uids';
 import { SharesService } from './interface';
 
 export class UploadTelemetry {
@@ -124,11 +125,7 @@ function getErrorCategory(error: unknown): MetricsUploadErrorType | undefined {
         if (error.name === 'TimeoutError') {
             return 'server_error';
         }
-        if (
-            error.name === 'OfflineError' ||
-            error.name === 'NetworkError' ||
-            error.message?.toLowerCase() === 'network error'
-        ) {
+        if (isNetworkError(error)) {
             return 'network_error';
         }
         if (error.name === 'AbortError') {

package/src/polyfill.ts

@@ -0,0 +1 @@
+import '@protontech/crypto/polyfill';

package/src/protonDriveClient.ts

@@ -2,47 +2,37 @@ import { getConfig } from './config';
 import { DriveCrypto, SessionKey } from './crypto';
 import { NullFeatureFlagProvider } from './featureFlags';
 import {
+    BookmarkOrUid,
+    Device,
+    DeviceOrUid,
+    DeviceType,
+    FileDownloader,
+    FileUploader,
     Logger,
-    ProtonDriveClientContructorParameters,
-    NodeOrUid,
-    MaybeNode,
+    MaybeBookmark,
     MaybeMissingNode,
+    MaybeNode,
+    MemberRole,
+    NodeOrUid,
     NodeResult,
     NodeResultWithError,
     NodeResultWithNewUid,
-    Revision,
-    RevisionOrUid,
-    ShareNodeSettings,
-    UnshareNodeSettings,
+    NodeType,
+    NonProtonInvitationOrUid,
+    ProtonDriveClientContructorParameters,
     ProtonInvitation,
     ProtonInvitationOrUid,
-    NonProtonInvitationOrUid,
     ProtonInvitationWithNode,
-    MaybeBookmark,
-    BookmarkOrUid,
+    Revision,
+    RevisionOrUid,
+    SDKEvent,
+    ShareNodeSettings,
     ShareResult,
-    Device,
-    DeviceType,
-    DeviceOrUid,
-    UploadMetadata,
-    FileDownloader,
-    FileUploader,
-    ThumbnailType,
     ThumbnailResult,
-    SDKEvent,
-    NodeType,
-    MemberRole,
+    ThumbnailType,
+    UnshareNodeSettings,
+    UploadMetadata,
 } from './interface';
-import {
-    getUid,
-    getUids,
-    convertInternalNodePromise,
-    convertInternalNodeIterator,
-    convertInternalMissingNodeIterator,
-    convertInternalNode,
-    convertInternalRevisionIterator,
-} from './transformers';
-import { Telemetry } from './telemetry';
 import { DriveAPIService } from './internal/apiService';
 import { initDevicesModule } from './internal/devices';
 import { initDownloadModule } from './internal/download';
@@ -51,10 +41,20 @@ import { initNodesModule } from './internal/nodes';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
-import { SharingPublicSessionManager, getTokenAndPasswordFromUrl } from './internal/sharingPublic';
-import { initUploadModule } from './internal/upload';
+import { getTokenAndPasswordFromUrl, SharingPublicSessionManager } from './internal/sharingPublic';
 import { makeNodeUid } from './internal/uids';
+import { initUploadModule } from './internal/upload';
 import { ProtonDrivePublicLinkClient } from './protonDrivePublicLinkClient';
+import { Telemetry } from './telemetry';
+import {
+    convertInternalMissingNodeIterator,
+    convertInternalNode,
+    convertInternalNodeIterator,
+    convertInternalNodePromise,
+    convertInternalRevisionIterator,
+    getUid,
+    getUids,
+} from './transformers';
 
 /**
  * ProtonDriveClient is the main interface for the ProtonDrive SDK.

package/src/protonDrivePhotosClient.ts

@@ -1,54 +1,54 @@
+import { getConfig } from './config';
+import { DriveCrypto } from './crypto';
+import { NullFeatureFlagProvider } from './featureFlags';
 import {
-    Logger,
-    ProtonDriveClientContructorParameters,
-    NodeOrUid,
-    MaybeMissingPhotoNode,
-    UploadMetadata,
     FileDownloader,
     FileUploader,
-    SDKEvent,
+    Logger,
+    MaybeMissingPhotoNode,
     MaybePhotoNode,
-    ThumbnailType,
-    ThumbnailResult,
-    ShareNodeSettings,
-    ShareResult,
-    UnshareNodeSettings,
-    ProtonInvitation,
-    ProtonInvitationOrUid,
-    NonProtonInvitationOrUid,
-    ProtonInvitationWithNode,
+    NodeOrUid,
     NodeResult,
     NodeResultWithError,
+    NonProtonInvitationOrUid,
     PhotoTag,
+    ProtonDriveClientContructorParameters,
+    ProtonInvitation,
+    ProtonInvitationOrUid,
+    ProtonInvitationWithNode,
+    SDKEvent,
+    ShareNodeSettings,
+    ShareResult,
+    ThumbnailResult,
+    ThumbnailType,
+    UnshareNodeSettings,
+    UploadMetadata,
 } from './interface';
-import { getConfig } from './config';
-import { DriveCrypto } from './crypto';
-import { Telemetry } from './telemetry';
-import {
-    convertInternalMissingPhotoNodeIterator,
-    convertInternalPhotoNode,
-    convertInternalPhotoNodeIterator,
-    convertInternalPhotoNodePromise,
-    getUid,
-    getUids,
-} from './transformers';
 import { DriveAPIService } from './internal/apiService';
-import { makeNodeUid } from './internal/uids';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
 import {
-    PHOTOS_SHARE_TARGET_TYPES,
-    initPhotosModule,
+    AlbumItem,
     initPhotoSharesModule,
-    initPhotoUploadModule,
+    initPhotosModule,
     initPhotosNodesModule,
-    AlbumItem,
+    initPhotoUploadModule,
+    PHOTOS_SHARE_TARGET_TYPES,
     TimelineItem,
 } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
 import { initSharingModule } from './internal/sharing';
-import { NullFeatureFlagProvider } from './featureFlags';
+import { makeNodeUid } from './internal/uids';
+import { Telemetry } from './telemetry';
+import {
+    convertInternalMissingPhotoNodeIterator,
+    convertInternalPhotoNode,
+    convertInternalPhotoNodeIterator,
+    convertInternalPhotoNodePromise,
+    getUid,
+    getUids,
+} from './transformers';
 
 /**
  * ProtonDrivePhotosClient is the interface to access Photos functionality.
@@ -511,6 +511,16 @@ export class ProtonDrivePhotosClient {
         return this.upload.getFileUploader(getUid(parentFolderUid), name, metadata, signal);
     }
 
+    /**
+     * Returns an available name for a new node in the given parent folder.
+     *
+     * See `ProtonDriveClient.getAvailableName` for more information.
+     */
+    async getAvailableName(parentFolderUid: NodeOrUid, name: string): Promise<string> {
+        this.logger.info(`Getting available name in photos folder ${getUid(parentFolderUid)}`);
+        return this.nodes.management.findAvailableName(getUid(parentFolderUid), name);
+    }
+
     /**
      * Check if the photo is a duplicate.
      *