@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/interface/httpClient.ts

@@ -4,39 +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,
-}
-
-export type ProtonDriveConfig = {
-    /**
-     * The base URL for the Proton Drive (without schema).
-     *
-     * If not provided, defaults to 'drive-api.proton.me'.
-     */
-    baseUrl?: string,
-
-    /**
-     * The language to use for error messages.
-     *
-     * If not provided, defaults to 'en'.
-     */
-    language?: string,
-}
+    timeoutMs: number;
+    signal?: AbortSignal;
+};

package/src/interface/index.ts

@@ -1,24 +1,84 @@
 import { ProtonDriveCache } from '../cache';
 import { OpenPGPCrypto, PrivateKey, SessionKey, SRPModule } from '../crypto';
+import { LatestEventIdProvider } from '../internal/events/interface';
 import { ProtonDriveAccount } from './account';
-import { ProtonDriveHTTPClient, ProtonDriveConfig } from './httpClient';
+import { ProtonDriveConfig } from './config';
+import { ProtonDriveHTTPClient } from './httpClient';
 import { Telemetry, MetricEvent } 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 { ProtonDriveConfig } from './config';
 export type { Device, DeviceOrUid } from './devices';
 export { DeviceType } from './devices';
 export type { FileDownloader, DownloadController } from './download';
-export type { NodeEvent, DeviceEvent, DeviceEventCallback, NodeEventCallback } from './events';
-export { SDKEvent } from './events';
-export type { ProtonDriveHTTPClient, ProtonDriveHTTPClientJsonOptions, ProtonDriveHTTPClientBlobOptions, ProtonDriveConfig } from './httpClient';
-export type { MaybeNode, NodeEntity, DegradedNode, MaybeMissingNode, MissingNode, InvalidNameError, Revision, NodeOrUid, RevisionOrUid, NodeResult } from './nodes';
+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 { 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';
@@ -28,19 +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,
-};
+    httpClient: ProtonDriveHTTPClient;
+    entitiesCache: ProtonDriveEntitiesCache;
+    cryptoCache: ProtonDriveCryptoCache;
+    account: ProtonDriveAccount;
+    openPGPCryptoModule: OpenPGPCrypto;
+    srpModule: SRPModule;
+    config?: ProtonDriveConfig;
+    telemetry?: ProtonDriveTelemetry;
+    latestEventIdProvider?: LatestEventIdProvider;
+}

package/src/interface/nodes.ts

@@ -3,7 +3,7 @@ import { Author } from './author';
 
 /**
  * Node representing a file or folder in the system.
- * 
+ *
  * This covers both happy path and degraded path. It is used in the SDK to
  * represent the node in a way that is easy to work with. Whenever any field
  * cannot be decrypted, it is returned as `DegradedNode` type.
@@ -12,7 +12,7 @@ export type MaybeNode = Result<NodeEntity, DegradedNode>;
 
 /**
  * Node representing a file or folder in the system, or missing node.
- * 
+ *
  * In most cases, SDK returns `MaybeNode`, but in some specific cases, when
  * client is requesting specific nodes, SDK must return `MissingNode` type
  * to indicate the case when the node is not available. That can be when
@@ -22,49 +22,49 @@ export type MaybeNode = Result<NodeEntity, DegradedNode>;
 export type MaybeMissingNode = Result<NodeEntity, DegradedNode | MissingNode>;
 
 export type MissingNode = {
-    missingUid: string,
+    missingUid: string;
 };
 
 /**
  * Node representing a file or folder in the system.
- * 
+ *
  * This is a happy path representation of the node. It is used in the SDK to
  * represent the node in a way that is easy to work with. Whenever any field
  * cannot be decrypted, it is returned as `DegradedNode` type.
- * 
+ *
  * SDK never returns this entity directly but wrapped in `MaybeNode`.
  *
  * Note on naming: Node is reserved by JS/DOM, thus we need exception how the
  * entity is called.
  */
 export type NodeEntity = {
-    uid: string,
-    parentUid?: string,
-    name: string,
+    uid: string;
+    parentUid?: string;
+    name: string;
     /**
      * Author of the node key.
-     * 
+     *
      * Person who created the node and keys for it. If user A uploads the file
      * and user B renames the file and uploads new revision, name and content
      * 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,53 +73,62 @@ 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.
+     *
+     * By subscribing to events in a scope, all updates to nodes
+     * withing that scope will be passed to the client. The scope can
+     * comprise one or more folder trees and will be shared by all
+     * nodes in the tree. Nodes cannot change scopes.
+     */
+    treeEventScopeId: string;
+};
 
 /**
  * Degraded node representing a file or folder in the system.
- * 
+ *
  * This is a degraded path representation of the node. It is used in the SDK to
  * represent the node in a way that is easy to work with. Whenever any field
  * cannot be decrypted, it is returned as `DegradedNode` type.
- * 
+ *
  * SDK never returns this entity directly but wrapped in `MaybeNode`.
- * 
+ *
  * The node can be still used around, but it is not guaranteed that all
  * properties are decrypted, or that all actions can be performed on it.
- * 
+ *
  * For example, if the node has issue decrypting the name, the name will be
  * set as `Error` and potentially rename or move actions will not be
  * 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.
-     * 
+     *
      * For example, if the node has issue decrypting the name, the name will be
      * set as `Error` while this will be empty.
-     * 
+     *
      * On the other hand, if the node has issue decrypting the node key, but
      * 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.
@@ -128,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.
      *
@@ -145,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 };

package/src/interface/sharing.ts

@@ -3,107 +3,111 @@ import { UnverifiedAuthorError } from './author';
 import { NodeType, MemberRole, InvalidNameError } from './nodes';
 
 export type Member = {
-    uid: string,
-    invitationTime: Date,
-    addedByEmail: Result<string, UnverifiedAuthorError>,
-    inviteeEmail: string,
-    role: MemberRole,
-}
+    uid: string;
+    invitationTime: Date;
+    addedByEmail: Result<string, UnverifiedAuthorError>;
+    inviteeEmail: string;
+    role: MemberRole;
+};
 
 export type ProtonInvitation = Member;
 
 export type ProtonInvitationWithNode = ProtonInvitation & {
     node: {
-        name: Result<string, Error | InvalidNameError>,
-        type: NodeType,
-        mediaType?: string,
-    },
-}
+        uid: string;
+        name: Result<string, Error | InvalidNameError>;
+        type: NodeType;
+        mediaType?: string;
+    };
+};
 
 export type NonProtonInvitation = ProtonInvitation & {
-    state: NonProtonInvitationState,
-}
+    state: NonProtonInvitationState;
+};
 
 export enum NonProtonInvitationState {
-    Pending = "pending",
-    UserRegistered = "userRegistered",
+    Pending = 'pending',
+    UserRegistered = 'userRegistered',
 }
 
 export type PublicLink = {
-    uid: string,
-    creationTime: Date,
-    role: MemberRole,
-    url: string,
-    customPassword?: string,
-    expirationTime?: Date,
-}
+    uid: string;
+    creationTime: Date;
+    role: MemberRole;
+    url: string;
+    customPassword?: string;
+    expirationTime?: Date;
+    numberOfInitializedDownloads: number;
+};
 
 /**
  * Bookmark representing a saved link to publicly shared node.
- * 
+ *
  * This covers both happy path and degraded path.
  */
 export type MaybeBookmark = Result<Bookmark, DegradedBookmark>;
 
 export type Bookmark = {
-    uid: string,
-    creationTime: Date,
-    url: string,
+    uid: string;
+    creationTime: Date;
+    url: string;
     node: {
-        name: string,
-        type: NodeType,
-        mediaType?: string,
-    },
-}
+        name: string;
+        type: NodeType;
+        mediaType?: string;
+    };
+};
 
 /**
  * Degraded bookmark representing a saved link to publicly shared node.
- * 
+ *
  * This is a degraded path representation of the bookmark. It is used in the
  * SDK to represent the bookmark in a way that is easy to work with. Whenever
  * any field cannot be decrypted, it is returned as `DegradedBookmark` type.
  */
 export type DegradedBookmark = Omit<Bookmark, 'url' | 'node'> & {
-    url: Result<string, Error>,
+    url: Result<string, Error>;
     node: Omit<Bookmark['node'], 'name'> & {
-        name: Result<string, Error | InvalidNameError>,
-    },
-}
+        name: Result<string, Error | InvalidNameError>;
+    };
+};
 
 export type ProtonInvitationOrUid = ProtonInvitation | string;
 export type NonProtonInvitationOrUid = NonProtonInvitation | string;
 export type BookmarkOrUid = Bookmark | string;
 
 export type ShareNodeSettings = {
-    users?: ShareMembersSettings,
-    publicLink?: SharePublicLinkSettings,
+    users?: ShareMembersSettings;
+    publicLink?: SharePublicLinkSettings;
     emailOptions?: {
-        message?: string,
-        includeNodeName?: boolean,
-    },
-}
+        message?: string;
+        includeNodeName?: boolean;
+    };
+};
 
-export type ShareMembersSettings = string[] | {
-    email: string,
-    role: MemberRole,
-}[];
+export type ShareMembersSettings =
+    | string[]
+    | {
+          email: string;
+          role: MemberRole;
+      }[];
 
 export type SharePublicLinkSettings = boolean | SharePublicLinkSettingsObject;
 
 export type SharePublicLinkSettingsObject = {
-    role: MemberRole,
-    customPassword?: string | undefined,
-    expiration?: Date | undefined,
+    role: MemberRole;
+    customPassword?: string | undefined;
+    expiration?: Date | undefined;
 };
 
 export type ShareResult = {
-    protonInvitations: ProtonInvitation[],
-    nonProtonInvitations: NonProtonInvitation[],
-    members: Member[],
-    publicLink?: PublicLink,
-}
+    protonInvitations: ProtonInvitation[];
+    nonProtonInvitations: NonProtonInvitation[];
+    members: Member[];
+    publicLink?: PublicLink;
+};
 
 export type UnshareNodeSettings = {
-    users?: string[],
-    publicLink?: 'remove',
+    users?: string[];
+    publicLink?: 'remove';
 };