@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/interface/telemetry.ts

@@ -1,6 +1,6 @@
 export interface Telemetry<MetricEvent> {
-    getLogger: (name: string) => Logger,
-    logEvent: (event: MetricEvent) => void,
+    getLogger: (name: string) => Logger;
+    logEvent: (event: MetricEvent) => void;
 }
 
 export interface Logger {
@@ -11,98 +11,98 @@ export interface Logger {
 }
 
 export type MetricEvent =
-    MetricAPIRetrySucceededEvent |
-    MetricUploadEvent |
-    MetricDownloadEvent |
-    MetricDecryptionErrorEvent |
-    MetricVerificationErrorEvent |
-    MetricBlockVerificationErrorEvent |
-    MetricVolumeEventsSubscriptionsChangedEvent;
+    | MetricAPIRetrySucceededEvent
+    | MetricUploadEvent
+    | MetricDownloadEvent
+    | MetricDecryptionErrorEvent
+    | MetricVerificationErrorEvent
+    | MetricBlockVerificationErrorEvent
+    | MetricVolumeEventsSubscriptionsChangedEvent;
 
 export interface MetricAPIRetrySucceededEvent {
-    eventName: 'apiRetrySucceeded',
-    url: string,
-    failedAttempts: number,
-};
+    eventName: 'apiRetrySucceeded';
+    url: string;
+    failedAttempts: number;
+}
 
 export interface MetricUploadEvent {
-    eventName: 'upload',
-    volumeType?: MetricVolumeType,
-    uploadedSize: number,
-    expectedSize: number,
-    error?: MetricsUploadErrorType,
-    originalError?: unknown,
-};
+    eventName: 'upload';
+    volumeType?: MetricVolumeType;
+    uploadedSize: number;
+    expectedSize: number;
+    error?: MetricsUploadErrorType;
+    originalError?: unknown;
+}
 export type MetricsUploadErrorType =
-    'server_error' |
-    'network_error' |
-    'integrity_error' |
-    'rate_limited' |
-    '4xx' |
-    'unknown';
+    | 'server_error'
+    | 'network_error'
+    | 'integrity_error'
+    | 'rate_limited'
+    | '4xx'
+    | 'unknown';
 
 export interface MetricDownloadEvent {
-    eventName: 'download',
-    volumeType?: MetricVolumeType,
-    downloadedSize: number,
-    claimedFileSize?: number,
-    error?: MetricsDownloadErrorType,
-    originalError?: unknown,
-};
+    eventName: 'download';
+    volumeType?: MetricVolumeType;
+    downloadedSize: number;
+    claimedFileSize?: number;
+    error?: MetricsDownloadErrorType;
+    originalError?: unknown;
+}
 export type MetricsDownloadErrorType =
-    'server_error' |
-    'network_error' |
-    'decryption_error' |
-    'integrity_error' |
-    'rate_limited' |
-    '4xx' |
-    'unknown';
+    | 'server_error'
+    | 'network_error'
+    | 'decryption_error'
+    | 'integrity_error'
+    | 'rate_limited'
+    | '4xx'
+    | 'unknown';
 
 export interface MetricDecryptionErrorEvent {
-    eventName: 'decryptionError',
-    volumeType?: MetricVolumeType,
-    field: MetricsDecryptionErrorField,
-    fromBefore2024?: boolean,
-    error?: unknown,
-};
+    eventName: 'decryptionError';
+    volumeType?: MetricVolumeType;
+    field: MetricsDecryptionErrorField;
+    fromBefore2024?: boolean;
+    error?: unknown;
+}
 export type MetricsDecryptionErrorField =
-    'shareKey' |
-    'shareUrlPassword' |
-    'nodeKey' |
-    'nodeName' |
-    'nodeHashKey' |
-    'nodeExtendedAttributes' |
-    'nodeContentKey' |
-    'content';
+    | 'shareKey'
+    | 'shareUrlPassword'
+    | 'nodeKey'
+    | 'nodeName'
+    | 'nodeHashKey'
+    | 'nodeExtendedAttributes'
+    | 'nodeContentKey'
+    | 'content';
 
 export interface MetricVerificationErrorEvent {
-    eventName: 'verificationError',
-    volumeType?: MetricVolumeType,
-    field: MetricVerificationErrorField,
-    addressMatchingDefaultShare?: boolean,
-    fromBefore2024?: boolean,
-};
+    eventName: 'verificationError';
+    volumeType?: MetricVolumeType;
+    field: MetricVerificationErrorField;
+    addressMatchingDefaultShare?: boolean;
+    fromBefore2024?: boolean;
+}
 export type MetricVerificationErrorField =
-    'shareKey' |
-    'nodeKey' |
-    'nodeName' |
-    'nodeHashKey' |
-    'nodeExtendedAttributes' |
-    'nodeContentKey' |
-    'content';
+    | 'shareKey'
+    | 'nodeKey'
+    | 'nodeName'
+    | 'nodeHashKey'
+    | 'nodeExtendedAttributes'
+    | 'nodeContentKey'
+    | 'content';
 
 export interface MetricBlockVerificationErrorEvent {
-    eventName: 'blockVerificationError',
-    retryHelped: boolean,
-};
+    eventName: 'blockVerificationError';
+    retryHelped: boolean;
+}
 
 export interface MetricVolumeEventsSubscriptionsChangedEvent {
-    eventName: 'volumeEventsSubscriptionsChanged',
-    numberOfVolumeSubscriptions: number,
-};
+    eventName: 'volumeEventsSubscriptionsChanged';
+    numberOfVolumeSubscriptions: number;
+}
 
 export enum MetricVolumeType {
     OwnVolume = 'own_volume',
     Shared = 'shared',
     SharedPublic = 'shared_public',
-};
+}

package/src/interface/thumbnail.ts

@@ -1,8 +1,7 @@
-
 export type Thumbnail = {
-    type: ThumbnailType,
-    thumbnail: Uint8Array,
-}
+    type: ThumbnailType;
+    thumbnail: Uint8Array;
+};
 
 export enum ThumbnailType {
     Type1 = 1,
@@ -10,5 +9,5 @@ export enum ThumbnailType {
 }
 
 export type ThumbnailResult =
-    {nodeUid: string, ok: true, thumbnail: Uint8Array } |
-    {nodeUid: string, ok: false, error: string};
+    | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+    | { nodeUid: string; ok: false; error: string };

package/src/interface/upload.ts

@@ -1,7 +1,7 @@
-import { Thumbnail } from "./thumbnail";
+import { Thumbnail } from './thumbnail';
 
 export type UploadMetadata = {
-    mediaType: string,
+    mediaType: string;
     /**
      * Expected size of the file.
      *
@@ -9,13 +9,13 @@ export type UploadMetadata = {
      * If the expected size does not match the actual size, the upload will
      * fail.
      */
-    expectedSize: number,
+    expectedSize: number;
     /**
      * Modification time of the file.
      *
      * The modification time will be encrypted and stored with the file.
      */
-    modificationTime?: Date,
+    modificationTime?: Date;
     /**
      * Additional metadata to be stored with the file.
      *
@@ -23,7 +23,13 @@ export type UploadMetadata = {
      *
      * The metadata will be encrypted and stored with the file.
      */
-    additionalMetadata?: object,
+    additionalMetadata?: object;
+    /**
+     * If there is an existing draft by another client, the upload will be
+     * rejected. If user decides to override the existing draft and continue
+     * with the upload, set this to true.
+     */
+    overrideExistingDraftByOtherClient?: boolean;
 };
 
 export interface FileRevisionUploader {
@@ -35,7 +41,11 @@ export interface FileRevisionUploader {
      *
      * The function will reject if the node with the given name already exists.
      */
-    writeStream(stream: ReadableStream, thumnbails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<UploadController>,
+    writeStream(
+        stream: ReadableStream,
+        thumnbails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<UploadController>;
 
     /**
      * Uploads a file from a file object. It is convenient to use this method
@@ -47,7 +57,11 @@ export interface FileRevisionUploader {
      *
      * The function will reject if the node with the given name already exists.
      */
-    writeFile(fileObject: File, thumnbails: Thumbnail[], onProgress?: (uploadedBytes: number) => void): Promise<UploadController>,
+    writeFile(
+        fileObject: File,
+        thumnbails: Thumbnail[],
+        onProgress?: (uploadedBytes: number) => void,
+    ): Promise<UploadController>;
 }
 
 export interface FileUploader extends FileRevisionUploader {
@@ -59,11 +73,11 @@ export interface FileUploader extends FileRevisionUploader {
      *
      * Example new name: `file (2).txt`.
      */
-    getAvailableName(): Promise<string>,
+    getAvailableName(): Promise<string>;
 }
 
 export interface UploadController {
-    pause(): void,
-    resume(): void,
-    completion(): Promise<string>,
+    pause(): void;
+    resume(): void;
+    completion(): Promise<string>;
 }

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

@@ -1,6 +1,6 @@
-import { ProtonDriveHTTPClient, SDKEvent } from "../../interface";
-import { getMockTelemetry } from "../../tests/telemetry";
-import { SDKEvents } from "../sdkEvents";
+import { ProtonDriveHTTPClient, SDKEvent } from '../../interface';
+import { getMockTelemetry } from '../../tests/telemetry';
+import { SDKEvents } from '../sdkEvents';
 import { DriveAPIService } from './apiService';
 import { HTTPErrorCode, ErrorCode } from './errorCodes';
 
@@ -10,7 +10,7 @@ function generateOkResponse() {
     return new Response(JSON.stringify({ Code: ErrorCode.OK }), { status: HTTPErrorCode.OK });
 }
 
-describe("DriveAPIService", () => {
+describe('DriveAPIService', () => {
     let sdkEvents: SDKEvents;
     let httpClient: ProtonDriveHTTPClient;
     let api: DriveAPIService;
@@ -24,7 +24,7 @@ describe("DriveAPIService", () => {
             transfersResumed: jest.fn(),
             requestsThrottled: jest.fn(),
             requestsUnthrottled: jest.fn(),
-        }
+        };
         httpClient = {
             fetchJson: jest.fn(() => Promise.resolve(generateOkResponse())),
             fetchBlob: jest.fn(() => Promise.resolve(new Response(new Uint8Array([1, 2, 3])))),
@@ -36,23 +36,25 @@ describe("DriveAPIService", () => {
         expect(sdkEvents.transfersPaused).toHaveBeenCalledTimes(events.includes(SDKEvent.TransfersPaused) ? 1 : 0);
         expect(sdkEvents.transfersResumed).toHaveBeenCalledTimes(events.includes(SDKEvent.TransfersResumed) ? 1 : 0);
         expect(sdkEvents.requestsThrottled).toHaveBeenCalledTimes(events.includes(SDKEvent.RequestsThrottled) ? 1 : 0);
-        expect(sdkEvents.requestsUnthrottled).toHaveBeenCalledTimes(events.includes(SDKEvent.RequestsUnthrottled) ? 1 : 0);
+        expect(sdkEvents.requestsUnthrottled).toHaveBeenCalledTimes(
+            events.includes(SDKEvent.RequestsUnthrottled) ? 1 : 0,
+        );
     }
 
-    describe("should make", () => {
-        it("GET request", async () => {
+    describe('should make', () => {
+        it('GET request', async () => {
             const result = await api.get('test');
             expect(result).toEqual({ Code: ErrorCode.OK });
             await expectFetchJsonToBeCalledWith('GET');
         });
 
-        it("POST request", async () => {
+        it('POST request', async () => {
             const result = await api.post('test', { data: 'test' });
             expect(result).toEqual({ Code: ErrorCode.OK });
             await expectFetchJsonToBeCalledWith('POST', { data: 'test' });
         });
 
-        it("PUT request", async () => {
+        it('PUT request', async () => {
             const result = await api.put('test', { data: 'test' });
             expect(result).toEqual({ Code: ErrorCode.OK });
             await expectFetchJsonToBeCalledWith('PUT', { data: 'test' });
@@ -63,24 +65,28 @@ describe("DriveAPIService", () => {
             const request = httpClient.fetchJson.mock.calls[0][0];
             expect(request.method).toEqual(method);
             expect(request.timeoutMs).toEqual(30000);
-            expect(Array.from(request.headers.entries())).toEqual(Array.from(new Headers({
-                "Accept": "application/vnd.protonmail.v1+json",
-                "Content-Type": "application/json",
-                "Language": 'en',
-                "x-pm-drive-sdk-version": `js@${process.env.npm_package_version}`,
-            }).entries()));
+            expect(Array.from(request.headers.entries())).toEqual(
+                Array.from(
+                    new Headers({
+                        Accept: 'application/vnd.protonmail.v1+json',
+                        'Content-Type': 'application/json',
+                        Language: 'en',
+                        'x-pm-drive-sdk-version': `js@${process.env.npm_package_version}`,
+                    }).entries(),
+                ),
+            );
             expect(await request.json).toEqual(data);
             expectSDKEvents();
         }
 
-        it("storage GET request", async () => {
+        it('storage GET request', async () => {
             const stream = await api.getBlockStream('test', 'token');
             const result = await Array.fromAsync(stream);
             expect(result).toEqual([new Uint8Array([1, 2, 3])]);
             await expectFetchBlobToBeCalledWith('GET');
         });
 
-        it("storage POST request", async () => {
+        it('storage POST request', async () => {
             const data = new Blob();
             await api.postBlockStream('test', 'token', data);
             await expectFetchBlobToBeCalledWith('POST', data);
@@ -91,35 +97,44 @@ describe("DriveAPIService", () => {
             const request = httpClient.fetchBlob.mock.calls[0][0];
             expect(request.method).toEqual(method);
             expect(request.timeoutMs).toEqual(90000);
-            expect(Array.from(request.headers.entries())).toEqual(Array.from(new Headers({
-                "pm-storage-token": 'token',
-                "Language": 'en',
-                "x-pm-drive-sdk-version": `js@${process.env.npm_package_version}`,
-            }).entries()));
+            expect(Array.from(request.headers.entries())).toEqual(
+                Array.from(
+                    new Headers({
+                        'pm-storage-token': 'token',
+                        Language: 'en',
+                        'x-pm-drive-sdk-version': `js@${process.env.npm_package_version}`,
+                    }).entries(),
+                ),
+            );
             expect(request.body).toEqual(data);
             expectSDKEvents();
         }
     });
 
-    describe("should throw", () => {
-        it("APIHTTPError on 4xx response without JSON body", async () => {
-            httpClient.fetchJson = jest.fn(() => Promise.resolve(new Response('Not found', { status: 404, statusText: 'Not found' })));
+    describe('should throw', () => {
+        it('APIHTTPError on 4xx response without JSON body', async () => {
+            httpClient.fetchJson = jest.fn(() =>
+                Promise.resolve(new Response('Not found', { status: 404, statusText: 'Not found' })),
+            );
             await expect(api.get('test')).rejects.toThrow(new Error('Not found'));
             expectSDKEvents();
         });
 
-        it("APIError on 4xx response with JSON body", async () => {
-            httpClient.fetchJson = jest.fn(() => Promise.resolve(new Response(JSON.stringify({ Code: 42, Error: 'General error' }), { status: 422 })));
+        it('APIError on 4xx response with JSON body', async () => {
+            httpClient.fetchJson = jest.fn(() =>
+                Promise.resolve(new Response(JSON.stringify({ Code: 42, Error: 'General error' }), { status: 422 })),
+            );
             await expect(api.get('test')).rejects.toThrow('General error');
             expectSDKEvents();
         });
     });
 
-    describe("should retry", () => {
-        it("on offline error", async () => {
+    describe('should retry', () => {
+        it('on offline error', async () => {
             const error = new Error('Network offline');
             error.name = 'OfflineError';
-            httpClient.fetchJson = jest.fn()
+            httpClient.fetchJson = jest
+                .fn()
                 .mockRejectedValueOnce(error)
                 .mockRejectedValueOnce(error)
                 .mockResolvedValueOnce(generateOkResponse());
@@ -131,10 +146,11 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("on timeout error", async () => {
+        it('on timeout error', async () => {
             const error = new Error('Timeouted');
             error.name = 'TimeoutError';
-            httpClient.fetchJson = jest.fn()
+            httpClient.fetchJson = jest
+                .fn()
                 .mockRejectedValueOnce(error)
                 .mockRejectedValueOnce(error)
                 .mockResolvedValueOnce(generateOkResponse());
@@ -146,8 +162,9 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("on general error", async () => {
-            httpClient.fetchJson = jest.fn()
+        it('on general error', async () => {
+            httpClient.fetchJson = jest
+                .fn()
                 .mockRejectedValueOnce(new Error('Error'))
                 .mockResolvedValueOnce(generateOkResponse());
 
@@ -158,23 +175,29 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("only once on general error", async () => {
-            httpClient.fetchJson = jest.fn()
+        it('only once on general error', async () => {
+            httpClient.fetchJson = jest
+                .fn()
                 .mockRejectedValueOnce(new Error('First error'))
                 .mockRejectedValueOnce(new Error('Second error'))
                 .mockResolvedValueOnce(generateOkResponse());
 
             const result = api.get('test');
 
-            await expect(result).rejects.toThrow("Second error");
+            await expect(result).rejects.toThrow('Second error');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
         });
 
-        it("on 429 response", async () => {
-            httpClient.fetchJson = jest.fn()
-                .mockResolvedValueOnce(new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }))
-                .mockResolvedValueOnce(new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }))
+        it('on 429 response', async () => {
+            httpClient.fetchJson = jest
+                .fn()
+                .mockResolvedValueOnce(
+                    new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }),
+                )
+                .mockResolvedValueOnce(
+                    new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }),
+                )
                 .mockResolvedValueOnce(generateOkResponse());
 
             const result = api.get('test');
@@ -185,9 +208,12 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("on 5xx response", async () => {
-            httpClient.fetchJson = jest.fn()
-                .mockResolvedValueOnce(new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }))
+        it('on 5xx response', async () => {
+            httpClient.fetchJson = jest
+                .fn()
+                .mockResolvedValueOnce(
+                    new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }),
+                )
                 .mockResolvedValueOnce(generateOkResponse());
 
             const result = api.get('test');
@@ -197,28 +223,34 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("only once on 5xx response", async () => {
-            httpClient.fetchJson = jest.fn()
-                .mockResolvedValue(new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }));
+        it('only once on 5xx response', async () => {
+            httpClient.fetchJson = jest
+                .fn()
+                .mockResolvedValue(
+                    new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }),
+                );
 
             const result = api.get('test');
 
-            await expect(result).rejects.toThrow("Some error");
+            await expect(result).rejects.toThrow('Some error');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(2);
             expectSDKEvents();
         });
     });
 
-    describe("should handle subsequent errors", () => {
-        it("limit 429 errors", async () => {
-            httpClient.fetchJson = jest.fn()
-                .mockResolvedValue(new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }));
+    describe('should handle subsequent errors', () => {
+        it('limit 429 errors', async () => {
+            httpClient.fetchJson = jest
+                .fn()
+                .mockResolvedValue(
+                    new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' }),
+                );
 
             for (let i = 0; i < 20; i++) {
                 await api.get('test').catch(() => {});
             }
 
-            await expect(api.get('test')).rejects.toThrow("Too many server requests, please try again later");
+            await expect(api.get('test')).rejects.toThrow('Too many server requests, please try again later');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(50);
             expectSDKEvents(SDKEvent.RequestsThrottled);
 
@@ -229,15 +261,14 @@ describe("DriveAPIService", () => {
             expect(sdkEvents.requestsThrottled).toHaveBeenCalledTimes(1);
         });
 
-        it("do not limit 429s when some pass", async () => {
+        it('do not limit 429s when some pass', async () => {
             let attempt = 0;
-            httpClient.fetchJson = jest.fn()
-                .mockImplementation(() => {
-                    if (attempt++ % 5 === 0) {
-                        return generateOkResponse();
-                    }
-                    return new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' });
-                });
+            httpClient.fetchJson = jest.fn().mockImplementation(() => {
+                if (attempt++ % 5 === 0) {
+                    return generateOkResponse();
+                }
+                return new Response('', { status: HTTPErrorCode.TOO_MANY_REQUESTS, statusText: 'Some error' });
+            });
 
             for (let i = 0; i < 20; i++) {
                 await api.get('test').catch(() => {});
@@ -249,34 +280,36 @@ describe("DriveAPIService", () => {
             expectSDKEvents();
         });
 
-        it("limit server errors", async () => {
-            httpClient.fetchJson = jest.fn()
-                .mockResolvedValue(new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }));
+        it('limit server errors', async () => {
+            httpClient.fetchJson = jest
+                .fn()
+                .mockResolvedValue(
+                    new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' }),
+                );
 
             for (let i = 0; i < 20; i++) {
                 await api.get('test').catch(() => {});
             }
 
-            await expect(api.get('test')).rejects.toThrow("Too many server errors, please try again later");
+            await expect(api.get('test')).rejects.toThrow('Too many server errors, please try again later');
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(10);
             expectSDKEvents();
         });
 
-        it("do not limit server errors when some pass", async () => {
+        it('do not limit server errors when some pass', async () => {
             let attempt = 0;
-            httpClient.fetchJson = jest.fn()
-                .mockImplementation(() => {
-                    if (attempt++ % 5 === 0) {
-                        return generateOkResponse();
-                    }
-                    return new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' });
-                });
-        
+            httpClient.fetchJson = jest.fn().mockImplementation(() => {
+                if (attempt++ % 5 === 0) {
+                    return generateOkResponse();
+                }
+                return new Response('', { status: HTTPErrorCode.INTERNAL_SERVER_ERROR, statusText: 'Some error' });
+            });
+
             for (let i = 0; i < 20; i++) {
                 await api.get('test').catch(() => {});
             }
 
-            await expect(api.get('test')).rejects.toThrow("Some error");
+            await expect(api.get('test')).rejects.toThrow('Some error');
             // 15 erroring calls * 2 attempts + 5 successful calls
             expect(httpClient.fetchJson).toHaveBeenCalledTimes(35);
             expectSDKEvents();