@protontech/drive-sdk 0.1.0 → 0.1.2

package/src/telemetry.ts

@@ -1,7 +1,7 @@
 import { Logger as LoggerInterface } from './interface';
 
 export interface LogRecord {
-    time: Date,
+    time: Date;
     level: LogLevel;
     loggerName: string;
     message: string;
@@ -24,13 +24,13 @@ export interface LogHandler {
 }
 
 export interface MetricRecord<T extends MetricEvent> {
-    time: Date,
+    time: Date;
     event: T;
 }
 
 export type MetricEvent = {
     eventName: string;
-}
+};
 
 export interface MetricHandler<T extends MetricEvent> {
     onEvent(metric: MetricRecord<T>): void;
@@ -38,12 +38,12 @@ export interface MetricHandler<T extends MetricEvent> {
 
 /**
  * Telemetry class that logs messages and metrics.
- * 
+ *
  * Example:
- * 
+ *
  * ```typescript
  * const memoryLogHandler = new MemoryLogHandler();
- * 
+ *
  * interface MetricEvents = {
  *    name: string,
  *    value: number,
@@ -53,7 +53,7 @@ export interface MetricHandler<T extends MetricEvent> {
  *        // Process metric event
  *    }
  * }
- * 
+ *
  * const telemetry = new Telemetry<MetricEvents>({
  *    // Enable debug logging
  *    logFilter: new LogFilter({ level: LogLevel.DEBUG }),
@@ -62,16 +62,16 @@ export interface MetricHandler<T extends MetricEvent> {
  *    // Log to console and own handler to process further
  *    metricHandlers: [new ConsoleMetricHandler(), ownMetricHandler],
  * });
- * 
+ *
  * const logger = telemetry.getLogger('myLogger');
  * logger.debug('Debug message');
- * 
+ *
  * telemetry.logEvent({ name: 'somethingHappened', value: 42 });
- * 
+ *
  * const logs = memoryLogHandler.getLogs();
  * // Process logs
  * ```
- * 
+ *
  * @param logFilter - Log filter to filter logs based on log level, default INFO
  * @param logHandlers - Log handlers to use for logging, see LogHandler implementations
  * @param metricHandlers - Metric handlers to use for logging, see MetricHandler implementations
@@ -81,13 +81,7 @@ export class Telemetry<T extends MetricEvent> {
     private logHandlers: LogHandler[];
     private metricHandlers: MetricHandler<T>[];
 
-    constructor(
-        options?: {
-            logFilter?: LogFilter,
-            logHandlers?: LogHandler[],
-            metricHandlers?: MetricHandler<T>[],
-        }
-    ) {
+    constructor(options?: { logFilter?: LogFilter; logHandlers?: LogHandler[]; metricHandlers?: MetricHandler<T>[] }) {
         this.logFilter = options?.logFilter || new LogFilter();
         this.logHandlers = options?.logHandlers || [new ConsoleLogHandler()];
         this.metricHandlers = options?.metricHandlers || [new ConsoleMetricHandler()];
@@ -102,18 +96,22 @@ export class Telemetry<T extends MetricEvent> {
             time: new Date(),
             event,
         };
-        this.metricHandlers.forEach(handler => handler.onEvent(metric));
+        this.metricHandlers.forEach((handler) => handler.onEvent(metric));
     }
 }
 
 /**
  * Logger class that logs messages with different levels.
- * 
+ *
  * @param name - Name of the logger
  * @param handlers - Log handlers to use for logging, see LogHandler implementations
  */
 class Logger {
-    constructor(private name: string, private filter: LogFilter, private handlers: LogHandler[]) {
+    constructor(
+        private name: string,
+        private filter: LogFilter,
+        private handlers: LogHandler[],
+    ) {
         this.name = name;
         this.filter = filter;
         this.handlers = handlers;
@@ -160,15 +158,15 @@ class Logger {
         if (!this.filter.filter(log)) {
             return;
         }
-        this.handlers.forEach(handler => handler.log(log));
+        this.handlers.forEach((handler) => handler.log(log));
     }
 }
 
 /**
  * Logger class that logs messages with a prefix.
- * 
+ *
  * Example:
- * 
+ *
  * ```typescript
  * const logger = new Logger('myLogger', new LogFilter(), [new ConsoleLogHandler()]);
  * const loggerWithPrefix = new LoggerWithPrefix(logger, 'prefix');
@@ -176,7 +174,10 @@ class Logger {
  * ```
  */
 export class LoggerWithPrefix {
-    constructor(private logger: LoggerInterface, private prefix: string) {
+    constructor(
+        private logger: LoggerInterface,
+        private prefix: string,
+    ) {
         this.logger = logger;
         this.prefix = prefix;
     }
@@ -201,28 +202,29 @@ export class LoggerWithPrefix {
 /**
  * Filter logs based on log level. It can be configured by global level or
  * per logger level.
- * 
+ *
  * @param globalLevel - Global log level, default INFO
  * @param loggerLevels - Log levels for specific loggers, default empty
  */
 export class LogFilter {
     private logLevelMap = {
-        'DEBUG': 0,
-        'INFO': 1,
-        'WARNING': 2,
-        'ERROR': 3,
-    }
+        DEBUG: 0,
+        INFO: 1,
+        WARNING: 2,
+        ERROR: 3,
+    };
 
     private globalLevel: number;
     private loggerLevels: { [loggerName: string]: number };
 
-    constructor(options?: {
-        globalLevel?: LogLevel,
-        loggerLevels?: { [loggerName: string]: LogLevel },
-    }) {
+    constructor(options?: { globalLevel?: LogLevel; loggerLevels?: { [loggerName: string]: LogLevel } }) {
         this.globalLevel = this.logLevelMap[options?.globalLevel || LogLevel.INFO];
-        this.loggerLevels = Object.fromEntries(Object.entries(options?.loggerLevels || {})
-            .map(([loggerName, level]) => [loggerName, this.logLevelMap[level]]));
+        this.loggerLevels = Object.fromEntries(
+            Object.entries(options?.loggerLevels || {}).map(([loggerName, level]) => [
+                loggerName,
+                this.logLevelMap[level],
+            ]),
+        );
     }
 
     /**
@@ -243,16 +245,16 @@ export class LogFilter {
 
 /**
  * Log handler that logs to console.
- * 
+ *
  * @param formatter - Formatter to use for log messages, default BasicLogFormatter
  */
 export class ConsoleLogHandler implements LogHandler {
     private logLevelMap = {
-        'DEBUG': console.debug, // eslint-disable-line no-console
-        'INFO': console.info, // eslint-disable-line no-console
-        'WARNING': console.warn, // eslint-disable-line no-console
-        'ERROR': console.error, // eslint-disable-line no-console
-    }
+        DEBUG: console.debug, // eslint-disable-line no-console
+        INFO: console.info, // eslint-disable-line no-console
+        WARNING: console.warn, // eslint-disable-line no-console
+        ERROR: console.error, // eslint-disable-line no-console
+    };
 
     private formatter: LogFormatter;
 
@@ -268,10 +270,10 @@ export class ConsoleLogHandler implements LogHandler {
 
 /**
  * Log handler that stores logs in memory with option to retrieve later.
- * 
+ *
  * Useful for keeping logs around and retrieve them on demand when an error
  * occures.
- * 
+ *
  * @param formatter - Formatter to use for log messages, default JSONLogFormatter
  * @param maxLogs - Maximum number of logs to store, default 10000
  */
@@ -280,7 +282,10 @@ export class MemoryLogHandler implements LogHandler {
 
     private formatter: LogFormatter;
 
-    constructor(formatter?: LogFormatter, private maxLogs = 10000) {
+    constructor(
+        formatter?: LogFormatter,
+        private maxLogs = 10000,
+    ) {
         this.formatter = formatter || new JSONLogFormatter();
         this.maxLogs = maxLogs;
     }
@@ -305,7 +310,7 @@ export class MemoryLogHandler implements LogHandler {
 
 /**
  * Formatter that formats logs as JSON.
- * 
+ *
  * Useful for machine processing.
  */
 export class JSONLogFormatter implements LogFormatter {
@@ -323,16 +328,17 @@ export class JSONLogFormatter implements LogFormatter {
 
 /**
  * Formatter that formats logs as plain text.
- * 
+ *
  * Useful for human reading.
  */
 export class BasicLogFormatter implements LogFormatter {
     format(log: LogRecord) {
         let errorDetails = '';
         if (log.error) {
-            errorDetails = log.error instanceof Error
-                ? `\nError: ${log.error.message}\nStack:\n${log.error.stack}`
-                : `\nError: ${log.error}`;
+            errorDetails =
+                log.error instanceof Error
+                    ? `\nError: ${log.error.message}\nStack:\n${log.error.stack}`
+                    : `\nError: ${log.error}`;
         }
         return `${log.time.toISOString()} ${log.level} [${log.loggerName}] ${log.message}${errorDetails}`;
     }
@@ -341,6 +347,8 @@ export class BasicLogFormatter implements LogFormatter {
 class ConsoleMetricHandler<T extends MetricEvent> implements MetricHandler<T> {
     onEvent(metric: MetricRecord<T>) {
         // eslint-disable-next-line no-console
-        console.info(`${metric.time.toISOString()} INFO [metric] ${metric.event.eventName} ${JSON.stringify({ ...metric.event, name: undefined })}`);
+        console.info(
+            `${metric.time.toISOString()} INFO [metric] ${metric.event.eventName} ${JSON.stringify({ ...metric.event, name: undefined })}`,
+        );
     }
 }

package/src/tests/logger.ts

@@ -6,5 +6,5 @@ export function getMockLogger(): Logger {
         info: jest.fn(),
         warn: jest.fn(),
         error: jest.fn(),
-    }
+    };
 }

package/src/tests/telemetry.ts

@@ -1,5 +1,5 @@
-import { ProtonDriveTelemetry } from "../interface";
-import { getMockLogger } from "./logger";
+import { ProtonDriveTelemetry } from '../interface';
+import { getMockLogger } from './logger';
 
 export function getMockTelemetry(): ProtonDriveTelemetry {
     return {

package/src/transformers.ts

@@ -13,28 +13,29 @@ import { DecryptedNode as InternalNode, DecryptedRevision as InternalRevision }
 
 type InternalPartialNode = Pick<
     InternalNode,
-    'uid' |
-    'parentUid' |
-    'name' |
-    'keyAuthor' |
-    'nameAuthor' |
-    'directMemberRole' |
-    'type' |
-    'mediaType' |
-    'isShared' |
-    'creationTime' |
-    'trashTime' |
-    'activeRevision' |
-    'folder' |
-    'totalStorageSize' |
-    'errors' |
-    'shareId'
+    | 'uid'
+    | 'parentUid'
+    | 'name'
+    | 'keyAuthor'
+    | 'nameAuthor'
+    | 'directMemberRole'
+    | 'type'
+    | 'mediaType'
+    | 'isShared'
+    | 'creationTime'
+    | 'trashTime'
+    | 'activeRevision'
+    | 'folder'
+    | 'totalStorageSize'
+    | 'errors'
+    | 'shareId'
+    | 'treeEventScopeId'
 >;
 
 type NodeUid = string | { uid: string } | Result<{ uid: string }, { uid: string }>;
 
 export function getUid(nodeUid: NodeUid): string {
-    if (typeof nodeUid === "string") {
+    if (typeof nodeUid === 'string') {
         return nodeUid;
     }
     // Directly passed NodeEntity or DegradedNode that has UID directly.
@@ -52,13 +53,17 @@ export function getUids(nodeUids: NodeUid[]): string[] {
     return nodeUids.map(getUid);
 }
 
-export async function *convertInternalNodeIterator(nodeIterator: AsyncGenerator<InternalPartialNode>): AsyncGenerator<PublicMaybeNode> {
+export async function* convertInternalNodeIterator(
+    nodeIterator: AsyncGenerator<InternalPartialNode>,
+): AsyncGenerator<PublicMaybeNode> {
     for await (const node of nodeIterator) {
         yield convertInternalNode(node);
     }
 }
 
-export async function *convertInternalMissingNodeIterator(nodeIterator: AsyncGenerator<InternalPartialNode | MissingNode>): AsyncGenerator<PublicMaybeMissingNode> {
+export async function* convertInternalMissingNodeIterator(
+    nodeIterator: AsyncGenerator<InternalPartialNode | MissingNode>,
+): AsyncGenerator<PublicMaybeMissingNode> {
     for await (const node of nodeIterator) {
         if ('missingUid' in node) {
             yield resultError(node);
@@ -88,6 +93,7 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         totalStorageSize: node.totalStorageSize,
         folder: node.folder,
         deprecatedShareId: node.shareId,
+        treeEventScopeId: node.treeEventScopeId,
     };
 
     const name = node.name;
@@ -97,7 +103,9 @@ export function convertInternalNode(node: InternalPartialNode): PublicMaybeNode
         return resultError({
             ...baseNodeMetadata,
             name,
-            activeRevision: activeRevision?.ok ? resultOk(convertInternalRevision(activeRevision.value)) : activeRevision,
+            activeRevision: activeRevision?.ok
+                ? resultOk(convertInternalRevision(activeRevision.value))
+                : activeRevision,
             errors: node.errors,
         } as PublicDegradedNode);
     }
@@ -120,5 +128,5 @@ function convertInternalRevision(revision: InternalRevision): PublicRevision {
         claimedModificationTime: revision.claimedModificationTime,
         claimedDigests: revision.claimedDigests,
         claimedAdditionalMetadata: revision.claimedAdditionalMetadata,
-    }
+    };
 }

package/src/version.ts

@@ -1,4 +1,3 @@
 import { version } from '../package.json';
 
 export const VERSION = version;
-