@protontech/drive-sdk 0.9.9 → 0.11.0

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

@@ -0,0 +1,233 @@
+import { DriveAPIService } from '../apiService/apiService';
+import { APICodeError, InvalidRequirementsAPIError } from '../apiService/errors';
+import { PhotosAPIService } from './apiService';
+import { MissingRelatedPhotosError } from './errors';
+
+describe('photosAPIService', () => {
+    let apiMock: DriveAPIService;
+    let api: PhotosAPIService;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // @ts-expect-error Mocking for testing purposes
+        apiMock = {
+            get: jest.fn(),
+            post: jest.fn(),
+            put: jest.fn(),
+        };
+
+        api = new PhotosAPIService(apiMock);
+    });
+
+    const albumNodeUid = 'volumeId1~albumNodeId';
+
+    describe('addPhotosToAlbum', () => {
+        const photoPayloads = [
+            {
+                nodeUid: 'volumeId1~photoNodeId1',
+                contentHash: 'contentHash1',
+                nameHash: 'nameHash1',
+                encryptedName: 'encryptedName1',
+                nameSignatureEmail: 'nameSignatureEmail1',
+                nodePassphrase: 'nodePassphrase1',
+                nodePassphraseSignature: 'nodePassphraseSignature1',
+                signatureEmail: 'signatureEmail1',
+                relatedPhotos: [
+                    {
+                        nodeUid: 'volumeId1~photoNodeId2',
+                        contentHash: 'contentHash2',
+                        nameHash: 'nameHash2',
+                        encryptedName: 'encryptedName2',
+                        nameSignatureEmail: 'nameSignatureEmail2',
+                        nodePassphrase: 'nodePassphrase2',
+                        nodePassphraseSignature: 'nodePassphraseSignature2',
+                        signatureEmail: 'signatureEmail2',
+                    },
+                ],
+            },
+        ];
+
+        it('should add photos to album', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 1000,
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.addPhotosToAlbum(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: true,
+                },
+            ]);
+            expect(apiMock.post).toHaveBeenCalledWith(
+                `drive/photos/volumes/volumeId1/albums/albumNodeId/add-multiple`,
+                {
+                    AlbumData: [
+                        expect.objectContaining({
+                            LinkID: 'photoNodeId1',
+                            Hash: 'nameHash1',
+                            Name: 'encryptedName1',
+                            NameSignatureEmail: 'nameSignatureEmail1',
+                        }),
+                        expect.objectContaining({
+                            LinkID: 'photoNodeId2',
+                            Hash: 'nameHash2',
+                            Name: 'encryptedName2',
+                            NameSignatureEmail: 'nameSignatureEmail2',
+                        }),
+                    ],
+                },
+                undefined,
+            );
+        });
+
+        it('should return MissingRelatedPhotosError if related photos are missing', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 2000,
+                            Details: {
+                                Missing: ['photoNodeId3'],
+                            },
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.addPhotosToAlbum(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: false,
+                    error: new MissingRelatedPhotosError([]),
+                },
+            ]);
+            expect((result[0] as any).error.missingNodeUids).toEqual(['volumeId1~photoNodeId3']);
+        });
+
+        it('should return error for unknown error', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: 1000,
+                Responses: [
+                    {
+                        LinkID: 'photoNodeId1',
+                        Response: {
+                            Code: 3000,
+                            Error: 'Some error',
+                        },
+                    },
+                ],
+            });
+
+            const result = await Array.fromAsync(api.addPhotosToAlbum(albumNodeUid, photoPayloads));
+
+            expect(result).toEqual([
+                {
+                    uid: 'volumeId1~photoNodeId1',
+                    ok: false,
+                    error: new APICodeError('Some error', 3000),
+                },
+            ]);
+        });
+    });
+
+    describe('copyPhotoToAlbum', () => {
+        const photoPayloads = [
+            {
+                nodeUid: 'volumeId2~photoNodeId1',
+                contentHash: 'contentHash1',
+                nameHash: 'nameHash1',
+                encryptedName: 'encryptedName1',
+                nameSignatureEmail: 'nameSignatureEmail1',
+                nodePassphrase: 'nodePassphrase1',
+                nodePassphraseSignature: 'nodePassphraseSignature1',
+                signatureEmail: 'signatureEmail1',
+                relatedPhotos: [
+                    {
+                        nodeUid: 'volumeId2~photoNodeId2',
+                        contentHash: 'contentHash2',
+                        nameHash: 'nameHash2',
+                        encryptedName: 'encryptedName2',
+                        nameSignatureEmail: 'nameSignatureEmail2',
+                        nodePassphrase: 'nodePassphrase2',
+                        nodePassphraseSignature: 'nodePassphraseSignature2',
+                        signatureEmail: 'signatureEmail2',
+                    },
+                ],
+            },
+        ];
+
+        it('should copy photo to album', async () => {
+            apiMock.post = jest.fn().mockResolvedValue({
+                Code: 1000,
+                LinkID: 'photoNodeId1',
+            });
+
+            const result = await api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+
+            expect(result).toEqual('volumeId1~photoNodeId1');
+            expect(apiMock.post).toHaveBeenCalledWith(
+                `drive/volumes/volumeId2/links/photoNodeId1/copy`,
+                expect.objectContaining({
+                    TargetVolumeID: 'volumeId1',
+                    TargetParentLinkID: 'albumNodeId',
+                    Hash: 'nameHash1',
+                    Name: 'encryptedName1',
+                    Photos: {
+                        ContentHash: 'contentHash1',
+                        RelatedPhotos: expect.arrayContaining([
+                            expect.objectContaining({
+                                LinkID: 'photoNodeId2',
+                                Hash: 'nameHash2',
+                                Name: 'encryptedName2',
+                            }),
+                        ]),
+                    },
+                }),
+                undefined,
+            );
+        });
+
+        it('should return MissingRelatedPhotosError if related photos are missing', async () => {
+            apiMock.post = jest.fn().mockRejectedValue(new InvalidRequirementsAPIError(
+                'Missing related photos',
+                2000,
+                {
+                    Missing: ['photoNodeId3'],
+                },
+            ));
+
+            const promise = api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+
+            await expect(promise).rejects.toThrow(MissingRelatedPhotosError);
+            try {
+                await promise;
+            } catch (error) {
+                expect((error as MissingRelatedPhotosError).missingNodeUids).toEqual(['volumeId2~photoNodeId3']);
+            }
+        });
+
+        it('should return error for unknown error', async () => {
+            const error = new APICodeError('Some error', 3000);
+            apiMock.post = jest.fn().mockRejectedValue(error);
+
+            const promise = api.copyPhotoToAlbum(albumNodeUid, photoPayloads[0]);
+
+            await expect(promise).rejects.toThrow(error);
+        });
+    });
+});

package/src/internal/photos/apiService.ts

@@ -1,12 +1,14 @@
 import { c } from 'ttag';
 
 import { ValidationError } from '../../errors';
-import { NodeResult } from '../../interface';
-import { APICodeError, DriveAPIService, drivePaths } from '../apiService';
+import { NodeResultWithError, PhotoTag } from '../../interface';
+import { APICodeError, DriveAPIService, drivePaths, InvalidRequirementsAPIError, isCodeOk } from '../apiService';
 import { batch } from '../batch';
 import { EncryptedRootShare, EncryptedShareCrypto, ShareType } from '../shares/interface';
 import { makeNodeUid, splitNodeUid } from '../uids';
+import { MissingRelatedPhotosError } from './errors';
 import { AlbumItem } from './interface';
+import { TransferEncryptedPhotoPayload } from './photosTransferPayloadBuilder';
 
 type GetPhotoShareResponse =
     drivePaths['/drive/v2/shares/photos']['get']['responses']['200']['content']['application/json'];
@@ -46,6 +48,20 @@ type PostPhotoDuplicateRequest = Extract<
 type PostPhotoDuplicateResponse =
     drivePaths['/drive/volumes/{volumeID}/photos/duplicates']['post']['responses']['200']['content']['application/json'];
 
+type PostAddPhotosToAlbumRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/add-multiple']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostAddPhotosToAlbumResponse =
+    drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/add-multiple']['post']['responses']['200']['content']['application/json'];
+
+type PostCopyLinkRequest = Extract<
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCopyLinkResponse =
+    drivePaths['/drive/volumes/{volumeID}/links/{linkID}/copy']['post']['responses']['200']['content']['application/json'];
+
 type PostRemovePhotosFromAlbumRequest = Extract<
     drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/remove-multiple']['post']['requestBody'],
     { content: object }
@@ -53,6 +69,19 @@ type PostRemovePhotosFromAlbumRequest = Extract<
 type PostRemovePhotosFromAlbumResponse =
     drivePaths['/drive/photos/volumes/{volumeID}/albums/{linkID}/remove-multiple']['post']['responses']['200']['content']['application/json'];
 
+type PostAddPhotoTagsRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/tags']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostRemovePhotoTagsRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/tags']['delete']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostFavoritePhotoRequest = Extract<
+    drivePaths['/drive/photos/volumes/{volumeID}/links/{linkID}/favorite']['post']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+
 const ALBUM_CONTAINS_PHOTOS_NOT_IN_TIMELINE_ERROR_CODE = 200302;
 
 /**
@@ -186,10 +215,7 @@ export class PhotosAPIService {
         }
     }
 
-    async *iterateAlbumChildren(
-        albumNodeUid: string,
-        signal?: AbortSignal,
-    ): AsyncGenerator<AlbumItem> {
+    async *iterateAlbumChildren(albumNodeUid: string, signal?: AbortSignal): AsyncGenerator<AlbumItem> {
         const { volumeId, nodeId: linkId } = splitNodeUid(albumNodeUid);
         let anchor = '';
         while (true) {
@@ -289,20 +315,17 @@ export class PhotosAPIService {
     ): Promise<void> {
         const { volumeId, nodeId: linkId } = splitNodeUid(albumNodeUid);
         const coverLinkId = coverPhotoNodeUid ? splitNodeUid(coverPhotoNodeUid).nodeId : undefined;
-        await this.apiService.put<PutUpdateAlbumRequest, void>(
-            `drive/photos/volumes/${volumeId}/albums/${linkId}`,
-            {
-                CoverLinkID: coverLinkId,
-                Link: updatedName
-                    ? {
-                          Name: updatedName.encryptedName,
-                          Hash: updatedName.hash,
-                          OriginalHash: updatedName.originalHash,
-                          NameSignatureEmail: updatedName.nameSignatureEmail,
-                      }
-                    : null,
-            },
-        );
+        await this.apiService.put<PutUpdateAlbumRequest, void>(`drive/photos/volumes/${volumeId}/albums/${linkId}`, {
+            CoverLinkID: coverLinkId,
+            Link: updatedName
+                ? {
+                      Name: updatedName.encryptedName,
+                      Hash: updatedName.hash,
+                      OriginalHash: updatedName.originalHash,
+                      NameSignatureEmail: updatedName.nameSignatureEmail,
+                  }
+                : null,
+        });
     }
 
     async deleteAlbum(albumNodeUid: string, options: { force?: boolean } = {}): Promise<void> {
@@ -319,11 +342,143 @@ export class PhotosAPIService {
         }
     }
 
+    /**
+     * Add photos from the same volume to an album.
+     *
+     * To add photos from different volumes, use the {@link copyPhotoToAlbum} method.
+     *
+     * In the future, these two methods will be merged into a single one.
+     */
+    async *addPhotosToAlbum(
+        albumNodeUid: string,
+        photoPayloads: TransferEncryptedPhotoPayload[],
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResultWithError> {
+        const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
+
+        const allPhotoPayloads = photoPayloads.flatMap((photoPayload) => [photoPayload, ...photoPayload.relatedPhotos]);
+        const allPhotoData = allPhotoPayloads.map((photoPayload) => {
+            const { nodeId } = splitNodeUid(photoPayload.nodeUid);
+            return {
+                LinkID: nodeId,
+                Hash: photoPayload.nameHash,
+                Name: photoPayload.encryptedName,
+                NameSignatureEmail: photoPayload.nameSignatureEmail,
+                NodePassphrase: photoPayload.nodePassphrase,
+                ContentHash: photoPayload.contentHash,
+            };
+        });
+
+        const response = await this.apiService.post<PostAddPhotosToAlbumRequest, PostAddPhotosToAlbumResponse>(
+            `drive/photos/volumes/${volumeId}/albums/${albumLinkId}/add-multiple`,
+            {
+                AlbumData: allPhotoData,
+            },
+            signal,
+        );
+
+        const errors = new Map<string, Error>();
+
+        for (const r of response.Responses || []) {
+            // @ts-expect-error - API definition is not correct.
+            const details = r as {
+                LinkID: string;
+                Response: {
+                    Code: number;
+                    Error?: string;
+                    Details: { Missing: string[] };
+                };
+            };
+
+            if (!details.Response.Code || !isCodeOk(details.Response.Code) || details.Response?.Error) {
+                const nodeUid = makeNodeUid(volumeId, details.LinkID);
+
+                if (details.Response.Details?.Missing) {
+                    const missingNodeUids = details.Response.Details.Missing.map((linkId) =>
+                        makeNodeUid(volumeId, linkId),
+                    );
+                    errors.set(nodeUid, new MissingRelatedPhotosError(missingNodeUids));
+                } else {
+                    errors.set(
+                        nodeUid,
+                        new APICodeError(details.Response.Error || c('Error').t`Unknown error`, details.Response.Code),
+                    );
+                }
+            }
+        }
+
+        for (const photoPayload of photoPayloads) {
+            const uid = photoPayload.nodeUid;
+            const error = errors.get(uid);
+            if (error) {
+                yield { uid, ok: false, error };
+            } else {
+                yield { uid, ok: true };
+            }
+        }
+    }
+
+    /**
+     * Copy a photo to a shared album on a different volume.
+     *
+     * To add photos from the same volume to an album, use the {@link addPhotosToAlbum} method.
+     *
+     * In the future, these two methods will be merged into a single one.
+     */
+    async copyPhotoToAlbum(
+        albumNodeUid: string,
+        payload: TransferEncryptedPhotoPayload,
+        signal?: AbortSignal,
+    ): Promise<string> {
+        const { volumeId: sourceVolumeId, nodeId: sourceLinkId } = splitNodeUid(payload.nodeUid);
+        const { volumeId: targetVolumeId, nodeId: targetAlbumLinkId } = splitNodeUid(albumNodeUid);
+
+        try {
+            const response = await this.apiService.post<PostCopyLinkRequest, PostCopyLinkResponse>(
+                `drive/volumes/${sourceVolumeId}/links/${sourceLinkId}/copy`,
+                {
+                    TargetVolumeID: targetVolumeId,
+                    TargetParentLinkID: targetAlbumLinkId,
+                    Hash: payload.nameHash,
+                    Name: payload.encryptedName,
+                    NameSignatureEmail: payload.nameSignatureEmail,
+                    NodePassphrase: payload.nodePassphrase,
+                    // @ts-expect-error: API accepts NodePassphraseSignature as optional.
+                    NodePassphraseSignature: payload.nodePassphraseSignature,
+                    // @ts-expect-error: API accepts SignatureEmail as optional.
+                    SignatureEmail: payload.signatureEmail,
+                    Photos: {
+                        ContentHash: payload.contentHash,
+                        RelatedPhotos: payload.relatedPhotos.map((related) => ({
+                            LinkID: splitNodeUid(related.nodeUid).nodeId,
+                            Hash: related.nameHash,
+                            Name: related.encryptedName,
+                            NodePassphrase: related.nodePassphrase,
+                            ContentHash: related.contentHash,
+                        })),
+                    },
+                },
+                signal,
+            );
+            return makeNodeUid(targetVolumeId, response.LinkID);
+        } catch (error) {
+            if (error instanceof InvalidRequirementsAPIError) {
+                const { Missing: missingLinkIds } = error.details as { Missing: string[] };
+                if (missingLinkIds.length > 0) {
+                    throw new MissingRelatedPhotosError(
+                        missingLinkIds.map((linkId) => makeNodeUid(sourceVolumeId, linkId)),
+                    );
+                }
+            }
+            throw error;
+        }
+    }
+
     async *removePhotosFromAlbum(
         albumNodeUid: string,
         photoNodeUids: string[],
         signal?: AbortSignal,
-    ): AsyncGenerator<NodeResult> {
+    ): AsyncGenerator<NodeResultWithError> {
         const { volumeId, nodeId: albumLinkId } = splitNodeUid(albumNodeUid);
 
         const batchSize = 50;
@@ -331,7 +486,7 @@ export class PhotosAPIService {
         for (const photoNodeUidsBatch of batch(photoNodeUids, batchSize)) {
             const linkIds = photoNodeUidsBatch.map((nodeUid) => splitNodeUid(nodeUid).nodeId);
 
-            let errorMessage: string | undefined;
+            let error: Error | undefined;
             try {
                 await this.apiService.post<PostRemovePhotosFromAlbumRequest, PostRemovePhotosFromAlbumResponse>(
                     `drive/photos/volumes/${volumeId}/albums/${albumLinkId}/remove-multiple`,
@@ -340,18 +495,65 @@ export class PhotosAPIService {
                     },
                     signal,
                 );
-            } catch (error) {
-                errorMessage = error instanceof Error ? error.message : c('Error').t`Unknown error`;
+            } catch (e) {
+                error = e instanceof Error ? e : new Error(c('Error').t`Unknown error`);
             }
 
             // The API does not return individual results for each photo.
             for (const uid of photoNodeUidsBatch) {
-                if (errorMessage) {
-                    yield { uid, ok: false, error: errorMessage };
+                if (error) {
+                    yield { uid, ok: false, error };
                 } else {
                     yield { uid, ok: true };
                 }
             }
         }
     }
+
+    async addPhotoTags(nodeUid: string, tags: PhotoTag[]): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        await this.apiService.post<PostAddPhotoTagsRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/tags`,
+            { Tags: tags },
+        );
+    }
+
+    async removePhotoTags(nodeUid: string, tags: PhotoTag[]): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        await this.apiService.delete<PostRemovePhotoTagsRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/tags`,
+            { Tags: tags },
+        );
+    }
+
+    async setPhotoFavorite(nodeUid: string, payload?: TransferEncryptedPhotoPayload): Promise<void> {
+        const { volumeId, nodeId: linkId } = splitNodeUid(nodeUid);
+        const requestBody = payload
+            ? {
+                  PhotoData: {
+                      Hash: payload.nameHash,
+                      Name: payload.encryptedName,
+                      NameSignatureEmail: payload.nameSignatureEmail,
+                      NodePassphrase: payload.nodePassphrase,
+                      ContentHash: payload.contentHash,
+                      NodePassphraseSignature: payload.nodePassphraseSignature ?? null,
+                      SignatureEmail: payload.signatureEmail ?? null,
+                      RelatedPhotos: payload.relatedPhotos.map((related) => ({
+                          LinkID: splitNodeUid(related.nodeUid).nodeId,
+                          Hash: related.nameHash,
+                          Name: related.encryptedName,
+                          NameSignatureEmail: related.nameSignatureEmail,
+                          NodePassphrase: related.nodePassphrase,
+                          ContentHash: related.contentHash,
+                          NodePassphraseSignature: related.nodePassphraseSignature ?? null,
+                          SignatureEmail: related.signatureEmail ?? null,
+                      })),
+                  },
+              }
+            : undefined;
+        await this.apiService.post<PostFavoritePhotoRequest, { Code: number }>(
+            `drive/photos/volumes/${volumeId}/links/${linkId}/favorite`,
+            requestBody,
+        );
+    }
 }

package/src/internal/photos/errors.ts

@@ -0,0 +1,11 @@
+import { c } from 'ttag';
+
+export class MissingRelatedPhotosError extends Error {
+    constructor(public missingNodeUids: string[]) {
+        // We do not want to leak the technical details of the error to the user.
+        // When this error happens, it is retried by the SDK, so very likely the
+        // user will not see this error unless the operation fails twice in a row.
+        super(c('Error').t`Operation failed, try again later`);
+        this.name = 'MissingRelatedPhotosError';
+    }
+}

package/src/internal/photos/index.ts

@@ -18,13 +18,14 @@ import { SharesCryptoService } from '../shares/cryptoService';
 import { NodesService as UploadNodesService } from '../upload/interface';
 import { UploadTelemetry } from '../upload/telemetry';
 import { UploadQueue } from '../upload/queue';
-import { Albums } from './albums';
+import { AlbumsManager } from './albumsManager';
 import { AlbumsCryptoService } from './albumsCrypto';
 import { PhotosAPIService } from './apiService';
 import { SharesService } from './interface';
 import { PhotosNodesAPIService, PhotosNodesAccess, PhotosNodesCache, PhotosNodesManagement } from './nodes';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
+import { PhotosManager } from './photosManager';
 import {
     PhotoFileUploader,
     PhotoUploadAPIService,
@@ -33,7 +34,7 @@ import {
     PhotoUploadMetadata,
 } from './upload';
 
-export type { DecryptedPhotoNode, TimelineItem, AlbumItem, PhotoTag } from './interface';
+export type { DecryptedPhotoNode, TimelineItem, AlbumItem } from './interface';
 
 // Only photos and albums can be shared in photos volume.
 export const PHOTOS_SHARE_TARGET_TYPES = [ShareTargetType.Photo, ShareTargetType.Album];
@@ -60,11 +61,13 @@ export function initPhotosModule(
         photoShares,
         nodesService,
     );
-    const albums = new Albums(api, albumsCryptoService, photoShares, nodesService);
+    const albums = new AlbumsManager(telemetry, api, albumsCryptoService, photoShares, nodesService);
+    const photos = new PhotosManager(telemetry.getLogger('photos-update'), api, albumsCryptoService, nodesService);
 
     return {
         timeline,
         albums,
+        photos,
     };
 }
 

package/src/internal/photos/interface.ts

@@ -1,5 +1,5 @@
 import { PrivateKey } from '../../crypto';
-import { MetricVolumeType, PhotoAttributes } from '../../interface';
+import { MetricVolumeType, PhotoAttributes, AlbumAttributes, PhotoTag } from '../../interface';
 import { DecryptedNode, EncryptedNode, DecryptedUnparsedNode } from '../nodes/interface';
 import { EncryptedShare } from '../shares';
 
@@ -24,18 +24,21 @@ export interface SharesService {
 }
 
 export type EncryptedPhotoNode = EncryptedNode & {
-    photo?: EcnryptedPhotoAttributes;
+    photo?: EncryptedPhotoAttributes;
+    album?: AlbumAttributes;
 };
 
 export type DecryptedUnparsedPhotoNode = DecryptedUnparsedNode & {
     photo?: PhotoAttributes;
+    album?: AlbumAttributes;
 };
 
 export type DecryptedPhotoNode = DecryptedNode & {
     photo?: PhotoAttributes;
+    album?: AlbumAttributes;
 };
 
-export type EcnryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
+export type EncryptedPhotoAttributes = Omit<PhotoAttributes, 'albums'> & {
     contentHash?: string;
     albums: (PhotoAttributes['albums'][0] & {
         nameHash?: string;
@@ -47,22 +50,9 @@ export type TimelineItem = {
     nodeUid: string;
     captureTime: Date;
     tags: PhotoTag[];
-}
+};
 
 export type AlbumItem = {
     nodeUid: string;
     captureTime: Date;
-}
-
-export enum PhotoTag {
-    Favorites = 0,
-    Screenshots = 1,
-    Videos = 2,
-    LivePhotos = 3,
-    MotionPhotos = 4,
-    Selfies = 5,
-    Portraits = 6,
-    Bursts = 7,
-    Panoramas = 8,
-    Raw = 9,
-}
+};