@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/diagnostic/interface.ts

@@ -1,5 +1,5 @@
-import { DegradedNode, MaybeNode, MetricEvent } from "../interface";
-import { LogRecord } from "../telemetry";
+import { DegradedNode, MaybeNode, MetricEvent } from '../interface';
+import { LogRecord } from '../telemetry';
 
 export interface Diagnostic {
     verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult>;
@@ -7,11 +7,11 @@ export interface Diagnostic {
 }
 
 export type DiagnosticOptions = {
-    verifyContent?: boolean,
-    verifyThumbnails?: boolean,
-}
+    verifyContent?: boolean;
+    verifyThumbnails?: boolean;
+};
 
-export type DiagnosticResult = 
+export type DiagnosticResult =
     | FatalErrorResult
     | SdkErrorResult
     | HttpErrorResult
@@ -30,129 +30,129 @@ export type DiagnosticResult =
 // Event representing that fatal error occurred during the diagnostic.
 // This error prevents the diagnostic to finish.
 export type FatalErrorResult = {
-    type: 'fatal_error',
-    message: string,
-    error?: unknown,
-}
+    type: 'fatal_error';
+    message: string;
+    error?: unknown;
+};
 
 // Event representing that SDK call failed.
 // It can be any throwable error from any SDK call. Normally no error should be thrown.
 export type SdkErrorResult = {
-    type: 'sdk_error',
-    call: string,
-    error?: unknown,
-}
+    type: 'sdk_error';
+    call: string;
+    error?: unknown;
+};
 
 // Event representing that HTTP call failed.
 // It can be any call from the SDK, including validation error. Normally no error should be present.
 export type HttpErrorResult = {
-    type: 'http_error',
+    type: 'http_error';
     request: {
-        url: string,
-        method: string,
-        json: unknown,
-    },
+        url: string;
+        method: string;
+        json: unknown;
+    };
     // Error if the whole call failed (`fetch` failed).
-    error?: unknown,
+    error?: unknown;
     // Response if the response is not 2xx or 3xx.
     response?: {
-        status: number,
-        statusText: string,
+        status: number;
+        statusText: string;
         // Either json object or error if the response is not JSON.
-        json?: object,
-        jsonError?: unknown,
-    },
-}
+        json?: object;
+        jsonError?: unknown;
+    };
+};
 
 // Event representing that node has some decryption or other (e.g., invalid name) issues.
 export type DegradedNodeResult = {
-    type: 'degraded_node',
-    nodeUid: string,
-    node: DegradedNode,
-}
+    type: 'degraded_node';
+    nodeUid: string;
+    node: DegradedNode;
+};
 
 // Event representing that signature verification failing.
 export type UnverifiedAuthorResult = {
-    type: 'unverified_author',
-    nodeUid: string,
-    revisionUid?: string,
-    authorType: string,
-    claimedAuthor?: string,
-    error: string,
-    node: MaybeNode,
-}
+    type: 'unverified_author';
+    nodeUid: string;
+    revisionUid?: string;
+    authorType: string;
+    claimedAuthor?: string;
+    error: string;
+    node: MaybeNode;
+};
 
 // Event representing that field from the extended attributes is not valid format.
 // Currently only `sha1` verification is supported.
 export type ExtendedAttributesErrorResult = {
-    type: 'extended_attributes_error',
-    nodeUid: string,
-    revisionUid?: string,
-    field: 'sha1',
-    value: string,
-}
+    type: 'extended_attributes_error';
+    nodeUid: string;
+    revisionUid?: string;
+    field: 'sha1';
+    value: string;
+};
 
 // Event representing that field from the extended attributes is missing.
 // Currently only `sha1` verification is supported.
 export type ExtendedAttributesMissingFieldResult = {
-    type: 'extended_attributes_missing_field',
-    nodeUid: string,
-    revisionUid?: string,
-    missingField: 'sha1',
-}
+    type: 'extended_attributes_missing_field';
+    nodeUid: string;
+    revisionUid?: string;
+    missingField: 'sha1';
+};
 
 // Event representing that file is missing the active revision.
 export type ContentFileMissingRevisionResult = {
-    type: 'content_file_missing_revision',
-    nodeUid: string,
-    revisionUid?: string,
-}
+    type: 'content_file_missing_revision';
+    nodeUid: string;
+    revisionUid?: string;
+};
 
 // Event representing that file content is not valid - either sha1 or size is not correct.
 export type ContentIntegrityErrorResult = {
-    type: 'content_integrity_error',
-    nodeUid: string,
-    revisionUid?: string,
-    claimedSha1?: string,
-    computedSha1?: string,
-    claimedSizeInBytes?: number,
-    computedSizeInBytes?: number,
-}
+    type: 'content_integrity_error';
+    nodeUid: string;
+    revisionUid?: string;
+    claimedSha1?: string;
+    computedSha1?: string;
+    claimedSizeInBytes?: number;
+    computedSizeInBytes?: number;
+};
 
 // Event representing that downloading the file content failed.
 // This can be connection issue or server error. If its integrity issue,
 // it should be reported as `ContentIntegrityErrorResult`.
 export type ContentDownloadErrorResult = {
-    type: 'content_download_error',
-    nodeUid: string,
-    revisionUid?: string,
-    error: unknown,
-}
+    type: 'content_download_error';
+    nodeUid: string;
+    revisionUid?: string;
+    error: unknown;
+};
 
 // Event representing that getting the thumbnails failed.
 // This can be connection issue or server error.
 export type ThumbnailsErrorResult = {
-    type: 'thumbnails_error',
-    nodeUid: string,
-    revisionUid?: string,
-    message?: string,
-    error?: unknown,
-}
+    type: 'thumbnails_error';
+    nodeUid: string;
+    revisionUid?: string;
+    message?: string;
+    error?: unknown;
+};
 
 // Event representing errors logged during the diagnostic.
 export type LogErrorResult = {
-    type: 'log_error',
-    log: LogRecord,
-}
+    type: 'log_error';
+    log: LogRecord;
+};
 
 // Event representing warnings logged during the diagnostic.
 export type LogWarningResult = {
-    type: 'log_warning',
-    log: LogRecord,
-}
+    type: 'log_warning';
+    log: LogRecord;
+};
 
 // Event representing metrics logged during the diagnostic.
 export type MetricResult = {
-    type: 'metric',
-    event: MetricEvent,
-}
+    type: 'metric';
+    event: MetricEvent;
+};

package/src/diagnostic/sdkDiagnostic.ts

@@ -1,7 +1,7 @@
-import { Author, FileDownloader, MaybeNode, NodeType, Revision, ThumbnailType } from "../interface";
-import { ProtonDriveClient } from "../protonDriveClient";
-import { Diagnostic, DiagnosticOptions, DiagnosticResult } from "./interface";
-import { IntegrityVerificationStream } from "./integrityVerificationStream";
+import { Author, FileDownloader, MaybeNode, NodeType, Revision, ThumbnailType } from '../interface';
+import { ProtonDriveClient } from '../protonDriveClient';
+import { Diagnostic, DiagnosticOptions, DiagnosticResult } from './interface';
+import { IntegrityVerificationStream } from './integrityVerificationStream';
 
 /**
  * Diagnostic tool that uses SDK to traverse the node tree and verify
@@ -15,7 +15,7 @@ export class SDKDiagnostic implements Diagnostic {
         this.protonDriveClient = protonDriveClient;
     }
 
-    async* verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    async *verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         let myFilesRootFolder: MaybeNode;
 
         try {
@@ -32,7 +32,7 @@ export class SDKDiagnostic implements Diagnostic {
         yield* this.verifyNodeTree(myFilesRootFolder, options);
     }
 
-    async* verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    async *verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         const isFolder = getNodeType(node) === NodeType.Folder;
 
         yield* this.verifyNode(node, options);
@@ -42,7 +42,7 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async* verifyNode(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    private async *verifyNode(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         const nodeUid = node.ok ? node.value.uid : node.error.uid;
 
         if (!node.ok) {
@@ -57,10 +57,16 @@ export class SDKDiagnostic implements Diagnostic {
         const nodeInfo = {
             ...getNodeUids(node),
             node,
-        }
-
-        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, { ...nodeInfo, authorType: 'key' });
-        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, { ...nodeInfo, authorType: 'name' });
+        };
+
+        yield* this.verifyAuthor(node.ok ? node.value.keyAuthor : node.error.keyAuthor, {
+            ...nodeInfo,
+            authorType: 'key',
+        });
+        yield* this.verifyAuthor(node.ok ? node.value.nameAuthor : node.error.nameAuthor, {
+            ...nodeInfo,
+            authorType: 'name',
+        });
         if (activeRevision) {
             yield* this.verifyAuthor(activeRevision.contentAuthor, { ...nodeInfo, authorType: 'content' });
         }
@@ -75,7 +81,10 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async* verifyAuthor(author: Author, info: { nodeUid: string, authorType: string, revisionUid?: string, node: MaybeNode }): AsyncGenerator<DiagnosticResult> {
+    private async *verifyAuthor(
+        author: Author,
+        info: { nodeUid: string; authorType: string; revisionUid?: string; node: MaybeNode },
+    ): AsyncGenerator<DiagnosticResult> {
         if (!author.ok) {
             yield {
                 type: 'unverified_author',
@@ -86,7 +95,7 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async* verifyFileExtendedAttributes(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
+    private async *verifyFileExtendedAttributes(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
         const activeRevision = getActiveRevision(node);
 
         const expectedAttributes = getNodeType(node) === NodeType.File;
@@ -98,7 +107,7 @@ export class SDKDiagnostic implements Diagnostic {
                 ...getNodeUids(node),
                 field: 'sha1',
                 value: claimedSha1,
-            }
+            };
         }
 
         if (expectedAttributes && !claimedSha1) {
@@ -106,11 +115,11 @@ export class SDKDiagnostic implements Diagnostic {
                 type: 'extended_attributes_missing_field',
                 ...getNodeUids(node),
                 missingField: 'sha1',
-            }
+            };
         }
     }
 
-    private async* verifyContent(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
+    private async *verifyContent(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
         if (getNodeType(node) !== NodeType.File) {
             return;
         }
@@ -119,7 +128,7 @@ export class SDKDiagnostic implements Diagnostic {
             yield {
                 type: 'content_file_missing_revision',
                 nodeUid: node.ok ? node.value.uid : node.error.uid,
-            }
+            };
             return;
         }
 
@@ -165,7 +174,7 @@ export class SDKDiagnostic implements Diagnostic {
         }
     }
 
-    private async* verifyThumbnails(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
+    private async *verifyThumbnails(node: MaybeNode): AsyncGenerator<DiagnosticResult> {
         if (getNodeType(node) !== NodeType.File) {
             return;
         }
@@ -173,14 +182,16 @@ export class SDKDiagnostic implements Diagnostic {
         const nodeUid = node.ok ? node.value.uid : node.error.uid;
 
         try {
-            const result = await Array.fromAsync(this.protonDriveClient.iterateThumbnails([nodeUid], ThumbnailType.Type1));
+            const result = await Array.fromAsync(
+                this.protonDriveClient.iterateThumbnails([nodeUid], ThumbnailType.Type1),
+            );
 
             if (result.length === 0) {
                 yield {
                     type: 'sdk_error',
                     call: `iterateThumbnails(${nodeUid})`,
                     error: new Error('No thumbnails found'),
-                }
+                };
             }
             // TODO: We should have better way to check if the thumbnail is not expected.
             if (!result[0].ok && result[0].error !== 'Node has no thumbnail') {
@@ -188,18 +199,18 @@ export class SDKDiagnostic implements Diagnostic {
                     type: 'thumbnails_error',
                     nodeUid,
                     error: result[0].error,
-                }
+                };
             }
         } catch (error: unknown) {
             yield {
                 type: 'sdk_error',
                 call: `iterateThumbnails(${nodeUid})`,
                 error,
-            }
+            };
         }
     }
 
-    private async* verifyNodeChildren(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    private async *verifyNodeChildren(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         const nodeUid = node.ok ? node.value.uid : node.error.uid;
         try {
             for await (const child of this.protonDriveClient.iterateFolderChildren(node)) {
@@ -215,7 +226,7 @@ export class SDKDiagnostic implements Diagnostic {
     }
 }
 
-function getNodeUids(node: MaybeNode): { nodeUid: string, revisionUid?: string } {
+function getNodeUids(node: MaybeNode): { nodeUid: string; revisionUid?: string } {
     const activeRevision = getActiveRevision(node);
     return {
         nodeUid: node.ok ? node.value.uid : node.error.uid,

package/src/diagnostic/sdkDiagnosticFull.ts

@@ -1,40 +1,37 @@
-import { MaybeNode } from "../interface";
-import { DiagnosticHTTPClient } from "./httpClient";
-import { Diagnostic, DiagnosticOptions, DiagnosticResult } from "./interface";
-import { DiagnosticTelemetry } from "./telemetry";
-import { zipGenerators } from "./zipGenerators";
+import { MaybeNode } from '../interface';
+import { DiagnosticHTTPClient } from './httpClient';
+import { Diagnostic, DiagnosticOptions, DiagnosticResult } from './interface';
+import { DiagnosticTelemetry } from './telemetry';
+import { zipGenerators } from './zipGenerators';
 
 /**
  * Diagnostic tool that produces full diagnostic, including logs and metrics
  * by reading the events from the telemetry and HTTP client.
  */
 export class FullSDKDiagnostic implements Diagnostic {
-    constructor(private diagnostic: Diagnostic, private telemetry: DiagnosticTelemetry, private httpClient: DiagnosticHTTPClient) {
+    constructor(
+        private diagnostic: Diagnostic,
+        private telemetry: DiagnosticTelemetry,
+        private httpClient: DiagnosticHTTPClient,
+    ) {
         this.diagnostic = diagnostic;
         this.telemetry = telemetry;
         this.httpClient = httpClient;
     }
 
-    async* verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    async *verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         yield* this.yieldEvents(this.diagnostic.verifyMyFiles(options));
     }
 
-    async* verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
+    async *verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
         yield* this.yieldEvents(this.diagnostic.verifyNodeTree(node, options));
     }
 
-    private async* yieldEvents(generator: AsyncGenerator<DiagnosticResult>): AsyncGenerator<DiagnosticResult> {
-        yield* zipGenerators(
-            generator,
-            this.internalGenerator(),
-            { stopOnFirstDone: true },
-        );
+    private async *yieldEvents(generator: AsyncGenerator<DiagnosticResult>): AsyncGenerator<DiagnosticResult> {
+        yield* zipGenerators(generator, this.internalGenerator(), { stopOnFirstDone: true });
     }
 
-    private async* internalGenerator(): AsyncGenerator<DiagnosticResult> {
-        yield* zipGenerators(
-            this.telemetry.iterateEvents(),
-            this.httpClient.iterateEvents(),
-        );
+    private async *internalGenerator(): AsyncGenerator<DiagnosticResult> {
+        yield* zipGenerators(this.telemetry.iterateEvents(), this.httpClient.iterateEvents());
     }
 }

package/src/diagnostic/telemetry.ts

@@ -36,7 +36,10 @@ export class DiagnosticTelemetry extends EventsGenerator {
 }
 
 class Logger {
-    constructor(private name: string, private callback?: (log: LogRecord) => void) {
+    constructor(
+        private name: string,
+        private callback?: (log: LogRecord) => void,
+    ) {
         this.name = name;
         this.callback = callback;
     }

package/src/diagnostic/zipGenerators.test.ts

@@ -2,7 +2,7 @@ import { zipGenerators } from './zipGenerators';
 
 async function* createTimedGenerator<T>(values: { value: T; delay: number }[]): AsyncGenerator<T> {
     for (const { value, delay } of values) {
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await new Promise((resolve) => setTimeout(resolve, delay));
         yield value;
     }
 }

package/src/diagnostic/zipGenerators.ts

@@ -8,7 +8,7 @@ export async function* zipGenerators<T, U>(
     genA: AsyncGenerator<T>,
     genB: AsyncGenerator<U>,
     options?: {
-        stopOnFirstDone?: boolean
+        stopOnFirstDone?: boolean;
     },
 ): AsyncGenerator<T | U> {
     const { stopOnFirstDone = false } = options || {};
@@ -21,8 +21,8 @@ export async function* zipGenerators<T, U>(
 
     while (promiseA && promiseB) {
         const result = await Promise.race([
-            promiseA.then(res => ({ source: 'A' as const, result: res })),
-            promiseB.then(res => ({ source: 'B' as const, result: res }))
+            promiseA.then((res) => ({ source: 'A' as const, result: res })),
+            promiseB.then((res) => ({ source: 'B' as const, result: res })),
         ]);
 
         if (result.source === 'A') {

package/src/errors.ts

@@ -2,13 +2,13 @@ import { c } from 'ttag';
 
 /**
  * Base class for all SDK errors.
- * 
+ *
  * This class can be used for catching all SDK errors. The error should have
  * translated message in the `message` property that should be shown to the
  * user without any modification.
- * 
+ *
  * No retries should be done as that is already handled by the SDK.
- * 
+ *
  * When SDK throws an error and it is not `ProtonDriveError`, it is unhandled error
  * by the SDK and usually indicates bug in the SDK. Please, report it.
  */
@@ -18,7 +18,7 @@ export class ProtonDriveError extends Error {
 
 /**
  * Error thrown when the operation is aborted.
- * 
+ *
  * This error is thrown when the operation is aborted by the user.
  * For example, by calling `abort()` on the `AbortSignal`.
  */
@@ -32,7 +32,7 @@ export class AbortError extends ProtonDriveError {
 
 /**
  * Error thrown when the validation fails.
- * 
+ *
  * This error is thrown when the validation of the input fails.
  * Validation can be done on the client side or on the server side.
  *
@@ -45,7 +45,7 @@ export class ValidationError extends ProtonDriveError {
 
     /**
      * Internal API code.
-     * 
+     *
      * Use only for debugging purposes.
      */
     public readonly code?: number;
@@ -64,7 +64,7 @@ export class ValidationError extends ProtonDriveError {
 
 /**
  * Error thrown when the node already exists.
- * 
+ *
  * This error is thrown when the node with the same name already exists in the
  * parent folder. The client should ask the user to replace the existing node
  * or choose another name. The available name is provided in the `availableName`
@@ -86,11 +86,11 @@ export class NodeAlreadyExistsValidationError extends ValidationError {
 
 /**
  * Error thrown when the API call fails.
- * 
+ *
  * This error covers both HTTP errors and API errors. SDK automatically
  * retries the request before the error is thrown. The sepcific algorithm
  * used for retries depends on the type of the error.
- * 
+ *
  * Client should not retry the request when this error is thrown.
  */
 export class ServerError extends ProtonDriveError {
@@ -98,13 +98,13 @@ export class ServerError extends ProtonDriveError {
 
     /**
      * HTTP status code of the response.
-     * 
+     *
      * Use only for debugging purposes.
      */
     public readonly statusCode?: number;
     /**
      * Internal API code.
-     * 
+     *
      * Use only for debugging purposes.
      */
     public readonly code?: number;
@@ -112,16 +112,16 @@ export class ServerError extends ProtonDriveError {
 
 /**
  * Error thrown when the client makes too many requests to the API.
- * 
+ *
  * SDK is configured to stay below the rate limits, but it can still happen if
  * client is running multiple SDKs in parallel, or if the rate limits are
  * changed on the server side.
- * 
+ *
  * SDK automatically retries the request before the error is thrown after
  * waiting for the required time specified by the server.
- * 
+ *
  * Client should slow down calling SDK when this error is thrown.
- * 
+ *
  * You can be also notified about the rate limits by the `requestsThrottled`
  * event. See `onMessage` method on the SDK class for more details.
  */
@@ -133,9 +133,9 @@ export class RateLimitedError extends ServerError {
 
 /**
  * Error thrown when the client is not connected to the internet.
- * 
+ *
  * Client should check the internet connection when this error is thrown.
- * 
+ *
  * You can also be notified about the connection status by the `offline` event
  * See `onMessage` method on the SDK class for more details.
  */
@@ -145,9 +145,9 @@ export class ConnectionError extends ProtonDriveError {
 
 /**
  * Error thrown when the decryption fails.
- * 
+ *
  * Client should report this error to the user and report bug report.
- * 
+ *
  * In most cases, there is no decryption error. Every decryption error should
  * be not exposed but set as empty value on the node, for example. But in the
  * case of the file content, if block cannot be decrypted, decryption error
@@ -159,9 +159,9 @@ export class DecryptionError extends ProtonDriveError {
 
 /**
  * Error thrown when the data integrity check fails.
- * 
+ *
  * Client should report this error to the user and report bug report.
- * 
+ *
  * For example, it can happen when hashes don't match, etc. In some cases,
  * SDK allows to run command without verification checks for debug purposes.
  */

package/src/index.ts

@@ -14,12 +14,12 @@ export { VERSION } from './version';
 
 /**
  * Provides the node UID for the given raw volume and node IDs.
- * 
+ *
  * This is required only for the internal implementation to provide
  * backward compatibility with the old Drive web setup.
- * 
+ *
  * If you are having share ID, use `ProtonDriveClient::getNodeUid` instead.
- * 
+ *
  * @deprecated This method is not part of the public API.
  * @param volumeId - Volume of the node.
  * @param nodeId - Node/link ID (not UID).