@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/interface/account.ts

@@ -6,17 +6,17 @@ export interface ProtonDriveAccount {
      *
      * @throws Error If there is no primary address.
      */
-    getOwnPrimaryAddress(): Promise<ProtonDriveAccountAddress>,
+    getOwnPrimaryAddress(): Promise<ProtonDriveAccountAddress>;
     /**
      * Get own address by email or addressId.
      *
      * @throws Error If there is no address with given email or addressId.
      */
-    getOwnAddress(emailOrAddressId: string): Promise<ProtonDriveAccountAddress>,
+    getOwnAddress(emailOrAddressId: string): Promise<ProtonDriveAccountAddress>;
     /**
      * Returns whether given email can be used to share files with Proton Drive.
      */
-    hasProtonAccount(email: string): Promise<boolean>,
+    hasProtonAccount(email: string): Promise<boolean>;
     /**
      * Get public keys for given email.
      *
@@ -24,15 +24,15 @@ export interface ProtonDriveAccount {
      *
      * @throws Error Only if there is an error while fetching keys.
      */
-    getPublicKeys(email: string): Promise<PublicKey[]>,
+    getPublicKeys(email: string): Promise<PublicKey[]>;
 }
 
 export interface ProtonDriveAccountAddress {
-    email: string,
-    addressId: string,
-    primaryKeyIndex: number,
+    email: string;
+    addressId: string;
+    primaryKeyIndex: number;
     keys: {
-        id: string,
-        key: PrivateKey,
-    }[],
+        id: string;
+        key: PrivateKey;
+    }[];
 }

package/src/interface/author.ts

@@ -2,9 +2,9 @@ import { Result } from './result';
 
 /**
  * Author with verification status.
- * 
+ *
  * It can be either a string (email) or an anonymous user.
- * 
+ *
  * If author cannot be verified, the result is failure with an error.
  * The client can still get claimed author from the error object, but
  * it must be used with caution.
@@ -19,11 +19,11 @@ export type AnonymousUser = null;
 
 /**
  * Unverified author.
- * 
+ *
  * If author cannot be verified, the result is this object containing
  * the claimed author and the verification error.
  */
 export type UnverifiedAuthorError = {
-    claimedAuthor?: string,
-    error: string,
-}
+    claimedAuthor?: string;
+    error: string;
+};

package/src/interface/config.ts

@@ -4,14 +4,14 @@ export type ProtonDriveConfig = {
      *
      * If not provided, defaults to 'drive-api.proton.me'.
      */
-    baseUrl?: string,
+    baseUrl?: string;
 
     /**
      * The language to use for error messages.
      *
      * If not provided, defaults to 'en'.
      */
-    language?: string,
+    language?: string;
 
     /**
      * Client UID is used to identify the client for the upload.
@@ -24,5 +24,5 @@ export type ProtonDriveConfig = {
      * You can force the upload by setting up
      * `overrideExistingDraftByOtherClient` to true.
      */
-    clientUid?: string,
-}
+    clientUid?: string;
+};

package/src/interface/devices.ts

@@ -2,15 +2,15 @@ import { Result } from './result';
 import { InvalidNameError } from './nodes';
 
 export type Device = {
-    uid: string,
-    type: DeviceType,
-    name: Result<string, Error | InvalidNameError>,
-    rootFolderUid: string,
-    creationTime: Date,
+    uid: string;
+    type: DeviceType;
+    name: Result<string, Error | InvalidNameError>;
+    rootFolderUid: string;
+    creationTime: Date;
     lastSyncDate?: Date;
     /** @deprecated to be removed once Volume-based navigation is implemented in web */
     shareId: string;
-}
+};
 
 export enum DeviceType {
     Windows = 'Windows',

package/src/interface/download.ts

@@ -1,32 +1,35 @@
 export interface FileDownloader {
     /**
      * Get the claimed size of the file in bytes.
-     * 
+     *
      * This provides total clear-text size of the file. This is encrypted
      * information that is not known to the Proton Drive and thus it is
      * explicitely stated as claimed only and must be treated that way.
      * It can be wrong or missing completely.
      */
-    getClaimedSizeInBytes(): number | undefined,
+    getClaimedSizeInBytes(): number | undefined;
 
     /**
      * Download, decrypt and verify the content from the server and write
      * to the provided stream.
-     * 
+     *
      * @param onProgress - Callback that is called with the number of downloaded bytes
      */
-    writeToStream(streamFactory: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController,
+    writeToStream(streamFactory: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController;
 
     /**
      * Same as `writeToStream` but without verification checks.
-     * 
+     *
      * Use this only for debugging purposes.
      */
-    unsafeWriteToStream(streamFactory: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController,
+    unsafeWriteToStream(
+        streamFactory: WritableStream,
+        onProgress?: (downloadedBytes: number) => void,
+    ): DownloadController;
 }
 
 export interface DownloadController {
-    pause(): void,
-    resume(): void,
-    completion(): Promise<void>,
+    pause(): void;
+    resume(): void;
+    completion(): Promise<void>;
 }

package/src/interface/events.ts

@@ -1,8 +1,8 @@
 export enum SDKEvent {
-    TransfersPaused = "transfersPaused",
-    TransfersResumed = "transfersResumed",
-    RequestsThrottled = "requestsThrottled",
-    RequestsUnthrottled = "requestsUnthrottled",
+    TransfersPaused = 'transfersPaused',
+    TransfersResumed = 'transfersResumed',
+    RequestsThrottled = 'requestsThrottled',
+    RequestsUnthrottled = 'requestsUnthrottled',
 }
 
 export interface LatestEventIdProvider {
@@ -20,49 +20,55 @@ export interface LatestEventIdProvider {
  */
 export type DriveListener = (event: DriveEvent) => Promise<void>;
 
-type NodeCruEventType = DriveEventType.NodeCreated | DriveEventType.NodeUpdated;
+export type DriveEvent =
+    | NodeEvent
+    | FastForwardEvent
+    | TreeRefreshEvent
+    | TreeRemovalEvent
+    | FastForwardEvent
+    | SharedWithMeUpdated;
 
-export type NodeEvent = {
-    type: NodeCruEventType,
-    nodeUid: string,
-    parentNodeUid?: string,
-    isTrashed: boolean,
-    isShared: boolean,
-    treeEventScopeId: string,
-    eventId: string,
-} | {
-    type: DriveEventType.NodeDeleted,
-    nodeUid: string,
-    parentNodeUid?: string,
-    treeEventScopeId: string,
-    eventId: string,
-}
+export type NodeEvent =
+    | {
+          type: DriveEventType.NodeCreated | DriveEventType.NodeUpdated;
+          nodeUid: string;
+          parentNodeUid?: string;
+          isTrashed: boolean;
+          isShared: boolean;
+          treeEventScopeId: string;
+          eventId: string;
+      }
+    | {
+          type: DriveEventType.NodeDeleted;
+          nodeUid: string;
+          parentNodeUid?: string;
+          treeEventScopeId: string;
+          eventId: string;
+      };
 
 export type FastForwardEvent = {
-    type: DriveEventType.FastForward,
-    treeEventScopeId: string,
-    eventId: string,
-}
+    type: DriveEventType.FastForward;
+    treeEventScopeId: string;
+    eventId: string;
+};
 
 export type TreeRefreshEvent = {
-    type: DriveEventType.TreeRefresh,
-    treeEventScopeId: string,
-    eventId: string,
-}
+    type: DriveEventType.TreeRefresh;
+    treeEventScopeId: string;
+    eventId: string;
+};
 
 export type TreeRemovalEvent = {
-    type: DriveEventType.TreeRemove,
-    treeEventScopeId: string,
-    eventId: 'none',
-}
+    type: DriveEventType.TreeRemove;
+    treeEventScopeId: string;
+    eventId: 'none';
+};
 
 export type SharedWithMeUpdated = {
-    type: DriveEventType.SharedWithMeUpdated,
-    eventId: string,
-    treeEventScopeId: 'core',
-}
-
-export type DriveEvent = NodeEvent | FastForwardEvent | TreeRefreshEvent | TreeRemovalEvent | FastForwardEvent | SharedWithMeUpdated;
+    type: DriveEventType.SharedWithMeUpdated;
+    eventId: string;
+    treeEventScopeId: 'core';
+};
 
 export enum DriveEventType {
     NodeCreated = 'node_created',
@@ -71,5 +77,5 @@ export enum DriveEventType {
     SharedWithMeUpdated = 'shared_with_me_updated',
     TreeRefresh = 'tree_refresh',
     TreeRemove = 'tree_remove',
-    FastForward = 'fast_forward'
+    FastForward = 'fast_forward',
 }

package/src/interface/httpClient.ts

@@ -4,23 +4,23 @@ export interface ProtonDriveHTTPClient {
 }
 
 export type ProtonDriveHTTPClientJsonOptions = ProtonDriveHTTPClientBaseOptions & {
-    json?: object,
-}
+    json?: object;
+};
 
 export type ProtonDriveHTTPClientBlobOptions = ProtonDriveHTTPClientBaseOptions & {
-    body?: XMLHttpRequestBodyInit,
-    onProgress?: (progress: number) => void,
-}
+    body?: XMLHttpRequestBodyInit;
+    onProgress?: (progress: number) => void;
+};
 
 type ProtonDriveHTTPClientBaseOptions = {
-    url: string,
-    method: string,
-    headers: Headers,
+    url: string;
+    method: string;
+    headers: Headers;
     /**
      * The timeout in milliseconds.
      *
      * When timeout is reached, the request will be aborted with TimeoutError.
      */
-    timeoutMs: number,
-    signal?: AbortSignal,
-}
+    timeoutMs: number;
+    signal?: AbortSignal;
+};

package/src/interface/index.ts

@@ -14,14 +14,71 @@ export type { ProtonDriveConfig } from './config';
 export type { Device, DeviceOrUid } from './devices';
 export { DeviceType } from './devices';
 export type { FileDownloader, DownloadController } from './download';
-export type { DriveListener, LatestEventIdProvider, DriveEvent } from './events';
+export type {
+    DriveListener,
+    LatestEventIdProvider,
+    DriveEvent,
+    NodeEvent,
+    FastForwardEvent,
+    TreeRefreshEvent,
+    TreeRemovalEvent,
+    SharedWithMeUpdated,
+} from './events';
 export { DriveEventType, SDKEvent } from './events';
-export type { ProtonDriveHTTPClient, ProtonDriveHTTPClientJsonOptions, ProtonDriveHTTPClientBlobOptions } from './httpClient';
-export type { MaybeNode, NodeEntity, DegradedNode, MaybeMissingNode, MissingNode, InvalidNameError, Revision, NodeOrUid, RevisionOrUid, NodeResult } from './nodes';
+export type {
+    ProtonDriveHTTPClient,
+    ProtonDriveHTTPClientJsonOptions,
+    ProtonDriveHTTPClientBlobOptions,
+} from './httpClient';
+export type {
+    MaybeNode,
+    NodeEntity,
+    DegradedNode,
+    MaybeMissingNode,
+    MissingNode,
+    InvalidNameError,
+    Revision,
+    NodeOrUid,
+    RevisionOrUid,
+    NodeResult,
+} from './nodes';
 export { NodeType, MemberRole, RevisionState } from './nodes';
-export type { ProtonInvitation, ProtonInvitationWithNode, NonProtonInvitation, Member, PublicLink, MaybeBookmark, Bookmark, DegradedBookmark, ProtonInvitationOrUid, NonProtonInvitationOrUid, BookmarkOrUid, ShareNodeSettings, UnshareNodeSettings, ShareMembersSettings, SharePublicLinkSettings, SharePublicLinkSettingsObject, ShareResult } from './sharing';
+export type {
+    ProtonInvitation,
+    ProtonInvitationWithNode,
+    NonProtonInvitation,
+    Member,
+    PublicLink,
+    MaybeBookmark,
+    Bookmark,
+    DegradedBookmark,
+    ProtonInvitationOrUid,
+    NonProtonInvitationOrUid,
+    BookmarkOrUid,
+    ShareNodeSettings,
+    UnshareNodeSettings,
+    ShareMembersSettings,
+    SharePublicLinkSettings,
+    SharePublicLinkSettingsObject,
+    ShareResult,
+} from './sharing';
 export { NonProtonInvitationState } from './sharing';
-export type { Telemetry, Logger, MetricAPIRetrySucceededEvent, MetricUploadEvent, MetricsUploadErrorType, MetricDownloadEvent, MetricsDownloadErrorType, MetricDecryptionErrorEvent, MetricsDecryptionErrorField, MetricVerificationErrorEvent, MetricVerificationErrorField, MetricBlockVerificationErrorEvent, MetricVolumeEventsSubscriptionsChangedEvent, MetricEvent } from './telemetry';
+export type {
+    Telemetry,
+    Logger,
+    MetricAPIRetrySucceededEvent,
+    MetricUploadEvent,
+    MetricsUploadErrorType,
+    MetricDownloadEvent,
+    MetricsDownloadErrorType,
+    MetricDecryptionErrorEvent,
+    MetricsDecryptionErrorField,
+    MetricVerificationErrorEvent,
+    MetricVerificationErrorField,
+    MetricBlockVerificationErrorEvent,
+    MetricVolumeEventsSubscriptionsChangedEvent,
+    MetricEvent,
+} from './telemetry';
 export { MetricVolumeType } from './telemetry';
 export type { FileUploader, FileRevisionUploader, UploadController, UploadMetadata } from './upload';
 export type { Thumbnail, ThumbnailResult } from './thumbnail';
@@ -31,20 +88,20 @@ export type ProtonDriveTelemetry = Telemetry<MetricEvent>;
 export type ProtonDriveEntitiesCache = ProtonDriveCache<string>;
 export type ProtonDriveCryptoCache = ProtonDriveCache<CachedCryptoMaterial>;
 export type CachedCryptoMaterial = {
-    passphrase?: string,
-    key: PrivateKey,
-    passphraseSessionKey: SessionKey,
-    hashKey?: Uint8Array,
+    passphrase?: string;
+    key: PrivateKey;
+    passphraseSessionKey: SessionKey;
+    hashKey?: Uint8Array;
 };
 
 export interface ProtonDriveClientContructorParameters {
-    httpClient: ProtonDriveHTTPClient,
-    entitiesCache: ProtonDriveEntitiesCache,
-    cryptoCache: ProtonDriveCryptoCache,
-    account: ProtonDriveAccount,
-    openPGPCryptoModule: OpenPGPCrypto,
-    srpModule: SRPModule,
-    config?: ProtonDriveConfig,
-    telemetry?: ProtonDriveTelemetry,
-    latestEventIdProvider?: LatestEventIdProvider
-};
+    httpClient: ProtonDriveHTTPClient;
+    entitiesCache: ProtonDriveEntitiesCache;
+    cryptoCache: ProtonDriveCryptoCache;
+    account: ProtonDriveAccount;
+    openPGPCryptoModule: OpenPGPCrypto;
+    srpModule: SRPModule;
+    config?: ProtonDriveConfig;
+    telemetry?: ProtonDriveTelemetry;
+    latestEventIdProvider?: LatestEventIdProvider;
+}

package/src/interface/nodes.ts

@@ -22,7 +22,7 @@ export type MaybeNode = Result<NodeEntity, DegradedNode>;
 export type MaybeMissingNode = Result<NodeEntity, DegradedNode | MissingNode>;
 
 export type MissingNode = {
-    missingUid: string,
+    missingUid: string;
 };
 
 /**
@@ -38,9 +38,9 @@ export type MissingNode = {
  * entity is called.
  */
 export type NodeEntity = {
-    uid: string,
-    parentUid?: string,
-    name: string,
+    uid: string;
+    parentUid?: string;
+    name: string;
     /**
      * Author of the node key.
      *
@@ -49,22 +49,22 @@ export type NodeEntity = {
      * author is user B, while key author stays to user A who has forever
      * option to decrypt latest versions.
      */
-    keyAuthor: Author,
+    keyAuthor: Author;
     /**
      * Author of the name.
      *
      * Person who named the file. If user A uploads the file and user B renames
      * the file, key and content author is user A, while name author is user B.
      */
-    nameAuthor: Author,
-    directMemberRole: MemberRole,
-    type: NodeType,
-    mediaType?: string,
+    nameAuthor: Author;
+    directMemberRole: MemberRole;
+    type: NodeType;
+    mediaType?: string;
     /**
      * Whether the node is shared. If true, the node is shared with at least
      * one user, or via public link.
      */
-    isShared: boolean,
+    isShared: boolean;
     /**
      * Provides the ID of the share that the node is shared with.
      *
@@ -73,20 +73,20 @@ export type NodeEntity = {
      *
      * @deprecated This field is not part of the public API.
      */
-    deprecatedShareId?: string,
+    deprecatedShareId?: string;
     /**
      * Created on server date.
      */
-    creationTime: Date,
-    trashTime?: Date,
+    creationTime: Date;
+    trashTime?: Date;
     /**
      * Total size of all revisions, encrypted size on the server.
      */
-    totalStorageSize?: number,
-    activeRevision?: Revision,
+    totalStorageSize?: number;
+    activeRevision?: Revision;
     folder?: {
-        claimedModificationTime?: Date,
-    },
+        claimedModificationTime?: Date;
+    };
     /**
      * Provides an ID for the event scope.
      *
@@ -95,8 +95,8 @@ export type NodeEntity = {
      * comprise one or more folder trees and will be shared by all
      * nodes in the tree. Nodes cannot change scopes.
      */
-    treeEventScopeId: string,
-}
+    treeEventScopeId: string;
+};
 
 /**
  * Degraded node representing a file or folder in the system.
@@ -115,8 +115,8 @@ export type NodeEntity = {
  * possible, but download and upload new revision will still work.
  */
 export type DegradedNode = Omit<NodeEntity, 'name' | 'activeRevision'> & {
-    name: Result<string, Error | InvalidNameError>,
-    activeRevision?: Result<Revision, Error>,
+    name: Result<string, Error | InvalidNameError>;
+    activeRevision?: Result<Revision, Error>;
     /**
      * If the error is not related to any specific field, it is set here.
      *
@@ -127,8 +127,8 @@ export type DegradedNode = Omit<NodeEntity, 'name' | 'activeRevision'> & {
      * the name is still working, this will include the node key error, while
      * the name will be set to the decrypted value.
      */
-    errors?: unknown[],
-}
+    errors?: unknown[];
+};
 
 /**
  * Invalid name error represents node name that includes invalid characters.
@@ -137,13 +137,13 @@ export type InvalidNameError = {
     /**
      * Placeholder instead of node name that client can use to display.
      */
-    name: string,
-    error: string,
-}
+    name: string;
+    error: string;
+};
 
 export enum NodeType {
-    File = "file",
-    Folder = "folder",
+    File = 'file',
+    Folder = 'folder',
     /**
      * Album is a special type available only in Photos section.
      *
@@ -154,44 +154,42 @@ export enum NodeType {
      *
      * @deprecated This type is not part of the public API.
      */
-    Album = "album",
+    Album = 'album',
 }
 
 export enum MemberRole {
-    Viewer = "viewer",
-    Editor = "editor",
-    Admin = "admin",
-    Inherited = "inherited",
+    Viewer = 'viewer',
+    Editor = 'editor',
+    Admin = 'admin',
+    Inherited = 'inherited',
 }
 
 export type Revision = {
-    uid: string,
-    state: RevisionState,
-    creationTime: Date, // created on server date
-    contentAuthor: Author,
+    uid: string;
+    state: RevisionState;
+    creationTime: Date; // created on server date
+    contentAuthor: Author;
     /**
      * Encrypted size of the revision, as stored on the server.
      */
-    storageSize: number,
+    storageSize: number;
     /**
      * Raw size of the revision, as stored in extended attributes.
      */
-    claimedSize?: number,
-    claimedModificationTime?: Date,
+    claimedSize?: number;
+    claimedModificationTime?: Date;
     claimedDigests?: {
-        sha1?: string,
-    },
-    claimedAdditionalMetadata?: object,
-}
+        sha1?: string;
+    };
+    claimedAdditionalMetadata?: object;
+};
 
 export enum RevisionState {
-    Active = "active",
-    Superseded = "superseded",
+    Active = 'active',
+    Superseded = 'superseded',
 }
 
 export type NodeOrUid = MaybeNode | NodeEntity | DegradedNode | string;
 export type RevisionOrUid = Revision | string;
 
-export type NodeResult =
-    {uid: string, ok: true} |
-    {uid: string, ok: false, error: string};
+export type NodeResult = { uid: string; ok: true } | { uid: string; ok: false; error: string };

package/src/interface/result.ts

@@ -1,6 +1,4 @@
-export type Result<T, E> =
-| { ok: true; value: T }
-| { ok: false; error: E };
+export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
 
 export function resultOk<T, E>(value: T): Result<T, E> {
     return { ok: true, value };