@protontech/drive-sdk 0.6.2 → 0.7.1

package/src/internal/upload/interface.ts

@@ -1,6 +1,6 @@
 import { PrivateKey, SessionKey } from '../../crypto';
 
-import { MetricVolumeType, ThumbnailType, Result, Revision } from '../../interface';
+import { MetricVolumeType, ThumbnailType, Result, Revision, AnonymousUser } from '../../interface';
 import { DecryptedNode } from '../nodes';
 
 export type NodeRevisionDraft = {
@@ -22,7 +22,7 @@ export type NodeRevisionDraft = {
 export type NodeRevisionDraftKeys = {
     key: PrivateKey;
     contentKeyPacketSessionKey: SessionKey;
-    signatureAddress: NodeCryptoSignatureAddress;
+    signingKeys: NodeCryptoSigningKeys;
 };
 
 export type NodeCrypto = {
@@ -51,13 +51,14 @@ export type NodeCrypto = {
         encryptedName: string;
         hash: string;
     };
-    signatureAddress: NodeCryptoSignatureAddress;
+    signingKeys: NodeCryptoSigningKeys;
 };
 
-export type NodeCryptoSignatureAddress = {
-    email: string;
-    addressId: string;
-    addressKey: PrivateKey;
+export type NodeCryptoSigningKeys = {
+    email: string | AnonymousUser;
+    addressId: string | AnonymousUser;
+    nameAndPassphraseSigningKey: PrivateKey;
+    contentSigningKey: PrivateKey;
 };
 
 export type EncryptedBlockMetadata = {
@@ -102,12 +103,9 @@ export interface NodesService {
         contentKeyPacketSessionKey?: SessionKey;
         hashKey?: Uint8Array;
     }>;
-    getRootNodeEmailKey(nodeUid: string): Promise<{
-        email: string;
-        addressId: string;
-        addressKey: PrivateKey;
-        addressKeyId: string;
-    }>;
+    getNodeSigningKeys(
+        uids: { nodeUid: string; parentNodeUid?: string } | { nodeUid?: string; parentNodeUid: string },
+    ): Promise<NodeSigningKeys>;
     notifyChildCreated(nodeUid: string): Promise<void>;
     notifyNodeChanged(nodeUid: string): Promise<void>;
 }
@@ -126,6 +124,19 @@ export interface NodesServiceNode {
     activeRevision?: Result<Revision, Error>;
 }
 
+export type NodeSigningKeys =
+    | {
+          type: 'userAddress';
+          email: string;
+          addressId: string;
+          key: PrivateKey;
+      }
+    | {
+          type: 'nodeKey';
+          nodeKey?: PrivateKey;
+          parentNodeKey?: PrivateKey;
+      };
+
 /**
  * Interface describing the dependencies to the shares module.
  */

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

@@ -50,7 +50,7 @@ describe('UploadManager', () => {
                     encryptedName: 'newNode:encryptedName',
                     hash: 'newNode:hash',
                 },
-                signatureAddress: {
+                signingKeys: {
                     email: 'signatureEmail',
                 },
             }),
@@ -69,7 +69,8 @@ describe('UploadManager', () => {
                 hashKey: 'parentNode:hashKey',
                 key: 'parentNode:nodekey',
             }),
-            getRootNodeEmailKey: jest.fn().mockResolvedValue({
+            getNodeSigningKeys: jest.fn().mockResolvedValue({
+                type: 'userAddress',
                 email: 'signatureEmail',
                 addressId: 'addressId',
             }),
@@ -100,7 +101,7 @@ describe('UploadManager', () => {
                 nodeKeys: {
                     key: 'newNode:key',
                     contentKeyPacketSessionKey: 'newNode:ContentKeyPacketSessionKey',
-                    signatureAddress: {
+                    signingKeys: {
                         email: 'signatureEmail',
                     },
                 },
@@ -153,7 +154,7 @@ describe('UploadManager', () => {
                 nodeKeys: {
                     key: 'newNode:key',
                     contentKeyPacketSessionKey: 'newNode:ContentKeyPacketSessionKey',
-                    signatureAddress: {
+                    signingKeys: {
                         email: 'signatureEmail',
                     },
                 },

package/src/internal/upload/manager.ts

@@ -57,7 +57,7 @@ export class UploadManager {
             nodeKeys: {
                 key: generatedNodeCrypto.nodeKeys.decrypted.key,
                 contentKeyPacketSessionKey: generatedNodeCrypto.contentKey.decrypted.contentKeyPacketSessionKey,
-                signatureAddress: generatedNodeCrypto.signatureAddress,
+                signingKeys: generatedNodeCrypto.signingKeys,
             },
             parentNodeKeys: {
                 hashKey: parentKeys.hashKey,
@@ -93,7 +93,7 @@ export class UploadManager {
                 base64ContentKeyPacket: generatedNodeCrypto.contentKey.encrypted.base64ContentKeyPacket,
                 armoredContentKeyPacketSignature:
                     generatedNodeCrypto.contentKey.encrypted.armoredContentKeyPacketSignature,
-                signatureEmail: generatedNodeCrypto.signatureAddress.email,
+                signatureEmail: generatedNodeCrypto.signingKeys.email,
             });
             return result;
         } catch (error: unknown) {
@@ -192,7 +192,10 @@ export class UploadManager {
             throw new ValidationError(c('Error').t`Creating revisions in non-files is not allowed`);
         }
 
-        const signatureAddress = await this.nodesService.getRootNodeEmailKey(nodeUid);
+        const signingKeys = await this.cryptoService.getSigningKeysForExistingNode({
+            nodeUid,
+            parentNodeUid: node.parentUid,
+        });
 
         const { nodeRevisionUid } = await this.apiService.createDraftRevision(nodeUid, {
             currentRevisionUid: node.activeRevision.value.uid,
@@ -205,7 +208,7 @@ export class UploadManager {
             nodeKeys: {
                 key: nodeKeys.key,
                 contentKeyPacketSessionKey: nodeKeys.contentKeyPacketSessionKey,
-                signatureAddress: signatureAddress,
+                signingKeys,
             },
         };
     }

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

@@ -110,7 +110,9 @@ describe('StreamUploader', () => {
             nodeRevisionUid: 'revisionUid',
             nodeUid: 'nodeUid',
             nodeKeys: {
-                signatureAddress: { addressId: 'addressId' },
+                signingKeys: {
+                    addressId: 'addressId',
+                },
             },
         } as NodeRevisionDraft;
 
@@ -312,8 +314,9 @@ describe('StreamUploader', () => {
                 throw new Error('Failed to encrypt block');
             });
 
-            // Encrypting thumbnails is before blocks, thus it can be uploaded before failure.
-            await verifyFailure('Failed to encrypt block', 1024);
+            // Thumbnail are uploaded with the first content block. If the
+            // content block fails to encrypt, nothing is uploaded.
+            await verifyFailure('Failed to encrypt block', 0);
             // 1 block + 1 retry, others are skipped
             expect(cryptoService.encryptBlock).toHaveBeenCalledTimes(2);
         });
@@ -415,7 +418,7 @@ describe('StreamUploader', () => {
             expect(apiService.requestBlockUpload).toHaveBeenCalledTimes(2);
             expect(apiService.requestBlockUpload).toHaveBeenCalledWith(
                 revisionDraft.nodeRevisionUid,
-                revisionDraft.nodeKeys.signatureAddress.addressId,
+                revisionDraft.nodeKeys.signingKeys.addressId,
                 {
                     contentBlocks: [
                         {
@@ -436,7 +439,7 @@ describe('StreamUploader', () => {
         describe('verifyIntegrity', () => {
             it('should report block verification error', async () => {
                 blockVerifier.verifyBlock = jest.fn().mockRejectedValue(new IntegrityError('Block verification error'));
-                await verifyFailure('Block verification error', 1024);
+                await verifyFailure('Block verification error', 0);
                 expect(telemetry.logBlockVerificationError).toHaveBeenCalledWith(false);
             });
 

package/src/internal/upload/streamUploader.ts

@@ -319,7 +319,7 @@ export class StreamUploader {
         this.logger.info(`Requesting upload tokens for ${this.encryptedBlocks.size} blocks`);
         const uploadTokens = await this.apiService.requestBlockUpload(
             this.revisionDraft.nodeRevisionUid,
-            this.revisionDraft.nodeKeys.signatureAddress.addressId,
+            this.revisionDraft.nodeKeys.signingKeys.addressId,
             {
                 contentBlocks: Array.from(
                     this.encryptedBlocks.values().map((block) => ({
@@ -340,6 +340,12 @@ export class StreamUploader {
             },
         );
 
+        // If the upload was aborted while requesting next upload tokens,
+        // do not schedule any next upload.
+        if (this.isUploadAborted) {
+            throw this.error || new AbortError();
+        }
+
         for (const thumbnailToken of uploadTokens.thumbnailTokens) {
             let encryptedThumbnail = this.encryptedThumbnails.get(thumbnailToken.type);
             if (!encryptedThumbnail) {
@@ -418,7 +424,7 @@ export class StreamUploader {
                 break;
             } catch (error: unknown) {
                 // Do not retry or report anything if the upload was aborted.
-                if (error instanceof AbortError) {
+                if (error instanceof AbortError || this.isUploadAborted) {
                     throw error;
                 }
 
@@ -485,7 +491,7 @@ export class StreamUploader {
                 break;
             } catch (error: unknown) {
                 // Do not retry or report anything if the upload was aborted.
-                if (error instanceof AbortError) {
+                if (error instanceof AbortError || this.isUploadAborted) {
                     throw error;
                 }
 
@@ -501,7 +507,7 @@ export class StreamUploader {
                     logger.warn(`Token expired, fetching new token and retrying`);
                     const uploadTokens = await this.apiService.requestBlockUpload(
                         this.revisionDraft.nodeRevisionUid,
-                        this.revisionDraft.nodeKeys.signatureAddress.addressId,
+                        this.revisionDraft.nodeKeys.signingKeys.addressId,
                         {
                             contentBlocks: [
                                 {

package/src/protonDriveClient.ts

@@ -106,7 +106,11 @@ export class ProtonDriveClient {
          * Experimental feature to authenticate a public link and
          * return the client for the public link to access it.
          */
-        authPublicLink: (url: string, customPassword?: string) => Promise<ProtonDrivePublicLinkClient>;
+        authPublicLink: (
+            url: string,
+            customPassword?: string,
+            isAnonymousContext?: boolean,
+        ) => Promise<ProtonDrivePublicLinkClient>;
     };
 
     constructor({
@@ -222,7 +226,7 @@ export class ProtonDriveClient {
                 this.logger.info(`Getting info for public link ${url}`);
                 return this.publicSessionManager.getInfo(url);
             },
-            authPublicLink: async (url: string, customPassword?: string) => {
+            authPublicLink: async (url: string, customPassword?: string, isAnonymousContext: boolean = false) => {
                 this.logger.info(`Authenticating public link ${url}`);
                 const { httpClient, token, shareKey, rootUid } = await this.publicSessionManager.auth(
                     url,
@@ -239,6 +243,7 @@ export class ProtonDriveClient {
                     token,
                     publicShareKey: shareKey,
                     publicRootNodeUid: rootUid,
+                    isAnonymousContext,
                 });
             },
         };
@@ -419,6 +424,12 @@ export class ProtonDriveClient {
      * The operation is performed node by node and the results are yielded
      * as they are available. Order of the results is not guaranteed.
      *
+     * The `nodeUids` can be a list of node entities or their UIDs, or a list
+     * of objects with `uid` and `name` properties where the name is the new
+     * name of the copied node. By default, the name is the same as the
+     * original node. Use `getAvailableName` to get the available name for the
+     * new node in the target parent node in case of a name conflict.
+     *
      * If one of the nodes fails to copy, the operation continues with the
      * rest of the nodes. Use `NodeResult` to check the status of the action.
      *
@@ -428,12 +439,23 @@ export class ProtonDriveClient {
      * @returns An async generator of the results of the copy operation
      */
     async *copyNodes(
-        nodeUids: NodeOrUid[],
+        nodesOrNodeUidsOrWithNames: (NodeOrUid | { uid: string; name: string })[],
         newParentNodeUid: NodeOrUid,
         signal?: AbortSignal,
     ): AsyncGenerator<NodeResultWithNewUid> {
-        this.logger.info(`Copying ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
-        yield* this.nodes.management.copyNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
+        this.logger.info(`Copying ${nodesOrNodeUidsOrWithNames.length} nodes to ${getUid(newParentNodeUid)}`);
+
+        const nodeUidsOrWithNames = nodesOrNodeUidsOrWithNames.map((param) => {
+            if (typeof param === 'string') {
+                return param;
+            }
+            if ('uid' in param && 'name' in param && typeof param.uid === 'string' && typeof param.name === 'string') {
+                return { uid: param.uid, name: param.name };
+            }
+            return getUid(param);
+        });
+
+        yield* this.nodes.management.copyNodes(nodeUidsOrWithNames, getUid(newParentNodeUid), signal);
     }
 
     /**

package/src/protonDrivePhotosClient.ts

@@ -2,12 +2,12 @@ import {
     Logger,
     ProtonDriveClientContructorParameters,
     NodeOrUid,
-    MaybeMissingNode,
+    MaybeMissingPhotoNode,
     UploadMetadata,
     FileDownloader,
     FileUploader,
     SDKEvent,
-    MaybeNode,
+    MaybePhotoNode,
     ThumbnailType,
     ThumbnailResult,
     ShareNodeSettings,
@@ -22,22 +22,22 @@ import { getConfig } from './config';
 import { DriveCrypto } from './crypto';
 import { Telemetry } from './telemetry';
 import {
-    convertInternalMissingNodeIterator,
-    convertInternalNode,
-    convertInternalNodeIterator,
-    convertInternalNodePromise,
+    convertInternalMissingPhotoNodeIterator,
+    convertInternalPhotoNode,
+    convertInternalPhotoNodeIterator,
+    convertInternalPhotoNodePromise,
     getUid,
     getUids,
 } from './transformers';
 import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { DriveEventsService, DriveListener, EventSubscription } from './internal/events';
-import { initNodesModule } from './internal/nodes';
 import {
     PHOTOS_SHARE_TARGET_TYPES,
     initPhotosModule,
     initPhotoSharesModule,
     initPhotoUploadModule,
+    initPhotosNodesModule,
 } from './internal/photos';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharesModule } from './internal/shares';
@@ -56,7 +56,7 @@ export class ProtonDrivePhotosClient {
     private sdkEvents: SDKEvents;
     private events: DriveEventsService;
     private photoShares: ReturnType<typeof initPhotoSharesModule>;
-    private nodes: ReturnType<typeof initNodesModule>;
+    private nodes: ReturnType<typeof initPhotosNodesModule>;
     private sharing: ReturnType<typeof initSharingModule>;
     private download: ReturnType<typeof initDownloadModule>;
     private upload: ReturnType<typeof initPhotoUploadModule>;
@@ -107,7 +107,7 @@ export class ProtonDrivePhotosClient {
             cryptoModule,
             coreShares,
         );
-        this.nodes = initNodesModule(
+        this.nodes = initPhotosNodesModule(
             telemetry,
             apiService,
             entitiesCache,
@@ -224,9 +224,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateTrashedNodes` for more information.
      */
-    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateTrashedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating trashed nodes');
-        yield* convertInternalNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
+        yield * convertInternalPhotoNodeIterator(this.nodes.access.iterateTrashedNodes(signal));
     }
 
     /**
@@ -234,10 +234,10 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateNodes` for more information.
      */
-    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingNode> {
+    async *iterateNodes(nodeUids: NodeOrUid[], signal?: AbortSignal): AsyncGenerator<MaybeMissingPhotoNode> {
         this.logger.info(`Iterating ${nodeUids.length} nodes`);
         // TODO: expose photo type
-        yield* convertInternalMissingNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
+        yield * convertInternalMissingPhotoNodeIterator(this.nodes.access.iterateNodes(getUids(nodeUids), signal));
     }
 
     /**
@@ -245,9 +245,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.getNode` for more information.
      */
-    async getNode(nodeUid: NodeOrUid): Promise<MaybeNode> {
+    async getNode(nodeUid: NodeOrUid): Promise<MaybePhotoNode> {
         this.logger.info(`Getting node ${getUid(nodeUid)}`);
-        return convertInternalNodePromise(this.nodes.access.getNode(getUid(nodeUid)));
+        return convertInternalPhotoNodePromise(this.nodes.access.getNode(getUid(nodeUid)));
     }
 
     /**
@@ -255,9 +255,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.renameNode` for more information.
      */
-    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
+    async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybePhotoNode> {
         this.logger.info(`Renaming node ${getUid(nodeUid)}`);
-        return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
+        return convertInternalPhotoNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
     }
 
     /**
@@ -305,9 +305,9 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateSharedNodes` for more information.
      */
-    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodes(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating shared nodes by me');
-        yield* convertInternalNodeIterator(this.sharing.access.iterateSharedNodes(signal));
+        yield * convertInternalPhotoNodeIterator(this.sharing.access.iterateSharedNodes(signal));
     }
 
     /**
@@ -315,11 +315,11 @@ export class ProtonDrivePhotosClient {
      *
      * See `ProtonDriveClient.iterateSharedNodesWithMe` for more information.
      */
-    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateSharedNodesWithMe(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating shared nodes with me');
 
         for await (const node of this.sharing.access.iterateSharedNodesWithMe(signal)) {
-            yield convertInternalNode(node);
+            yield convertInternalPhotoNode(node);
         }
     }
 
@@ -482,9 +482,9 @@ export class ProtonDrivePhotosClient {
      *
      * The output is not sorted and the order of the nodes is not guaranteed.
      */
-    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateAlbums(signal?: AbortSignal): AsyncGenerator<MaybePhotoNode> {
         this.logger.info('Iterating albums');
         // TODO: expose album type
-        yield* convertInternalNodeIterator(this.photos.albums.iterateAlbums(signal));
+        yield * convertInternalPhotoNodeIterator(this.photos.albums.iterateAlbums(signal));
     }
 }

package/src/protonDrivePublicLinkClient.ts

@@ -18,6 +18,7 @@ import {
     UploadMetadata,
     FileUploader,
     NodeResult,
+    SDKEvent,
 } from './interface';
 import { Telemetry } from './telemetry';
 import {
@@ -27,10 +28,9 @@ import {
     convertInternalMissingNodeIterator,
     getUids,
 } from './transformers';
-import { DriveAPIService } from './internal/apiService';
 import { initDownloadModule } from './internal/download';
 import { SDKEvents } from './internal/sdkEvents';
-import { initSharingPublicModule } from './internal/sharingPublic';
+import { initSharingPublicModule, UnauthDriveAPIService } from './internal/sharingPublic';
 import { initUploadModule } from './internal/upload';
 
 /**
@@ -81,6 +81,7 @@ export class ProtonDrivePublicLinkClient {
         token,
         publicShareKey,
         publicRootNodeUid,
+        isAnonymousContext,
     }: {
         httpClient: ProtonDriveHTTPClient;
         account: ProtonDriveAccount;
@@ -92,6 +93,7 @@ export class ProtonDrivePublicLinkClient {
         token: string;
         publicShareKey: PrivateKey;
         publicRootNodeUid: string;
+        isAnonymousContext: boolean;
     }) {
         if (!telemetry) {
             telemetry = new Telemetry();
@@ -105,7 +107,7 @@ export class ProtonDrivePublicLinkClient {
         const fullConfig = getConfig(config);
         this.sdkEvents = new SDKEvents(telemetry);
 
-        const apiService = new DriveAPIService(
+        const apiService = new UnauthDriveAPIService(
             telemetry,
             this.sdkEvents,
             httpClient,
@@ -124,6 +126,7 @@ export class ProtonDrivePublicLinkClient {
             token,
             publicShareKey,
             publicRootNodeUid,
+            isAnonymousContext,
         );
         this.download = initDownloadModule(
             telemetry,
@@ -133,6 +136,9 @@ export class ProtonDrivePublicLinkClient {
             this.sharingPublic.shares,
             this.sharingPublic.nodes.access,
             this.sharingPublic.nodes.revisions,
+            // Ignore manifest integrity verifications for public links.
+            // Anonymous user on public page cannot load public keys of other users (yet).
+            true,
         );
         this.upload = initUploadModule(
             telemetry,
@@ -159,6 +165,16 @@ export class ProtonDrivePublicLinkClient {
         };
     }
 
+    /**
+     * Subscribes to the general SDK events.
+     *
+     * See `ProtonDriveClient.onMessage` for more information.
+     */
+    onMessage(eventName: SDKEvent, callback: () => void): () => void {
+        this.logger.debug(`Subscribing to event ${eventName}`);
+        return this.sdkEvents.addListener(eventName, callback);
+    }
+
     /**
      * @returns The root folder to the public link.
      */

package/src/transformers.ts

@@ -1,15 +1,19 @@
 import {
     MaybeNode as PublicMaybeNode,
     MaybeMissingNode as PublicMaybeMissingNode,
-    NodeEntity as PublicNodeEntity,
     DegradedNode as PublicDegradedNode,
     Revision as PublicRevision,
     Result,
     resultOk,
     resultError,
     MissingNode,
+    MaybePhotoNode as PublicMaybePhotoNode,
+    MaybeMissingPhotoNode as PublicMaybeMissingPhotoNode,
+    PhotoNode as PublicPhotoNode,
+    DegradedPhotoNode as PublicDegradedPhotoNode,
 } from './interface';
 import { DecryptedNode as InternalNode, DecryptedRevision as InternalRevision } from './internal/nodes';
+import { DecryptedPhotoNode as InternalPartialPhotoNode } from './internal/photos';
 
 type InternalPartialNode = Pick<
     InternalNode,
@@ -25,6 +29,7 @@ type InternalPartialNode = Pick<
     | 'isShared'
     | 'isSharedPublicly'
     | 'creationTime'
+    | 'modificationTime'
     | 'trashTime'
     | 'activeRevision'
     | 'folder'
@@ -93,6 +98,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         isShared: node.isShared,
         isSharedPublicly: node.isSharedPublicly,
         creationTime: node.creationTime,
+        modificationTime: node.modificationTime,
         trashTime: node.trashTime,
         totalStorageSize: node.totalStorageSize,
         folder: node.folder,
@@ -118,7 +124,48 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         ...baseNodeMetadata,
         name: name.value,
         activeRevision: activeRevision?.ok ? convertInternalRevision(activeRevision.value) : undefined,
-    } as PublicNodeEntity);
+    });
+}
+
+export async function* convertInternalPhotoNodeIterator(
+    photoNodeIterator: AsyncGenerator<InternalPartialPhotoNode>,
+): AsyncGenerator<PublicMaybePhotoNode> {
+    for await (const photoNode of photoNodeIterator) {
+        yield convertInternalPhotoNode(photoNode);
+    }
+}
+
+export async function* convertInternalMissingPhotoNodeIterator(
+    photoNodeIterator: AsyncGenerator<InternalPartialPhotoNode | MissingNode>,
+): AsyncGenerator<PublicMaybeMissingPhotoNode> {
+    for await (const photoNode of photoNodeIterator) {
+        if ('missingUid' in photoNode) {
+            yield resultError(photoNode);
+        } else {
+            yield convertInternalPhotoNode(photoNode);
+        }
+    }
+}
+
+export async function convertInternalPhotoNodePromise(
+    photoNodePromise: Promise<InternalPartialPhotoNode>,
+): Promise<PublicMaybePhotoNode> {
+    const photoNode = await photoNodePromise;
+    return convertInternalPhotoNode(photoNode);
+}
+
+export function convertInternalPhotoNode(photoNode: InternalPartialPhotoNode): PublicMaybePhotoNode {
+    const node = convertInternalNode(photoNode);
+    if (node.ok) {
+        return resultOk({
+            ...node.value,
+            photo: photoNode.photo,
+        } as PublicPhotoNode);
+    }
+    return resultError({
+        ...node.error,
+        photo: photoNode.photo,
+    } as PublicDegradedPhotoNode);
 }
 
 export async function* convertInternalRevisionIterator(