@protontech/drive-sdk 0.6.0 → 0.6.1

package/src/diagnostic/diagnostic.ts

@@ -1,8 +1,10 @@
 import { MaybeNode } from '../interface';
 import { ProtonDriveClient } from '../protonDriveClient';
+import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
 import { DiagnosticHTTPClient } from './httpClient';
-import { DiagnosticOptions, DiagnosticResult } from './interface';
-import { SDKDiagnostic } from './sdkDiagnostic';
+import { DiagnosticOptions, DiagnosticProgressCallback, DiagnosticResult } from './interface';
+import { SDKDiagnosticMain } from './sdkDiagnosticMain';
+import { SDKDiagnosticPhotos } from './sdkDiagnosticPhotos';
 import { DiagnosticTelemetry } from './telemetry';
 import { zipGenerators } from './zipGenerators';
 
@@ -15,20 +17,37 @@ export class Diagnostic {
         private telemetry: DiagnosticTelemetry,
         private httpClient: DiagnosticHTTPClient,
         private protonDriveClient: ProtonDriveClient,
+        private protonDrivePhotosClient: ProtonDrivePhotosClient,
     ) {
         this.telemetry = telemetry;
         this.httpClient = httpClient;
         this.protonDriveClient = protonDriveClient;
+        this.protonDrivePhotosClient = protonDrivePhotosClient;
     }
 
-    async *verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
-        const diagnostic = new SDKDiagnostic(this.protonDriveClient);
-        yield* this.yieldEvents(diagnostic.verifyMyFiles(options));
+    async *verifyMyFiles(
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult> {
+        const diagnostic = new SDKDiagnosticMain(this.protonDriveClient, options, onProgress);
+        yield* this.yieldEvents(diagnostic.verifyMyFiles(options?.expectedStructure));
     }
 
-    async *verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult> {
-        const diagnostic = new SDKDiagnostic(this.protonDriveClient);
-        yield* this.yieldEvents(diagnostic.verifyNodeTree(node, options));
+    async *verifyNodeTree(
+        node: MaybeNode,
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult> {
+        const diagnostic = new SDKDiagnosticMain(this.protonDriveClient, options, onProgress);
+        yield* this.yieldEvents(diagnostic.verifyNodeTree(node, options?.expectedStructure));
+    }
+
+    async *verifyPhotosTimeline(
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult> {
+        const diagnostic = new SDKDiagnosticPhotos(this.protonDrivePhotosClient, options, onProgress);
+        yield* this.yieldEvents(diagnostic.verifyTimeline(options?.expectedStructure));
     }
 
     private async *yieldEvents(generator: AsyncGenerator<DiagnosticResult>): AsyncGenerator<DiagnosticResult> {

package/src/diagnostic/index.ts

@@ -5,8 +5,15 @@ import { Diagnostic as DiagnosticClass } from './diagnostic';
 import { Diagnostic } from './interface';
 import { DiagnosticHTTPClient } from './httpClient';
 import { DiagnosticTelemetry } from './telemetry';
+import { ProtonDrivePhotosClient } from '../protonDrivePhotosClient';
 
-export type { Diagnostic, DiagnosticResult } from './interface';
+export type {
+    Diagnostic,
+    DiagnosticOptions,
+    ExpectedTreeNode,
+    DiagnosticProgressCallback,
+    DiagnosticResult,
+} from './interface';
 
 /**
  * Initializes the diagnostic tool. It creates the instance of
@@ -34,5 +41,13 @@ export function initDiagnostic(
         telemetry,
     });
 
-    return new DiagnosticClass(telemetry, httpClient, protonDriveClient);
+    const protonDrivePhotosClient = new ProtonDrivePhotosClient({
+        ...options,
+        httpClient,
+        entitiesCache: new NullCache(),
+        cryptoCache: new MemoryCache(),
+        telemetry,
+    });
+
+    return new DiagnosticClass(telemetry, httpClient, protonDriveClient, protonDrivePhotosClient);
 }

package/src/diagnostic/interface.ts

@@ -2,24 +2,48 @@ import { Author, MaybeNode, MetricEvent, NodeType, AnonymousUser } from '../inte
 import { LogRecord } from '../telemetry';
 
 export interface Diagnostic {
-    verifyMyFiles(options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult>;
-    verifyNodeTree(node: MaybeNode, options?: DiagnosticOptions): AsyncGenerator<DiagnosticResult>;
+    verifyMyFiles(
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult>;
+    verifyNodeTree(
+        node: MaybeNode,
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult>;
+    verifyPhotosTimeline(
+        options?: DiagnosticOptions,
+        onProgress?: DiagnosticProgressCallback,
+    ): AsyncGenerator<DiagnosticResult>;
 }
 
 export type DiagnosticOptions = {
-    verifyContent?: boolean;
+    verifyContent?: boolean | 'peakOnly';
     verifyThumbnails?: boolean;
-    expectedStructure?: ExcpectedTreeNode;
+    expectedStructure?: ExpectedTreeNode;
 };
 
 // Tree structure of the expected node tree.
-export type ExcpectedTreeNode = {
+export type ExpectedTreeNode = {
     name: string;
+    expectedMediaType?: string;
     expectedSha1?: string;
     expectedSizeInBytes?: number;
-    children?: ExcpectedTreeNode[];
+    // If expectedAuthors is provided, it will be used to verify authors.
+    // If it's a string, it will be used to verify all authors match the same email.
+    // If it's an object, it will be used to verify specific authors by type.
+    expectedAuthors?: ExpectedAuthor | { key?: ExpectedAuthor; name?: ExpectedAuthor; content?: ExpectedAuthor };
+    children?: ExpectedTreeNode[];
 };
 
+export type ExpectedAuthor = string | 'anonymous';
+
+export type DiagnosticProgressCallback = (progress: {
+    allNodesLoaded: boolean;
+    loadedNodes: number;
+    checkedNodes: number;
+}) => void;
+
 export type DiagnosticResult =
     | FatalErrorResult
     | SdkErrorResult
@@ -138,7 +162,7 @@ export type ThumbnailsErrorResult = {
 // the expected structure.
 export type ExpectedStructureMissingNode = {
     type: 'expected_structure_missing_node';
-    expectedNode: ExcpectedTreeNode;
+    expectedNode: ExpectedTreeNode;
     parentNodeUid: string;
 };
 
@@ -155,7 +179,7 @@ export type ExpectedStructureUnexpectedNode = {
 // the claimed values with the real content.
 export type ExpectedStructureIntegrityError = {
     type: 'expected_structure_integrity_error';
-    expectedNode: ExcpectedTreeNode;
+    expectedNode: ExpectedTreeNode;
     claimedSha1?: string;
     claimedSizeInBytes?: number;
 } & NodeDetails;
@@ -181,11 +205,13 @@ export type MetricResult = {
 export type NodeDetails = {
     safeNodeDetails: {
         nodeUid: string;
-        revisionUid?: string;
+        revisionUid: string | undefined;
         nodeType: NodeType;
+        mediaType: string | undefined;
         nodeCreationTime: Date;
         keyAuthor: Author;
         nameAuthor: Author;
+        contentAuthor: Author | undefined;
         errors: {
             field: string;
             error: unknown;

package/src/diagnostic/nodeUtils.ts

@@ -0,0 +1,100 @@
+import { MaybeNode, NodeType, Revision } from '../interface';
+import {
+    NodeDetails,
+    ExpectedTreeNode,
+} from './interface';
+
+export function getNodeDetails(node: MaybeNode): NodeDetails {
+    const errors: {
+        field: string;
+        error: unknown;
+    }[] = [];
+
+    if (!node.ok) {
+        const degradedNode = node.error;
+        if (!degradedNode.name.ok) {
+            errors.push({
+                field: 'name',
+                error: degradedNode.name.error,
+            });
+        }
+        if (degradedNode.activeRevision?.ok === false) {
+            errors.push({
+                field: 'activeRevision',
+                error: degradedNode.activeRevision.error,
+            });
+        }
+        for (const error of degradedNode.errors ?? []) {
+            if (error instanceof Error) {
+                errors.push({
+                    field: 'error',
+                    error,
+                });
+            }
+        }
+    }
+
+    return {
+        safeNodeDetails: {
+            ...getNodeUids(node),
+            nodeType: getNodeType(node),
+            mediaType: getMediaType(node),
+            nodeCreationTime: node.ok ? node.value.creationTime : node.error.creationTime,
+            keyAuthor: node.ok ? node.value.keyAuthor : node.error.keyAuthor,
+            nameAuthor: node.ok ? node.value.nameAuthor : node.error.nameAuthor,
+            contentAuthor: getActiveRevision(node)?.contentAuthor,
+            errors,
+        },
+        sensitiveNodeDetails: node,
+    };
+}
+
+export function getNodeUids(node: MaybeNode): { nodeUid: string; revisionUid: string | undefined } {
+    const activeRevision = getActiveRevision(node);
+    return {
+        nodeUid: node.ok ? node.value.uid : node.error.uid,
+        revisionUid: activeRevision?.uid,
+    };
+}
+
+export function getNodeType(node: MaybeNode): NodeType {
+    return node.ok ? node.value.type : node.error.type;
+}
+
+export function getMediaType(node: MaybeNode): string | undefined {
+    return node.ok ? node.value.mediaType : node.error.mediaType;
+}
+
+export function getActiveRevision(node: MaybeNode): Revision | undefined {
+    if (node.ok) {
+        return node.value.activeRevision;
+    }
+    if (node.error.activeRevision?.ok) {
+        return node.error.activeRevision.value;
+    }
+    return undefined;
+}
+
+export function getNodeName(node: MaybeNode): string {
+    if (node.ok) {
+        return node.value.name;
+    }
+    if (node.error.name.ok) {
+        return node.error.name.value;
+    }
+    return 'N/A';
+}
+
+export function getExpectedTreeNodeDetails(expectedNode: ExpectedTreeNode): ExpectedTreeNode {
+    return {
+        ...expectedNode,
+        children: undefined,
+    };
+}
+
+export function getTreeNodeChildByNodeName(
+    expectedSubtree: ExpectedTreeNode | undefined,
+    nodeName: string,
+): ExpectedTreeNode | undefined {
+    return expectedSubtree?.children?.find((expectedNode) => expectedNode.name === nodeName);
+}