@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/internal/download/thumbnailDownloader.ts

@@ -1,11 +1,11 @@
 import { c } from 'ttag';
 
-import { NodeType, ThumbnailType, ProtonDriveTelemetry, Logger, ThumbnailResult } from "../../interface";
+import { NodeType, ThumbnailType, ProtonDriveTelemetry, Logger, ThumbnailResult } from '../../interface';
 import { ValidationError } from '../../errors';
 import { LoggerWithPrefix } from '../../telemetry';
-import { DownloadAPIService } from "./apiService";
-import { DownloadCryptoService } from "./cryptoService";
-import { NodesService } from "./interface";
+import { DownloadAPIService } from './apiService';
+import { DownloadCryptoService } from './cryptoService';
+import { NodesService } from './interface';
 import { getErrorMessage } from '../errors';
 
 /**
@@ -24,8 +24,8 @@ export class ThumbnailDownloader {
     private batchThumbnailToNodeUids = new Map<string, string>();
     private ongoingDownloads = new Map<string, Promise<void>>();
     private bufferedThumbnails: (
-        { nodeUid: string, ok: true, thumbnail: Uint8Array } |
-        { nodeUid: string, ok: false, error: string }
+        | { nodeUid: string; ok: true; thumbnail: Uint8Array }
+        | { nodeUid: string; ok: false; error: string }
     )[] = [];
 
     constructor(
@@ -34,7 +34,7 @@ export class ThumbnailDownloader {
         private apiService: DownloadAPIService,
         private cryptoService: DownloadCryptoService,
     ) {
-        this.logger = telemetry.getLogger("download");
+        this.logger = telemetry.getLogger('download');
         this.nodesService = nodesService;
         this.apiService = apiService;
         this.cryptoService = cryptoService;
@@ -79,40 +79,41 @@ export class ThumbnailDownloader {
         this.bufferedThumbnails = [];
     }
 
-    private async *iterateThumbnailUids(nodeUids: string[], thumbnailType: ThumbnailType, signal?: AbortSignal): AsyncGenerator<
-        { nodeUid: string, ok: true, thumbnailUid: string } |
-        { nodeUid: string, ok: false, error: string }
+    private async *iterateThumbnailUids(
+        nodeUids: string[],
+        thumbnailType: ThumbnailType,
+        signal?: AbortSignal,
+    ): AsyncGenerator<
+        { nodeUid: string; ok: true; thumbnailUid: string } | { nodeUid: string; ok: false; error: string }
     > {
         for await (const node of this.nodesService.iterateNodes(nodeUids, signal)) {
             if ('missingUid' in node) {
                 yield {
                     nodeUid: node.missingUid,
                     ok: false,
-                    error: c("Error").t`Node not found`,
-                }
+                    error: c('Error').t`Node not found`,
+                };
                 continue;
             }
             if (node.type !== NodeType.File) {
                 yield {
                     nodeUid: node.uid,
                     ok: false,
-                    error: c("Error").t`Node is not a file`,
-                }
+                    error: c('Error').t`Node is not a file`,
+                };
                 continue;
             }
 
             let thumbnail;
             if (node.activeRevision?.ok) {
-                thumbnail = node.activeRevision.value.thumbnails?.find(
-                    (t) => t.type === thumbnailType,
-                );
+                thumbnail = node.activeRevision.value.thumbnails?.find((t) => t.type === thumbnailType);
             }
             if (!thumbnail) {
                 yield {
                     nodeUid: node.uid,
                     ok: false,
-                    error: c("Error").t`Node has no thumbnail`,
-                }
+                    error: c('Error').t`Node has no thumbnail`,
+                };
                 continue;
             }
 
@@ -120,7 +121,7 @@ export class ThumbnailDownloader {
                 nodeUid: node.uid,
                 ok: true,
                 thumbnailUid: thumbnail.uid,
-            }
+            };
         }
     }
 
@@ -163,13 +164,15 @@ export class ThumbnailDownloader {
                     }),
             );
         }
-        
+
         this.batchThumbnailToNodeUids.clear();
     }
 
-    private async *iterateThumbnailDownloads(signal?: AbortSignal): AsyncGenerator<
-        { nodeUid: string, ok: true, downloadPromise: Promise<Uint8Array> } |
-        { nodeUid: string, ok: false, error: string }
+    private async *iterateThumbnailDownloads(
+        signal?: AbortSignal,
+    ): AsyncGenerator<
+        | { nodeUid: string; ok: true; downloadPromise: Promise<Uint8Array> }
+        | { nodeUid: string; ok: false; error: string }
     > {
         const missingThumbnailUids = new Set(this.batchThumbnailToNodeUids.keys());
 
@@ -190,7 +193,7 @@ export class ThumbnailDownloader {
                     nodeUid,
                     ok: false,
                     error: result.error,
-                }
+                };
                 continue;
             }
 
@@ -198,7 +201,7 @@ export class ThumbnailDownloader {
                 nodeUid,
                 ok: true,
                 downloadPromise: this.downloadThumbnail(nodeUid, result.bareUrl, result.token, signal),
-            }
+            };
         }
 
         for (const uid of missingThumbnailUids) {
@@ -207,14 +210,19 @@ export class ThumbnailDownloader {
             yield {
                 nodeUid,
                 ok: false,
-                error: c("Error").t`Thumbnail not found`,
-            }
+                error: c('Error').t`Thumbnail not found`,
+            };
         }
     }
 
-    private async downloadThumbnail(nodeUid: string, bareUrl: string, token: string, signal?: AbortSignal): Promise<Uint8Array> {
+    private async downloadThumbnail(
+        nodeUid: string,
+        bareUrl: string,
+        token: string,
+        signal?: AbortSignal,
+    ): Promise<Uint8Array> {
         const logger = new LoggerWithPrefix(this.logger, `thumbnail ${token}`);
-        
+
         let decryptedBlock: Uint8Array | null = null;
         let attempt = 0;
 
@@ -229,11 +237,14 @@ export class ThumbnailDownloader {
                 ]);
 
                 if (!nodeKeys.contentKeyPacketSessionKey) {
-                    throw new ValidationError(c("Error").t`File has no content key`);
+                    throw new ValidationError(c('Error').t`File has no content key`);
                 }
 
                 logger.debug(`Decrypting`);
-                decryptedBlock = await this.cryptoService.decryptThumbnail(encryptedBlock, nodeKeys.contentKeyPacketSessionKey);
+                decryptedBlock = await this.cryptoService.decryptThumbnail(
+                    encryptedBlock,
+                    nodeKeys.contentKeyPacketSessionKey,
+                );
             } catch (error: unknown) {
                 if (attempt <= MAX_THUMBNAIL_DOWNLOAD_ATTEMPTS) {
                     logger.warn(`Thumbnail download failed #${attempt}, retrying: ${getErrorMessage(error)}`);

package/src/internal/errors.ts

@@ -1,6 +1,6 @@
 import { c } from 'ttag';
 
-import { VERIFICATION_STATUS } from "../crypto";
+import { VERIFICATION_STATUS } from '../crypto';
 
 export function getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : c('Error').t`Unknown error`;
@@ -9,11 +9,13 @@ export function getErrorMessage(error: unknown): string {
 /**
  * @param signatureType - Must be translated before calling this function.
  */
-export function getVerificationMessage(verified: VERIFICATION_STATUS, signatureType?: string, notAvailableVerificationKeys = false): string {
+export function getVerificationMessage(
+    verified: VERIFICATION_STATUS,
+    signatureType?: string,
+    notAvailableVerificationKeys = false,
+): string {
     if (verified === VERIFICATION_STATUS.NOT_SIGNED) {
-        return signatureType
-            ? c('Error').t`Missing signature for ${signatureType}`
-            : c('Error').t`Missing signature`;
+        return signatureType ? c('Error').t`Missing signature for ${signatureType}` : c('Error').t`Missing signature`;
     }
 
     if (notAvailableVerificationKeys) {

package/src/internal/events/apiService.ts

@@ -1,31 +1,36 @@
-import { Logger } from "../../interface";
-import { DriveAPIService, drivePaths, corePaths } from "../apiService";
-import { makeNodeUid } from "../uids";
-import { DriveEvents, DriveEvent, DriveEventType } from "./interface";
+import { DriveAPIService, drivePaths, corePaths } from '../apiService';
+import { makeNodeUid } from '../uids';
+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 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 GetVolumeLatestEventResponse =
+    drivePaths['/drive/volumes/{volumeID}/events/latest']['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 +38,24 @@ 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,
@@ -51,35 +63,33 @@ export class EventsAPIService {
     }
 
     async getVolumeLatestEventId(volumeId: string): Promise<string> {
-        const result = await this.apiService.get<GetVolumeLatestEventResponse>(`drive/volumes/${volumeId}/events/latest`);
+        const result = await this.apiService.get<GetVolumeLatestEventResponse>(
+            `drive/volumes/${volumeId}/events/latest`,
+        );
         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 { Logger } from '../../interface';
+import { LoggerWithPrefix } from '../../telemetry';
+import { EventsAPIService } from './apiService';
+import { DriveEvent, DriveEventType, EventManagerInterface } from './interface';
 
 /**
  * Combines API and event manager to provide a service for listening to
@@ -11,59 +9,39 @@ 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;
     }
 }