@protontech/drive-sdk 0.14.10 → 0.15.0

package/src/crypto/openPGPCrypto.ts

@@ -1,97 +1,13 @@
 import { c } from 'ttag';
 
-import { OpenPGPCrypto, PrivateKey, PublicKey, SessionKey, VERIFICATION_STATUS } from './interface';
-import { uint8ArrayToBase64String } from './utils';
-
-/**
- * Interface matching CryptoProxy interface from client's monorepo:
- * clients/packages/crypto/lib/proxy/proxy.ts.
- */
-export interface OpenPGPCryptoProxy {
-    generateKey: (options: {
-        userIDs: { name: string }[];
-        type: 'ecc';
-        curve: 'ed25519Legacy';
-        config?: { aeadProtect: boolean };
-    }) => Promise<PrivateKey>;
-    exportPrivateKey: (options: { privateKey: PrivateKey; passphrase: string | null }) => Promise<string>;
-    importPrivateKey: (options: { armoredKey: string; passphrase: string | null }) => Promise<PrivateKey>;
-    generateSessionKey: (options: {
-        recipientKeys: PublicKey[];
-        config?: { ignoreSEIPDv2FeatureFlag: boolean };
-    }) => Promise<SessionKey>;
-    encryptSessionKey: (
-        options: SessionKey & {
-            format: 'binary';
-            encryptionKeys?: PublicKey | PublicKey[];
-            passwords?: string[];
-        },
-    ) => Promise<Uint8Array<ArrayBuffer>>;
-    decryptSessionKey: (options: {
-        armoredMessage?: string;
-        binaryMessage?: Uint8Array<ArrayBuffer>;
-        decryptionKeys: PrivateKey | PrivateKey[];
-    }) => Promise<SessionKey | undefined>;
-    encryptMessage: <Format extends 'armored' | 'binary' = 'armored', Detached extends boolean = false>(options: {
-        format?: Format;
-        binaryData: Uint8Array<ArrayBuffer>;
-        sessionKey?: SessionKey;
-        encryptionKeys: PublicKey[];
-        signingKeys?: PrivateKey;
-        detached?: Detached;
-        compress?: boolean;
-        config?: { ignoreSEIPDv2FeatureFlag: boolean };
-    }) => Promise<
-        Detached extends true
-            ? {
-                  message: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
-                  signature: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
-              }
-            : {
-                  message: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
-              }
-    >;
-    decryptMessage: <Format extends 'utf8' | 'binary' = 'utf8'>(options: {
-        format: Format;
-        armoredMessage?: string;
-        binaryMessage?: Uint8Array<ArrayBuffer>;
-        armoredSignature?: string;
-        binarySignature?: Uint8Array<ArrayBuffer>;
-        sessionKeys?: SessionKey;
-        passwords?: string[];
-        decryptionKeys?: PrivateKey | PrivateKey[];
-        verificationKeys?: PublicKey | PublicKey[];
-    }) => Promise<{
-        data: Format extends 'binary' ? Uint8Array<ArrayBuffer> : string;
-        verificationStatus: VERIFICATION_STATUS;
-        verificationErrors?: Error[];
-    }>;
-    signMessage: <Format extends 'binary' | 'armored' = 'armored'>(options: {
-        format: Format;
-        binaryData: Uint8Array<ArrayBuffer>;
-        signingKeys: PrivateKey | PrivateKey[];
-        detached: boolean;
-        signatureContext?: { critical: boolean; value: string };
-    }) => Promise<Format extends 'binary' ? Uint8Array<ArrayBuffer> : string>;
-    verifyMessage: (options: {
-        binaryData: Uint8Array<ArrayBuffer>;
-        armoredSignature?: string;
-        binarySignature?: Uint8Array<ArrayBuffer>;
-        verificationKeys: PublicKey | PublicKey[];
-        signatureContext?: { required: boolean; value: string };
-    }) => Promise<{
-        verificationStatus: VERIFICATION_STATUS;
-        errors?: Error[];
-    }>;
-}
+import type { CryptoApiInterface, OpenPGPCrypto, PrivateKey, PublicKey, SessionKey } from './interface';
 
 /**
  * Implementation of OpenPGPCrypto interface using CryptoProxy from clients
- * monorepo that must be passed as dependency. In the future, CryptoProxy
- * will be published separately and this implementation will use it directly.
+ * monorepo that must be passed as dependency.
  */
 export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
-    constructor(private cryptoProxy: OpenPGPCryptoProxy) {
+    constructor(private cryptoProxy: CryptoApiInterface) {
         this.cryptoProxy = cryptoProxy;
     }
 
@@ -99,7 +15,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         const value = crypto.getRandomValues(new Uint8Array(32));
         // TODO: Once all clients can use non-ascii bytes, switch to simple
         // generating of random bytes without encoding it into base64.
-        return uint8ArrayToBase64String(value);
+        return value.toBase64();
     }
 
     async generateSessionKey(encryptionKeys: PublicKey[], options: { enableAeadWithEncryptionKeys: boolean }) {

package/src/diagnostic/index.ts

@@ -1,18 +1,18 @@
 import { MemoryCache, NullCache } from '../cache';
 import { ProtonDriveClientContructorParameters } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
+import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
 import { Diagnostic as DiagnosticClass } from './diagnostic';
-import { Diagnostic } from './interface';
 import { DiagnosticHTTPClient } from './httpClient';
+import { Diagnostic } from './interface';
 import { DiagnosticTelemetry } from './telemetry';
-import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
 
 export type {
     Diagnostic,
     DiagnosticOptions,
-    ExpectedTreeNode,
     DiagnosticProgressCallback,
     DiagnosticResult,
+    ExpectedTreeNode,
 } from './interface';
 
 /**

package/src/diagnostic/integrityVerificationStream.ts

@@ -1,5 +1,4 @@
 import { sha1 } from '@noble/hashes/legacy';
-import { bytesToHex } from '@noble/hashes/utils';
 
 /**
  * A WritableStream that computes SHA1 hash on the fly.
@@ -23,7 +22,7 @@ export class IntegrityVerificationStream extends WritableStream<Uint8Array> {
             },
             close: () => {
                 if (!this._isClosed) {
-                    this._computedSha1 = bytesToHex(this.sha1Hash.digest());
+                    this._computedSha1 = this.sha1Hash.digest().toHex();
                     this._isClosed = true;
                 }
             },

package/src/diagnostic/interface.ts

@@ -1,4 +1,4 @@
-import { Author, MaybeNode, MetricEvent, NodeType, AnonymousUser } from '../interface';
+import { AnonymousUser, Author, MaybeNode, MetricEvent, NodeType } from '../interface';
 import { LogRecord } from '../telemetry';
 
 export interface Diagnostic {

package/src/diagnostic/nodeUtils.ts

@@ -1,7 +1,7 @@
 import { MaybeNode, NodeType, Revision } from '../interface';
 import {
-    NodeDetails,
     ExpectedTreeNode,
+    NodeDetails,
 } from './interface';
 
 export function getNodeDetails(node: MaybeNode): NodeDetails {

package/src/diagnostic/sdkDiagnosticBase.ts

@@ -1,19 +1,19 @@
-import { Author, FileDownloader, MaybeNode, NodeOrUid, NodeType, ThumbnailType, ThumbnailResult } from '../interface';
+import { Author, FileDownloader, MaybeNode, NodeOrUid, NodeType, ThumbnailResult, ThumbnailType } from '../interface';
 import { isProtonDocument, isProtonSheet } from '../internal/nodes/mediaTypes';
+import { IntegrityVerificationStream } from './integrityVerificationStream';
 import {
     DiagnosticOptions,
+    DiagnosticProgressCallback,
     DiagnosticResult,
     ExpectedTreeNode,
-    DiagnosticProgressCallback,
 } from './interface';
-import { IntegrityVerificationStream } from './integrityVerificationStream';
 import {
-    getNodeType,
-    getNodeDetails,
     getActiveRevision,
-    getMediaType,
     getExpectedTreeNodeDetails,
+    getMediaType,
+    getNodeDetails,
     getNodeName,
+    getNodeType,
 } from './nodeUtils';
 
 const PROGRESS_REPORT_INTERVAL = 500;

package/src/diagnostic/sdkDiagnosticMain.ts

@@ -7,9 +7,9 @@ import {
     ExpectedTreeNode,
     TreeNode,
 } from './interface';
-import { zipGenerators } from './zipGenerators';
-import { getNodeType, getNodeName, getTreeNodeChildByNodeName, getActiveRevision } from './nodeUtils';
+import { getActiveRevision, getNodeName, getNodeType, getTreeNodeChildByNodeName } from './nodeUtils';
 import { SDKDiagnosticBase } from './sdkDiagnosticBase';
+import { zipGenerators } from './zipGenerators';
 
 /**
  * Diagnostic tool that uses the main Drive SDK to traverse and verify

package/src/diagnostic/sdkDiagnosticPhotos.ts

@@ -7,9 +7,9 @@ import {
     ExpectedTreeNode,
     TreeNode,
 } from './interface';
-import { zipGenerators } from './zipGenerators';
-import { getNodeName, getTreeNodeChildByNodeName, getActiveRevision, getNodeType } from './nodeUtils';
+import { getActiveRevision, getNodeName, getNodeType, getTreeNodeChildByNodeName } from './nodeUtils';
 import { SDKDiagnosticBase } from './sdkDiagnosticBase';
+import { zipGenerators } from './zipGenerators';
 
 /**
  * Diagnostic tool that uses the Photos SDK to traverse and verify

package/src/diagnostic/telemetry.ts

@@ -1,5 +1,5 @@
 import { MetricEvent } from '../interface';
-import { LogRecord, LogLevel } from '../telemetry';
+import { LogLevel, LogRecord } from '../telemetry';
 import { EventsGenerator } from './eventsGenerator';
 
 /**

package/src/index.ts

@@ -4,12 +4,13 @@
 
 import { makeNodeUid } from './internal/uids';
 
-export * from './interface';
 export * from './cache';
-export * from './errors';
-export type { OpenPGPCrypto, OpenPGPCryptoProxy } from './crypto';
+export type { OpenPGPCrypto } from './crypto';
 export { OpenPGPCryptoWithCryptoProxy } from './crypto';
+export * from './errors';
 export { NullFeatureFlagProvider } from './featureFlags';
+export * from './interface';
+export type { EventSubscription } from './internal/events';
 export { ProtonDriveClient } from './protonDriveClient';
 export { VERSION } from './version';
 

package/src/interface/account.ts

@@ -28,7 +28,7 @@ export interface ProtonDriveAccount {
      *
      * Does not throw if there is no public key for given email, but returns empty array.
      *
-     * @param forceRefresh If true, bypasses the cache and fetches fresh keys from the API.
+     * @param forceRefresh - If true, bypasses the cache and fetches fresh keys from the API.
      * @throws Error Only if there is an error while fetching keys.
      */
     getPublicKeys(email: string, forceRefresh?: boolean): Promise<PublicKey[]>;

package/src/interface/devices.ts

@@ -1,5 +1,5 @@
-import { Result } from './result';
 import { InvalidNameError } from './nodes';
+import { Result } from './result';
 
 export type Device = {
     uid: string;

package/src/interface/index.ts

@@ -5,99 +5,99 @@ import { ProtonDriveAccount } from './account';
 import { ProtonDriveConfig } from './config';
 import { FeatureFlagProvider } from './featureFlags';
 import { ProtonDriveHTTPClient } from './httpClient';
-import { Telemetry, MetricEvent } from './telemetry';
+import { MetricEvent, Telemetry } from './telemetry';
 
-export type { Result } from './result';
-export { resultOk, resultError } from './result';
 export type { ProtonDriveAccount, ProtonDriveAccountAddress } from './account';
-export type { Author, UnverifiedAuthorError, AnonymousUser } from './author';
+export type { AnonymousUser, Author, UnverifiedAuthorError } from './author';
 export type { ProtonDriveConfig } from './config';
 export type { Device, DeviceOrUid } from './devices';
-export type { FeatureFlagProvider } from './featureFlags';
-export { FeatureFlags } from './featureFlags';
 export { DeviceType } from './devices';
-export type { FileDownloader, DownloadController, SeekableReadableStream } from './download';
+export type { DownloadController, FileDownloader, SeekableReadableStream } from './download';
 export type {
+    DriveEvent,
     DriveListener,
+    FastForwardEvent,
     LatestEventIdProvider,
-    DriveEvent,
     NodeEvent,
-    FastForwardEvent,
+    SharedWithMeUpdated,
     TreeRefreshEvent,
     TreeRemovalEvent,
-    SharedWithMeUpdated,
 } from './events';
 export { DriveEventType, SDKEvent } from './events';
+export type { FeatureFlagProvider } from './featureFlags';
+export { FeatureFlags } from './featureFlags';
 export type {
     ProtonDriveHTTPClient,
-    ProtonDriveHTTPClientJsonRequest,
     ProtonDriveHTTPClientBlobRequest,
+    ProtonDriveHTTPClientJsonRequest,
 } from './httpClient';
 export type {
-    MaybeNode,
-    NodeEntity,
     DegradedNode,
+    InvalidNameError,
     MaybeMissingNode,
+    MaybeNode,
+    Membership,
     MissingNode,
-    InvalidNameError,
-    Revision,
+    NodeEntity,
     NodeOrUid,
-    RevisionOrUid,
     NodeResult,
     NodeResultWithError,
     NodeResultWithNewUid,
-    Membership,
+    Revision,
+    RevisionOrUid,
 } from './nodes';
-export { NodeType, MemberRole, RevisionState } from './nodes';
+export { MemberRole, NodeType, RevisionState } from './nodes';
 export type {
-    MaybePhotoNode,
-    MaybeMissingPhotoNode,
-    PhotoNode,
+    AlbumAttributes,
     DegradedPhotoNode,
+    MaybeMissingPhotoNode,
+    MaybePhotoNode,
     PhotoAttributes,
-    AlbumAttributes,
+    PhotoNode,
 } from './photos';
 export { PhotoTag } from './photos';
+export type { Result } from './result';
+export { resultError, resultOk } from './result';
 export type {
-    ProtonInvitation,
-    ProtonInvitationWithNode,
-    NonProtonInvitation,
-    Member,
-    PublicLink,
-    MaybeBookmark,
     Bookmark,
+    BookmarkOrUid,
     DegradedBookmark,
-    ProtonInvitationOrUid,
+    MaybeBookmark,
+    Member,
+    NonProtonInvitation,
     NonProtonInvitationOrUid,
-    BookmarkOrUid,
-    ShareNodeSettings,
-    UnshareNodeSettings,
+    ProtonInvitation,
+    ProtonInvitationOrUid,
+    ProtonInvitationWithNode,
+    PublicLink,
     ShareMembersSettings,
+    ShareNodeSettings,
     SharePublicLinkSettings,
     SharePublicLinkSettingsObject,
     ShareResult,
+    UnshareNodeSettings,
 } from './sharing';
 export { NonProtonInvitationState } from './sharing';
 export type {
-    Telemetry,
     Logger,
     MetricAPIRetrySucceededEvent,
-    MetricUploadEvent,
-    MetricsUploadErrorType,
-    MetricDownloadEvent,
-    MetricsDownloadErrorType,
+    MetricBlockVerificationErrorEvent,
     MetricDecryptionErrorEvent,
+    MetricDownloadEvent,
+    MetricEvent,
     MetricsDecryptionErrorField,
+    MetricsDownloadErrorType,
+    MetricsUploadErrorType,
+    MetricUploadEvent,
     MetricVerificationErrorEvent,
     MetricVerificationErrorField,
-    MetricBlockVerificationErrorEvent,
     MetricVolumeEventsSubscriptionsChangedEvent,
-    MetricEvent,
+    Telemetry,
 } from './telemetry';
 export { MetricVolumeType } from './telemetry';
-export type { FileUploader, UploadController, UploadMetadata } from './upload';
 export type { Thumbnail, ThumbnailResult } from './thumbnail';
 export { ThumbnailType } from './thumbnail';
+export type { FileUploader, UploadController, UploadMetadata } from './upload';
 
 export type ProtonDriveTelemetry = Telemetry<MetricEvent>;
 export type ProtonDriveEntitiesCache = ProtonDriveCache<string>;

package/src/interface/nodes.ts

@@ -1,5 +1,5 @@
-import { Result } from './result';
 import { Author } from './author';
+import { Result } from './result';
 
 /**
  * Node representing a file or folder in the system.

package/src/interface/photos.ts

@@ -1,5 +1,5 @@
+import { DegradedNode, MissingNode, NodeEntity, NodeType } from './nodes';
 import { Result } from './result';
-import { DegradedNode, NodeEntity, NodeType, MissingNode } from './nodes';
 
 /**
  * Node representing a photo or album for Photos SDK.

package/src/interface/sharing.ts

@@ -1,6 +1,6 @@
-import { Result } from './result';
 import { UnverifiedAuthorError } from './author';
-import { NodeType, MemberRole, InvalidNameError } from './nodes';
+import { InvalidNameError, MemberRole, NodeType } from './nodes';
+import { Result } from './result';
 
 export type Member = {
     uid: string;

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

@@ -1,9 +1,9 @@
 import { AbortError } from '../../errors';
-import { ProtonDriveHTTPClient, SDKEvent, Telemetry, MetricEvent } from '../../interface';
+import { MetricEvent, ProtonDriveHTTPClient, SDKEvent, Telemetry } from '../../interface';
 import { getMockTelemetry } from '../../tests/telemetry';
 import { SDKEvents } from '../sdkEvents';
 import { DriveAPIService } from './apiService';
-import { HTTPErrorCode, ErrorCode } from './errorCodes';
+import { ErrorCode, HTTPErrorCode } from './errorCodes';
 
 jest.useFakeTimers();
 

package/src/internal/apiService/apiService.ts

@@ -1,10 +1,10 @@
 import { c } from 'ttag';
 
+import { AbortError, ProtonDriveError, RateLimitedError, ServerError } from '../../errors';
+import { Logger, ProtonDriveHTTPClient, ProtonDriveTelemetry } from '../../interface';
 import { VERSION } from '../../version';
-import { ProtonDriveHTTPClient, ProtonDriveTelemetry, Logger } from '../../interface';
-import { AbortError, ServerError, RateLimitedError, ProtonDriveError } from '../../errors';
-import { waitSeconds } from '../wait';
 import { SDKEvents } from '../sdkEvents';
+import { waitSeconds } from '../wait';
 import { HTTPErrorCode, isCodeOk, isCodeOkAsync } from './errorCodes';
 import { apiErrorFactory } from './errors';