@protontech/drive-sdk 0.7.0 → 0.7.2

package/src/internal/photos/index.ts

@@ -6,6 +6,10 @@ import {
     ProtonDriveEntitiesCache,
     ProtonDriveTelemetry,
 } from '../../interface';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { NodesCryptoReporter } from '../nodes/cryptoReporter';
+import { NodesCryptoCache } from '../nodes/cryptoCache';
+import { ShareTargetType } from '../shares';
 import { SharesCache } from '../shares/cache';
 import { SharesCryptoCache } from '../shares/cryptoCache';
 import { SharesCryptoService } from '../shares/cryptoService';
@@ -14,7 +18,8 @@ import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
 import { Albums } from './albums';
 import { PhotosAPIService } from './apiService';
-import { NodesService, SharesService } from './interface';
+import { SharesService } from './interface';
+import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
 import {
@@ -24,7 +29,10 @@ import {
     PhotoUploadManager,
     PhotoUploadMetadata,
 } from './upload';
-import { ShareTargetType } from '../shares';
+import { NodesRevisons } from '../nodes/nodesRevisions';
+import { NodesEventsHandler } from '../nodes/events';
+
+export type { DecryptedPhotoNode } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
@@ -40,7 +48,7 @@ export function initPhotosModule(
     apiService: DriveAPIService,
     driveCrypto: DriveCrypto,
     photoShares: PhotoSharesManager,
-    nodesService: NodesService,
+    nodesService: PhotosNodesAccess,
 ) {
     const api = new PhotosAPIService(apiService);
     const timeline = new PhotosTimeline(
@@ -89,6 +97,40 @@ export function initPhotoSharesModule(
     );
 }
 
+/**
+ * Provides facade for the photo nodes module.
+ *
+ * The photo nodes module wraps the core nodes module and adds photo specific
+ * metadata. It provides the same interface so it can be used in the same way.
+ */
+export function initPhotosNodesModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveEntitiesCache: ProtonDriveEntitiesCache,
+    driveCryptoCache: ProtonDriveCryptoCache,
+    account: ProtonDriveAccount,
+    driveCrypto: DriveCrypto,
+    sharesService: PhotoSharesManager,
+    clientUid: string | undefined,
+) {
+    const api = new PhotosNodesAPIService(telemetry.getLogger('nodes-api'), apiService, clientUid);
+    const cache = new PhotosNodesCache(telemetry.getLogger('nodes-cache'), driveEntitiesCache);
+    const cryptoCache = new NodesCryptoCache(telemetry.getLogger('nodes-cache'), driveCryptoCache);
+    const cryptoReporter = new NodesCryptoReporter(telemetry, sharesService);
+    const cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, cryptoReporter);
+    const nodesAccess = new PhotosNodesAccess(telemetry, api, cache, cryptoCache, cryptoService, sharesService);
+    const nodesEventHandler = new NodesEventsHandler(telemetry.getLogger('nodes-events'), cache);
+    const nodesManagement = new PhotosNodesManagement(api, cryptoCache, cryptoService, nodesAccess);
+    const nodesRevisions = new NodesRevisons(telemetry.getLogger('nodes'), api, cryptoService, nodesAccess);
+
+    return {
+        access: nodesAccess,
+        management: nodesManagement,
+        revisions: nodesRevisions,
+        eventHandler: nodesEventHandler,
+    };
+}
+
 /**
  * Provides facade for the photo upload module.
  *

package/src/internal/photos/interface.ts

@@ -1,6 +1,6 @@
 import { PrivateKey } from '../../crypto';
-import { MissingNode, MetricVolumeType } from '../../interface';
-import { DecryptedNode } from '../nodes';
+import { MetricVolumeType, PhotoAttributes } from '../../interface';
+import { DecryptedNode, EncryptedNode, DecryptedUnparsedNode } from '../nodes/interface';
 import { EncryptedShare } from '../shares';
 
 export interface SharesService {
@@ -23,10 +23,22 @@ export interface SharesService {
     getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>;
 }
 
-export interface NodesService {
-    getNode(nodeUid: string): Promise<DecryptedNode>;
-    iterateNodes(nodeUids: string[], signal?: AbortSignal): AsyncGenerator<DecryptedNode | MissingNode>;
-    getNodeKeys(nodeUid: string): Promise<{
-        hashKey?: Uint8Array;
-    }>;
-}
+export type EncryptedPhotoNode = EncryptedNode & {
+    photo?: EcnryptedPhotoAttributes;
+};
+
+export type DecryptedUnparsedPhotoNode = DecryptedUnparsedNode & {
+    photo?: PhotoAttributes;
+};
+
+export type DecryptedPhotoNode = DecryptedNode & {
+    photo?: PhotoAttributes;
+};
+
+export type EcnryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
+    contentHash?: string;
+    albums: (PhotoAttributes['albums'][0] & {
+        nameHash?: string;
+        contentHash?: string;
+    })[];
+};

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

@@ -0,0 +1,258 @@
+import { MemoryCache } from '../../cache';
+import { NodeType, MemberRole } from '../../interface';
+import { getMockLogger } from '../../tests/logger';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { DriveAPIService } from '../apiService';
+import { PhotosNodesAPIService, PhotosNodesCache, PhotosNodesAccess, PhotosNodesCryptoService } from './nodes';
+
+function generateAPINode() {
+    return {
+        Link: {
+            LinkID: 'linkId',
+            ParentLinkID: 'parentLinkId',
+            NameHash: 'nameHash',
+            CreateTime: 123456789,
+            ModifyTime: 1234567890,
+            TrashTime: 0,
+            Name: 'encName',
+            SignatureEmail: 'sigEmail',
+            NameSignatureEmail: 'nameSigEmail',
+            NodeKey: 'nodeKey',
+            NodePassphrase: 'nodePass',
+            NodePassphraseSignature: 'nodePassSig',
+        },
+        SharingSummary: null,
+        Sharing: null,
+        Membership: null,
+    };
+}
+
+function generateAPIFolderNode(linkOverrides = {}, overrides = {}) {
+    const node = generateAPINode();
+    return {
+        ...node,
+        Link: { ...node.Link, Type: 1, ...linkOverrides },
+        Folder: { XAttr: '{folder}', NodeHashKey: 'nodeHashKey' },
+        Photo: null,
+        ...overrides,
+    };
+}
+
+function generateAPIAlbumNode(linkOverrides = {}, overrides = {}) {
+    const node = generateAPINode();
+    return {
+        ...node,
+        Link: { ...node.Link, Type: 3, ...linkOverrides },
+        Photo: null,
+        Folder: null,
+        ...overrides,
+    };
+}
+
+function generateAPIPhotoNode(linkOverrides = {}, overrides = {}) {
+    const node = generateAPINode();
+    return {
+        ...node,
+        Link: { ...node.Link, Type: 2, ...linkOverrides },
+        Photo: {
+            CaptureTime: 1700000000,
+            MainPhotoLinkID: null,
+            RelatedPhotosLinkIDs: [],
+            ContentHash: 'contentHash123',
+            Tags: [1, 2],
+            Albums: [
+                {
+                    AlbumLinkID: 'albumLinkId1',
+                    AddedTime: 1700001000,
+                    Hash: 'albumHash',
+                    ContentHash: 'albumContentHash',
+                },
+            ],
+            ActiveRevision: {
+                RevisionID: 'revisionId',
+                CreateTime: 1234567890,
+                SignatureEmail: 'revSigEmail',
+                XAttr: '{photo}',
+                EncryptedSize: 12,
+            },
+            MediaType: 'image/jpeg',
+            ContentKeyPacket: 'contentKeyPacket',
+            ContentKeyPacketSignature: 'contentKeyPacketSig',
+        },
+        Folder: null,
+        ...overrides,
+    };
+}
+
+describe('PhotosNodesAPIService', () => {
+    let apiMock: DriveAPIService;
+    let api: PhotosNodesAPIService;
+
+    beforeEach(() => {
+        // @ts-expect-error Mocking for testing purposes
+        apiMock = {
+            post: jest.fn(),
+        };
+        api = new PhotosNodesAPIService(getMockLogger(), apiMock, 'clientUid');
+    });
+
+    describe('linkToEncryptedNode', () => {
+        async function testIterateNodes(mockedLink: object, expectedType: NodeType) {
+            apiMock.post = jest.fn().mockResolvedValue({ Links: [mockedLink] });
+
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
+            expect(nodes).toHaveLength(1);
+            expect(nodes[0].type).toBe(expectedType);
+        }
+
+        it('should convert folder (type 1) to folder node', async () => {
+            await testIterateNodes(generateAPIFolderNode(), NodeType.Folder);
+        });
+
+        it('should convert album (type 3) to album node', async () => {
+            await testIterateNodes(generateAPIAlbumNode(), NodeType.Album);
+        });
+
+        it('should convert photo (type 2) to photo node with photo attributes', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({ Links: [generateAPIPhotoNode()] });
+
+            const nodes = await Array.fromAsync(api.iterateNodes(['volumeId~nodeId'], 'volumeId'));
+
+            expect(nodes).toHaveLength(1);
+            expect(nodes[0].type).toBe(NodeType.Photo);
+            expect(nodes[0].photo).toBeDefined();
+            expect(nodes[0].photo?.captureTime).toEqual(new Date(1700000000 * 1000));
+            expect(nodes[0].photo?.tags).toEqual([1, 2]);
+            expect(nodes[0].photo?.albums).toHaveLength(1);
+            expect(nodes[0].photo?.albums[0].nodeUid).toBe('volumeId~albumLinkId1');
+            expect(nodes[0].photo?.albums[0].additionTime).toEqual(new Date(1700001000 * 1000));
+        });
+    });
+});
+
+describe('PhotosNodesCache', () => {
+    let cache: PhotosNodesCache;
+
+    beforeEach(() => {
+        const memoryCache = new MemoryCache<string>();
+        cache = new PhotosNodesCache(getMockLogger(), memoryCache);
+    });
+
+    describe('deserialiseNode', () => {
+        it('should convert photo attributes dates from strings to Date objects', () => {
+            const serialisedNode = JSON.stringify({
+                uid: 'volumeId~linkId',
+                parentUid: 'volumeId~parentLinkId',
+                type: NodeType.Photo,
+                directRole: MemberRole.Admin,
+                isShared: false,
+                isSharedPublicly: false,
+                creationTime: '2023-11-14T22:13:20.000Z',
+                modificationTime: '2023-11-14T22:13:20.000Z',
+                photo: {
+                    captureTime: '2023-11-14T22:13:20.000Z',
+                    mainPhotoNodeUid: undefined,
+                    relatedPhotoNodeUids: [],
+                    tags: [1],
+                    albums: [
+                        {
+                            nodeUid: 'volumeId~albumId',
+                            additionTime: '2023-11-15T10:00:00.000Z',
+                        },
+                    ],
+                },
+            });
+
+            const node = cache.deserialiseNode(serialisedNode);
+
+            expect(node.photo).toBeDefined();
+            expect(node.photo?.captureTime).toBeInstanceOf(Date);
+            expect(node.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
+            expect(node.photo?.albums[0].additionTime).toBeInstanceOf(Date);
+            expect(node.photo?.albums[0].additionTime).toEqual(new Date('2023-11-15T10:00:00.000Z'));
+        });
+
+        it('should handle node without photo attributes', () => {
+            const serialisedNode = JSON.stringify({
+                uid: 'volumeId~linkId',
+                parentUid: 'volumeId~parentLinkId',
+                type: NodeType.Folder,
+                directRole: MemberRole.Admin,
+                isShared: false,
+                isSharedPublicly: false,
+                creationTime: '2023-11-14T22:13:20.000Z',
+                modificationTime: '2023-11-14T22:13:20.000Z',
+            });
+
+            const node = cache.deserialiseNode(serialisedNode);
+
+            expect(node.photo).toBeUndefined();
+        });
+    });
+});
+
+describe('PhotosNodesAccess', () => {
+    describe('parseNode', () => {
+        it('should keep photo type and add photo object', async () => {
+            const telemetry = getMockTelemetry();
+
+            // @ts-expect-error Mocking for testing purposes
+            const cryptoService: PhotosNodesCryptoService = {};
+            // @ts-expect-error Mocking for testing purposes
+            const apiService: PhotosNodesAPIService = {};
+            // @ts-expect-error Mocking for testing purposes
+            const cacheService: PhotosNodesCache = {};
+            // @ts-expect-error Mocking for testing purposes
+            const cryptoCache: NodesCryptoCache = {};
+            // @ts-expect-error Mocking for testing purposes
+            const sharesService: SharesService = {};
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const nodesAccess = new PhotosNodesAccess(telemetry, apiService, cacheService, cryptoCache, cryptoService, sharesService);
+
+            const unparsedNode = {
+                uid: 'volumeId~linkId',
+                parentUid: 'volumeId~parentLinkId',
+                type: NodeType.Photo,
+                name: 'photo.jpg',
+                hash: 'hash123',
+                directRole: MemberRole.Admin,
+                isShared: false,
+                isSharedPublicly: false,
+                creationTime: new Date(),
+                modificationTime: new Date(),
+                trashTime: undefined,
+                mediaType: 'image/jpeg',
+                folder: undefined,
+                file: {
+                    activeRevision: {
+                        uid: 'revisionId',
+                        state: 'active' as const,
+                        creationTime: new Date(),
+                        storageSize: 100,
+                        signatureEmail: 'test@example.com',
+                        claimedModificationTime: new Date(),
+                        claimedSize: 100,
+                        claimedDigests: { sha1: 'sha1hash' },
+                        claimedBlockSizes: [100],
+                    },
+                },
+                photo: {
+                    captureTime: new Date('2023-11-14T22:13:20.000Z'),
+                    mainPhotoNodeUid: undefined,
+                    relatedPhotoNodeUids: [],
+                    tags: [1, 2],
+                    albums: [],
+                },
+            };
+
+            // @ts-expect-error Accessing protected method for testing
+            const parsedNode = nodesAccess.parseNode(unparsedNode);
+
+            expect(parsedNode.type).toBe(NodeType.Photo);
+            expect(parsedNode.photo).toBeDefined();
+            expect(parsedNode.photo?.captureTime).toEqual(new Date('2023-11-14T22:13:20.000Z'));
+            expect(parsedNode.photo?.tags).toEqual([1, 2]);
+        });
+    });
+});

package/src/internal/photos/nodes.ts

@@ -0,0 +1,234 @@
+import { PrivateKey } from '../../crypto';
+import { DecryptionError } from '../../errors';
+import { NodeType } from '../../interface';
+import { drivePaths } from '../apiService';
+import { NodeAPIServiceBase, linkToEncryptedNode, linkToEncryptedNodeBaseMetadata } from '../nodes/apiService';
+import { NodesCacheBase, serialiseNode, deserialiseNode } from '../nodes/cache';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { DecryptedNodeKeys } from '../nodes/interface';
+import { NodesAccessBase, parseNode as parseNodeBase } from '../nodes/nodesAccess';
+import { NodesManagementBase } from '../nodes/nodesManagement';
+import { makeNodeUid } from '../uids';
+import { EncryptedPhotoNode, DecryptedPhotoNode, DecryptedUnparsedPhotoNode } from './interface';
+
+type PostLoadLinksMetadataRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostLoadLinksMetadataResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/links']['post']['responses']['200']['content']['application/json'];
+
+export class PhotosNodesAPIService extends NodeAPIServiceBase<
+    EncryptedPhotoNode,
+    PostLoadLinksMetadataResponse['Links'][0]
+> {
+    protected async fetchNodeMetadata(volumeId: string, linkIds: string[], signal?: AbortSignal) {
+        const response = await this.apiService.post<PostLoadLinksMetadataRequest, PostLoadLinksMetadataResponse>(
+            `drive/photos/volumes/${volumeId}/links`,
+            {
+                LinkIDs: linkIds,
+            },
+            signal,
+        );
+        return response.Links;
+    }
+
+    protected linkToEncryptedNode(
+        volumeId: string,
+        link: PostLoadLinksMetadataResponse['Links'][0],
+        isOwnVolumeId: boolean,
+    ): EncryptedPhotoNode {
+        const { baseNodeMetadata, baseCryptoNodeMetadata } = linkToEncryptedNodeBaseMetadata(
+            this.logger,
+            volumeId,
+            link,
+            isOwnVolumeId,
+        );
+
+        if (link.Link.Type === 2 && link.Photo && link.Photo.ActiveRevision) {
+            const node = linkToEncryptedNode(
+                this.logger,
+                volumeId,
+                { ...link, File: link.Photo, Folder: null },
+                isOwnVolumeId,
+            );
+            return {
+                ...node,
+                type: NodeType.Photo,
+                photo: {
+                    captureTime: new Date(link.Photo.CaptureTime * 1000),
+                    mainPhotoNodeUid: link.Photo.MainPhotoLinkID
+                        ? makeNodeUid(volumeId, link.Photo.MainPhotoLinkID)
+                        : undefined,
+                    relatedPhotoNodeUids: link.Photo.RelatedPhotosLinkIDs.map((relatedLinkId) =>
+                        makeNodeUid(volumeId, relatedLinkId),
+                    ),
+                    contentHash: link.Photo.ContentHash || undefined,
+                    tags: link.Photo.Tags,
+                    albums: link.Photo.Albums.map((album) => ({
+                        nodeUid: makeNodeUid(volumeId, album.AlbumLinkID),
+                        additionTime: new Date(album.AddedTime * 1000),
+                        nameHash: album.Hash,
+                        contentHash: album.ContentHash,
+                    })),
+                },
+            };
+        }
+
+        if (link.Link.Type === 3) {
+            return {
+                ...baseNodeMetadata,
+                encryptedCrypto: {
+                    ...baseCryptoNodeMetadata,
+                },
+            };
+        }
+
+        const baseLink = {
+            Link: link.Link,
+            Membership: link.Membership,
+            Sharing: link.Sharing,
+            // @ts-expect-error The photo link can have a folder type, but not always. If not set, it will use other paths.
+            Folder: link.Folder,
+            File: null, // The photo link metadata never returns a file type.
+        };
+        return linkToEncryptedNode(this.logger, volumeId, baseLink, isOwnVolumeId);
+    }
+}
+
+export class PhotosNodesCache extends NodesCacheBase<DecryptedPhotoNode> {
+    serialiseNode(node: DecryptedPhotoNode): string {
+        return serialiseNode(node);
+    }
+
+    // TODO: use better deserialisation with validation
+    deserialiseNode(nodeData: string): DecryptedPhotoNode {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const node = deserialiseNode(nodeData) as any;
+
+        if (
+            !node ||
+            typeof node !== 'object' ||
+            (typeof node.photo !== 'object' && node.photo !== undefined) ||
+            (typeof node.photo?.captureTime !== 'string' && node.folder?.captureTime !== undefined) ||
+            (typeof node.photo?.albums !== 'object' && node.photo?.albums !== undefined)
+        ) {
+            throw new Error(`Invalid node data: ${nodeData}`);
+        }
+
+        return {
+            ...node,
+            photo: !node.photo
+                ? undefined
+                : {
+                      captureTime: new Date(node.photo.captureTime),
+                      mainPhotoNodeUid: node.photo.mainPhotoNodeUid,
+                      relatedPhotoNodeUids: node.photo.relatedPhotoNodeUids,
+                      contentHash: node.photo.contentHash,
+                      tags: node.photo.tags,
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      albums: node.photo.albums?.map((album: any) => ({
+                          nodeUid: album.nodeUid,
+                          additionTime: new Date(album.additionTime),
+                      })),
+                  },
+        } as DecryptedPhotoNode;
+    }
+}
+
+export class PhotosNodesAccess extends NodesAccessBase<EncryptedPhotoNode, DecryptedPhotoNode, PhotosNodesCryptoService> {
+    async getParentKeys(
+        node: Pick<EncryptedPhotoNode, 'uid' | 'parentUid' | 'shareId' | 'photo'>,
+    ): Promise<Pick<DecryptedNodeKeys, 'key' | 'hashKey'>> {
+        if (node.parentUid || node.shareId) {
+            return super.getParentKeys(node);
+        }
+
+        if (node.photo?.albums.length) {
+            // If photo is in multiple albums, we just need to get keys for one of them.
+            // Prefer to find a cached key first.
+            for (const album of node.photo.albums) {
+                try {
+                    const keys = await this.cryptoCache.getNodeKeys(album.nodeUid);
+                    return {
+                        key: keys.key,
+                        hashKey: keys.hashKey,
+                    };
+                } catch {
+                    // We ignore missing or invalid keys here, its just optimization.
+                    // If it cannot be fixed, it will bubble up later when requesting
+                    // the node keys for one of the albums.
+                }
+            }
+
+            const albumNodeUid = node.photo.albums[0].nodeUid;
+            return this.getNodeKeys(albumNodeUid);
+        }
+
+        // This is bug that should not happen.
+        // API cannot provide node without parent or share or album.
+        throw new Error('Node has neither parent node nor share nor album');
+    }
+
+    protected getDegradedUndecryptableNode(
+        encryptedNode: EncryptedPhotoNode,
+        error: DecryptionError,
+    ): DecryptedPhotoNode {
+        return this.getDegradedUndecryptableNodeBase(encryptedNode, error);
+    }
+
+    protected parseNode(unparsedNode: DecryptedUnparsedPhotoNode): DecryptedPhotoNode {
+        if (unparsedNode.type === NodeType.Photo) {
+            const node = parseNodeBase(this.logger, {
+                ...unparsedNode,
+                type: NodeType.File,
+            });
+            return {
+                ...node,
+                photo: unparsedNode.photo,
+                type: NodeType.Photo,
+            };
+        }
+
+        return parseNodeBase(this.logger, unparsedNode);
+    }
+}
+
+export class PhotosNodesCryptoService extends NodesCryptoService {
+    async decryptNode(
+        encryptedNode: EncryptedPhotoNode,
+        parentKey: PrivateKey,
+    ): Promise<{ node: DecryptedUnparsedPhotoNode; keys?: DecryptedNodeKeys }> {
+        const decryptedNode = await super.decryptNode(encryptedNode, parentKey);
+
+        if (decryptedNode.node.type === NodeType.Photo) {
+            return {
+                node: {
+                    ...decryptedNode.node,
+                    photo: encryptedNode.photo,
+                },
+            };
+        }
+
+        return decryptedNode;
+    }
+}
+
+export class PhotosNodesManagement extends NodesManagementBase<
+    EncryptedPhotoNode,
+    DecryptedPhotoNode,
+    PhotosNodesCryptoService
+> {
+    protected generateNodeFolder(
+        nodeUid: string,
+        parentNodeUid: string,
+        name: string,
+        encryptedCrypto: {
+            hash: string;
+            encryptedName: string;
+            signatureEmail: string | null;
+        },
+    ): DecryptedPhotoNode {
+        return this.generateNodeFolderBase(nodeUid, parentNodeUid, name, encryptedCrypto);
+    }
+}

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

@@ -2,7 +2,7 @@ import { getMockLogger } from '../../tests/logger';
 import { DriveCrypto } from '../../crypto';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
-import { NodesService } from './interface';
+import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
 
@@ -11,7 +11,7 @@ describe('PhotosTimeline', () => {
     let apiService: PhotosAPIService;
     let driveCrypto: DriveCrypto;
     let photoShares: PhotoSharesManager;
-    let nodesService: NodesService;
+    let nodesService: PhotosNodesAccess;
     let timeline: PhotosTimeline;
 
     const volumeId = 'volumeId';

package/src/internal/photos/timeline.ts

@@ -2,7 +2,7 @@ import { DriveCrypto } from '../../crypto';
 import { Logger } from '../../interface';
 import { makeNodeUid } from '../uids';
 import { PhotosAPIService } from './apiService';
-import { NodesService } from './interface';
+import { PhotosNodesAccess } from './nodes';
 import { PhotoSharesManager } from './shares';
 
 /**
@@ -14,7 +14,7 @@ export class PhotosTimeline {
         private apiService: PhotosAPIService,
         private driveCrypto: DriveCrypto,
         private photoShares: PhotoSharesManager,
-        private nodesService: NodesService,
+        private nodesService: PhotosNodesAccess,
     ) {
         this.logger = logger;
         this.apiService = apiService;