@protontech/drive-sdk 0.1.0 → 0.1.1

package/src/internal/apiService/errorCodes.ts

@@ -22,16 +22,16 @@ export const enum ErrorCode {
     // Following codes takes name from the API documentation.
     ALREADY_EXISTS = 2500,
     NOT_EXISTS = 2501,
-    INSUFFICIENT_QUOTA = 200001,	
+    INSUFFICIENT_QUOTA = 200001,
     INSUFFICIENT_SPACE = 200002,
     MAX_FILE_SIZE_FOR_FREE_USER = 200003,
     MAX_PUBLIC_EDIT_MODE_FOR_FREE_USER = 200004,
-    INSUFFICIENT_VOLUME_QUOTA= 200100,
-    INSUFFICIENT_DEVICE_QUOTA= 200101,
+    INSUFFICIENT_VOLUME_QUOTA = 200100,
+    INSUFFICIENT_DEVICE_QUOTA = 200101,
     ALREADY_MEMBER_OF_SHARE_IN_VOLUME_WITH_ANOTHER_ADDRESS = 200201,
     TOO_MANY_CHILDREN = 200300,
     NESTING_TOO_DEEP = 200301,
-    INSUFFICIENT_INVITATION_QUOTA = 200600,	
+    INSUFFICIENT_INVITATION_QUOTA = 200600,
     INSUFFICIENT_SHARE_QUOTA = 200601,
     INSUFFICIENT_SHARE_JOINED_QUOTA = 200602,
     INSUFFICIENT_BOOKMARKS_QUOTA = 200800,

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

@@ -1,19 +1,14 @@
-import { apiErrorFactory } from "./errors";
-import * as errors from "./errors";
+import { apiErrorFactory } from './errors';
+import * as errors from './errors';
 import { ErrorCode } from './errorCodes';
 
 function mockAPIResponseAndResult(options: {
-    httpStatusCode?: number,
-    httpStatusText?: string,
-    code: number,
-    message?: string,
+    httpStatusCode?: number;
+    httpStatusText?: string;
+    code: number;
+    message?: string;
 }) {
-    const {
-        httpStatusCode = 422,
-        httpStatusText = 'Unprocessable Entity',
-        code,
-        message = 'API error',
-    } = options;
+    const { httpStatusCode = 422, httpStatusText = 'Unprocessable Entity', code, message = 'API error' } = options;
 
     const result = { Code: code, Error: message };
     const response = new Response(JSON.stringify(result), { status: httpStatusCode, statusText: httpStatusText });
@@ -21,43 +16,50 @@ function mockAPIResponseAndResult(options: {
     return { response, result };
 }
 
-describe("apiErrorFactory should return", () => {
-    it("generic APIHTTPError when there is no specifc body", () => {
+describe('apiErrorFactory should return', () => {
+    it('generic APIHTTPError when there is no specifc body', () => {
         const response = new Response('', { status: 404, statusText: 'Not found' });
         const error = apiErrorFactory({ response });
         expect(error).toBeInstanceOf(errors.APIHTTPError);
-        expect(error.message).toBe("Not found");
+        expect(error.message).toBe('Not found');
         expect((error as errors.APIHTTPError).statusCode).toBe(404);
     });
 
-    it("generic APIHTTPError with generic message when there is no specifc statusText", () => {
+    it('generic APIHTTPError with generic message when there is no specifc statusText', () => {
         const response = new Response('', { status: 404, statusText: '' });
         const error = apiErrorFactory({ response });
         expect(error).toBeInstanceOf(errors.APIHTTPError);
-        expect(error.message).toBe("Unknown error");
+        expect(error.message).toBe('Unknown error');
         expect((error as errors.APIHTTPError).statusCode).toBe(404);
     });
 
-    it("generic APIHTTPError when there 404 both in status code and body code", () => {
-        const error = apiErrorFactory(mockAPIResponseAndResult({ httpStatusCode: 404, httpStatusText: 'Path not found', code: 404, message: 'Not found' }));
+    it('generic APIHTTPError when there 404 both in status code and body code', () => {
+        const error = apiErrorFactory(
+            mockAPIResponseAndResult({
+                httpStatusCode: 404,
+                httpStatusText: 'Path not found',
+                code: 404,
+                message: 'Not found',
+            }),
+        );
         expect(error).toBeInstanceOf(errors.APIHTTPError);
-        expect(error.message).toBe("Path not found");
+        expect(error.message).toBe('Path not found');
         expect((error as errors.APIHTTPError).statusCode).toBe(404);
     });
 
-    it("generic APICodeError when there is body even if wrong", () => {
+    it('generic APICodeError when there is body even if wrong', () => {
         const result = {};
         const response = new Response('', { status: 422 });
         const error = apiErrorFactory({ response, result });
         expectAPICodeError(error, 0, 'Unknown error');
     });
 
-    it("generic APICodeError when there is body but not specific handle", () => {
+    it('generic APICodeError when there is body but not specific handle', () => {
         const error = apiErrorFactory(mockAPIResponseAndResult({ code: 42, message: 'General error' }));
         expectAPICodeError(error, 42, 'General error');
     });
 
-    it("NotFoundAPIError when code is ErrorCode.NOT_EXISTS", () => {
+    it('NotFoundAPIError when code is ErrorCode.NOT_EXISTS', () => {
         const error = apiErrorFactory(mockAPIResponseAndResult({ code: ErrorCode.NOT_EXISTS, message: 'Not found' }));
         expect(error).toBeInstanceOf(errors.NotFoundAPIError);
         expectAPICodeError(error, ErrorCode.NOT_EXISTS, 'Not found');

package/src/internal/apiService/errors.ts

@@ -3,7 +3,7 @@ import { c } from 'ttag';
 import { ServerError, ValidationError } from '../../errors';
 import { ErrorCode, HTTPErrorCode } from './errorCodes';
 
-export function apiErrorFactory({ response, result }: { response: Response, result?: unknown }): ServerError {
+export function apiErrorFactory({ response, result }: { response: Response; result?: unknown }): ServerError {
     // Backend responses with 404 both in the response and body code.
     // In such a case we want to stick to APIHTTPError to be very clear
     // it is not NotFoundAPIError.
@@ -22,15 +22,21 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
         trace?: object;
     };
 
-    const [code, message, details] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`, typedResult.Details];
+    const [code, message, details] = [
+        typedResult.Code || 0,
+        typedResult.Error || c('Error').t`Unknown error`,
+        typedResult.Details,
+    ];
 
-    const debug = typedResult.exception ? {
-        exception: typedResult.exception,
-        message: typedResult.message,
-        file: typedResult.file,
-        line: typedResult.line,
-        trace: typedResult.trace,
-    } : undefined;
+    const debug = typedResult.exception
+        ? {
+              exception: typedResult.exception,
+              message: typedResult.message,
+              file: typedResult.file,
+              line: typedResult.line,
+              trace: typedResult.trace,
+          }
+        : undefined;
 
     switch (code) {
         case ErrorCode.NOT_EXISTS:

package/src/internal/apiService/index.ts

@@ -3,5 +3,5 @@ export type { paths as drivePaths } from './driveTypes';
 export type { paths as corePaths } from './coreTypes';
 export { HTTPErrorCode, ErrorCode, isCodeOk, isCodeOkAsync } from './errorCodes';
 export { nodeTypeNumberToNodeType, permissionsToDirectMemberRole, memberRoleToPermission } from './transformers';
-export { ObserverStream } from './observerStream';
+export { ObserverStream } from './observerStream';
 export * from './errors';

package/src/internal/apiService/transformers.ts

@@ -1,4 +1,4 @@
-import { Logger, NodeType, MemberRole } from "../../interface";
+import { Logger, NodeType, MemberRole } from '../../interface';
 
 export function nodeTypeNumberToNodeType(logger: Logger, nodeTypeNumber: number): NodeType {
     switch (nodeTypeNumber) {
@@ -34,7 +34,7 @@ export function permissionsToDirectMemberRole(logger: Logger, permissionsNumber?
 export function memberRoleToPermission(memberRole: MemberRole): 4 | 6 | 22 {
     if (memberRole === MemberRole.Inherited) {
         // This is developer error.
-        throw new Error("Cannot convert inherited role to permission");
+        throw new Error('Cannot convert inherited role to permission');
     }
     switch (memberRole) {
         case MemberRole.Viewer:

package/src/internal/asyncIteratorMap.test.ts

@@ -52,7 +52,7 @@ describe('asyncIteratorMap', () => {
         const inputGen = createAsyncGenerator(Object.keys(delays).map(Number));
 
         const slowMapper = async (x: number) => {
-            await new Promise(resolve => setTimeout(resolve, delays[x]));
+            await new Promise((resolve) => setTimeout(resolve, delays[x]));
             return x * 2;
         };
 
@@ -71,11 +71,11 @@ describe('asyncIteratorMap', () => {
     });
 
     test('handles errors from input iterator properly', async () => {
-        const throwingInputGen = async function*() {
+        const throwingInputGen = async function* () {
             yield 1;
             yield 2;
             throw new Error('Error providing value: 3');
-        }
+        };
 
         const mapper = async (x: number) => x * 2;
 
@@ -134,7 +134,7 @@ describe('asyncIteratorMap', () => {
             maxConcurrentExecutions = Math.max(maxConcurrentExecutions, concurrentExecutions);
 
             // Wait for 100ms to simulate work
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
 
             concurrentExecutions--;
             return x * 2;

package/src/internal/asyncIteratorMap.ts

@@ -8,7 +8,7 @@ const DEFAULT_CONCURRENCY = 10;
  *
  * Any error from the input iterator or the mapper function is propagated
  * to the output iterator.
- * 
+ *
  * @param inputIterator - The input async iterator.
  * @param mapper - The mapper function that maps the input values to output values.
  * @param concurrency - The concurrency limit. How many parallel async mapper calls are allowed.

package/src/internal/asyncIteratorRace.test.ts

@@ -0,0 +1,149 @@
+import { asyncIteratorRace } from './asyncIteratorRace';
+
+async function* createInputIterator<T>(generators: AsyncGenerator<T>[]): AsyncGenerator<AsyncGenerator<T>> {
+    for (const generator of generators) {
+        yield generator;
+    }
+}
+
+async function* createAsyncGenerator<T>(values: T[], delay: number = 0): AsyncGenerator<T> {
+    for (const value of values) {
+        if (delay > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        yield value;
+    }
+}
+
+function createTrackingGenerator<T>(
+    values: T[],
+    trackingSet: Set<number>,
+    id: number,
+    delay: number = 10,
+): AsyncGenerator<T> {
+    return (async function* () {
+        trackingSet.add(id);
+        try {
+            for (const value of values) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                yield value;
+            }
+        } finally {
+            trackingSet.delete(id);
+        }
+    })();
+}
+
+describe('asyncIteratorRace', () => {
+    it('should handle empty input iterator', async () => {
+        async function* emptyInput(): AsyncGenerator<AsyncGenerator<number>> {
+            return;
+        }
+
+        const result = asyncIteratorRace(emptyInput());
+        const values = await Array.fromAsync(result);
+
+        expect(values).toEqual([]);
+    });
+
+    it('should handle single generator with no values', async () => {
+        const input = createInputIterator([createAsyncGenerator([])]);
+
+        const result = asyncIteratorRace(input);
+        const values = await Array.fromAsync(result);
+
+        expect(values).toEqual([]);
+    });
+
+    it('should handle single generator with multiple values', async () => {
+        const input = createInputIterator([createAsyncGenerator([1, 2, 3])]);
+
+        const result = asyncIteratorRace(input);
+        const values = await Array.fromAsync(result);
+
+        expect(values).toEqual([1, 2, 3]);
+    });
+
+    it('should handle generators with mixed empty and non-empty results', async () => {
+        const input = createInputIterator([
+            createAsyncGenerator([]),
+            createAsyncGenerator([1, 3]),
+            createAsyncGenerator([]),
+            createAsyncGenerator([2]),
+        ]);
+
+        const result = asyncIteratorRace(input);
+        const values = await Array.fromAsync(result);
+
+        expect(values.sort()).toEqual([1, 2, 3]);
+    });
+
+    it('should limit concurrent reading of input iterators', async () => {
+        const concurrency = 2;
+        const activeIterators = new Set<number>();
+        let maxConcurrentActive = 0;
+
+        const generators = Array.from({ length: 5 }, (_, i) =>
+            createTrackingGenerator([i * 10, i * 10 + 1], activeIterators, i, 50),
+        );
+        const input = createInputIterator(generators);
+
+        const result = asyncIteratorRace(input, concurrency);
+
+        const values: number[] = [];
+        for await (const value of result) {
+            maxConcurrentActive = Math.max(maxConcurrentActive, activeIterators.size);
+            values.push(value);
+        }
+
+        expect(maxConcurrentActive).toBe(concurrency);
+        expect(values).toHaveLength(10);
+        expect(values.sort()).toEqual([0, 1, 10, 11, 20, 21, 30, 31, 40, 41]);
+    });
+
+    it('should yield values as soon as any generator yields', async () => {
+        const slowGenerator = (async function* () {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            yield 'slow';
+        })();
+        const fastGenerator = (async function* () {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            yield 'fast';
+        })();
+        const input = createInputIterator([slowGenerator, fastGenerator]);
+        const result = asyncIteratorRace(input, 2);
+
+        const yieldTimes: number[] = [];
+        const startTime = Date.now();
+        const values: string[] = [];
+        for await (const value of result) {
+            yieldTimes.push(Date.now() - startTime);
+            values.push(value);
+        }
+
+        expect(values).toEqual(['fast', 'slow']);
+        expect(yieldTimes[0]).toBeGreaterThan(40);
+        expect(yieldTimes[0]).toBeLessThan(60);
+        expect(yieldTimes[1]).toBeGreaterThan(90);
+        expect(yieldTimes[1]).toBeLessThan(110);
+    });
+
+    it('should propagate errors from input iterators', async () => {
+        const errorGenerator = (async function* () {
+            yield 'before-error';
+            throw new Error('Test error');
+        })();
+        const input = createInputIterator([errorGenerator]);
+
+        const result = asyncIteratorRace(input);
+
+        const values: string[] = [];
+        await expect(async () => {
+            for await (const value of result) {
+                values.push(value);
+            }
+        }).rejects.toThrow('Test error');
+
+        expect(values).toEqual(['before-error']);
+    });
+});

package/src/internal/asyncIteratorRace.ts

@@ -0,0 +1,79 @@
+const DEFAULT_CONCURRENCY = 10;
+
+/**
+ * Races multiple async iterators into a single async iterator.
+ *
+ * The input iterators are provided as an async iterator that yields async
+ * iterators. This allows to create the iterators lazily, e.g., when the
+ * input iterators are created from a database query.
+ *
+ * The number of input iterators being read at the same time is limited by
+ * the `concurrency` parameter.
+ *
+ * Any error from the input iterators is propagated to the output iterator.
+ */
+export async function* asyncIteratorRace<T>(
+    inputIterators: AsyncGenerator<AsyncGenerator<T>>,
+    concurrency: number = DEFAULT_CONCURRENCY,
+): AsyncGenerator<T> {
+    const promises = new Map<
+        number,
+        Promise<{
+            iteratorIndex: number;
+            result: IteratorResult<T>;
+        }>
+    >();
+
+    let nextIteratorIndex = 0;
+    let inputIteratorsExhausted = false;
+    const activeIterators = new Map<number, AsyncGenerator<T>>();
+
+    const startNewIterator = async (): Promise<void> => {
+        if (inputIteratorsExhausted || activeIterators.size >= concurrency) {
+            return;
+        }
+
+        const nextIteratorResult = await inputIterators.next();
+        if (nextIteratorResult.done) {
+            inputIteratorsExhausted = true;
+            return;
+        }
+
+        const iterator = nextIteratorResult.value;
+        const iteratorIndex = nextIteratorIndex++;
+        activeIterators.set(iteratorIndex, iterator);
+
+        promises.set(
+            iteratorIndex,
+            (async () => {
+                const result = await iterator.next();
+                return { iteratorIndex, result };
+            })(),
+        );
+    };
+
+    while (activeIterators.size < concurrency && !inputIteratorsExhausted) {
+        await startNewIterator();
+    }
+
+    while (promises.size > 0) {
+        const { iteratorIndex, result } = await Promise.race(promises.values());
+        promises.delete(iteratorIndex);
+
+        if (result.done) {
+            activeIterators.delete(iteratorIndex);
+            await startNewIterator();
+        } else {
+            yield result.value;
+
+            const iterator = activeIterators.get(iteratorIndex)!;
+            promises.set(
+                iteratorIndex,
+                (async () => {
+                    const result = await iterator.next();
+                    return { iteratorIndex, result };
+                })(),
+            );
+        }
+    }
+}

package/src/internal/batch.test.ts

@@ -0,0 +1,50 @@
+import { batch } from './batch';
+
+describe('batch', () => {
+    it('should batch an array of numbers into chunks of specified size', () => {
+        const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        const batchSize = 3;
+        const result = Array.from(batch(items, batchSize));
+
+        expect(result).toEqual([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]);
+    });
+
+    it('should handle batch size equal to array length', () => {
+        const items = [1, 2, 3, 4, 5];
+        const batchSize = 5;
+        const result = Array.from(batch(items, batchSize));
+
+        expect(result).toEqual([[1, 2, 3, 4, 5]]);
+    });
+
+    it('should handle batch size larger than array length', () => {
+        const items = [1, 2, 3];
+        const batchSize = 10;
+        const result = Array.from(batch(items, batchSize));
+
+        expect(result).toEqual([[1, 2, 3]]);
+    });
+
+    it('should handle batch size of 1', () => {
+        const items = [1, 2, 3];
+        const batchSize = 1;
+        const result = Array.from(batch(items, batchSize));
+
+        expect(result).toEqual([[1], [2], [3]]);
+    });
+
+    it('should handle empty array', () => {
+        const items: number[] = [];
+        const batchSize = 3;
+        const result = Array.from(batch(items, batchSize));
+
+        expect(result).toEqual([]);
+    });
+
+    it('should handle zero batch size gracefully', () => {
+        const items = [1, 2, 3];
+        const batchSize = 0;
+
+        expect(() => Array.from(batch(items, batchSize))).toThrow();
+    });
+});

package/src/internal/batch.ts

@@ -0,0 +1,9 @@
+export function* batch<T>(items: T[], batchSize: number): Generator<T[]> {
+    if (batchSize <= 0) {
+        throw new Error('Batch size must be greater than 0');
+    }
+
+    for (let i = 0; i < items.length; i += batchSize) {
+        yield items.slice(i, i + batchSize);
+    }
+}

package/src/internal/batchLoading.test.ts

@@ -1,19 +1,19 @@
 import { BatchLoading } from './batchLoading';
 
-describe("BatchLoading", () => {
+describe('BatchLoading', () => {
     let batchLoading: BatchLoading<string, string>;
 
     beforeEach(() => {
         jest.clearAllMocks();
     });
 
-    it("should load in batches with loadItems", async () => {
+    it('should load in batches with loadItems', async () => {
         const loadItems = jest.fn((items: string[]) => Promise.resolve(items.map((item) => `loaded:${item}`)));
 
         batchLoading = new BatchLoading<string, string>({ loadItems, batchSize: 2 });
 
         const result = [];
-        for (const item of ["a", "b", "c", "d", "e"]) {
+        for (const item of ['a', 'b', 'c', 'd', 'e']) {
             for await (const loadedItem of batchLoading.load(item)) {
                 result.push(loadedItem);
             }
@@ -22,15 +22,14 @@ describe("BatchLoading", () => {
             result.push(loadedItem);
         }
 
-
-        expect(result).toEqual(["loaded:a", "loaded:b", "loaded:c", "loaded:d", "loaded:e"]);
+        expect(result).toEqual(['loaded:a', 'loaded:b', 'loaded:c', 'loaded:d', 'loaded:e']);
         expect(loadItems).toHaveBeenCalledTimes(3);
-        expect(loadItems).toHaveBeenNthCalledWith(1, ["a", "b"]);
-        expect(loadItems).toHaveBeenNthCalledWith(2, ["c", "d"]);
-        expect(loadItems).toHaveBeenNthCalledWith(3, ["e"]);
+        expect(loadItems).toHaveBeenNthCalledWith(1, ['a', 'b']);
+        expect(loadItems).toHaveBeenNthCalledWith(2, ['c', 'd']);
+        expect(loadItems).toHaveBeenNthCalledWith(3, ['e']);
     });
 
-    it("should load in batches with iterateItems", async () => {
+    it('should load in batches with iterateItems', async () => {
         const iterateItems = jest.fn(async function* (items: string[]) {
             for (const item of items) {
                 yield `loaded:${item}`;
@@ -40,7 +39,7 @@ describe("BatchLoading", () => {
         batchLoading = new BatchLoading<string, string>({ iterateItems, batchSize: 2 });
 
         const result = [];
-        for (const item of ["a", "b", "c", "d", "e"]) {
+        for (const item of ['a', 'b', 'c', 'd', 'e']) {
             for await (const loadedItem of batchLoading.load(item)) {
                 result.push(loadedItem);
             }
@@ -49,10 +48,10 @@ describe("BatchLoading", () => {
             result.push(loadedItem);
         }
 
-        expect(result).toEqual(["loaded:a", "loaded:b", "loaded:c", "loaded:d", "loaded:e"]);
+        expect(result).toEqual(['loaded:a', 'loaded:b', 'loaded:c', 'loaded:d', 'loaded:e']);
         expect(iterateItems).toHaveBeenCalledTimes(3);
-        expect(iterateItems).toHaveBeenNthCalledWith(1, ["a", "b"]);
-        expect(iterateItems).toHaveBeenNthCalledWith(2, ["c", "d"]);
-        expect(iterateItems).toHaveBeenNthCalledWith(3, ["e"]);
+        expect(iterateItems).toHaveBeenNthCalledWith(1, ['a', 'b']);
+        expect(iterateItems).toHaveBeenNthCalledWith(2, ['c', 'd']);
+        expect(iterateItems).toHaveBeenNthCalledWith(3, ['e']);
     });
 });

package/src/internal/batchLoading.ts

@@ -2,14 +2,14 @@ const DEFAULT_BATCH_LOADING = 10;
 
 /**
  * Helper class for batch loading items.
- * 
+ *
  * The class is responsible for fetching items in batches. Any call to
  * `load` will add the item to the batch (without fetching anything),
  * and if the batch reaches the limit, it will fetch the items and yield
  * them transparently to the caller.
- * 
+ *
  * Example:
- * 
+ *
  * ```typescript
  * const batchLoading = new BatchLoading<string, DecryptedNode>({ loadItems: loadNodesCallback });
  * for (const nodeUid of nodeUids) {
@@ -29,19 +29,19 @@ export class BatchLoading<ID, ITEM> {
     private itemsToFetch: ID[];
 
     constructor(options: {
-        loadItems?: (ids: ID[]) => Promise<ITEM[]>,
-        iterateItems?: (ids: ID[]) => AsyncGenerator<ITEM>,
-        batchSize?: number,
+        loadItems?: (ids: ID[]) => Promise<ITEM[]>;
+        iterateItems?: (ids: ID[]) => AsyncGenerator<ITEM>;
+        batchSize?: number;
     }) {
         this.itemsToFetch = [];
-        
+
         if (options.loadItems) {
             const loadItems = options.loadItems;
             this.iterateItems = async function* (ids: ID[]) {
                 for (const item of await loadItems(ids)) {
                     yield item;
                 }
-            }
+            };
         } else if (options.iterateItems) {
             this.iterateItems = options.iterateItems;
         } else {