@protontech/drive-sdk 0.14.10 → 0.15.0

package/src/internal/errors.ts

@@ -67,3 +67,18 @@ export function isNotApplicationError(error?: unknown): boolean {
 
     return false;
 }
+
+export function isNetworkError(error: unknown): boolean {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (
+        error.name === 'OfflineError' ||
+        error.name === 'NetworkError' ||
+        error.message?.toLowerCase() === 'network error' ||
+        (error.name === 'TypeError' &&
+            ['Failed to fetch', 'NetworkError when attempting to fetch resource', 'Load failed'].includes(
+                error.message,
+            ))
+    );
+}

package/src/internal/events/apiService.ts

@@ -1,6 +1,6 @@
-import { DriveAPIService, drivePaths, corePaths } from '../apiService';
+import { corePaths, DriveAPIService, drivePaths } from '../apiService';
 import { makeNodeUid } from '../uids';
-import { DriveEventsListWithStatus, DriveEvent, DriveEventType, NodeEvent, NodeEventType } from './interface';
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType, NodeEvent, NodeEventType } from './interface';
 
 type GetCoreLatestEventResponse =
     corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];

package/src/internal/events/coreEventManager.test.ts

@@ -1,7 +1,7 @@
 import { getMockLogger } from '../../tests/logger';
 import { EventsAPIService } from './apiService';
-import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from './interface';
 import { CoreEventManager } from './coreEventManager';
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from './interface';
 
 describe('CoreEventManager', () => {
     let mockApiService: jest.Mocked<EventsAPIService>;

package/src/internal/events/eventManager.ts

@@ -1,5 +1,5 @@
 import { Logger } from '../../interface';
-import { EventManagerInterface, Event, EventSubscription } from './interface';
+import { Event, EventManagerInterface, EventSubscription } from './interface';
 
 const FIBONACCI_LIST = [1, 1, 2, 3, 5, 8, 13];
 
@@ -54,6 +54,7 @@ export class EventManager<T extends Event> {
                 const index = this.listeners.indexOf(callback);
                 this.listeners.splice(index, 1);
             },
+            getLatestEventId: () => this.latestEventId ?? null,
         };
     }
 

package/src/internal/events/index.ts

@@ -1,10 +1,10 @@
 import { Logger, ProtonDriveTelemetry } from '../../interface';
 import { DriveAPIService } from '../apiService';
-import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider, SharesService } from './interface';
 import { EventsAPIService } from './apiService';
 import { CoreEventManager } from './coreEventManager';
-import { VolumeEventManager } from './volumeEventManager';
 import { EventManager } from './eventManager';
+import { DriveEvent, DriveListener, EventSubscription, LatestEventIdProvider, SharesService } from './interface';
+import { VolumeEventManager } from './volumeEventManager';
 
 export type { DriveEvent, DriveListener, EventSubscription } from './interface';
 export { DriveEventType } from './interface';

package/src/internal/events/interface.ts

@@ -15,6 +15,14 @@ export interface Event {
 
 export interface EventSubscription {
     dispose(): void;
+    /**
+     * Returns the latest event ID for the subscription.
+     *
+     * @deprecated This is experimental to provide a way to the client to know
+     * the latest event ID before getting any events. It will be removed and
+     * replaced with a more robust solution.
+     */
+    getLatestEventId(): string | null;
 }
 
 export interface LatestEventIdProvider {

package/src/internal/events/volumeEventManager.test.ts

@@ -1,8 +1,8 @@
 import { getMockLogger } from '../../tests/logger';
 import { NotFoundAPIError } from '../apiService';
 import { EventsAPIService } from './apiService';
-import { VolumeEventManager } from './volumeEventManager';
 import { DriveEventsListWithStatus, DriveEventType } from './interface';
+import { VolumeEventManager } from './volumeEventManager';
 
 jest.mock('./apiService');
 

package/src/internal/events/volumeEventManager.ts

@@ -1,5 +1,6 @@
 import { Logger } from '../../interface';
 import { LoggerWithPrefix } from '../../telemetry';
+import { NotFoundAPIError } from '../apiService';
 import { EventsAPIService } from './apiService';
 import {
     DriveEvent,
@@ -8,7 +9,6 @@ import {
     EventManagerInterface,
     UnsubscribeFromEventsSourceError,
 } from './interface';
-import { NotFoundAPIError } from '../apiService';
 
 /**
  * Combines API and event manager to provide a service for listening to

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

@@ -2,10 +2,10 @@ import { NodeWithSameNameExistsValidationError, ValidationError } from '../../er
 import { MemberRole, NodeType } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { DriveAPIService, ErrorCode, InvalidRequirementsAPIError } from '../apiService';
-import { NodeAPIService, groupNodeUidsByVolumeAndIteratePerBatch } from './apiService';
+import { groupNodeUidsByVolumeAndIteratePerBatch, NodeAPIService } from './apiService';
 import { NodeOutOfSyncError } from './errors';
 
-function generateAPIFileNode(linkOverrides = {}, overrides = {}) {
+function generateAPIFileNode(linkOverrides = {}, overrides = {}, fileOverrides = {}) {
     const node = generateAPINode();
     return {
         Link: {
@@ -25,6 +25,7 @@ function generateAPIFileNode(linkOverrides = {}, overrides = {}) {
                 XAttr: '{file}',
                 EncryptedSize: 12,
             },
+            ...fileOverrides,
         },
         ...overrides,
     };
@@ -225,7 +226,7 @@ describe('nodeAPIService', () => {
             );
 
             const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], ownVolumeId));
-            expect(nodes).toStrictEqual([expectedNode]);
+            expect(nodes).toStrictEqual(expectedNode ? [expectedNode] : []);
         }
 
         it('should get folder node', async () => {
@@ -243,6 +244,10 @@ describe('nodeAPIService', () => {
             await testIterateNodes(generateAPIFileNode(), generateFileNode());
         });
 
+        fit('should skip file draft node without an error', async () => {
+            await testIterateNodes(generateAPIFileNode({}, {}, { ActiveRevision: null }), undefined);
+        });
+
         it('should get album node', async () => {
             await testIterateNodes(generateAPIAlbumNode(), generateAlbumNode());
         });

package/src/internal/nodes/apiService.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
 import { NodeWithSameNameExistsValidationError, ProtonDriveError, ValidationError } from '../../errors';
-import { Logger, NodeResult, MemberRole, RevisionState, AnonymousUser } from '../../interface';
+import { AnonymousUser, Logger, MemberRole, NodeResult, RevisionState } from '../../interface';
 import {
     DriveAPIService,
     drivePaths,
@@ -13,7 +13,7 @@ import {
 } from '../apiService';
 import { asyncIteratorRace } from '../asyncIteratorRace';
 import { batch } from '../batch';
-import { splitNodeUid, makeNodeUid, makeNodeRevisionUid, splitNodeRevisionUid, makeNodeThumbnailUid } from '../uids';
+import { makeNodeRevisionUid, makeNodeThumbnailUid, makeNodeUid, splitNodeRevisionUid, splitNodeUid } from '../uids';
 import { NodeOutOfSyncError } from './errors';
 import { EncryptedNode, EncryptedRevision, FilterOptions, Thumbnail } from './interface';
 
@@ -212,7 +212,7 @@ export abstract class NodeAPIServiceBase<
             for (const link of responseLinks) {
                 try {
                     const encryptedNode = this.linkToEncryptedNode(volumeId, link, isOwnVolumeId);
-                    if (filterOptions?.type && encryptedNode.type !== filterOptions.type) {
+                    if (!encryptedNode || (filterOptions?.type && encryptedNode.type !== filterOptions.type)) {
                         continue;
                     }
                     yield encryptedNode;
@@ -232,7 +232,17 @@ export abstract class NodeAPIServiceBase<
         signal?: AbortSignal,
     ): Promise<TMetadataResponseLink[]>;
 
-    protected abstract linkToEncryptedNode(volumeId: string, link: TMetadataResponseLink, isOwnVolumeId: boolean): T;
+    /**
+     * Converts a link from the API payload to an encrypted node entity.
+     *
+     * Returns undefined if the link is a draft as drafts are not exposed
+     * to the client and are internal to upload module only.
+     */
+    protected abstract linkToEncryptedNode(
+        volumeId: string,
+        link: TMetadataResponseLink,
+        isOwnVolumeId: boolean,
+    ): T | undefined;
 
     // Improvement requested: load next page sooner before all IDs are yielded.
     async *iterateChildrenNodeUids(
@@ -623,7 +633,7 @@ export class NodeAPIService extends NodeAPIServiceBase {
         volumeId: string,
         link: PostLoadLinksMetadataResponse['Links'][0],
         isOwnVolumeId: boolean,
-    ): EncryptedNode {
+    ): EncryptedNode | undefined {
         return linkToEncryptedNode(this.logger, volumeId, link, isOwnVolumeId);
     }
 }
@@ -683,7 +693,7 @@ export function linkToEncryptedNode(
     volumeId: string,
     link: Pick<PostLoadLinksMetadataResponse['Links'][0], 'Link' | 'Membership' | 'Sharing' | 'Folder' | 'File'>,
     isAdmin: boolean,
-): EncryptedNode {
+): EncryptedNode | undefined {
     const { baseNodeMetadata, baseCryptoNodeMetadata } = linkToEncryptedNodeBaseMetadata(
         logger,
         volumeId,
@@ -704,7 +714,12 @@ export function linkToEncryptedNode(
         };
     }
 
-    if (link.Link.Type === 2 && link.File && link.File.ActiveRevision) {
+    if (link.Link.Type === 2 && link.File) {
+        if (!link.File.ActiveRevision) {
+            logger.warn(`Requested draft file node, skipping from the result`);
+            return undefined;
+        }
+
         return {
             ...baseNodeMetadata,
             totalStorageSize: link.File.TotalEncryptedSize,

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

@@ -1,5 +1,5 @@
 import { MemoryCache } from '../../cache';
-import { NodeType, MemberRole, RevisionState, resultOk, Result } from '../../interface';
+import { MemberRole, NodeType, Result, resultOk, RevisionState } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { CACHE_TAG_KEYS, NodesCache } from './cache';
 import { DecryptedNode, DecryptedRevision } from './interface';

package/src/internal/nodes/cache.ts

@@ -1,5 +1,5 @@
 import { EntityResult } from '../../cache';
-import { ProtonDriveEntitiesCache, Logger, resultOk, Result } from '../../interface';
+import { Logger, ProtonDriveEntitiesCache, Result, resultOk } from '../../interface';
 import { splitNodeUid } from '../uids';
 import { DecryptedNode, DecryptedRevision } from './interface';
 

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

@@ -1,5 +1,5 @@
-import { PrivateKey, SessionKey } from '../../crypto';
 import { MemoryCache } from '../../cache';
+import { PrivateKey, SessionKey } from '../../crypto';
 import { CachedCryptoMaterial } from '../../interface';
 import { getMockLogger } from '../../tests/logger';
 import { NodesCryptoCache } from './cryptoCache';

package/src/internal/nodes/cryptoCache.ts

@@ -1,4 +1,4 @@
-import { ProtonDriveCryptoCache, Logger } from '../../interface';
+import { Logger, ProtonDriveCryptoCache } from '../../interface';
 import { DecryptedNodeKeys } from './interface';
 
 /**

package/src/internal/nodes/cryptoReporter.ts

@@ -1,14 +1,14 @@
 import { VERIFICATION_STATUS } from '../../crypto';
 import {
-    resultOk,
-    resultError,
-    Author,
     AnonymousUser,
-    ProtonDriveTelemetry,
+    Author,
     Logger,
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
     MetricVolumeType,
+    ProtonDriveTelemetry,
+    resultError,
+    resultOk,
 } from '../../interface';
 import { getVerificationMessage, isNotApplicationError } from '../errors';
 import { splitNodeUid } from '../uids';

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

@@ -1,6 +1,8 @@
 import { DriveCrypto, PrivateKey, PublicKey, SessionKey, VERIFICATION_STATUS } from '../../crypto';
 import { MemberRole, ProtonDriveAccount, ProtonDriveTelemetry, RevisionState } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
+import { NodesCryptoReporter } from './cryptoReporter';
+import { NodesCryptoService } from './cryptoService';
 import {
     DecryptedNode,
     DecryptedNodeKeys,
@@ -9,8 +11,6 @@ import {
     NodeSigningKeys,
     SharesService,
 } from './interface';
-import { NodesCryptoService } from './cryptoService';
-import { NodesCryptoReporter } from './cryptoReporter';
 
 describe('nodesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;

package/src/internal/nodes/cryptoService.ts

@@ -1,41 +1,40 @@
 import { c } from 'ttag';
 
 import {
-    base64StringToUint8Array,
     DriveCrypto,
     PrivateKey,
     PublicKey,
     SessionKey,
     VERIFICATION_STATUS,
 } from '../../crypto';
+import { ValidationError } from '../../errors';
 import {
-    resultOk,
-    resultError,
-    Result,
-    Author,
     AnonymousUser,
-    ProtonDriveTelemetry,
+    Author,
     Logger,
+    Membership,
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
-    Membership,
     ProtonDriveAccount,
+    ProtonDriveTelemetry,
+    Result,
+    resultError,
+    resultOk,
 } from '../../interface';
-import { ValidationError } from '../../errors';
 import { getErrorMessage } from '../errors';
+import { splitNodeUid } from '../uids';
 import {
-    EncryptedNode,
-    EncryptedNodeFolderCrypto,
-    DecryptedUnparsedNode,
     DecryptedNode,
     DecryptedNodeKeys,
-    EncryptedRevision,
+    DecryptedUnparsedNode,
     DecryptedUnparsedRevision,
-    NodeSigningKeys,
+    EncryptedNode,
     EncryptedNodeFileCrypto,
+    EncryptedNodeFolderCrypto,
+    EncryptedRevision,
+    NodeSigningKeys,
     SharesService,
 } from './interface';
-import { splitNodeUid } from '../uids';
 
 export interface NodesCryptoReporter {
     handleClaimedAuthor(
@@ -213,7 +212,7 @@ export class NodesCryptoService {
         let contentKeyPacketAuthor;
         let contentKeyPacket: Uint8Array<ArrayBuffer> | undefined;
         if ('file' in node.encryptedCrypto) {
-            contentKeyPacket = base64StringToUint8Array(node.encryptedCrypto.file.base64ContentKeyPacket);
+            contentKeyPacket = Uint8Array.fromBase64(node.encryptedCrypto.file.base64ContentKeyPacket);
             const [activeRevisionPromise, contentKeyPacketSessionKeyPromise] = [
                 this.decryptRevision(node.uid, node.encryptedCrypto.activeRevision, key),
                 this.decryptContentKeyPacket(node, node.encryptedCrypto, key, keyVerificationKeys),

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

@@ -1,8 +1,8 @@
 import { getMockLogger } from '../../tests/logger';
 import { DriveEvent, DriveEventType } from '../events';
+import { NodesCache } from './cache';
 import { NodesEventsHandler } from './events';
 import { DecryptedNode } from './interface';
-import { NodesCache } from './cache';
 
 describe('NodesEventsHandler', () => {
     const logger = getMockLogger();

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

@@ -1,11 +1,11 @@
 import { getMockLogger } from '../../tests/logger';
 import {
-    FolderExtendedAttributes,
     FileExtendedAttributesParsed,
-    generateFolderExtendedAttributes,
+    FolderExtendedAttributes,
     generateFileExtendedAttributes,
-    parseFolderExtendedAttributes,
+    generateFolderExtendedAttributes,
     parseFileExtendedAttributes,
+    parseFolderExtendedAttributes,
 } from './extendedAttributes';
 
 describe('extended attrbiutes', () => {

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

@@ -1,20 +1,20 @@
+import { MemoryCache } from '../../cache';
+import { DriveCrypto } from '../../crypto';
 import {
-    ProtonDriveEntitiesCache,
-    ProtonDriveCryptoCache,
-    ProtonDriveAccount,
     MemberRole,
     NodeType,
+    ProtonDriveAccount,
+    ProtonDriveCryptoCache,
+    ProtonDriveEntitiesCache,
 } from '../../interface';
-import { DriveCrypto } from '../../crypto';
-import { MemoryCache } from '../../cache';
+import { getMockLogger } from '../../tests/logger';
 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';
+import { initNodesModule } from './index';
+import { DecryptedNode, SharesService } from './interface';
 
 function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<DecryptedNode> = {}): DecryptedNode {
     return {

package/src/internal/nodes/index.ts

@@ -1,24 +1,24 @@
-import { DriveAPIService } from '../apiService';
 import { DriveCrypto } from '../../crypto';
 import {
-    ProtonDriveEntitiesCache,
-    ProtonDriveCryptoCache,
     ProtonDriveAccount,
+    ProtonDriveCryptoCache,
+    ProtonDriveEntitiesCache,
     ProtonDriveTelemetry,
 } from '../../interface';
+import { DriveAPIService } from '../apiService';
 import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
-import { NodesCryptoService } from './cryptoService';
 import { NodesCryptoReporter } from './cryptoReporter';
+import { NodesCryptoService } from './cryptoService';
+import { NodesEventsHandler } from './events';
 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';
 
 /**
  * Provides facade for the whole nodes module.

package/src/internal/nodes/interface.ts

@@ -1,16 +1,16 @@
 import { PrivateKey, SessionKey } from '../../crypto';
 import {
-    NodeEntity,
-    Result,
-    InvalidNameError,
+    AnonymousUser,
     Author,
+    InvalidNameError,
     MemberRole,
-    NodeType,
-    ThumbnailType,
     MetricVolumeType,
+    NodeEntity,
+    NodeType,
+    Result,
     Revision,
     RevisionState,
-    AnonymousUser,
+    ThumbnailType,
 } from '../../interface';
 
 export type FilterOptions = {

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

@@ -1,4 +1,4 @@
-import { splitExtension, joinNameAndExtension } from './nodeName';
+import { joinNameAndExtension, splitExtension } from './nodeName';
 
 describe('nodeName', () => {
     describe('splitExtension', () => {

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

@@ -1,13 +1,13 @@
-import { getMockTelemetry } from '../../tests/telemetry';
 import { PrivateKey } from '../../crypto';
 import { DecryptionError, ProtonDriveError } from '../../errors';
+import { NodeType } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
 import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { DecryptedNode, DecryptedNodeKeys, DecryptedUnparsedNode, EncryptedNode, SharesService } from './interface';
 import { NodesAccess } from './nodesAccess';
-import { SharesService, DecryptedNode, DecryptedUnparsedNode, EncryptedNode, DecryptedNodeKeys } from './interface';
-import { NodeType } from '../../interface';
 
 describe('nodesAccess', () => {
     let apiService: NodeAPIService;

package/src/internal/nodes/nodesAccess.ts

@@ -1,6 +1,7 @@
 import { c } from 'ttag';
 
 import { PrivateKey, SessionKey } from '../../crypto';
+import { DecryptionError, ProtonDriveError } from '../../errors';
 import {
     InvalidNameError,
     Logger,
@@ -11,10 +12,9 @@ import {
     resultError,
     resultOk,
 } from '../../interface';
-import { DecryptionError, ProtonDriveError } from '../../errors';
 import { asyncIteratorMap } from '../asyncIteratorMap';
-import { getErrorMessage } from '../errors';
 import { BatchLoading } from '../batchLoading';
+import { getErrorMessage } from '../errors';
 import { makeNodeUid, splitNodeUid } from '../uids';
 import { NodeAPIServiceBase } from './apiService';
 import { NodesCacheBase } from './cache';
@@ -23,16 +23,16 @@ import { NodesCryptoService } from './cryptoService';
 import { NodesDebouncer } from './debouncer';
 import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
 import {
-    SharesService,
-    EncryptedNode,
-    DecryptedUnparsedNode,
     DecryptedNode,
     DecryptedNodeKeys,
+    DecryptedUnparsedNode,
+    EncryptedNode,
     FilterOptions,
     NodeSigningKeys,
+    SharesService,
 } from './interface';
-import { validateNodeName } from './validations';
 import { isProtonDocument, isProtonSheet } from './mediaTypes';
+import { validateNodeName } from './validations';
 
 // This is the number of nodes that are loaded in parallel.
 // It is a trade-off between initial wait time and overhead of API calls.

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

@@ -1,12 +1,12 @@
+import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
+import { NodeResult, NodeResultWithError } from '../../interface';
 import { NodeAPIService } from './apiService';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
-import { NodesAccess } from './nodesAccess';
+import { NodeOutOfSyncError } from './errors';
 import { DecryptedNode } from './interface';
+import { NodesAccess } from './nodesAccess';
 import { NodesManagement } from './nodesManagement';
-import { NodeResult, NodeResultWithError } from '../../interface';
-import { NodeOutOfSyncError } from './errors';
-import { NodeWithSameNameExistsValidationError, ValidationError } from '../../errors';
 
 describe('NodesManagement', () => {
     let apiService: NodeAPIService;

package/src/internal/nodes/nodesManagement.ts

@@ -1,15 +1,15 @@
 import { c } from 'ttag';
 
+import { AbortError, ValidationError } from '../../errors';
 import {
+    InvalidNameError,
     MemberRole,
-    NodeType,
     NodeResult,
+    NodeResultWithError,
     NodeResultWithNewUid,
+    NodeType,
     resultOk,
-    InvalidNameError,
-    NodeResultWithError,
 } from '../../interface';
-import { AbortError, ValidationError } from '../../errors';
 import { createErrorFromUnknown, getErrorMessage } from '../errors';
 import { splitNodeUid } from '../uids';
 import { NodeAPIServiceBase } from './apiService';
@@ -18,9 +18,9 @@ import { NodesCryptoService } from './cryptoService';
 import { NodeOutOfSyncError } from './errors';
 import { generateFolderExtendedAttributes } from './extendedAttributes';
 import { DecryptedNode, EncryptedNode } from './interface';
-import { splitExtension, joinNameAndExtension } from './nodeName';
-import { NodesAccessBase } from './nodesAccess';
 import { FOLDER_MEDIA_TYPE } from './mediaTypes';
+import { joinNameAndExtension, splitExtension } from './nodeName';
+import { NodesAccessBase } from './nodesAccess';
 import { validateNodeName } from './validations';
 
 const AVAILABLE_NAME_BATCH_SIZE = 10;

package/src/internal/nodes/nodesRevisions.ts

@@ -2,9 +2,9 @@ import { Logger } from '../../interface';
 import { makeNodeUidFromRevisionUid } from '../uids';
 import { NodeAPIServiceBase } from './apiService';
 import { NodesCryptoService } from './cryptoService';
-import { NodesAccess } from './nodesAccess';
 import { parseFileExtendedAttributes } from './extendedAttributes';
 import { DecryptedRevision } from './interface';
+import { NodesAccess } from './nodesAccess';
 
 /**
  * Provides access to revisions metadata.

package/src/internal/photos/addToAlbum.ts

@@ -6,8 +6,8 @@ import { splitNodeUid } from '../uids';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { MissingRelatedPhotosError } from './errors';
-import { PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 import { PhotosNodesAccess } from './nodes';
+import { PhotoTransferPayloadBuilder, TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 
 /**
  * The number of photos that are loaded in parallel to prepare the payloads.

package/src/internal/photos/albumsCrypto.ts

@@ -1,4 +1,5 @@
 import { c } from 'ttag';
+
 import { DriveCrypto, PrivateKey, SessionKey } from '../../crypto';
 import { ValidationError } from '../../errors';
 import { InvalidNameError, Result } from '../../interface';

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

@@ -1,8 +1,8 @@
-import { NodeType } from '../../interface';
 import { ValidationError } from '../../errors';
+import { NodeType } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
-import { AlbumsManager } from './albumsManager';
 import { AlbumsCryptoService } from './albumsCrypto';
+import { AlbumsManager } from './albumsManager';
 import { PhotosAPIService } from './apiService';
 import { AlbumContainsPhotosNotInTimelineError } from './errors';
 import { DecryptedPhotoNode } from './interface';

package/src/internal/photos/apiService.ts

@@ -494,7 +494,7 @@ export class PhotosAPIService {
     ): AsyncGenerator<NodeResultWithError> {
         const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
 
-        const batchSize = 50;
+        const batchSize = 10;
 
         for (const photoNodeUidsBatch of batch(photoNodeUids, batchSize)) {
             const linkIds = photoNodeUidsBatch.map((nodeUid) => splitNodeUid(nodeUid).nodeId);