@protontech/drive-sdk 0.1.2 → 0.2.0

package/src/internal/download/seekableStream.ts

@@ -0,0 +1,182 @@
+interface UnderlyingSeekableSource extends UnderlyingDefaultSource<Uint8Array> {
+    seek: (position: number) => void | Promise<void>;
+}
+
+/**
+ * A seekable readable stream that can be used to seek to a specific position
+ * in the stream.
+ *
+ * This is useful for downloading the file in chunks or jumping to a specific
+ * position in the file when streaming a video.
+ *
+ * Example to get next chunk of data from the stream at position 100:
+ *
+ * ```
+ * const stream = new SeekableReadableStream(underlyingSource);
+ * const reader = stream.getReader();
+ * await stream.seek(100);
+ * const data = await stream.read();
+ * console.log(data);
+ * ```
+ */
+export class SeekableReadableStream extends ReadableStream<Uint8Array> {
+    private seekCallback: (position: number) => void | Promise<void>;
+
+    constructor({ seek, ...underlyingSource }: UnderlyingSeekableSource, queuingStrategy?: QueuingStrategy<Uint8Array>) {
+        super(underlyingSource, queuingStrategy);
+        this.seekCallback = seek;
+    }
+
+    seek(position: number): void | Promise<void> {
+        return this.seekCallback(position);
+    }
+}
+
+/**
+ * A buffered seekable stream that allows to seek and read specific number of
+ * bytes from the stream.
+ *
+ * This is useful for reading specific range of data from the stream. Example
+ * being video player buffering the next several bytes.
+ *
+ * The underlying source can chunk the data into various sizes. To ensure that
+ * every read operation is for the correct location, the SeekableStream is not
+ * queueing the data upfront. Instead, it will read the data and buffer it for
+ * the next read operation. If seek is called, the internal buffer is updated
+ * accordingly.
+ *
+ * Example to read 10 bytes from the stream at position 100:
+ *
+ * ```
+ * const stream = new BufferedSeekableStream(underlyingSource);
+ * await stream.seek(100);
+ * const data = await stream.read(10);
+ * console.log(data);
+ * ```
+ */
+export class BufferedSeekableStream extends SeekableReadableStream {
+    private buffer: Uint8Array = new Uint8Array(0);
+    private bufferPosition: number = 0;
+    private reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+    private streamClosed: boolean = false;
+    private currentPosition: number = 0;
+
+    constructor(underlyingSource: UnderlyingSeekableSource, queuingStrategy?: QueuingStrategy<Uint8Array>) {
+        // highWaterMark means that the stream will buffer up to this many
+        // bytes. We do not want to buffer anything
+        if (queuingStrategy && queuingStrategy.highWaterMark !== 0) {
+            throw new Error('highWaterMark must be 0');
+        }
+
+        super(underlyingSource, {
+            ...queuingStrategy,
+            highWaterMark: 0,
+        });
+
+        this.reader = super.getReader();
+    }
+
+    /**
+     * Read a specific number of bytes from the stream.
+     *
+     * When the underlying source provides more bytes than requested, the
+     * remaining bytes are buffered and used for the next read operation.
+     *
+     * @param numBytes - Number of bytes to read
+     * @returns Promise<Uint8Array> The read bytes
+     */
+    async read(numBytes: number): Promise<{ value: Uint8Array; done: boolean }> {
+        if (numBytes <= 0) {
+            throw new Error('Invalid number of bytes to read');
+        }
+
+        await this.ensureBufferSize(numBytes);
+
+        const result = this.buffer.slice(this.bufferPosition, this.bufferPosition + numBytes);
+        this.bufferPosition += numBytes;
+        this.currentPosition += numBytes;
+        return {
+            value: result,
+            done: this.streamClosed,
+        };
+    }
+
+    private async ensureBufferSize(minBytes: number): Promise<void> {
+        const availableBytes = this.buffer.length - this.bufferPosition;
+        const neededBytes = minBytes - availableBytes;
+
+        if (neededBytes <= 0 || this.streamClosed) {
+            return;
+        }
+
+        const chunks: Uint8Array[] = [];
+        let totalBytesRead = 0;
+
+        while (totalBytesRead < neededBytes && !this.streamClosed) {
+            if (!this.reader) {
+                throw new Error('Stream reader is not available');
+            }
+
+            const { done, value } = await this.reader.read();
+
+            if (done) {
+                this.streamClosed = true;
+                break;
+            }
+
+            if (value) {
+                chunks.push(value);
+                totalBytesRead += value.length;
+            }
+        }
+
+        if (chunks.length > 0) {
+            // Create new buffer with existing unused data plus new chunks
+            const unusedBufferData = this.buffer.slice(this.bufferPosition);
+            const newTotalLength = unusedBufferData.length + totalBytesRead;
+            const newBuffer = new Uint8Array(newTotalLength);
+
+            newBuffer.set(unusedBufferData, 0);
+            let offset = unusedBufferData.length;
+            for (const chunk of chunks) {
+                newBuffer.set(chunk, offset);
+                offset += chunk.length;
+            }
+
+            this.buffer = newBuffer;
+            this.bufferPosition = 0;
+        }
+    }
+
+    /**
+     * Seek to the given position in the stream.
+     *
+     * If the position is outside of internally buffered data, the buffer is
+     * cleared. If the position is seeked back, the buffer is read again from
+     * the underlying source.
+     *
+     * @param position - The position to seek to in bytes.
+     */
+    async seek(position: number): Promise<void> {
+        const endOfBufferPosition = this.currentPosition + (this.buffer.length - this.bufferPosition);
+
+        if (position > endOfBufferPosition) {
+            this.buffer = new Uint8Array(0);
+            this.bufferPosition = 0;
+        } else if (position < this.currentPosition) {
+            this.buffer = new Uint8Array(0);
+            this.bufferPosition = 0;
+        } else {
+            this.bufferPosition += position - this.currentPosition;
+        }
+
+        await super.seek(position);
+
+        if (this.reader) {
+            this.reader.releaseLock();
+        }
+        this.reader = super.getReader();
+        this.streamClosed = false;
+        this.currentPosition = position;
+    }
+}

package/src/internal/download/telemetry.test.ts

@@ -14,7 +14,7 @@ describe('DownloadTelemetry', () => {
 
     beforeEach(() => {
         mockTelemetry = {
-            logEvent: jest.fn(),
+            recordMetric: jest.fn(),
             getLogger: jest.fn().mockReturnValue({
                 info: jest.fn(),
                 warn: jest.fn(),
@@ -34,7 +34,7 @@ describe('DownloadTelemetry', () => {
         const error = new Error('Failed');
         await downloadTelemetry.downloadInitFailed(nodeUid, error);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'download',
             volumeType: 'own_volume',
             downloadedSize: 0,
@@ -47,7 +47,7 @@ describe('DownloadTelemetry', () => {
         const error = new Error('Failed');
         await downloadTelemetry.downloadFailed(revisionUid, error, 123, 456);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'download',
             volumeType: 'own_volume',
             downloadedSize: 123,
@@ -60,7 +60,7 @@ describe('DownloadTelemetry', () => {
     it('should log successful download (excludes error)', async () => {
         await downloadTelemetry.downloadFinished(revisionUid, 500);
 
-        expect(mockTelemetry.logEvent).toHaveBeenCalledWith({
+        expect(mockTelemetry.recordMetric).toHaveBeenCalledWith({
             eventName: 'download',
             volumeType: 'own_volume',
             downloadedSize: 500,
@@ -70,7 +70,7 @@ describe('DownloadTelemetry', () => {
 
     describe('detect error category', () => {
         const verifyErrorCategory = (error: string) => {
-            expect(mockTelemetry.logEvent).toHaveBeenCalledWith(
+            expect(mockTelemetry.recordMetric).toHaveBeenCalledWith(
                 expect.objectContaining({
                     error,
                 }),
@@ -80,7 +80,7 @@ describe('DownloadTelemetry', () => {
         it('should ignore ValidationError', async () => {
             const error = new ValidationError('Validation error');
             await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
-            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+            expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('should ignore AbortError', async () => {
@@ -88,7 +88,7 @@ describe('DownloadTelemetry', () => {
             error.name = 'AbortError';
             await downloadTelemetry.downloadFailed(revisionUid, error, 100, 200);
 
-            expect(mockTelemetry.logEvent).not.toHaveBeenCalled();
+            expect(mockTelemetry.recordMetric).not.toHaveBeenCalled();
         });
 
         it('should detect "rate_limited" error for RateLimitedError', async () => {

package/src/internal/download/telemetry.ts

@@ -80,7 +80,7 @@ export class DownloadTelemetry {
             this.logger.error('Failed to get metric volume type', error);
         }
 
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'download',
             volumeType,
             ...options,

package/src/internal/errors.test.ts

@@ -2,20 +2,54 @@ import { VERIFICATION_STATUS } from '../crypto';
 import { getVerificationMessage } from './errors';
 
 describe('getVerificationMessage', () => {
-    const testCases: [VERIFICATION_STATUS, string | undefined, boolean, string][] = [
-        [VERIFICATION_STATUS.NOT_SIGNED, 'type', false, 'Missing signature for type'],
-        [VERIFICATION_STATUS.NOT_SIGNED, undefined, false, 'Missing signature'],
-        [VERIFICATION_STATUS.NOT_SIGNED, 'type', true, 'Missing signature for type'],
-        [VERIFICATION_STATUS.NOT_SIGNED, undefined, true, 'Missing signature'],
-        [VERIFICATION_STATUS.SIGNED_AND_INVALID, 'type', false, 'Signature verification for type failed'],
-        [VERIFICATION_STATUS.SIGNED_AND_INVALID, undefined, false, 'Signature verification failed'],
-        [VERIFICATION_STATUS.SIGNED_AND_INVALID, 'type', true, 'Verification keys for type are not available'],
-        [VERIFICATION_STATUS.SIGNED_AND_INVALID, undefined, true, 'Verification keys are not available'],
+    const testCases: [VERIFICATION_STATUS, Error[] | undefined, string | undefined, boolean, string][] = [
+        [VERIFICATION_STATUS.NOT_SIGNED, undefined, 'type', false, 'Missing signature for type'],
+        [VERIFICATION_STATUS.NOT_SIGNED, undefined, undefined, false, 'Missing signature'],
+        [VERIFICATION_STATUS.NOT_SIGNED, undefined, 'type', true, 'Missing signature for type'],
+        [VERIFICATION_STATUS.NOT_SIGNED, undefined, undefined, true, 'Missing signature'],
+        [VERIFICATION_STATUS.SIGNED_AND_INVALID, undefined, 'type', false, 'Signature verification for type failed'],
+        [VERIFICATION_STATUS.SIGNED_AND_INVALID, undefined, undefined, false, 'Signature verification failed'],
+        [
+            VERIFICATION_STATUS.SIGNED_AND_INVALID,
+            undefined,
+            'type',
+            true,
+            'Verification keys for type are not available',
+        ],
+        [VERIFICATION_STATUS.SIGNED_AND_INVALID, undefined, undefined, true, 'Verification keys are not available'],
+        [
+            VERIFICATION_STATUS.SIGNED_AND_INVALID,
+            [new Error('error1'), new Error('error2')],
+            undefined,
+            false,
+            'Signature verification failed: error1, error2',
+        ],
+        [
+            VERIFICATION_STATUS.SIGNED_AND_INVALID,
+            [new Error('error1'), new Error('error2')],
+            'type',
+            false,
+            'Signature verification for type failed: error1, error2',
+        ],
+        [
+            VERIFICATION_STATUS.SIGNED_AND_INVALID,
+            [new Error('error1'), new Error('error2')],
+            undefined,
+            true,
+            'Verification keys are not available',
+        ],
+        [
+            VERIFICATION_STATUS.SIGNED_AND_INVALID,
+            [new Error('error1'), new Error('error2')],
+            'type',
+            true,
+            'Verification keys for type are not available',
+        ],
     ];
 
-    for (const [status, type, notAvailable, expected] of testCases) {
+    for (const [status, errors, type, notAvailable, expected] of testCases) {
         it(`returns correct message for status ${status} with type ${type} and notAvailable ${notAvailable}`, () => {
-            expect(getVerificationMessage(status, type, notAvailable)).toBe(expected);
+            expect(getVerificationMessage(status, errors, type, notAvailable)).toBe(expected);
         });
     }
 });

package/src/internal/errors.ts

@@ -11,6 +11,7 @@ export function getErrorMessage(error: unknown): string {
  */
 export function getVerificationMessage(
     verified: VERIFICATION_STATUS,
+    verificationErrors?: Error[],
     signatureType?: string,
     notAvailableVerificationKeys = false,
 ): string {
@@ -24,6 +25,13 @@ export function getVerificationMessage(
             : c('Error').t`Verification keys are not available`;
     }
 
+    if (verificationErrors) {
+        const errorMessage = verificationErrors?.map((e) => e.message).join(', ');
+        return signatureType
+            ? c('Error').t`Signature verification for ${signatureType} failed: ${errorMessage}`
+            : c('Error').t`Signature verification failed: ${errorMessage}`;
+    }
+
     return signatureType
         ? c('Error').t`Signature verification for ${signatureType} failed`
         : c('Error').t`Signature verification failed`;

package/src/internal/events/index.ts

@@ -121,7 +121,7 @@ export class DriveEventsService {
     }
 
     private sendNumberOfVolumeSubscriptionsToTelemetry() {
-        this.telemetry.logEvent({
+        this.telemetry.recordMetric({
             eventName: 'volumeEventsSubscriptionsChanged',
             numberOfVolumeSubscriptions: Object.keys(this.volumeEventManagers).length,
         });

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

@@ -76,7 +76,7 @@ function generateAPINode() {
     };
 }
 
-function generateFileNode(overrides = {}) {
+function generateFileNode(overrides = {}, encryptedCryptoOverrides = {}) {
     const node = generateNode();
     return {
         ...node,
@@ -98,12 +98,13 @@ function generateFileNode(overrides = {}) {
                 armoredExtendedAttributes: '{file}',
                 thumbnails: [],
             },
+            ...encryptedCryptoOverrides,
         },
         ...overrides,
     };
 }
 
-function generateFolderNode(overrides = {}) {
+function generateFolderNode(overrides = {}, encryptedCryptoOverrides = {}) {
     const node = generateNode();
     return {
         ...node,
@@ -114,6 +115,7 @@ function generateFolderNode(overrides = {}) {
                 armoredHashKey: 'nodeHashKey',
                 armoredExtendedAttributes: '{folder}',
             },
+            ...encryptedCryptoOverrides,
         },
         ...overrides,
     };
@@ -140,7 +142,8 @@ function generateNode() {
 
         shareId: undefined,
         isShared: false,
-        directMemberRole: MemberRole.Admin,
+        directRole: MemberRole.Admin,
+        membership: undefined,
 
         encryptedCrypto: {
             armoredKey: 'nodeKey',
@@ -148,6 +151,7 @@ function generateNode() {
             armoredNodePassphraseSignature: 'nodePassSig',
             nameSignatureEmail: 'nameSigEmail',
             signatureEmail: 'sigEmail',
+            membership: undefined,
         },
     };
 }
@@ -211,14 +215,34 @@ describe('nodeAPIService', () => {
                         },
                         Membership: {
                             Permissions: 22,
+                            InviteTime: 1234567890,
+                            InviterEmail: 'inviterEmail',
+                            MemberSharePassphraseKeyPacket: 'memberSharePassphraseKeyPacket',
+                            InviterSharePassphraseKeyPacketSignature: 'inviterSharePassphraseKeyPacketSignature',
+                            InviteeSharePassphraseSessionKeySignature: 'inviteeSharePassphraseSessionKeySignature',
+                        },
+                    },
+                ),
+                generateFolderNode(
+                    {
+                        isShared: true,
+                        shareId: 'shareId',
+                        directRole: MemberRole.Admin,
+                        membership: {
+                            role: MemberRole.Admin,
+                            inviteTime: new Date(1234567890000),
+                        },
+                    },
+                    {
+                        membership: {
+                            inviterEmail: 'inviterEmail',
+                            base64MemberSharePassphraseKeyPacket: 'memberSharePassphraseKeyPacket',
+                            armoredInviterSharePassphraseKeyPacketSignature: 'inviterSharePassphraseKeyPacketSignature',
+                            armoredInviteeSharePassphraseSessionKeySignature:
+                                'inviteeSharePassphraseSessionKeySignature',
                         },
                     },
                 ),
-                generateFolderNode({
-                    isShared: true,
-                    shareId: 'shareId',
-                    directMemberRole: MemberRole.Admin,
-                }),
             );
         });
 
@@ -232,14 +256,34 @@ describe('nodeAPIService', () => {
                         },
                         Membership: {
                             Permissions: 42,
+                            InviteTime: 1234567890,
+                            InviterEmail: 'inviterEmail',
+                            MemberSharePassphraseKeyPacket: 'memberSharePassphraseKeyPacket',
+                            InviterSharePassphraseKeyPacketSignature: 'inviterSharePassphraseKeyPacketSignature',
+                            InviteeSharePassphraseSessionKeySignature: 'inviteeSharePassphraseSessionKeySignature',
+                        },
+                    },
+                ),
+                generateFolderNode(
+                    {
+                        isShared: true,
+                        shareId: 'shareId',
+                        directRole: MemberRole.Viewer,
+                        membership: {
+                            role: MemberRole.Viewer,
+                            inviteTime: new Date(1234567890000),
+                        },
+                    },
+                    {
+                        membership: {
+                            inviterEmail: 'inviterEmail',
+                            base64MemberSharePassphraseKeyPacket: 'memberSharePassphraseKeyPacket',
+                            armoredInviterSharePassphraseKeyPacketSignature: 'inviterSharePassphraseKeyPacketSignature',
+                            armoredInviteeSharePassphraseSessionKeySignature:
+                                'inviteeSharePassphraseSessionKeySignature',
                         },
                     },
                 ),
-                generateFolderNode({
-                    isShared: true,
-                    shareId: 'shareId',
-                    directMemberRole: MemberRole.Viewer,
-                }),
                 'myVolumeId',
             );
         });
@@ -308,12 +352,12 @@ describe('nodeAPIService', () => {
                 generateFolderNode({
                     uid: 'volumeId1~nodeId1',
                     parentUid: 'volumeId1~parentNodeId1',
-                    directMemberRole: MemberRole.Admin,
+                    directRole: MemberRole.Admin,
                 }),
                 generateFolderNode({
                     uid: 'volumeId2~nodeId2',
                     parentUid: 'volumeId2~parentNodeId2',
-                    directMemberRole: MemberRole.Inherited,
+                    directRole: MemberRole.Inherited,
                 }),
             ]);
         });

package/src/internal/nodes/apiService.ts

@@ -8,7 +8,7 @@ import {
     drivePaths,
     isCodeOk,
     nodeTypeNumberToNodeType,
-    permissionsToDirectMemberRole,
+    permissionsToMemberRole,
 } from '../apiService';
 import { asyncIteratorRace } from '../asyncIteratorRace';
 import { batch } from '../batch';
@@ -471,6 +471,8 @@ function linkToEncryptedNode(
     link: PostLoadLinksMetadataResponse['Links'][0],
     isAdmin: boolean,
 ): EncryptedNode {
+    const membershipRole = permissionsToMemberRole(logger, link.Membership?.Permissions);
+
     const baseNodeMetadata = {
         // Internal metadata
         hash: link.Link.NameHash || undefined,
@@ -486,16 +488,31 @@ function linkToEncryptedNode(
         // Sharing node metadata
         shareId: link.Sharing?.ShareID || undefined,
         isShared: !!link.Sharing,
-        directMemberRole: isAdmin
-            ? MemberRole.Admin
-            : permissionsToDirectMemberRole(logger, link.Membership?.Permissions),
+        directRole: isAdmin ? MemberRole.Admin : membershipRole,
+        membership: link.Membership
+            ? {
+                  role: membershipRole,
+                  inviteTime: new Date(link.Membership.InviteTime * 1000),
+              }
+            : undefined,
     };
+
     const baseCryptoNodeMetadata = {
         signatureEmail: link.Link.SignatureEmail || undefined,
         nameSignatureEmail: link.Link.NameSignatureEmail || undefined,
         armoredKey: link.Link.NodeKey,
         armoredNodePassphrase: link.Link.NodePassphrase,
         armoredNodePassphraseSignature: link.Link.NodePassphraseSignature,
+        membership: link.Membership
+            ? {
+                  inviterEmail: link.Membership.InviterEmail,
+                  base64MemberSharePassphraseKeyPacket: link.Membership.MemberSharePassphraseKeyPacket,
+                  armoredInviterSharePassphraseKeyPacketSignature:
+                      link.Membership.InviterSharePassphraseKeyPacketSignature,
+                  armoredInviteeSharePassphraseSessionKeySignature:
+                      link.Membership.InviteeSharePassphraseSessionKeySignature,
+              }
+            : undefined,
     };
 
     if (link.Link.Type === 1 && link.Folder) {

package/src/internal/nodes/cache.test.ts

@@ -12,7 +12,12 @@ function generateNode(
     return {
         uid: `${params.volumeId || 'volumeId'}~:${uid}`,
         parentUid: `${params.volumeId || 'volumeId'}~:${parentUid}`,
-        directMemberRole: MemberRole.Admin,
+        directRole: MemberRole.Admin,
+        membership: {
+            role: MemberRole.Admin,
+            inviteTime: new Date(),
+            sharedBy: resultOk('test@example.com'),
+        },
         type: NodeType.File,
         mediaType: 'text',
         isShared: false,

package/src/internal/nodes/cache.ts

@@ -252,8 +252,9 @@ function deserialiseNode(nodeData: string): DecryptedNode {
         typeof node !== 'object' ||
         !node.uid ||
         typeof node.uid !== 'string' ||
-        !node.directMemberRole ||
-        typeof node.directMemberRole !== 'string' ||
+        !node.directRole ||
+        typeof node.directRole !== 'string' ||
+        (typeof node.membership !== 'object' && node.membership !== undefined) ||
         !node.type ||
         typeof node.type !== 'string' ||
         (typeof node.mediaType !== 'string' && node.mediaType !== undefined) ||
@@ -271,6 +272,12 @@ function deserialiseNode(nodeData: string): DecryptedNode {
         creationTime: new Date(node.creationTime),
         trashTime: node.trashTime ? new Date(node.trashTime) : undefined,
         activeRevision: node.activeRevision ? deserialiseRevision(node.activeRevision) : undefined,
+        membership: node.membership
+            ? {
+                  ...node.membership,
+                  inviteTime: new Date(node.membership.inviteTime),
+              }
+            : undefined,
         folder: node.folder
             ? {
                   ...node.folder,