@protontech/drive-sdk 0.0.10 → 0.0.11

package/src/internal/sharing/cryptoService.ts

@@ -2,10 +2,11 @@ import bcrypt from 'bcryptjs';
 import { c } from 'ttag';
 
 import { DriveCrypto, PrivateKey, SessionKey, SRPVerifier, uint8ArrayToBase64String, VERIFICATION_STATUS } from '../../crypto';
-import { ProtonDriveAccount, ProtonInvitation, ProtonInvitationWithNode, NonProtonInvitation, Author, Result, Member, UnverifiedAuthorError, resultError, resultOk } from "../../interface";
+import { ProtonDriveAccount, ProtonInvitation, ProtonInvitationWithNode, NonProtonInvitation, Author, Result, Member, UnverifiedAuthorError, resultError, resultOk, InvalidNameError, ProtonDriveTelemetry, MetricVolumeType } from "../../interface";
+import { validateNodeName } from '../nodes/validations';
 import { getErrorMessage, getVerificationMessage } from "../errors";
 import { EncryptedShare } from "../shares";
-import { EncryptedInvitation, EncryptedInvitationWithNode, EncryptedExternalInvitation, EncryptedMember, EncryptedPublicLink, PublicLinkWithCreatorEmail } from "./interface";
+import { EncryptedInvitation, EncryptedInvitationWithNode, EncryptedExternalInvitation, EncryptedMember, EncryptedPublicLink, PublicLinkWithCreatorEmail, EncryptedBookmark, SharesService } from "./interface";
 
 // Version 2 of bcrypt with 2**10 rounds.
 // https://en.wikipedia.org/wiki/Bcrypt#Description
@@ -31,11 +32,15 @@ enum PublicLinkFlags {
  */
 export class SharingCryptoService {
     constructor(
+        private telemetry: ProtonDriveTelemetry,
         private driveCrypto: DriveCrypto,
         private account: ProtonDriveAccount,
+        private sharesService: SharesService,
     ) {
+        this.telemetry = telemetry;
         this.driveCrypto = driveCrypto;
         this.account = account;
+        this.sharesService = sharesService;
     }
 
     /**
@@ -346,7 +351,7 @@ export class SharingCryptoService {
     }
 
     private async decryptShareUrlPassword(
-        encryptedPublicLink: EncryptedPublicLink,
+        encryptedPublicLink: Pick<EncryptedPublicLink, 'armoredUrlPassword' | 'flags'>,
         addressKeys: PrivateKey[],
     ): Promise<{
         password: string,
@@ -375,4 +380,133 @@ export class SharingCryptoService {
                 throw new Error(`Unsupported public link with flags: ${encryptedPublicLink.flags}`);
         }
     }
+
+    async decryptBookmark(encryptedBookmark: EncryptedBookmark): Promise<{
+        url: Result<string, Error>,
+        nodeName: Result<string, Error | InvalidNameError>,
+    }> {
+        // TODO: Signatures are not checked and not specified in the interface.
+        // In the future, we will need to add authorship verification.
+
+        let urlPassword: string;
+        try {
+            urlPassword = await this.decryptBookmarkUrlPassword(encryptedBookmark);
+        } catch (originalError: unknown) {
+            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            return {
+                url: resultError(error),
+                nodeName: resultError(error),
+            };
+        }
+
+        // TODO: API should provide the full URL.
+        const url = resultOk<string, Error>(`https://drive.proton.me/urls/${encryptedBookmark.tokenId}#${urlPassword}`);
+
+        let shareKey: PrivateKey;
+        try {
+            shareKey = await this.decryptBookmarkKey(encryptedBookmark, urlPassword);
+        } catch (originalError: unknown) {
+            const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
+            return {
+                url,
+                nodeName: resultError(error),
+            };
+        }
+
+        const nodeName = await this.decryptBookmarkName(encryptedBookmark, shareKey);
+
+        return {
+            url,
+            nodeName,
+        };
+    }
+
+    private async decryptBookmarkUrlPassword(encryptedBookmark: EncryptedBookmark): Promise<string> {
+        if (!encryptedBookmark.url.encryptedUrlPassword) {
+            throw new Error(c('Error').t`Bookmark password is not available`);
+        }
+
+        const { addressId } = await this.sharesService.getMyFilesShareMemberEmailKey();
+        const address = await this.account.getOwnAddress(addressId);
+        const addressKeys = address.keys.map(({ key }) => key);
+
+        try {
+            // Decrypt the password for the share URL.
+            const urlPassword = await this.driveCrypto.decryptShareUrlPassword(
+                encryptedBookmark.url.encryptedUrlPassword,
+                addressKeys,
+            );
+
+            return urlPassword;
+        } catch (error: unknown) {
+            this.telemetry.logEvent({
+                eventName: 'decryptionError',
+                volumeType: MetricVolumeType.SharedPublic,
+                field: 'shareUrlPassword',
+                error,
+            });
+
+            const message = getErrorMessage(error);
+            const errorMessage = c('Error').t`Failed to decrypt bookmark password: ${message}`;
+            throw new Error(errorMessage);
+        }
+    }
+
+    private async decryptBookmarkKey(encryptedBookmark: EncryptedBookmark, urlPassword: string): Promise<PrivateKey> {
+        try {
+            // Use the password to decrypt the share key.
+            const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
+                urlPassword,
+                encryptedBookmark.url.base64SharePasswordSalt,
+                encryptedBookmark.share.armoredKey,
+                encryptedBookmark.share.armoredPassphrase,
+            );
+
+            return shareKey;
+        } catch (error: unknown) {
+            this.telemetry.logEvent({
+                eventName: 'decryptionError',
+                volumeType: MetricVolumeType.SharedPublic,
+                field: 'shareKey',
+                error,
+            });
+
+            const message = getErrorMessage(error);
+            const errorMessage = c('Error').t`Failed to decrypt bookmark key: ${message}`;
+            throw new Error(errorMessage);
+        }
+    }
+
+    private async decryptBookmarkName(encryptedBookmark: EncryptedBookmark, shareKey: PrivateKey): Promise<Result<string, Error | InvalidNameError>> {
+        try {
+            // Use the share key to decrypt the node name of the bookmark.
+            const { name } = await this.driveCrypto.decryptNodeName(
+                encryptedBookmark.node.encryptedName,
+                shareKey,
+                [],
+            );
+
+            try {
+                validateNodeName(name);
+            } catch (error: unknown) {
+                return resultError({
+                    name,
+                    error: error instanceof Error ? error.message : c('Error').t`Unknown error`,
+                });
+            }
+
+            return resultOk(name);
+        } catch (error: unknown) {
+            this.telemetry.logEvent({
+                eventName: 'decryptionError',
+                volumeType: MetricVolumeType.SharedPublic,
+                field: 'nodeName',
+                error,
+            });
+
+            const message = getErrorMessage(error);
+            const errorMessage = c('Error').t`Failed to decrypt bookmark name: ${message}`;
+            return resultError(new Error(errorMessage));
+        }
+    }
 }

package/src/internal/sharing/index.ts

@@ -30,7 +30,7 @@ export function initSharingModule(
 ) {
     const api = new SharingAPIService(telemetry.getLogger('sharing-api'), apiService);
     const cache = new SharingCache(driveEntitiesCache);
-    const cryptoService = new SharingCryptoService(crypto, account);
+    const cryptoService = new SharingCryptoService(telemetry, crypto, account, sharesService);
     const sharingAccess = new SharingAccess(api, cache, cryptoService, sharesService, nodesService);
     const sharingEvents = new SharingEvents(telemetry.getLogger('sharing-events'), driveEvents, cache, nodesService, sharingAccess);
     const sharingManagement = new SharingManagement(telemetry.getLogger('sharing'), api, cryptoService, account, sharesService, nodesService, nodesEvents);

package/src/internal/sharing/interface.ts

@@ -143,6 +143,10 @@ export interface PublicLinkWithCreatorEmail extends PublicLink {
 export interface SharesService {
     getMyFilesIDs(): Promise<{ volumeId: string }>,
     loadEncryptedShare(shareId: string): Promise<EncryptedShare>,
+    getMyFilesShareMemberEmailKey(): Promise<{
+        addressId: string,
+        addressKey: PrivateKey,
+    }>,
     getContextShareMemberEmailKey(shareId: string): Promise<{
         email: string,
         addressId: string,

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

@@ -1,3 +1,4 @@
+import { NodeType, resultError, resultOk } from "../../interface";
 import { SharingAPIService } from "./apiService";
 import { SharingCache } from "./cache";
 import { SharingCryptoService } from "./cryptoService";
@@ -26,6 +27,16 @@ describe("SharingAccess", () => {
         apiService = {
             iterateSharedNodeUids: jest.fn().mockImplementation(() => nodeUidsIterator()),
             iterateSharedWithMeNodeUids: jest.fn().mockImplementation(() => nodeUidsIterator()),
+            iterateBookmarks: jest.fn().mockImplementation(async function* () {
+                yield {
+                    tokenId: "tokenId",
+                    creationTime: new Date('2025-01-01'),
+                    node: {
+                        type: NodeType.File,
+                        mediaType: "mediaType",
+                    },
+                }
+            }),
         }
         // @ts-expect-error No need to implement all methods for mocking
         cache = {
@@ -35,6 +46,7 @@ describe("SharingAccess", () => {
         // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             decryptInvitation: jest.fn(),
+            decryptBookmark: jest.fn(),
         }
         // @ts-expect-error No need to implement all methods for mocking
         sharesService = {
@@ -99,4 +111,66 @@ describe("SharingAccess", () => {
             expect(cache.setSharedWithMeNodeUids).toHaveBeenCalledWith(nodeUids);
         });
     });
+
+    describe("iterateBookmarks", () => {
+        it("should return decrypted bookmark", async () => {
+            cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
+                url: resultOk("url"),
+                nodeName: resultOk("nodeName"),
+            });
+
+            const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
+
+            expect(result).toEqual([resultOk({
+                uid: "tokenId",
+                creationTime: new Date('2025-01-01'),
+                url: "url",
+                node: {
+                    name: "nodeName",
+                    type: NodeType.File,
+                    mediaType: "mediaType",
+                },
+            })]);
+        });
+
+        it("should return degraded bookmark if URL password cannot be decrypted", async () => {
+            cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
+                url: resultError("url cannot be decrypted"),
+                nodeName: resultError("url cannot be decrypted"),
+            });
+
+            const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
+
+            expect(result).toEqual([resultError({
+                uid: "tokenId",
+                creationTime: new Date('2025-01-01'),
+                url: resultError("url cannot be decrypted"),
+                node: {
+                    name: resultError("url cannot be decrypted"),
+                    type: NodeType.File,
+                    mediaType: "mediaType",
+                },
+            })]);
+        });
+
+        it("should return degraded bookmark if node name cannot be decrypted", async () => {
+            cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
+                url: resultOk("url"),
+                nodeName: resultError("node name cannot be decrypted"),
+            });
+
+            const result = await Array.fromAsync(sharingAccess.iterateBookmarks());
+
+            expect(result).toEqual([resultError({
+                uid: "tokenId",
+                creationTime: new Date('2025-01-01'),
+                url: resultOk("url"),
+                node: {
+                    name: resultError("node name cannot be decrypted"),
+                    type: NodeType.File,
+                    mediaType: "mediaType",
+                },
+            })]);
+        });
+    });
 });

package/src/internal/sharing/sharingAccess.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { ProtonInvitationWithNode } from "../../interface";
+import { MaybeBookmark, ProtonInvitationWithNode, resultError, resultOk } from "../../interface";
 import { ValidationError } from "../../errors";
 import { DecryptedNode } from "../nodes";
 import { BatchLoading } from "../batchLoading";
@@ -120,14 +120,38 @@ export class SharingAccess {
         await this.apiService.rejectInvitation(invitationUid);
     }
 
-    // FIXME: return decrypted bookmarks
-    async* iterateSharedBookmarks(signal?: AbortSignal): AsyncGenerator<string> {
+    async* iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
         for await (const bookmark of this.apiService.iterateBookmarks(signal)) {
-            yield bookmark.tokenId;
+            const { url, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
+
+            if (!url.ok || !nodeName.ok) {
+                yield resultError({
+                    uid: bookmark.tokenId,
+                    creationTime: bookmark.creationTime,
+                    url: url,
+                    node: {
+                        name: nodeName,
+                        type: bookmark.node.type,
+                        mediaType: bookmark.node.mediaType,
+                    }
+                });
+            } else {
+                yield resultOk({
+                    uid: bookmark.tokenId,
+                    creationTime: bookmark.creationTime,
+                    url: url.value,
+                    node: {
+                        name: nodeName.value,
+                        type: bookmark.node.type,
+                        mediaType: bookmark.node.mediaType,
+                    }
+                });
+            }
         }
     }
 
-    async deleteBookmark(tokenId: string): Promise<void> {
+    async deleteBookmark(bookmarkUid: string): Promise<void> {
+        const tokenId = bookmarkUid;
         await this.apiService.deleteBookmark(tokenId);
     }
 }

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

@@ -533,7 +533,7 @@ describe("SharingManagement", () => {
                 expect(apiService.createPublicLink).toHaveBeenCalledWith("shareId", expect.objectContaining({
                     role: MemberRole.Viewer,
                     includesCustomPassword: false,
-                    expirationDuration: undefined,
+                    expirationTime: undefined,
                     crypto: "publicLinkCrypto",
                     srp: "publicLinkSrp",
                 }));
@@ -570,7 +570,7 @@ describe("SharingManagement", () => {
                 expect(apiService.createPublicLink).toHaveBeenCalledWith("shareId", expect.objectContaining({
                     role: MemberRole.Viewer,
                     includesCustomPassword: true,
-                    expirationDuration: 86400,
+                    expirationTime: 1735776000,
                     crypto: "publicLinkCrypto",
                     srp: "publicLinkSrp",
                 }));
@@ -617,7 +617,7 @@ describe("SharingManagement", () => {
                 expect(apiService.updatePublicLink).toHaveBeenCalledWith("publicLinkUid", expect.objectContaining({
                     role: MemberRole.Editor,
                     includesCustomPassword: true,
-                    expirationDuration: 86400,
+                    expirationTime: 1735776000,
                     crypto: "publicLinkCrypto",
                     srp: "publicLinkSrp",
                 }));

package/src/internal/sharing/sharingManagement.ts

@@ -474,7 +474,7 @@ export class SharingManagement {
             creatorEmail,
             role: options.role,
             includesCustomPassword: !!options.customPassword,
-            expirationDuration: options.expiration ? Math.floor((options.expiration.getTime() - Date.now()) / 1000) : undefined,
+            expirationTime: options.expiration ? Math.floor(options.expiration.getTime() / 1000) : undefined,
             crypto,
             srp,
         });
@@ -502,7 +502,7 @@ export class SharingManagement {
         await this.apiService.updatePublicLink(publicLink.uid, {
             role: options.role,
             includesCustomPassword: !!options.customPassword,
-            expirationDuration: options.expiration ? Math.floor((options.expiration.getTime() - Date.now()) / 1000) : undefined,
+            expirationTime: options.expiration ? Math.floor(options.expiration.getTime() / 1000) : undefined,
             crypto,
             srp,
         });

package/src/internal/upload/interface.ts

@@ -1,6 +1,6 @@
 import { PrivateKey, SessionKey } from "../../crypto";
 
-import { MetricContext, ThumbnailType, Result, Revision } from "../../interface";
+import { MetricVolumeType, ThumbnailType, Result, Revision } from "../../interface";
 import { DecryptedNode } from "../nodes";
 
 export type NodeRevisionDraft = {
@@ -124,5 +124,5 @@ export interface NodesServiceNode {
  * Interface describing the dependencies to the shares module.
  */
 export interface SharesService {
-    getVolumeMetricContext(volumeId: string): Promise<MetricContext>,
+    getVolumeMetricContext(volumeId: string): Promise<MetricVolumeType>,
 }

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

@@ -31,26 +31,30 @@ describe('UploadTelemetry', () => {
     });
 
     it('should log failure during init (excludes uploaded size)', async () => {
-        await uploadTelemetry.uploadInitFailed(parentNodeUid, new Error('Failed'), 1000);
+        const error = new Error('Failed');
+        await uploadTelemetry.uploadInitFailed(parentNodeUid, error, 1000);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
             eventName: "upload",
-            context: "own_volume",
+            volumeType: "own_volume",
             uploadedSize: 0,
             expectedSize: 1000,
             error: "unknown",
+            originalError: error,
         });
     });
 
     it('should log failure upload', async () => {
-        await uploadTelemetry.uploadFailed(revisionUid, new Error('Failed'), 500, 1000);
+        const error = new Error('Failed');
+        await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
             eventName: "upload",
-            context: "own_volume",
+            volumeType: "own_volume",
             uploadedSize: 500,
             expectedSize: 1000,
             error: "unknown",
+            originalError: error,
         });
     });
 
@@ -59,7 +63,7 @@ describe('UploadTelemetry', () => {
 
         expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
             eventName: "upload",
-            context: "own_volume",
+            volumeType: "own_volume",
             uploadedSize: 1000,
             expectedSize: 1000,
         });
@@ -109,7 +113,7 @@ describe('UploadTelemetry', () => {
         it('should detect "5xx" error for APIHTTPError with 5xx status code', async () => {
             const error = new APIHTTPError('Server error', 500);
             await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
-            verifyErrorCategory('5xx');
+            verifyErrorCategory('server_error');
         });
 
         it('should detect "server_error" for TimeoutError', async () => {

package/src/internal/upload/telemetry.ts

@@ -40,6 +40,7 @@ export class UploadTelemetry {
             uploadedSize: 0,
             expectedSize,
             error: errorCategory,
+            originalError: error,
         });
     }
 
@@ -57,6 +58,7 @@ export class UploadTelemetry {
             uploadedSize,
             expectedSize,
             error: errorCategory,
+            originalError: error,
         });
     }
 
@@ -72,17 +74,18 @@ export class UploadTelemetry {
         uploadedSize: number,
         expectedSize: number,
         error?: MetricsUploadErrorType,
+        originalError?: unknown,
     }) {
-        let context;
+        let volumeType;
         try {
-            context = await this.sharesService.getVolumeMetricContext(volumeId);
+            volumeType = await this.sharesService.getVolumeMetricContext(volumeId);
         } catch (error: unknown) {
-            this.logger.error('Failed to get metric context', error);
+            this.logger.error('Failed to get metric volume type', error);
         }
 
         this.telemetry.logEvent({
             eventName: 'upload',
-            context,
+            volumeType,
             ...options,
         });
     }
@@ -103,7 +106,7 @@ function getErrorCategory(error: unknown): MetricsUploadErrorType | undefined {
             return '4xx';
         }
         if (error.statusCode >= 500) {
-            return '5xx';
+            return 'server_error';
         }
     }
     if (error instanceof Error) {

package/src/protonDriveClient.ts

@@ -11,6 +11,8 @@ import {
     ProtonInvitationOrUid,
     NonProtonInvitationOrUid,
     ProtonInvitationWithNode,
+    MaybeBookmark,
+    BookmarkOrUid,
     ShareResult,
     Device,
     DeviceType,
@@ -410,7 +412,7 @@ export class ProtonDriveClient {
      * @throws {@link Error} If another node with the same name already exists.
      */
     async renameNode(nodeUid: NodeOrUid, newName: string): Promise<MaybeNode> {
-        this.logger.info(`Renaming node ${nodeUid} to ${newName}`);
+        this.logger.info(`Renaming node ${getUid(nodeUid)}`);
         return convertInternalNodePromise(this.nodes.management.renameNode(getUid(nodeUid), newName));
     }
 
@@ -511,7 +513,7 @@ export class ProtonDriveClient {
      * @throws {@link Error} If another node with the same name already exists.
      */
     async createFolder(parentNodeUid: NodeOrUid, name: string, modificationTime?: Date): Promise<MaybeNode> {
-        this.logger.info(`Creating folder ${name} in ${getUid(parentNodeUid)}`);
+        this.logger.info(`Creating folder in ${getUid(parentNodeUid)}`);
         return convertInternalNodePromise(this.nodes.management.createFolder(getUid(parentNodeUid), name, modificationTime));
     }
 
@@ -645,6 +647,29 @@ export class ProtonDriveClient {
         await this.sharing.access.rejectInvitation(invitationId);
     }
 
+    /**
+     * Iterates the shared bookmarks.
+     *
+     * The output is not sorted and the order of the bookmarks is not guaranteed.
+     *
+     * @param signal - Signal to abort the operation.
+     * @returns An async generator of the shared bookmarks.
+     */
+    async* iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
+        this.logger.info('Iterating shared bookmarks');
+        yield* this.sharing.access.iterateBookmarks(signal);
+    }
+
+    /**
+     * Remove the shared bookmark.
+     *
+     * @param bookmarkOrUid - Bookmark entity or its UID string.
+     */
+    async removeBookmark(bookmarkOrUid: BookmarkOrUid): Promise<void> {
+        this.logger.info(`Removing bookmark ${getUid(bookmarkOrUid)}`);
+        await this.sharing.access.deleteBookmark(getUid(bookmarkOrUid));
+    }
+
     /**
      * Get sharing info of the node.
      * 

package/src/transformers.ts

@@ -1,5 +1,15 @@
-import { MaybeNode as PublicMaybeNode, MaybeMissingNode as PublicMaybeMissingNode, NodeEntity as PublicNodeEntity, DegradedNode as PublicDegradedNode, Result, resultOk, resultError, MissingNode } from './interface';
-import { DecryptedNode as InternalNode } from './internal/nodes';
+import {
+    MaybeNode as PublicMaybeNode,
+    MaybeMissingNode as PublicMaybeMissingNode,
+    NodeEntity as PublicNodeEntity,
+    DegradedNode as PublicDegradedNode,
+    Revision as PublicRevision,
+    Result,
+    resultOk,
+    resultError,
+    MissingNode,
+} from './interface';
+import { DecryptedNode as InternalNode, DecryptedRevision as InternalRevision } from './internal/nodes';
 
 type InternalPartialNode = Pick<
     InternalNode,
@@ -17,7 +27,8 @@ type InternalPartialNode = Pick<
     'activeRevision' |
     'folder' |
     'totalStorageSize' |
-    'errors'
+    'errors' |
+    'shareId'
 >;
 
 type NodeUid = string | { uid: string } | Result<{ uid: string }, { uid: string }>;
@@ -76,6 +87,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         trashTime: node.trashTime,
         totalStorageSize: node.totalStorageSize,
         folder: node.folder,
+        deprecatedShareId: node.shareId,
     };
 
     const name = node.name;
@@ -85,7 +97,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         return resultError({
             ...baseNodeMetadata,
             name,
-            activeRevision,
+            activeRevision: activeRevision?.ok ? resultOk(convertInternalRevision(activeRevision.value)) : activeRevision,
             errors: node.errors,
         } as PublicDegradedNode);
     }
@@ -93,6 +105,20 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
     return resultOk({
         ...baseNodeMetadata,
         name: name.value,
-        activeRevision: activeRevision?.value,
+        activeRevision: activeRevision?.ok ? convertInternalRevision(activeRevision.value) : undefined,
     } as PublicNodeEntity);
 }
+
+function convertInternalRevision(revision: InternalRevision): PublicRevision {
+    return {
+        uid: revision.uid,
+        state: revision.state,
+        creationTime: revision.creationTime,
+        contentAuthor: revision.contentAuthor,
+        storageSize: revision.storageSize,
+        claimedSize: revision.claimedSize,
+        claimedModificationTime: revision.claimedModificationTime,
+        claimedDigests: revision.claimedDigests,
+        claimedAdditionalMetadata: revision.claimedAdditionalMetadata,
+    }
+}

package/dist/cache/index.d.ts

@@ -1,2 +0,0 @@
-export type { ProtonDriveCache, EntityResult } from './interface';
-export { MemoryCache } from './memoryCache';

package/dist/cache/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryCache = void 0;
-var memoryCache_1 = require("./memoryCache");
-Object.defineProperty(exports, "MemoryCache", { enumerable: true, get: function () { return memoryCache_1.MemoryCache; } });
-//# sourceMappingURL=index.js.map

package/dist/cache/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":";;;AACA,6CAA4C;AAAnC,0GAAA,WAAW,OAAA"}