@protontech/drive-sdk 0.1.2 → 0.2.1

package/src/internal/sharing/cryptoService.ts

@@ -148,7 +148,7 @@ export class SharingCryptoService {
         }
         const addressPublicKeys = await this.account.getPublicKeys(share.creatorEmail);
 
-        const { key, passphraseSessionKey, verified } = await this.driveCrypto.decryptKey(
+        const { key, passphraseSessionKey, verified, verificationErrors } = await this.driveCrypto.decryptKey(
             share.encryptedCrypto.armoredKey,
             share.encryptedCrypto.armoredPassphrase,
             share.encryptedCrypto.armoredPassphraseSignature,
@@ -161,7 +161,7 @@ export class SharingCryptoService {
                 ? resultOk(share.creatorEmail)
                 : resultError({
                       claimedAuthor: share.creatorEmail,
-                      error: getVerificationMessage(verified),
+                      error: getVerificationMessage(verified, verificationErrors),
                   });
 
         return {
@@ -411,10 +411,7 @@ export class SharingCryptoService {
                 };
             case PublicLinkFlags.GeneratedPasswordIncluded:
             case PublicLinkFlags.GeneratedPasswordWithCustomPassword:
-                return {
-                    password: password.substring(0, PUBLIC_LINK_GENERATED_PASSWORD_LENGTH),
-                    customPassword: password.substring(PUBLIC_LINK_GENERATED_PASSWORD_LENGTH) || undefined,
-                };
+                return splitGeneratedAndCustomPassword(password);
             default:
                 throw new Error(`Unsupported public link with flags: ${encryptedPublicLink.flags}`);
         }
@@ -422,18 +419,24 @@ export class SharingCryptoService {
 
     async decryptBookmark(encryptedBookmark: EncryptedBookmark): Promise<{
         url: Result<string, Error>;
+        customPassword: Result<string | undefined, 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;
+        let customPassword: Result<string | undefined, Error>;
         try {
-            urlPassword = await this.decryptBookmarkUrlPassword(encryptedBookmark);
+            const password = await this.decryptBookmarkUrlPassword(encryptedBookmark);
+            const result = splitGeneratedAndCustomPassword(password);
+            urlPassword = result.password;
+            customPassword = resultOk(result.customPassword);
         } catch (originalError: unknown) {
             const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
             return {
                 url: resultError(error),
+                customPassword: resultError(error),
                 nodeName: resultError(error),
             };
         }
@@ -448,6 +451,7 @@ export class SharingCryptoService {
             const error = originalError instanceof Error ? originalError : new Error(c('Error').t`Unknown error`);
             return {
                 url,
+                customPassword,
                 nodeName: resultError(error),
             };
         }
@@ -456,6 +460,7 @@ export class SharingCryptoService {
 
         return {
             url,
+            customPassword,
             nodeName,
         };
     }
@@ -478,11 +483,12 @@ export class SharingCryptoService {
 
             return urlPassword;
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareUrlPassword',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);
@@ -503,11 +509,12 @@ export class SharingCryptoService {
 
             return shareKey;
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'shareKey',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);
@@ -535,11 +542,12 @@ export class SharingCryptoService {
 
             return resultOk(name);
         } catch (error: unknown) {
-            this.telemetry.logEvent({
+            this.telemetry.recordMetric({
                 eventName: 'decryptionError',
                 volumeType: MetricVolumeType.SharedPublic,
                 field: 'nodeName',
                 error,
+                uid: encryptedBookmark.tokenId,
             });
 
             const message = getErrorMessage(error);
@@ -548,3 +556,12 @@ export class SharingCryptoService {
         }
     }
 }
+
+function splitGeneratedAndCustomPassword(concatenatedPassword: string): {
+    password: string;
+    customPassword?: string;
+} {
+    const password = concatenatedPassword.substring(0, PUBLIC_LINK_GENERATED_PASSWORD_LENGTH);
+    const customPassword = concatenatedPassword.substring(PUBLIC_LINK_GENERATED_PASSWORD_LENGTH) || undefined;
+    return { password, customPassword };
+}

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

@@ -116,6 +116,7 @@ describe('SharingAccess', () => {
         it('should return decrypted bookmark', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultOk('url'),
+                customPassword: resultOk('customPassword'),
                 nodeName: resultOk('nodeName'),
             });
 
@@ -126,6 +127,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: 'url',
+                    customPassword: 'customPassword',
                     node: {
                         name: 'nodeName',
                         type: NodeType.File,
@@ -138,6 +140,7 @@ describe('SharingAccess', () => {
         it('should return degraded bookmark if URL password cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultError('url cannot be decrypted'),
+                customPassword: resultOk('url cannot be decrypted'),
                 nodeName: resultError('url cannot be decrypted'),
             });
 
@@ -148,6 +151,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: resultError('url cannot be decrypted'),
+                    customPassword: resultOk('url cannot be decrypted'),
                     node: {
                         name: resultError('url cannot be decrypted'),
                         type: NodeType.File,
@@ -160,6 +164,7 @@ describe('SharingAccess', () => {
         it('should return degraded bookmark if node name cannot be decrypted', async () => {
             cryptoService.decryptBookmark = jest.fn().mockResolvedValue({
                 url: resultOk('url'),
+                customPassword: resultOk(undefined),
                 nodeName: resultError('node name cannot be decrypted'),
             });
 
@@ -170,6 +175,7 @@ describe('SharingAccess', () => {
                     uid: 'tokenId',
                     creationTime: new Date('2025-01-01'),
                     url: resultOk('url'),
+                    customPassword: resultOk(undefined),
                     node: {
                         name: resultError('node name cannot be decrypted'),
                         type: NodeType.File,

package/src/internal/sharing/sharingAccess.ts

@@ -140,13 +140,14 @@ export class SharingAccess {
 
     async *iterateBookmarks(signal?: AbortSignal): AsyncGenerator<MaybeBookmark> {
         for await (const bookmark of this.apiService.iterateBookmarks(signal)) {
-            const { url, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
+            const { url, customPassword, nodeName } = await this.cryptoService.decryptBookmark(bookmark);
 
-            if (!url.ok || !nodeName.ok) {
+            if (!url.ok || !customPassword.ok || !nodeName.ok) {
                 yield resultError({
                     uid: bookmark.tokenId,
                     creationTime: bookmark.creationTime,
                     url: url,
+                    customPassword,
                     node: {
                         name: nodeName,
                         type: bookmark.node.type,
@@ -158,6 +159,7 @@ export class SharingAccess {
                     uid: bookmark.tokenId,
                     creationTime: bookmark.creationTime,
                     url: url.value,
+                    customPassword: customPassword.value,
                     node: {
                         name: nodeName.value,
                         type: bookmark.node.type,

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

@@ -14,7 +14,7 @@ describe('UploadTelemetry', () => {
 
     beforeEach(() => {
         mockTelemetry = {
-            logEvent: jest.fn(),
+            recordMetric: jest.fn(),
             getLogger: jest.fn().mockReturnValue({
                 info: jest.fn(),
                 warn: jest.fn(),
@@ -34,7 +34,7 @@ describe('UploadTelemetry', () => {
         const error = new Error('Failed');
         await uploadTelemetry.uploadInitFailed(parentNodeUid, error, 1000);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 0,
@@ -48,7 +48,7 @@ describe('UploadTelemetry', () => {
         const error = new Error('Failed');
         await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 500,
@@ -61,7 +61,7 @@ describe('UploadTelemetry', () => {
     it('should log successful upload (excludes error)', async () => {
         await uploadTelemetry.uploadFinished(revisionUid, 1000);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'upload',
             volumeType: 'own_volume',
             uploadedSize: 1000,
@@ -71,7 +71,7 @@ describe('UploadTelemetry', () => {
 
     describe('detect error category', () => {
         const verifyErrorCategory = (error: string) => {
-            expect(mockTelemetry.logEvent).toHaveBeenCalledWith(
+            expect(mockTelemetry.recordMetric).toHaveBeenCalledWith(
                 expect.objectContaining({
                     error,
                 }),
@@ -81,7 +81,7 @@ describe('UploadTelemetry', () => {
         it('should ignore ValidationError', async () => {
             const error = new ValidationError('Validation error');
             await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
-            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+            expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('should ignore AbortError', async () => {
@@ -89,7 +89,7 @@ describe('UploadTelemetry', () => {
             error.name = 'AbortError';
             await uploadTelemetry.uploadFailed(revisionUid, error, 500, 1000);
 
-            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+            expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('should detect "rate_limited" error for RateLimitedError', async () => {

package/src/internal/upload/telemetry.ts

@@ -23,7 +23,7 @@ export class UploadTelemetry {
     }
 
     logBlockVerificationError(retryHelped: boolean) {
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'blockVerificationError',
             retryHelped,
         });
@@ -89,7 +89,7 @@ export class UploadTelemetry {
             this.logger.error('Failed to get metric volume type', error);
         }
 
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'upload',
             volumeType,
             ...options,

package/src/telemetry.ts

@@ -66,7 +66,7 @@ export interface MetricHandler<T extends MetricEvent> {
  * const logger = telemetry.getLogger('myLogger');
  * logger.debug('Debug message');
  *
- * telemetry.logEvent({ name: 'somethingHappened', value: 42 });
+ * telemetry.recordMetric({ name: 'somethingHappened', value: 42 });
  *
  * const logs = memoryLogHandler.getLogs();
  * // Process logs
@@ -91,7 +91,7 @@ export class Telemetry<T extends MetricEvent> {
         return new Logger(name, this.logFilter, this.logHandlers);
     }
 
-    logEvent(event: T): void {
+    recordMetric(event: T): void {
         const metric = {
             time: new Date(),
             event,

package/src/tests/telemetry.ts

@@ -4,6 +4,6 @@ import { getMockLogger } from './logger';
 export function getMockTelemetry(): ProtonDriveTelemetry {
     return {
         getLogger: getMockLogger,
-        logEvent: jest.fn(),
+        recordMetric: jest.fn(),
     };
 }

package/src/transformers.ts

@@ -18,7 +18,8 @@ type InternalPartialNode = Pick<
     | 'name'
     | 'keyAuthor'
     | 'nameAuthor'
-    | 'directMemberRole'
+    | 'directRole'
+    | 'membership'
     | 'type'
     | 'mediaType'
     | 'isShared'
@@ -84,7 +85,8 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         parentUid: node.parentUid,
         keyAuthor: node.keyAuthor,
         nameAuthor: node.nameAuthor,
-        directMemberRole: node.directMemberRole,
+        directRole: node.directRole,
+        membership: node.membership,
         type: node.type,
         mediaType: node.mediaType,
         isShared: node.isShared,