@protontech/drive-sdk 0.0.12 → 0.1.0

package/src/internal/apiService/errors.ts

@@ -14,6 +14,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
     const typedResult = result as {
         Code?: number;
         Error?: string;
+        Details?: object;
         exception?: string;
         message?: string;
         file?: string;
@@ -21,7 +22,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
         trace?: object;
     };
 
-    const [code, message] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`];
+    const [code, message, details] = [typedResult.Code || 0, typedResult.Error || c('Error').t`Unknown error`, typedResult.Details];
 
     const debug = typedResult.exception ? {
         exception: typedResult.exception,
@@ -55,7 +56,7 @@ export function apiErrorFactory({ response, result }: { response: Response, resu
         case ErrorCode.INSUFFICIENT_SHARE_QUOTA:
         case ErrorCode.INSUFFICIENT_SHARE_JOINED_QUOTA:
         case ErrorCode.INSUFFICIENT_BOOKMARKS_QUOTA:
-            return new ValidationError(message, code);
+            return new ValidationError(message, code, details);
         default:
             return new APICodeError(message, code, debug);
     }

package/src/internal/apiService/transformers.ts

@@ -6,6 +6,8 @@ export function nodeTypeNumberToNodeType(logger: Logger, nodeTypeNumber: number)
             return NodeType.Folder;
         case 2:
             return NodeType.File;
+        case 3:
+            return NodeType.Album;
         default:
             logger.warn(`Unknown node type: ${nodeTypeNumber}`);
             return NodeType.File;

package/src/internal/asyncIteratorMap.test.ts

@@ -0,0 +1,150 @@
+import { asyncIteratorMap } from './asyncIteratorMap';
+
+// Helper function to create an async generator from array
+async function* createAsyncGenerator<T>(items: T[]): AsyncGenerator<T> {
+    for (const item of items) {
+        yield item;
+    }
+}
+
+// Helper function to collect all results from async generator
+async function collectResults<T>(asyncGen: AsyncGenerator<T>): Promise<T[]> {
+    const results: T[] = [];
+    for await (const item of asyncGen) {
+        results.push(item);
+    }
+    return results;
+}
+
+describe('asyncIteratorMap', () => {
+    test('works with empty input', async () => {
+        const inputGen = createAsyncGenerator([]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([]);
+    });
+
+    test('works with single item', async () => {
+        const inputGen = createAsyncGenerator([42]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([84]);
+    });
+
+    test('works with 5 values', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5]);
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(inputGen, mapper);
+        const results = await collectResults(mappedGen);
+
+        expect(results).toEqual([2, 4, 6, 8, 10]);
+    });
+
+    test('works with slow mapper - finishes as fast as the longest delay', async () => {
+        const delays: { [key: number]: number } = { 1: 100, 2: 50, 3: 200, 4: 30, 5: 80 };
+        const inputGen = createAsyncGenerator(Object.keys(delays).map(Number));
+
+        const slowMapper = async (x: number) => {
+            await new Promise(resolve => setTimeout(resolve, delays[x]));
+            return x * 2;
+        };
+
+        const startTime = Date.now();
+        const mappedGen = asyncIteratorMap(inputGen, slowMapper, 5);
+        const results = await collectResults(mappedGen);
+        const endTime = Date.now();
+
+        // Should complete in roughly the time of the longest delay (200ms) plus some overhead
+        const executionTime = endTime - startTime;
+        expect(executionTime).toBeGreaterThanOrEqual(195); // We had failures with 199ms - JS is not precise.
+        expect(executionTime).toBeLessThan(250);
+
+        // Results should be in the order of the delays
+        expect(results).toEqual([8, 4, 10, 2, 6]);
+    });
+
+    test('handles errors from input iterator properly', async () => {
+        const throwingInputGen = async function*() {
+            yield 1;
+            yield 2;
+            throw new Error('Error providing value: 3');
+        }
+
+        const mapper = async (x: number) => x * 2;
+
+        const mappedGen = asyncIteratorMap(throwingInputGen(), mapper);
+
+        const results: number[] = [];
+        let caughtError: Error | null = null;
+
+        try {
+            for await (const item of mappedGen) {
+                results.push(item);
+            }
+        } catch (error) {
+            caughtError = error as Error;
+        }
+
+        expect(caughtError?.message).toBe('Error providing value: 3');
+        expect(results).toEqual([2, 4]);
+    });
+
+    test('handles errors from mapper properly', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5]);
+
+        const throwingMapper = async (x: number) => {
+            if (x === 3) {
+                throw new Error(`Error processing value: ${x}`);
+            }
+            return x * 2;
+        };
+
+        const mappedGen = asyncIteratorMap(inputGen, throwingMapper);
+
+        const results: number[] = [];
+        let caughtError: Error | null = null;
+
+        try {
+            for await (const item of mappedGen) {
+                results.push(item);
+            }
+        } catch (error) {
+            caughtError = error as Error;
+        }
+
+        expect(caughtError?.message).toBe('Error processing value: 3');
+        expect(results).toEqual([2, 4]);
+    });
+
+    test('respects concurrency limit', async () => {
+        const inputGen = createAsyncGenerator([1, 2, 3, 4, 5, 6, 7, 8]);
+
+        let concurrentExecutions = 0;
+        let maxConcurrentExecutions = 0;
+
+        const mapper = async (x: number) => {
+            concurrentExecutions++;
+            maxConcurrentExecutions = Math.max(maxConcurrentExecutions, concurrentExecutions);
+
+            // Wait for 100ms to simulate work
+            await new Promise(resolve => setTimeout(resolve, 100));
+
+            concurrentExecutions--;
+            return x * 2;
+        };
+
+        const concurrencyLimit = 3;
+        const mappedGen = asyncIteratorMap(inputGen, mapper, concurrencyLimit);
+        const results = await collectResults(mappedGen);
+
+        expect(maxConcurrentExecutions).toBe(concurrencyLimit);
+        expect(results).toEqual([2, 4, 6, 8, 10, 12, 14, 16]);
+    });
+});

package/src/internal/asyncIteratorMap.ts

@@ -0,0 +1,64 @@
+const DEFAULT_CONCURRENCY = 10;
+
+/**
+ * Maps values from an input iterator and produces a new iterator.
+ * The mapper function is not awaited immediately to allow for parallel
+ * execution. The order of the items in the output iterator is not the
+ * same as the order of the items in the input iterator.
+ *
+ * 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.
+ * @returns An async iterator that yields the mapped values.
+ */
+export async function* asyncIteratorMap<I, O>(
+    inputIterator: AsyncGenerator<I>,
+    mapper: (item: I) => Promise<O>,
+    concurrency: number = DEFAULT_CONCURRENCY,
+): AsyncGenerator<O> {
+    let done = false;
+
+    const executing = new Set<Promise<void>>();
+    const results: Array<Promise<O>> = [];
+
+    const pump = async () => {
+        let next;
+        try {
+            next = await inputIterator.next();
+        } catch (error) {
+            results.push(Promise.reject(error));
+            return;
+        }
+
+        if (next.done) {
+            done = true;
+            return;
+        }
+
+        const promise = mapper(next.value)
+            .then((result) => {
+                results.push(Promise.resolve(result));
+            })
+            .catch((error) => {
+                results.push(Promise.reject(error));
+            });
+        executing.add(promise);
+        void promise.finally(() => executing.delete(promise));
+    };
+
+    while (!done || executing.size > 0 || results.length > 0) {
+        while (!done && executing.size < concurrency) {
+            await pump();
+        }
+
+        if (results.length > 0) {
+            yield await results.shift()!;
+        } else if (executing.size > 0) {
+            // Wait for at least one task to complete
+            await Promise.race(Array.from(executing));
+        }
+    }
+}

package/src/internal/download/apiService.ts

@@ -1,5 +1,3 @@
-import { c } from "ttag";
-import { ValidationError } from "../../errors";
 import { DriveAPIService, drivePaths, ObserverStream } from "../apiService";
 import { makeNodeThumbnailUid, splitNodeRevisionUid, splitNodeThumbnailUid } from "../uids";
 import { BlockMetadata } from "./interface";
@@ -85,19 +83,22 @@ export class DownloadAPIService {
         return encryptedBlock;
     }
 
-    // Improvement requested: support multiple volumes.
     async* iterateThumbnails(thumbnailUids: string[], signal?: AbortSignal): AsyncGenerator<
         { uid: string, ok: true, bareUrl: string, token: string } |
         { uid: string, ok: false, error: string }
     > {
-        const thumbnailIds = thumbnailUids.map(splitNodeThumbnailUid);
+        const splitedThumbnailsIds = thumbnailUids.map(splitNodeThumbnailUid);
 
-        const uniqueVolumeIds = new Set(thumbnailIds.map(({ volumeId }) => volumeId));
-        if (uniqueVolumeIds.size !== 1) {
-            throw new ValidationError(c('Error').t`Loading thumbnails from multiple sections is not allowed`);
+        const thumbnailIdsByVolumeId = new Map<string, { volumeId: string, thumbnailId: string, nodeId: string }[]>();
+        for (const { volumeId, thumbnailId, nodeId } of splitedThumbnailsIds) {
+            if (!thumbnailIdsByVolumeId.has(volumeId)) {
+                thumbnailIdsByVolumeId.set(volumeId, []);
+            }
+            thumbnailIdsByVolumeId.get(volumeId)?.push({ volumeId, thumbnailId, nodeId });
         }
-        const volumeId = thumbnailIds[0].volumeId;
 
+
+      for (const [volumeId, thumbnailIds] of thumbnailIdsByVolumeId.entries()) {
         const result = await this.apiService.post<PostGetThumbnailsRequest, PostGetThumbnailsResponse>(
             `drive/volumes/${volumeId}/thumbnails`,
             {
@@ -130,6 +131,8 @@ export class DownloadAPIService {
                 error: error.Error,
             };
         }
+
+      }
     }
 }
 

package/src/internal/download/fileDownloader.ts

@@ -49,7 +49,7 @@ export class FileDownloader {
         return this.revision.claimedSize;
     }
 
-    writeToStream(stream: WritableStream, onProgress: (downloadedBytes: number) => void): DownloadController {
+    writeToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
         if (this.controller.promise) {
             throw new Error(`Download already started`);
         }
@@ -57,7 +57,7 @@ export class FileDownloader {
         return this.controller;
     }
 
-    unsafeWriteToStream(stream: WritableStream, onProgress: (downloadedBytes: number) => void): DownloadController {
+    unsafeWriteToStream(stream: WritableStream, onProgress?: (downloadedBytes: number) => void): DownloadController {
         if (this.controller.promise) {
             throw new Error(`Download already started`);
         }

package/src/internal/events/apiService.ts

@@ -1,31 +1,32 @@
-import { Logger } from "../../interface";
 import { DriveAPIService, drivePaths, corePaths } from "../apiService";
 import { makeNodeUid } from "../uids";
-import { DriveEvents, DriveEvent, DriveEventType } from "./interface";
+import { DriveEventsListWithStatus, DriveEvent, DriveEventType, NodeEvent, NodeEventType } from "./interface";
 
 type GetCoreLatestEventResponse = corePaths['/core/{_version}/events/latest']['get']['responses']['200']['content']['application/json'];
 type GetCoreEventResponse = corePaths['/core/{_version}/events/{id}']['get']['responses']['200']['content']['application/json'];
 
 type GetVolumeLatestEventResponse = drivePaths['/drive/volumes/{volumeID}/events/latest']['get']['responses']['200']['content']['application/json'];
-type GetVokumeEventResponse = drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
+type GetVolumeEventResponse = drivePaths['/drive/v2/volumes/{volumeID}/events/{eventID}']['get']['responses']['200']['content']['application/json'];
 
-const VOLUME_EVENT_TYPE_MAP = {
+interface VolumeEventTypeMap {
+    [key: number]: NodeEventType,
+}
+const VOLUME_EVENT_TYPE_MAP: VolumeEventTypeMap = {
     0: DriveEventType.NodeDeleted,
     1: DriveEventType.NodeCreated,
     2: DriveEventType.NodeUpdated,
-    3: DriveEventType.NodeUpdatedMetadata,
+    3: DriveEventType.NodeUpdated,
 }
 
 /**
  * Provides API communication for fetching events.
- * 
+ *
  * The service is responsible for transforming local objects to API payloads
  * and vice versa. It should not contain any business logic.
  */
 export class EventsAPIService {
-    constructor(private apiService: DriveAPIService, private logger?: Logger) {
+    constructor(private apiService: DriveAPIService) {
         this.apiService = apiService;
-        this.logger = logger;
     }
 
     async getCoreLatestEventId(): Promise<string> {
@@ -33,17 +34,19 @@ export class EventsAPIService {
         return result.EventID as string;
     }
 
-    async getCoreEvents(eventId: string): Promise<DriveEvents> {
-        // TODO: Switch to v6 endpoint: DriveShareRefresh doesnt seem to be part of it.
+    async getCoreEvents(eventId: string): Promise<DriveEventsListWithStatus> {
+        // TODO: Switch to v6 endpoint?
         const result = await this.apiService.get<GetCoreEventResponse>(`core/v5/events/${eventId}`);
-        const events: DriveEvent[] = result.DriveShareRefresh?.Action === 2 ? [
-            {
-                type: DriveEventType.ShareWithMeUpdated,
-            }
-        ] : [];
+        // in core/v5/events, refresh is always all apps, value 255
+        const refresh = result.Refresh > 0;
+        const events: DriveEvent[] = (refresh || result.DriveShareRefresh?.Action === 2) ? [{
+            type: DriveEventType.SharedWithMeUpdated,
+            eventId: result.EventID,
+            treeEventScopeId: 'core',
+        }] : [];
 
         return {
-            lastEventId: result.EventID,
+            latestEventId: result.EventID,
             more: result.More === 1,
             refresh: result.Refresh === 1,
             events,
@@ -55,31 +58,25 @@ export class EventsAPIService {
         return result.EventID;
     }
 
-    async getVolumeEvents(volumeId: string, eventId: string, isOwnVolume = false): Promise<DriveEvents> {
-        const result = await this.apiService.get<GetVokumeEventResponse>(`drive/v2/volumes/${volumeId}/events/${eventId}`);
+    async getVolumeEvents(volumeId: string, eventId: string): Promise<DriveEventsListWithStatus> {
+        const result = await this.apiService.get<GetVolumeEventResponse>(`drive/v2/volumes/${volumeId}/events/${eventId}`);
         return {
-            lastEventId: result.EventID,
+            latestEventId: result.EventID,
             more: result.More,
             refresh: result.Refresh,
-            events: result.Events.map((event): DriveEvent => {
+            events: result.Events.map((event): NodeEvent => {
                 const type = VOLUME_EVENT_TYPE_MAP[event.EventType];
                 const uids = {
                     nodeUid: makeNodeUid(volumeId, event.Link.LinkID),
                     parentNodeUid: makeNodeUid(volumeId, event.Link.ParentLinkID as string),
                 }
-                // VOLUME_EVENT_TYPE_MAP will never return this event type.
-                // It is here to satisfy the type checker. It is safe to do.
-                if (type === DriveEventType.ShareWithMeUpdated) {
-                    return {
-                        type,
-                    };
-                }
                 return {
                     type,
                     ...uids,
                     isTrashed: event.Link.IsTrashed,
                     isShared: event.Link.IsShared,
-                    isOwnVolume,
+                    eventId: event.EventID,
+                    treeEventScopeId: volumeId,
                 };
             }),
         };

package/src/internal/events/coreEventManager.test.ts

@@ -0,0 +1,101 @@
+import { getMockLogger } from "../../tests/logger";
+import { EventsAPIService } from "./apiService";
+import { DriveEvent, DriveEventsListWithStatus, DriveEventType } from "./interface";
+import { CoreEventManager } from "./coreEventManager";
+
+describe("CoreEventManager", () => {
+    let mockApiService: jest.Mocked<EventsAPIService>;
+    let coreEventManager: CoreEventManager;
+    const mockLogger = getMockLogger();
+
+    beforeEach(() => {
+        // Reset mocks
+        jest.clearAllMocks();
+
+        mockApiService = {
+            getCoreLatestEventId: jest.fn(),
+            getCoreEvents: jest.fn(),
+            getVolumeLatestEventId: jest.fn(),
+            getVolumeEvents: jest.fn(),
+        } as unknown as jest.Mocked<EventsAPIService>;
+
+        coreEventManager = new CoreEventManager(mockLogger, mockApiService);
+    });
+
+    describe("getLatestEventId", () => {
+        it("should return the latest event ID from API service", async () => {
+            const expectedEventId = "event-123";
+            mockApiService.getCoreLatestEventId.mockResolvedValue(expectedEventId);
+
+            const result = await coreEventManager.getLatestEventId();
+
+            expect(result).toBe(expectedEventId);
+            expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
+        });
+
+        it("should handle API service errors", async () => {
+            const error = new Error("API error");
+            mockApiService.getCoreLatestEventId.mockRejectedValue(error);
+
+            await expect(coreEventManager.getLatestEventId()).rejects.toThrow("API error");
+            expect(mockApiService.getCoreLatestEventId).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe("getEvents", () => {
+        const eventId = "event1";
+        const latestEventId = "event2";
+
+        it("should yield ShareWithMeUpdated event when refresh is true", async () => {
+            const mockEvents: DriveEventsListWithStatus = {
+                latestEventId,
+                more: false,
+                refresh: true,
+                events: [],
+            };
+            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
+
+            const events = [];
+            for await (const event of coreEventManager.getEvents(eventId)) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(1);
+            expect(events[0]).toEqual({
+                type: DriveEventType.SharedWithMeUpdated,
+                treeEventScopeId: 'core',
+                eventId: latestEventId,
+            });
+            expect(mockApiService.getCoreEvents).toHaveBeenCalledWith(eventId);
+        });
+
+        it("should yield all events when there are actual events", async () => {
+            const mockEvent1: DriveEvent = {
+                type: DriveEventType.SharedWithMeUpdated,
+                eventId: "event-1",
+                treeEventScopeId: 'core',
+            };
+            const mockEvent2: DriveEvent = {
+                type: DriveEventType.SharedWithMeUpdated,
+                eventId: "event-2",
+                treeEventScopeId: 'core',
+            };
+            const mockEvents: DriveEventsListWithStatus = {
+                latestEventId,
+                more: false,
+                refresh: false,
+                events: [mockEvent1, mockEvent2],
+            };
+            mockApiService.getCoreEvents.mockResolvedValue(mockEvents);
+
+            const events = [];
+            for await (const event of coreEventManager.getEvents(eventId)) {
+                events.push(event);
+            }
+
+            expect(events).toHaveLength(2);
+            expect(events[0]).toEqual(mockEvent1);
+            expect(events[1]).toEqual(mockEvent2);
+        });
+    });
+});

package/src/internal/events/coreEventManager.ts

@@ -1,9 +1,7 @@
 import { Logger } from "../../interface";
 import { LoggerWithPrefix } from "../../telemetry";
 import { EventsAPIService } from "./apiService";
-import { EventsCache } from "./cache";
-import { DriveEvent, DriveEventType } from "./interface";
-import { EventManager } from "./eventManager";
+import { DriveEvent, DriveEventType, EventManagerInterface } from "./interface";
 
 /**
  * Combines API and event manager to provide a service for listening to
@@ -11,59 +9,36 @@ import { EventManager } from "./eventManager";
  * At this moment, Drive listenes only to shares with me updates from core
  * events. Such even indicates that user was invited to the new share or
  * that user's membership was removed from existing one and lost access.
- * 
+ *
  * The client might be already using own core events, thus this service
  * is here only in case the client is not connected to the Proton services
  * with own implementation.
  */
-export class CoreEventManager {
-    private manager: EventManager<DriveEvent>;
-
-    constructor(logger: Logger, private apiService: EventsAPIService, private cache: EventsCache) {
+export class CoreEventManager implements EventManagerInterface<DriveEvent> {
+    constructor(private logger: Logger, private apiService: EventsAPIService) {
         this.apiService = apiService;
 
-        this.manager = new EventManager(
-            new LoggerWithPrefix(logger, `core`),
-            () => this.getLastEventId(),
-            (eventId) => this.apiService.getCoreEvents(eventId),
-            (lastEventId) => this.cache.setLastEventId('core', {
-                lastEventId,
-                pollingIntervalInSeconds: this.manager.pollingIntervalInSeconds,
-                isOwnVolume: false,
-            }),
-        );
+        this.logger = new LoggerWithPrefix(logger, `core`);
     }
 
-    private async getLastEventId(): Promise<string> {
-        const lastEventId = await this.cache.getLastEventId('core');
-        if (lastEventId) {
-            return lastEventId;
-        }
-        return this.apiService.getCoreLatestEventId();
+    async getLatestEventId(): Promise<string> {
+        return await this.apiService.getCoreLatestEventId();
     }
 
-    async startSubscription(): Promise<void> {
-        await this.manager.start();
-    }
-
-    async stopSubscription(): Promise<void> {
-        await this.manager.stop();
+    async * getEvents(eventId: string): AsyncIterable<DriveEvent> {
+        const events = await this.apiService.getCoreEvents(eventId);
+        if (events.events.length === 0 && events.latestEventId !== eventId) {
+            yield {
+                type: DriveEventType.SharedWithMeUpdated,
+                treeEventScopeId: 'core',
+                eventId: events.latestEventId,
+            };
+            return;
+        }
+        yield* events.events;
     }
 
-    addListener(callback: (events: DriveEvent[]) => Promise<void>): void {
-        this.manager.addListener(async (events, fullRefresh) => {
-            if (events) {
-                await callback(events);
-            }
-            if (fullRefresh) {
-                // Because only updates about shares that are shared with me
-                // are listened to from core events, in the case of core full
-                // refresh, we don't have to refresh anything more than this
-                // one specific event.
-                await callback([{
-                    type: DriveEventType.ShareWithMeUpdated,
-                }]);
-            }
-        });
+    getLogger(): Logger {
+        return this.logger;
     }
 }