@protontech/drive-sdk 0.1.0 → 0.1.1

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();

package/src/internal/apiService/apiService.ts

@@ -1,7 +1,7 @@
 import { c } from 'ttag';
 
-import { VERSION } from "../../version";
-import { ProtonDriveHTTPClient, ProtonDriveTelemetry, Logger } 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';
@@ -107,19 +107,27 @@ export class DriveAPIService {
 
     async get<ResponsePayload>(url: string, signal?: AbortSignal): Promise<ResponsePayload> {
         return this.makeRequest(url, 'GET', undefined, signal);
-    };
+    }
 
-    async post<RequestPayload, ResponsePayload>(url: string, data?: RequestPayload, signal?: AbortSignal): Promise<ResponsePayload> {
+    async post<RequestPayload, ResponsePayload>(
+        url: string,
+        data?: RequestPayload,
+        signal?: AbortSignal,
+    ): Promise<ResponsePayload> {
         return this.makeRequest(url, 'POST', data, signal);
-    };
+    }
 
-    async put<RequestPayload, ResponsePayload>(url: string, data: RequestPayload, signal?: AbortSignal): Promise<ResponsePayload> {
+    async put<RequestPayload, ResponsePayload>(
+        url: string,
+        data: RequestPayload,
+        signal?: AbortSignal,
+    ): Promise<ResponsePayload> {
         return this.makeRequest(url, 'PUT', data, signal);
-    };
+    }
 
     async delete<Response>(url: string, signal?: AbortSignal): Promise<Response> {
         return this.makeRequest(url, 'DELETE', undefined, signal);
-    };
+    }
 
     private async makeRequest<RequestPayload, ResponsePayload>(
         url: string,
@@ -131,15 +139,15 @@ export class DriveAPIService {
             url: `${this.baseUrl}/${url}`,
             method,
             headers: new Headers({
-                "Accept": "application/vnd.protonmail.v1+json",
-                "Content-Type": "application/json",
-                "Language": this.language,
-                "x-pm-drive-sdk-version": `js@${VERSION}`,
+                Accept: 'application/vnd.protonmail.v1+json',
+                'Content-Type': 'application/json',
+                Language: this.language,
+                'x-pm-drive-sdk-version': `js@${VERSION}`,
             }),
             json: data || undefined,
             timeoutMs: DEFAULT_TIMEOUT_MS,
             signal,
-        }
+        };
 
         const response = await this.fetch(request, () => this.httpClient.fetchJson(request));
 
@@ -169,7 +177,13 @@ export class DriveAPIService {
         return response.body;
     }
 
-    async postBlockStream(baseUrl: string, token: string, data: XMLHttpRequestBodyInit, onProgress?: (uploadedBytes: number) => void, signal?: AbortSignal): Promise<void> {
+    async postBlockStream(
+        baseUrl: string,
+        token: string,
+        data: XMLHttpRequestBodyInit,
+        onProgress?: (uploadedBytes: number) => void,
+        signal?: AbortSignal,
+    ): Promise<void> {
         await this.makeStorageRequest('POST', baseUrl, token, data, onProgress, signal);
     }
 
@@ -185,9 +199,9 @@ export class DriveAPIService {
             url,
             method,
             headers: new Headers({
-                "pm-storage-token": token,
-                "Language": this.language,
-                "x-pm-drive-sdk-version": `js@${VERSION}`,
+                'pm-storage-token': token,
+                Language: this.language,
+                'x-pm-drive-sdk-version': `js@${VERSION}`,
             }),
             body,
             onProgress,
@@ -217,9 +231,9 @@ export class DriveAPIService {
     // u=5 for background (e.g., upload, download)
     // u=7 for optional (e.g., metrics, telemetry)
     private async fetch(
-        request: { method: string, url: string, signal?: AbortSignal },
+        request: { method: string; url: string; signal?: AbortSignal },
         callback: () => Promise<Response>,
-        attempt = 0
+        attempt = 0,
     ): Promise<Response> {
         if (request.signal?.aborted) {
             throw new AbortError(c('Error').t`Request aborted`);
@@ -244,19 +258,19 @@ export class DriveAPIService {
                 if (error.name === 'OfflineError') {
                     this.logger.info(`${request.method} ${request.url}: Offline error, retrying`);
                     await waitSeconds(OFFLINE_RETRY_DELAY_SECONDS);
-                    return this.fetch(request, callback, attempt+1);
+                    return this.fetch(request, callback, attempt + 1);
                 }
 
                 if (error.name === 'TimeoutError') {
                     this.logger.warn(`${request.method} ${request.url}: Timeout error, retrying`);
                     await waitSeconds(SERVER_ERROR_RETRY_DELAY_SECONDS);
-                    return this.fetch(request, callback, attempt+1);
+                    return this.fetch(request, callback, attempt + 1);
                 }
             }
             if (attempt === 0) {
                 this.logger.error(`${request.method} ${request.url}: failed, retrying once`, error);
                 await waitSeconds(GENERAL_RETRY_DELAY_SECONDS);
-                return this.fetch(request, callback, attempt+1);
+                return this.fetch(request, callback, attempt + 1);
             }
             this.logger.error(`${request.method} ${request.url}: failed`, error);
             throw error;
@@ -272,7 +286,7 @@ export class DriveAPIService {
             this.tooManyRequestsErrorHappened();
             const timeout = parseInt(response.headers.get('retry-after') || '0', DEFAULT_429_RETRY_DELAY_SECONDS);
             await waitSeconds(timeout);
-            return this.fetch(request, callback, attempt+1);
+            return this.fetch(request, callback, attempt + 1);
         } else {
             this.clearSubsequentTooManyRequestsError();
         }
@@ -286,7 +300,7 @@ export class DriveAPIService {
                 this.logger.warn(`${request.method} ${request.url}: ${response.status} - retry failed`);
             } else {
                 await waitSeconds(SERVER_ERROR_RETRY_DELAY_SECONDS);
-                return this.fetch(request, callback, attempt+1);
+                return this.fetch(request, callback, attempt + 1);
             }
         } else {
             if (attempt > 0) {
@@ -308,7 +322,7 @@ export class DriveAPIService {
         return (
             this.subsequentTooManyRequestsCounter >= TOO_MANY_SUBSEQUENT_429_ERRORS &&
             secondsSinceLast429Error < TOO_MANY_SUBSEQUENT_429_ERRORS_TIMEOUT_IN_SECONDS
-        )
+        );
     }
 
     private tooManyRequestsErrorHappened() {
@@ -338,7 +352,7 @@ export class DriveAPIService {
         return (
             this.subsequentServerErrorsCounter >= TOO_MANY_SUBSEQUENT_SERVER_ERRORS &&
             secondsSinceLastServerError < TOO_MANY_SUBSEQUENT_SERVER_ERRORS_TIMEOUT_IN_SECONDS
-        )
+        );
     }
 
     private serverErrorHappened() {