@protontech/drive-sdk 0.4.0 → 0.5.0

package/src/internal/nodes/debouncer.ts

@@ -0,0 +1,93 @@
+import { Logger } from "../../interface";
+import { LoggerWithPrefix } from '../../telemetry';
+
+/**
+ * The timeout for which the node is considered to be loading.
+ * If the node is not loaded after this timeout, it is considered to be
+ * loaded or failed to be loaded, and allowed other places to proceed.
+ *
+ * Decrypting many nodes in parallel can take a lot of time, so we allow
+ * more time for this.
+ */
+const DEBOUNCE_TIMEOUT = 5000;
+
+/**
+ * Helper to avoid loading the same node twice.
+ *
+ * Each place that loads a node should report it is being loaded,
+ * and when it is finished, it should report it is finished.
+ * The finish must be called even if the node fails to be loaded
+ * to clear the promise.
+ *
+ * Each place that loads a node from cache should first wait for
+ * the node to be loaded if that is the case.
+ */
+export class NodesDebouncer {
+    private promises: Map<
+        string,
+        {
+            promise: Promise<void>;
+            resolve: () => void;
+            timeout: NodeJS.Timeout;
+        }
+    > = new Map();
+
+    constructor(private logger: Logger) {
+        this.logger = new LoggerWithPrefix(logger, 'debouncer');
+    }
+
+    loadingNodes(nodeUids: string[]) {
+        for (const nodeUid of nodeUids) {
+            this.loadingNode(nodeUid);
+        }
+    }
+
+    loadingNode(nodeUid: string) {
+        const { promise, resolve } = Promise.withResolvers<void>();
+        if (this.promises.has(nodeUid)) {
+            this.logger.warn(`Loading twice for: ${nodeUid}`);
+            return;
+        }
+
+        const timeout = setTimeout(() => {
+            this.logger.warn(`Timeout for: ${nodeUid}`);
+            this.finishedLoadingNode(nodeUid);
+        }, DEBOUNCE_TIMEOUT);
+        this.promises.set(nodeUid, { promise, resolve, timeout });
+    }
+
+    finishedLoadingNodes(nodeUids: string[]) {
+        for (const nodeUid of nodeUids) {
+            this.finishedLoadingNode(nodeUid);
+        }
+    }
+
+    finishedLoadingNode(nodeUid: string) {
+        const result = this.promises.get(nodeUid);
+        if (!result) {
+            return;
+        }
+
+        clearTimeout(result.timeout);
+        result.resolve();
+        this.promises.delete(nodeUid);
+    }
+
+    async waitForLoadingNode(nodeUid: string) {
+        const result = this.promises.get(nodeUid);
+        if (!result) {
+            return;
+        }
+
+        this.logger.debug(`Wait for: ${nodeUid}`);
+        await result.promise;
+    }
+
+    clear() {
+        for (const result of this.promises.values()) {
+            clearTimeout(result.timeout);
+            result.resolve();
+        }
+        this.promises.clear();
+    }
+}

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

@@ -50,7 +50,7 @@ describe('extended attrbiutes', () => {
         });
     });
 
-    describe('should generate file attributes', () => {
+    describe('should generate file attributes without additional metadata', () => {
         const testCases: [object, string | undefined][] = [
             [{}, undefined],
             [
@@ -82,6 +82,28 @@ describe('extended attrbiutes', () => {
         });
     });
 
+    describe('should generate file attributes with additional metadata', () => {
+        const testCases: [object, string | undefined][] = [
+            [{}, '{"Media":{"Width":100,"Height":100}}'],
+            [{ size: undefined }, '{"Media":{"Width":100,"Height":100}}'],
+            [{ size: 123 }, '{"Common":{"Size":123},"Media":{"Width":100,"Height":100}}'],
+        ];
+        testCases.forEach(([input, expectedAttributes]) => {
+            it(`should generate ${input}`, () => {
+                const output = generateFileExtendedAttributes(input, { Media: { Width: 100, Height: 100 } });
+                expect(output).toBe(expectedAttributes);
+            });
+        });
+    });
+
+    describe('should throw an error if additional metadata contains common attributes', () => {
+        it('should throw an error', () => {
+            expect(() => generateFileExtendedAttributes({ size: 123 }, { Common: { Hello: 'World' } })).toThrow(
+                'Common attributes are not allowed in additional metadata',
+            );
+        });
+    });
+
     describe('should parses file attributes', () => {
         const testCases: [Date, string, FileExtendedAttributesParsed][] = [
             [new Date('2025-01-01'), '', {}],

package/src/internal/nodes/extendedAttributes.ts

@@ -83,34 +83,42 @@ export function parseFolderExtendedAttributes(logger: Logger, extendedAttributes
     }
 }
 
-export function generateFileExtendedAttributes(options: {
-    modificationTime?: Date;
-    size?: number;
-    blockSizes?: number[];
-    digests?: {
-        sha1?: string;
-    };
-}): string | undefined {
+export function generateFileExtendedAttributes(
+    common: {
+        modificationTime?: Date;
+        size?: number;
+        blockSizes?: number[];
+        digests?: {
+            sha1?: string;
+        };
+    },
+    additionalMetadata?: object,
+): string | undefined {
+    if (additionalMetadata && 'Common' in additionalMetadata) {
+        throw new Error('Common attributes are not allowed in additional metadata');
+    }
+
     const commonAttributes: FileExtendedAttributesSchema['Common'] = {};
-    if (options.modificationTime) {
-        commonAttributes.ModificationTime = dateToIsoString(options.modificationTime);
+    if (common.modificationTime) {
+        commonAttributes.ModificationTime = dateToIsoString(common.modificationTime);
     }
-    if (options.size !== undefined) {
-        commonAttributes.Size = options.size;
+    if (common.size !== undefined) {
+        commonAttributes.Size = common.size;
     }
-    if (options.blockSizes?.length) {
-        commonAttributes.BlockSizes = options.blockSizes;
+    if (common.blockSizes?.length) {
+        commonAttributes.BlockSizes = common.blockSizes;
     }
-    if (options.digests?.sha1) {
+    if (common.digests?.sha1) {
         commonAttributes.Digests = {
-            SHA1: options.digests.sha1,
+            SHA1: common.digests.sha1,
         };
     }
-    if (!Object.keys(commonAttributes).length) {
+    if (!Object.keys(commonAttributes).length && !additionalMetadata) {
         return undefined;
     }
     return JSON.stringify({
-        Common: commonAttributes,
+        ...(Object.keys(commonAttributes).length ? { Common: commonAttributes } : {}),
+        ...(additionalMetadata ? { ...additionalMetadata } : {}),
     });
 }
 

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

@@ -24,6 +24,7 @@ function generateNode(uid: string, parentUid = 'volumeId~root', params: Partial<
         type: NodeType.File,
         mediaType: 'text',
         isShared: false,
+        isSharedPublicly: false,
         creationTime: new Date(),
         trashTime: undefined,
         isStale: false,

package/src/internal/nodes/interface.ts

@@ -38,6 +38,7 @@ interface BaseNode {
     // Share node metadata
     shareId?: string;
     isShared: boolean;
+    isSharedPublicly: boolean;
     directRole: MemberRole;
     membership?: {
         role: MemberRole;

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

@@ -352,7 +352,7 @@ describe('nodesAccess', () => {
                 expect(cache.setFolderChildrenLoaded).not.toHaveBeenCalled();
             });
 
-            it.only('should return only filtered nodes from API', async () => {
+            it('should return only filtered nodes from API', async () => {
                 cache.isFolderChildrenLoaded = jest.fn().mockResolvedValue(false);
                 cache.getNode = jest.fn().mockImplementation((uid: string) => {
                     if (uid === parentNode.uid) {
@@ -444,7 +444,7 @@ describe('nodesAccess', () => {
             const node1 = { uid: 'volumeId~node1', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
             const node2 = { uid: 'volumeId~node2', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
             const node3 = { uid: 'volumeId~node3', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
-            const node4 = { uid: 'volume~node4', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
+            const node4 = { uid: 'volumeId~node4', isStale: false, treeEventScopeId: 'volumeId' } as DecryptedNode;
 
             it('should serve fully from cache', async () => {
                 cache.iterateNodes = jest.fn().mockImplementation(async function* () {

package/src/internal/nodes/nodesAccess.ts

@@ -11,6 +11,7 @@ import { NodeAPIService } from './apiService';
 import { NodesCache } from './cache';
 import { NodesCryptoCache } from './cryptoCache';
 import { NodesCryptoService } from './cryptoService';
+import { NodesDebouncer } from './debouncer';
 import { parseFileExtendedAttributes, parseFolderExtendedAttributes } from './extendedAttributes';
 import {
     SharesService,
@@ -40,13 +41,18 @@ const DECRYPTION_CONCURRENCY = 30;
  * nodes metadata.
  */
 export class NodesAccess {
+    private debouncer: NodesDebouncer;
+
     constructor(
         private logger: Logger,
         private apiService: NodeAPIService,
         private cache: NodesCache,
         private cryptoCache: NodesCryptoCache,
         private cryptoService: NodesCryptoService,
-        private shareService: SharesService,
+        private shareService: Pick<
+            SharesService,
+            'getOwnVolumeIDs' | 'getSharePrivateKey' | 'getContextShareMemberEmailKey'
+        >,
     ) {
         this.logger = logger;
         this.apiService = apiService;
@@ -54,6 +60,7 @@ export class NodesAccess {
         this.cryptoCache = cryptoCache;
         this.cryptoService = cryptoService;
         this.shareService = shareService;
+        this.debouncer = new NodesDebouncer(this.logger);
     }
 
     async getVolumeRootFolder() {
@@ -65,6 +72,7 @@ export class NodesAccess {
     async getNode(nodeUid: string): Promise<DecryptedNode> {
         let cachedNode;
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             cachedNode = await this.cache.getNode(nodeUid);
         } catch {}
 
@@ -112,6 +120,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateChildrenNodeUids(parentNode.uid, onlyFolders, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -143,6 +152,7 @@ export class NodesAccess {
         for await (const nodeUid of this.apiService.iterateTrashedNodeUids(volumeId, signal)) {
             let node;
             try {
+                await this.debouncer.waitForLoadingNode(nodeUid);
                 node = await this.cache.getNode(nodeUid);
             } catch {}
 
@@ -208,9 +218,14 @@ export class NodesAccess {
     }
 
     private async loadNode(nodeUid: string): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
-        const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
-        return this.decryptNode(encryptedNode);
+        this.debouncer.loadingNode(nodeUid);
+        try {
+            const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
+            const encryptedNode = await this.apiService.getNode(nodeUid, ownVolumeId);
+            return this.decryptNode(encryptedNode);
+        } finally {
+            this.debouncer.finishedLoadingNode(nodeUid);
+        }
     }
 
     private async *loadNodes(
@@ -236,7 +251,14 @@ export class NodesAccess {
 
         const { volumeId: ownVolumeId } = await this.shareService.getOwnVolumeIDs();
 
-        const encryptedNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+        const apiNodesIterator = this.apiService.iterateNodes(nodeUids, ownVolumeId, filterOptions, signal);
+
+        const debouncedNodeMapper = async (encryptedNode: EncryptedNode): Promise<EncryptedNode> => {
+            this.debouncer.loadingNode(encryptedNode.uid);
+            return encryptedNode;
+        };
+        const encryptedNodesIterator = asyncIteratorMap(apiNodesIterator, debouncedNodeMapper, 1);
+
         const decryptNodeMapper = async (encryptedNode: EncryptedNode): Promise<Result<DecryptedNode, unknown>> => {
             returnedNodeUids.push(encryptedNode.uid);
             try {
@@ -250,6 +272,7 @@ export class NodesAccess {
             encryptedNodesIterator,
             decryptNodeMapper,
             DECRYPTION_CONCURRENCY,
+            signal,
         );
         for await (const node of decryptedNodesIterator) {
             if (node.ok) {
@@ -329,6 +352,7 @@ export class NodesAccess {
                 this.logger.error(`Failed to cache node keys ${node.uid}`, error);
             }
         }
+        this.debouncer.finishedLoadingNode(node.uid);
         return { node, keys };
     }
 
@@ -360,6 +384,7 @@ export class NodesAccess {
 
     async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
         try {
+            await this.debouncer.waitForLoadingNode(nodeUid);
             return await this.cryptoCache.getNodeKeys(nodeUid);
         } catch {
             const { keys } = await this.loadNode(nodeUid);

package/src/internal/nodes/nodesManagement.ts

@@ -329,6 +329,7 @@ export class NodesManagement {
 
             // Share node metadata
             isShared: false,
+            isSharedPublicly: false,
             directRole: MemberRole.Inherited,
 
             // Decrypted metadata

package/src/internal/photos/index.ts

@@ -9,11 +9,21 @@ import {
 import { SharesCache } from '../shares/cache';
 import { SharesCryptoCache } from '../shares/cryptoCache';
 import { SharesCryptoService } from '../shares/cryptoService';
+import { NodesService as UploadNodesService } from '../upload/interface';
+import { UploadTelemetry } from '../upload/telemetry';
+import { UploadQueue } from '../upload/queue';
 import { Albums } from './albums';
 import { PhotosAPIService } from './apiService';
 import { NodesService, SharesService } from './interface';
 import { PhotoSharesManager } from './shares';
 import { PhotosTimeline } from './timeline';
+import {
+    PhotoFileUploader,
+    PhotoUploadAPIService,
+    PhotoUploadCryptoService,
+    PhotoUploadManager,
+    PhotoUploadMetadata,
+} from './upload';
 
 /**
  * Provides facade for the whole photos module.
@@ -66,3 +76,55 @@ export function initPhotoSharesModule(
         sharesService,
     );
 }
+
+/**
+ * Provides facade for the photo upload module.
+ *
+ * The photo upload wraps the core upload module and adds photo specific metadata.
+ * It provides the same interface so it can be used in the same way.
+ */
+export function initPhotoUploadModule(
+    telemetry: ProtonDriveTelemetry,
+    apiService: DriveAPIService,
+    driveCrypto: DriveCrypto,
+    sharesService: SharesService,
+    nodesService: UploadNodesService,
+    clientUid?: string,
+) {
+    const api = new PhotoUploadAPIService(apiService, clientUid);
+    const cryptoService = new PhotoUploadCryptoService(driveCrypto, nodesService);
+
+    const uploadTelemetry = new UploadTelemetry(telemetry, sharesService);
+    const manager = new PhotoUploadManager(telemetry, api, cryptoService, nodesService, clientUid);
+
+    const queue = new UploadQueue();
+
+    async function getFileUploader(
+        parentFolderUid: string,
+        name: string,
+        metadata: PhotoUploadMetadata,
+        signal?: AbortSignal,
+    ): Promise<PhotoFileUploader> {
+        await queue.waitForCapacity(signal);
+
+        const onFinish = () => {
+            queue.releaseCapacity();
+        };
+
+        return new PhotoFileUploader(
+            uploadTelemetry,
+            api,
+            cryptoService,
+            manager,
+            parentFolderUid,
+            name,
+            metadata,
+            onFinish,
+            signal,
+        );
+    }
+
+    return {
+        getFileUploader,
+    };
+}

package/src/internal/photos/upload.ts

@@ -0,0 +1,212 @@
+import { DriveCrypto } from '../../crypto';
+import { ProtonDriveTelemetry, UploadMetadata, Thumbnail } from '../../interface';
+import { DriveAPIService, drivePaths } from '../apiService';
+import { generateFileExtendedAttributes } from '../nodes';
+import { splitNodeRevisionUid } from '../uids';
+import { UploadAPIService } from '../upload/apiService';
+import { BlockVerifier } from '../upload/blockVerifier';
+import { UploadController } from '../upload/controller';
+import { UploadCryptoService } from '../upload/cryptoService';
+import { FileUploader } from '../upload/fileUploader';
+import { NodeRevisionDraft, NodesService } from '../upload/interface';
+import { UploadManager } from '../upload/manager';
+import { StreamUploader } from '../upload/streamUploader';
+import { UploadTelemetry } from '../upload/telemetry';
+
+type PostCommitRevisionRequest = Extract<
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['requestBody'],
+    { content: object }
+>['content']['application/json'];
+type PostCommitRevisionResponse =
+    drivePaths['/drive/v2/volumes/{volumeID}/files/{linkID}/revisions/{revisionID}']['put']['responses']['200']['content']['application/json'];
+
+export type PhotoUploadMetadata = UploadMetadata & {
+    captureTime?: Date;
+    mainPhotoLinkID?: string;
+    // TODO: handle tags enum in the SDK
+    tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+};
+
+export class PhotoFileUploader extends FileUploader {
+    private photoApiService: PhotoUploadAPIService;
+    private photoManager: PhotoUploadManager;
+    private photoMetadata: PhotoUploadMetadata;
+
+    constructor(
+        telemetry: UploadTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: UploadCryptoService,
+        manager: PhotoUploadManager,
+        parentFolderUid: string,
+        name: string,
+        metadata: PhotoUploadMetadata,
+        onFinish: () => void,
+        signal?: AbortSignal,
+    ) {
+        super(telemetry, apiService, cryptoService, manager, parentFolderUid, name, metadata, onFinish, signal);
+        this.photoApiService = apiService;
+        this.photoManager = manager;
+        this.photoMetadata = metadata;
+    }
+
+    protected async newStreamUploader(
+        blockVerifier: BlockVerifier,
+        revisionDraft: NodeRevisionDraft,
+        onFinish: (failure: boolean) => Promise<void>,
+    ): Promise<StreamUploader> {
+        return new PhotoStreamUploader(
+            this.telemetry,
+            this.photoApiService,
+            this.cryptoService,
+            this.photoManager,
+            blockVerifier,
+            revisionDraft,
+            this.photoMetadata,
+            onFinish,
+            this.controller,
+            this.signal,
+        );
+    }
+}
+
+export class PhotoStreamUploader extends StreamUploader {
+    private photoUploadManager: PhotoUploadManager;
+    private photoMetadata: PhotoUploadMetadata;
+
+    constructor(
+        telemetry: UploadTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: UploadCryptoService,
+        uploadManager: PhotoUploadManager,
+        blockVerifier: BlockVerifier,
+        revisionDraft: NodeRevisionDraft,
+        metadata: PhotoUploadMetadata,
+        onFinish: (failure: boolean) => Promise<void>,
+        controller: UploadController,
+        signal?: AbortSignal,
+    ) {
+        super(telemetry, apiService, cryptoService, uploadManager, blockVerifier, revisionDraft, metadata, onFinish, controller, signal);
+        this.photoUploadManager = uploadManager;
+        this.photoMetadata = metadata;
+    }
+
+    async commitFile(thumbnails: Thumbnail[]) {
+        this.verifyIntegrity(thumbnails);
+
+        const extendedAttributes = {
+            modificationTime: this.metadata.modificationTime,
+            size: this.metadata.expectedSize,
+            blockSizes: this.uploadedBlockSizes,
+            digests: this.digests.digests(),
+        };
+
+        await this.photoUploadManager.commitDraftPhoto(this.revisionDraft, this.manifest, extendedAttributes, this.photoMetadata);
+    }
+}
+
+export class PhotoUploadManager extends UploadManager {
+    private photoApiService: PhotoUploadAPIService;
+    private photoCryptoService: PhotoUploadCryptoService;
+
+    constructor(
+        telemetry: ProtonDriveTelemetry,
+        apiService: PhotoUploadAPIService,
+        cryptoService: PhotoUploadCryptoService,
+        nodesService: NodesService,
+        clientUid: string | undefined,
+    ) {
+        super(telemetry, apiService, cryptoService, nodesService, clientUid);
+        this.photoApiService = apiService;
+        this.photoCryptoService = cryptoService;
+    }
+
+    async commitDraftPhoto(
+        nodeRevisionDraft: NodeRevisionDraft,
+        manifest: Uint8Array,
+        extendedAttributes: {
+            modificationTime?: Date;
+            size: number;
+            blockSizes: number[];
+            digests: {
+                sha1: string;
+            };
+        },
+        uploadMetadata: PhotoUploadMetadata,
+    ): Promise<void> {
+        if (!nodeRevisionDraft.parentNodeKeys) {
+            throw new Error('Parent node keys are required for photo upload');
+        }
+
+        // TODO: handle photo extended attributes in the SDK - now it must be passed from the client
+        const generatedExtendedAttributes = generateFileExtendedAttributes(extendedAttributes, uploadMetadata.additionalMetadata);
+        const nodeCommitCrypto = await this.cryptoService.commitFile(
+            nodeRevisionDraft.nodeKeys,
+            manifest,
+            generatedExtendedAttributes,
+        );
+
+        const sha1 = extendedAttributes.digests.sha1;
+        const contentHash = await this.photoCryptoService.generateContentHash(sha1, nodeRevisionDraft.parentNodeKeys?.hashKey);
+        const photo = {
+            contentHash,
+            captureTime: uploadMetadata.captureTime || extendedAttributes.modificationTime,
+            mainPhotoLinkID: uploadMetadata.mainPhotoLinkID,
+            tags: uploadMetadata.tags,
+        }
+        await this.photoApiService.commitDraftPhoto(nodeRevisionDraft.nodeRevisionUid, nodeCommitCrypto, photo);
+        await this.notifyNodeUploaded(nodeRevisionDraft);
+    }
+}
+
+export class PhotoUploadCryptoService extends UploadCryptoService {
+    constructor(
+        driveCrypto: DriveCrypto,
+        nodesService: NodesService,
+    ) {
+        super(driveCrypto, nodesService);
+    }
+
+    async generateContentHash(sha1: string, parentHashKey: Uint8Array): Promise<string> {
+        return this.driveCrypto.generateLookupHash(sha1, parentHashKey);
+    }
+}
+
+export class PhotoUploadAPIService extends UploadAPIService {
+    constructor(apiService: DriveAPIService, clientUid: string | undefined) {
+        super(apiService, clientUid);
+    }
+
+    async commitDraftPhoto(
+        draftNodeRevisionUid: string,
+        options: {
+            armoredManifestSignature: string;
+            signatureEmail: string;
+            armoredExtendedAttributes?: string;
+        },
+        photo: {
+            contentHash: string;
+            captureTime?: Date;
+            mainPhotoLinkID?: string;
+            // TODO: handle tags enum in the SDK
+            tags?: (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)[];
+        },
+    ): Promise<void> {
+        const { volumeId, nodeId, revisionId } = splitNodeRevisionUid(draftNodeRevisionUid);
+        await this.apiService.put<
+            // TODO: Deprected fields but not properly marked in the types.
+            Omit<PostCommitRevisionRequest, 'BlockNumber' | 'BlockList' | 'ThumbnailToken' | 'State'>,
+            PostCommitRevisionResponse
+        >(`drive/v2/volumes/${volumeId}/files/${nodeId}/revisions/${revisionId}`, {
+            ManifestSignature: options.armoredManifestSignature,
+            SignatureAddress: options.signatureEmail,
+            XAttr: options.armoredExtendedAttributes || null,
+            Photo: {
+                ContentHash: photo.contentHash,
+                CaptureTime: photo.captureTime?.getTime() || 0,
+                MainPhotoLinkID: photo.mainPhotoLinkID || null,
+                Tags: photo.tags || [],
+                Exif: null, // Deprecated field, not used.
+            },
+        });
+    }
+}