@secrecy/lib 1.74.0-feat-groups-identity.4 → 1.74.0-feat-transfer-adaptations.1

package/dist/lib/client/SecrecyCloudClient.js

@@ -1,43 +1,48 @@
-import ky from 'ky';
 import { nodesCache, dataCache, dataContentCache, nodesEncryptionCache, } from '../cache.js';
-import { secretStreamKeygen } from '../crypto/data.js';
 import { decryptCryptoBox, encryptCryptoBox } from '../crypto/index.js';
-import { compress, decompress } from '../minify/index.js';
+import { decompress } from '../minify/index.js';
 import { sodium } from '../sodium.js';
-import { enumerate, chunks, concatenate } from '../utils/array.js';
 import { md5 } from '../worker/md5.js';
-import { decrypt, encrypt } from '../worker/sodium.js';
+import { decrypt } from '../worker/sodium.js';
 import { apiDataToExternal, apiDataToInternal } from './convert/data.js';
 import { apiNodeForEncryptionToInternal, apiNodeFullToInternalFull, apiNodeToExternal, apiNodeToExternalNodeFull, internalNodeFullToNodeFull, } from './convert/node.js';
-import { promiseAllLimit } from '../utils/promise.js';
-import { kiloToBytes } from '../utils.js';
-import { fileTypeFromBuffer } from 'file-type';
-import { encryptName, generateAndEncryptNameAndKey } from '../crypto/domain.js';
+import { buildBytesFromApiData } from '../crypto/domain.js';
 import { chunkByTotalItems } from '../utils/object.js';
-import axios from 'axios';
+import { createPublicDataLink, uploadData } from './upload.js';
+import { encryptName, generateAndEncryptNameAndKey } from '../crypto/helpers.js';
+import { downloadDataFromLink, } from './data-link.js';
 export class SecrecyCloudClient {
     #client;
-    constructor(client) {
+    #keys;
+    #apiClient;
+    constructor(client, keys, apiClient) {
         this.#client = client;
+        this.#keys = keys;
+        this.#apiClient = apiClient;
     }
     async addDataToHistory({ dataId, nodeId, }) {
-        const addDataToHistory = await this.#client.apiClient.cloud.addDataToHistory.mutate({
-            dataId,
-            nodeId,
-        });
-        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#client.keyPairs);
+        const addDataToHistory = await this.#apiClient.cloud.addDataToHistory.mutate({ dataId, nodeId });
+        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#keys);
         const data = node.history.find((d) => d.id === dataId);
         if (data !== undefined) {
-            const othersIdentities = Object.entries(node.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
-            const shares = othersIdentities.map(([publicKey]) => {
+            // TODO sad to have to make this extra request
+            const me = await this.#client.me();
+            const users = node.users.filter(([u]) => u.id !== me.id);
+            const userIds = users.map(([user]) => user.id);
+            const userKeys = await this.#client.app.userPublicKey(userIds);
+            const shares = users.map(([user]) => {
+                const publicKey = userKeys[user.id];
+                if (!publicKey) {
+                    throw new Error('Unable to retrieve share by public key!');
+                }
                 return {
-                    pubKey: publicKey,
+                    id: user.id,
                     key: data.key
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#client.uaPrivateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#keys.privateKey))
                         : null,
                 };
             });
-            await this.#client.apiClient.cloud.shareDataInHistory.mutate({
+            await this.#apiClient.cloud.shareDataInHistory.mutate({
                 dataId: data.id,
                 nodeId,
                 users: shares,
@@ -45,180 +50,12 @@ export class SecrecyCloudClient {
         }
         return internalNodeFullToNodeFull(node);
     }
-    async uploadData({ storageType, data, encrypted = true, encryptProgress, uploadProgress, signal, meta, }) {
-        const dataBuffer = data instanceof File ? new Uint8Array(await data.arrayBuffer()) : data;
-        let filetype;
-        if (meta === true) {
-            filetype = await fileTypeFromBuffer(dataBuffer);
-        }
-        else if (typeof meta !== 'undefined') {
-            filetype = meta;
-        }
-        else if (!encrypted) {
-            filetype = await fileTypeFromBuffer(dataBuffer);
-        }
-        if (storageType === 'lite' && dataBuffer.byteLength > kiloToBytes(1024)) {
-            throw new Error('The data is too big for lite upload!');
-        }
-        const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
-        const dataKey = encrypted ? secretStreamKeygen() : null;
-        const { data: encryptedData, md5: md5Data, md5Encrypted, } = dataKey
-            ? await encrypt(dataKey, compressed, encryptProgress, signal)
-            : { data: compressed, md5: await md5(compressed) };
-        const encryptedDataKey = dataKey
-            ? encryptCryptoBox(dataKey, this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
-            : null;
-        await uploadProgress?.({
-            total: encryptedData.byteLength,
-            current: 0,
-            percent: 0,
+    async uploadData(opts) {
+        return uploadData({
+            ...opts,
+            keyPair: this.#keys,
+            apiClient: this.#apiClient,
         });
-        if (storageType === 'lite') {
-            const uploadDataArgs = encryptedDataKey && md5Encrypted
-                ? {
-                    type: 'encrypted',
-                    content: Buffer.from(encryptedData),
-                    sizeEncrypted: BigInt(encryptedData.byteLength),
-                    size: BigInt(dataBuffer.byteLength),
-                    key: sodium.to_hex(encryptedDataKey),
-                    md5Encrypted,
-                    md5: md5Data,
-                    ...filetype,
-                }
-                : {
-                    type: 'unencrypted',
-                    content: Buffer.from(encryptedData),
-                    md5: md5Data,
-                    sizeEncrypted: undefined,
-                    size: BigInt(dataBuffer.byteLength),
-                    ...filetype,
-                };
-            const uploadData = await this.#client.apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
-            await uploadProgress?.({
-                total: encryptedData.byteLength,
-                current: encryptedData.byteLength,
-                percent: 1,
-            });
-            const localData = {
-                id: uploadData.id,
-                storageType: 'lite',
-                size: uploadDataArgs.size,
-                sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
-                data: dataBuffer,
-                ...filetype,
-            };
-            dataContentCache.set(uploadData.id, localData);
-            return localData;
-        }
-        if (storageType === 's3' || storageType === 'cold') {
-            const uploadDataArgs = encryptedDataKey && md5Encrypted
-                ? {
-                    type: 'encrypted',
-                    sizeEncrypted: BigInt(encryptedData.byteLength),
-                    size: BigInt(dataBuffer.byteLength),
-                    key: sodium.to_hex(encryptedDataKey),
-                    md5Encrypted,
-                    md5: md5Data,
-                    ...filetype,
-                }
-                : {
-                    type: 'unencrypted',
-                    md5: md5Data,
-                    size: BigInt(dataBuffer.byteLength),
-                    sizeEncrypted: undefined,
-                    ...filetype,
-                };
-            const uploadDataCaller = storageType === 's3'
-                ? this.#client.apiClient.cloud.uploadData
-                : this.#client.apiClient.cloud.uploadColdData;
-            const uploadData = await uploadDataCaller.mutate(uploadDataArgs, {
-                signal,
-            });
-            if (uploadData.parts.length === 0) {
-                if (uploadData.type === 'authed' &&
-                    uploadData.keyPair.pub !== this.#client.uaIdentity.identityPubKey) {
-                    throw new Error('The public key does not match with cached key!');
-                }
-                await uploadProgress?.({
-                    total: encryptedData.byteLength,
-                    current: encryptedData.byteLength,
-                    percent: 1,
-                });
-                const localData = {
-                    id: uploadData.id,
-                    storageType: storageType,
-                    size: uploadDataArgs.size,
-                    sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
-                    data: dataBuffer,
-                    ...filetype,
-                };
-                dataContentCache.set(uploadData.id, localData);
-                return localData;
-            }
-            const uploadDataPartEnd = async (md5, order) => {
-                return this.#client.apiClient.cloud.uploadDataPartEnd.mutate({ dataId: uploadData.id, md5, order }, { signal });
-            };
-            const chunkParts = new Array();
-            for (const [index, chunk] of enumerate(chunks(encryptedData, Number(uploadData.partSize)))) {
-                chunkParts.push({
-                    order: index + 1,
-                    data: chunk,
-                    md5: await md5(chunk),
-                });
-            }
-            const progressParts = {};
-            const onProgress = (part, progressEvent) => {
-                progressParts[part] = progressEvent;
-                const current = Object.values(progressParts).reduce((prv, cur) => prv + cur.transferredBytes, 0);
-                void uploadProgress?.({
-                    percent: current / encryptedData.byteLength,
-                    total: encryptedData.byteLength,
-                    current,
-                });
-            };
-            const byPart = async (part) => {
-                const formData = new FormData();
-                const chunk = chunkParts.find((p) => p.order === part.order);
-                if (chunk === undefined) {
-                    return;
-                }
-                for (const [key, value] of Object.entries(part.fields)) {
-                    formData.append(key, value);
-                }
-                formData.append('file', new Blob([chunk.data], { type: filetype?.mime }), `${uploadData.id}-${chunk.order}`);
-                // await ky.post(part.url, {
-                //   signal,
-                //   body: formData,
-                //   onUploadProgress: (progressEvent) => {
-                //     onProgress(part.order, progressEvent)
-                //   },
-                // })
-                await axios.post(part.url, formData, {
-                    onUploadProgress: (progressEvent) => {
-                        onProgress(part.order, {
-                            percent: progressEvent.progress ?? 0,
-                            totalBytes: progressEvent.total ?? 0,
-                            transferredBytes: progressEvent.loaded,
-                        });
-                    },
-                });
-                return uploadDataPartEnd(chunk.md5, chunk.order);
-            };
-            await promiseAllLimit(3, uploadData.parts.map((p) => async () => {
-                await byPart(p);
-            }));
-            const localData = {
-                id: uploadData.id,
-                storageType: storageType,
-                size: uploadDataArgs.size,
-                sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
-                data: dataBuffer,
-                ...filetype,
-            };
-            dataContentCache.set(uploadData.id, localData);
-            return localData;
-        }
-        throw new Error(`The "${storageType}" is not implemented yet!`);
     }
     async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType = 's3', signal, }) {
         const uploadedData = await this.uploadData({
@@ -231,21 +68,21 @@ export class SecrecyCloudClient {
         return await this.saveInCloud({ dataId: uploadedData.id, name, nodeId });
     }
     async deletedNodes() {
-        const deletedNodes = await this.#client.apiClient.cloud.nodesDeleted.query({});
-        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
+        const deletedNodes = await this.#apiClient.cloud.nodesDeleted.query({});
+        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#keys)));
     }
     async sharedNodes() {
-        const nodesShared = await this.#client.apiClient.cloud.nodesShared.query({});
-        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
+        const nodesShared = await this.#apiClient.cloud.nodesShared.query();
+        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#keys)));
     }
     async nodesSharedWithMe(type = 'FOLDER') {
-        const nodesSharedWithMe = await this.#client.apiClient.cloud.nodesSharedWithMe.query({ type });
-        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
+        const nodesSharedWithMe = await this.#apiClient.cloud.nodesSharedWithMe.query({ type });
+        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#keys)));
     }
-    async deleteNodeSharing({ nodeId, destPubKey, }) {
-        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeSharing.mutate({
+    async deleteNodeSharing({ nodeId, userId, }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteNodeSharing.mutate({
             nodeId,
-            destPubKey,
+            userId,
         });
         return isDeleted;
     }
@@ -258,14 +95,14 @@ export class SecrecyCloudClient {
                 throw new Error(`Node (${nodeId}) does not exists`);
             }
         }
-        if (!node.accesses[0]) {
-            throw new Error(`No access found for node ${nodeId}`);
+        if (node.access?.nameKey === undefined) {
+            throw new Error(`Can't have access to node ${nodeId}`);
         }
         name =
-            typeof name === 'string' && node.accesses[0].nameKey !== null
-                ? await encryptName(name, node.accesses[0].nameKey)
+            typeof name === 'string' && node.access.nameKey !== null
+                ? await encryptName(name, node.access.nameKey)
                 : null;
-        const { isDuplicated } = await this.#client.apiClient.cloud.duplicateNode.mutate({
+        const { isDuplicated } = await this.#apiClient.cloud.duplicateNode.mutate({
             nodeId,
             folderId: folderId ?? null,
             name,
@@ -273,54 +110,50 @@ export class SecrecyCloudClient {
         return isDuplicated;
     }
     async deleteNodeCloudTrash({ ids }) {
-        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
+        const { isDeleted } = await this.#apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
         return isDeleted;
     }
     async createFolder({ name, parentFolderId, }) {
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#client.uaPrivateKey,
-            publicKey: this.#client.uaIdentity.identityPubKey,
+            privateKey: this.#keys.privateKey,
+            publicKey: this.#keys.publicKey,
         });
-        const createdFolder = await this.#client.apiClient.cloud.createFolder.mutate({
+        const createdFolder = await this.#apiClient.cloud.createFolder.mutate({
             name: encryptedName,
             parentId: parentFolderId ?? null,
             nameKey: encryptedNameKey,
         });
-        const folder = await apiNodeToExternalNodeFull(createdFolder, this.#client.keyPairs);
-        if (folder.parent) {
-            const othersIdentities = Object.entries(folder.parent.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
-            // TODO: ??
-            if (othersIdentities.length > 0) {
-                await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
-                    pubKey: identityPubKey,
-                    nodeId: folder.id,
-                    rights: permissions.rights,
-                    addAccess: permissions.addAccess,
-                    delAccess: permissions.delAccess,
-                    sharingAddAccess: permissions.sharingAddAccess,
-                    sharingDelAccess: permissions.sharingDelAccess,
-                })));
-            }
+        const folder = await apiNodeToExternalNodeFull(createdFolder, this.#keys);
+        const users = folder.parent?.users?.filter(([u]) => u.id !== folder.owner.id) ?? [];
+        if (users.length > 0) {
+            await this.shareNode(users.map(([user, permissions]) => ({
+                userId: user.id,
+                nodeId: folder.id,
+                rights: permissions.rights,
+                addAccess: permissions.addAccess,
+                delAccess: permissions.delAccess,
+                sharingAddAccess: permissions.sharingAddAccess,
+                sharingDelAccess: permissions.sharingDelAccess,
+            })));
         }
         return folder;
     }
     async node({ id, deleted, } = {}) {
-        const node = await this.#client.apiClient.cloud.nodeFullById.query({
-            id,
-            deleted,
-        });
-        return await apiNodeToExternalNodeFull(node, this.#client.keyPairs);
+        const node = await this.#apiClient.cloud.nodeFullById.query({ id, deleted });
+        return await apiNodeToExternalNodeFull(node, this.#keys);
     }
     async dataMetadata({ id }) {
-        const data = await this.#client.apiClient.cloud.dataById.query({ id });
-        return apiDataToExternal(data, this.#client.keyPairs);
+        const data = await this.#apiClient.cloud.dataById.query({ id });
+        return apiDataToExternal(data, this.#keys);
     }
-    async shareNode(accesses, progress) {
+    async shareNode(input, progress) {
         // TODO: Validate input
-        const nodesMap = await this.#client.apiClient.cloud.shareNode.mutate({
-            accesses,
-        });
+        const nodesMap = await this.#apiClient.cloud.shareNode.mutate(input);
+        const neededUserKey = Object.entries(nodesMap)
+            .filter(([, nodes]) => nodes.some((node) => node.includeKeys))
+            .map(([userId]) => userId);
+        const publicKeysMap = await this.#client.app.userPublicKey(neededUserKey);
         const maxNodesBatchSize = 1000;
         const totalNodesToShare = Object.values(nodesMap).reduce((size, ids) => size + ids.length, 0);
         progress?.({ total: totalNodesToShare, current: 0, percent: 0 });
@@ -337,9 +170,9 @@ export class SecrecyCloudClient {
                 return filtered.length > 0 ? [userId, filtered] : null;
             })
                 .filter((entry) => entry !== null));
-            const infos = await this.encryptNodesForIdentities(nodesToEncrypt);
-            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([pubKey, nodes]) => [
-                pubKey,
+            const infos = await this.encryptNodesForUsers(nodesToEncrypt, publicKeysMap);
+            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([userId, nodes]) => [
+                userId,
                 nodes
                     .filter((node) => !node.includeKeys)
                     .map((node) => {
@@ -355,13 +188,13 @@ export class SecrecyCloudClient {
                     };
                 }),
             ]));
-            const withKeys = Object.fromEntries(Object.entries(infos).map(([pubKey, nodes]) => {
+            const withKeys = Object.fromEntries(Object.entries(infos).map(([userId, nodes]) => {
                 return [
-                    pubKey,
+                    userId,
                     {
-                        pubKey,
+                        userId,
                         nodes: nodes.map((node) => {
-                            const map = nodesMap[pubKey];
+                            const map = nodesMap[userId];
                             if (!map) {
                                 throw new Error('Unable to retrieve mapped nodes!');
                             }
@@ -384,22 +217,20 @@ export class SecrecyCloudClient {
                 ];
             }));
             const finishInput = [];
-            for (const [pubKey, nodes] of Object.entries(withKeys)) {
+            for (const [userId, nodes] of Object.entries(withKeys)) {
                 if (nodes.nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ pubKey, nodes: nodes.nodes });
+                finishInput.push({ userId, nodes: nodes.nodes });
             }
-            for (const [pubKey, nodes] of Object.entries(nodesToUpdateRights)) {
+            for (const [userId, nodes] of Object.entries(nodesToUpdateRights)) {
                 if (nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ pubKey, nodes });
+                finishInput.push({ userId, nodes });
             }
             const subState = finishInput.length > 0
-                ? await this.#client.apiClient.cloud.shareNodeFinish.mutate({
-                    accesses: finishInput,
-                })
+                ? await this.#apiClient.cloud.shareNodeFinish.mutate(finishInput)
                 : { isFinished: true, details: {} };
             const currentProgress = Math.min((index + 1) * maxNodesBatchSize, totalNodesToShare);
             progress?.({
@@ -446,31 +277,27 @@ export class SecrecyCloudClient {
                 throw `Can't find Node ${nodeId}`;
             }
         }
-        if (node.accesses.find((a) => ['delete', 'write'].includes(a.rights)) ===
-            undefined) {
-            throw new Error(`No access to update node ${nodeId}`);
-        }
-        if (!node.accesses[0]) {
-            throw new Error(`No access found for node ${nodeId}`);
+        if (node.access?.nameKey === undefined) {
+            throw new Error(`Can't have access to node ${nodeId}`);
         }
         name =
-            typeof name === 'string' && node.accesses[0].nameKey !== null
-                ? await encryptName(name, node.accesses[0].nameKey)
+            typeof name === 'string' && node.access.nameKey !== null
+                ? await encryptName(name, node.access.nameKey)
                 : null;
-        const updateNode = await this.#client.apiClient.cloud.updateNode.mutate({
+        const updateNode = await this.#apiClient.cloud.updateNode.mutate({
             deletedAt: deletedAt ?? null,
             id: nodeId,
             isFavorite: isFavorite ?? null,
             name,
         });
-        return await apiNodeToExternalNodeFull(updateNode, this.#client.keyPairs);
+        return await apiNodeToExternalNodeFull(updateNode, this.#keys);
     }
     async dataContent({ dataId, onDownloadProgress, progressDecrypt, signal, }) {
         const cached = dataContentCache.get(dataId);
         if (cached !== undefined) {
             return cached;
         }
-        const dataContent = await this.#client.apiClient.cloud.dataContentById.query({
+        const dataContent = await this.#apiClient.cloud.dataContentById.query({
             id: dataId,
         });
         const totalBytes = Number(dataContent.sizeEncrypted ?? dataContent.size);
@@ -491,7 +318,7 @@ export class SecrecyCloudClient {
         if (cachedData.length === dataIds.length) {
             return cachedData;
         }
-        const missingContents = await this.#client.apiClient.cloud.dataContentByIds.query({
+        const missingContents = await this.#apiClient.cloud.dataContentByIds.query({
             ids: dataIds.filter((dataId) => !cachedData.some((datum) => datum.id === dataId)),
         });
         const allDataContents = [
@@ -522,33 +349,33 @@ export class SecrecyCloudClient {
         }));
     }
     async deleteNodes({ nodeIds, }) {
-        return this.#client.apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
+        return this.#apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
     }
     async deleteData({ dataId, nodeId, }) {
-        const { isDeleted } = await this.#client.apiClient.cloud.deleteData.mutate({
+        const { isDeleted } = await this.#apiClient.cloud.deleteData.mutate({
             dataId,
             nodeId,
         });
         return isDeleted;
     }
     async deleteNode({ nodeId }) {
-        const { isDeleted } = await this.#client.apiClient.cloud.deleteNode.mutate({
+        const { isDeleted } = await this.#apiClient.cloud.deleteNode.mutate({
             id: nodeId,
         });
         return isDeleted;
     }
     async emptyTrash() {
-        const { isCleaned } = await this.#client.apiClient.cloud.emptyNodeCloudTrash.mutate({});
+        const { isCleaned } = await this.#apiClient.cloud.emptyNodeCloudTrash.mutate({});
         return isCleaned;
     }
     async recoverNode(id) {
-        const { isRecovered } = await this.#client.apiClient.cloud.recoverNode.mutate({
+        const { isRecovered } = await this.#apiClient.cloud.recoverNode.mutate({
             id,
         });
         return isRecovered;
     }
     async moveNodes({ nodeIds, parentNodeId, }) {
-        const { isMoved } = await this.#client.apiClient.cloud.moveNodes.mutate({
+        const { isMoved } = await this.#apiClient.cloud.moveNodes.mutate({
             ids: nodeIds,
             parentId: parentNodeId ?? null,
         });
@@ -593,7 +420,7 @@ export class SecrecyCloudClient {
                 }
                 const senderPubKey = await this.#client.app.userPublicKey(mail.sender.id);
                 const dataKey = attachment.key
-                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#client.uaPrivateKey)
+                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#keys.privateKey)
                     : null;
                 key = dataKey !== null ? sodium.to_hex(dataKey) : null;
             }
@@ -605,27 +432,28 @@ export class SecrecyCloudClient {
             key = data.key;
         }
         key = key
-            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
+            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#keys.publicKey, this.#keys.privateKey))
             : null;
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#client.uaPrivateKey,
-            publicKey: this.#client.uaIdentity.identityPubKey,
+            privateKey: this.#keys.privateKey,
+            publicKey: this.#keys.publicKey,
         });
-        const saveInCloud = await this.#client.apiClient.cloud.saveInCloud.mutate({
+        const saveInCloud = await this.#apiClient.cloud.saveInCloud.mutate({
             dataId,
             key,
             nodeId: nodeId ?? null,
             fileName: encryptedName,
             nameKey: encryptedNameKey,
         });
-        const node = await apiNodeToExternalNodeFull(saveInCloud, this.#client.keyPairs);
-        if (node.parent) {
-            const othersIdentities = Object.entries(node.parent.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
-            // TODO: ??
-            if (othersIdentities.length > 0) {
-                await this.shareNode(othersIdentities.map(([identityPubKey, permissions]) => ({
-                    pubKey: identityPubKey,
+        const node = await apiNodeToExternalNodeFull(saveInCloud, this.#keys);
+        const me = node.parent?.users.find(([u]) => u.id === node.owner.id);
+        // TODO: ??
+        if (me !== undefined && ['delete', 'write'].includes(me[1].rights)) {
+            const others = node.parent?.users.filter(([u]) => u.id !== node.owner.id) ?? [];
+            if (others.length > 0) {
+                await this.shareNode(others.map(([user, permissions]) => ({
+                    userId: user.id,
                     nodeId: node.id,
                     ...permissions,
                 })));
@@ -633,13 +461,20 @@ export class SecrecyCloudClient {
         }
         return node;
     }
-    encryptNodesForIdentities = async (identityNodes) => {
-        const pubKeys = Object.keys(identityNodes).map((identityPubKey) => identityPubKey);
-        const nodeIds = Object.values(identityNodes).flatMap((nodeIds) => nodeIds);
+    encryptNodesForUsers = async (userNodes, // { [userId]: nodeIds[] }
+    userPublicKeys) => {
+        const userIds = Object.keys(userNodes).map((userId) => userId);
+        const nodeIds = Object.values(userNodes).flatMap((nodeIds) => nodeIds);
         if (nodeIds.length === 0) {
             return {};
         }
         const nodes = [];
+        // Pre check to ensure we get all public keys for users!
+        for (const userId of userIds) {
+            if (userPublicKeys[userId] === undefined) {
+                throw new Error(`Unable to retrieve some user public keys!`);
+            }
+        }
         // Retrieve and format nodes.
         for (const nodeId of nodeIds) {
             let node = nodesEncryptionCache.get(nodeId) ?? nodesCache.get(nodeId);
@@ -664,7 +499,7 @@ export class SecrecyCloudClient {
         // Retrieve all missing nodes from cache to api.
         const missingNodeIds = nodeIds.filter((nodeId) => !nodes.some((node) => node.id === nodeId));
         const fetchedNodes = missingNodeIds.length > 0
-            ? await this.#client.apiClient.cloud.nodesForEncryption.query({
+            ? await this.#apiClient.cloud.nodesForEncryption.query({
                 ids: missingNodeIds,
             })
             : [];
@@ -673,13 +508,13 @@ export class SecrecyCloudClient {
             throw new Error(`Unable to fetch some node infos (${diff.join(', ')})`);
         }
         const finalNodes = await Promise.all(fetchedNodes.map((node) => {
-            return apiNodeForEncryptionToInternal(node, this.#client.keyPairs);
+            return apiNodeForEncryptionToInternal(node, this.#keys);
         }));
         nodes.push(...finalNodes);
         const nodesMappedUsers = {};
-        for (const pubKey in identityNodes) {
-            nodesMappedUsers[pubKey] ??= [];
-            for (const nodeId of identityNodes[pubKey]) {
+        for (const userId in userNodes) {
+            nodesMappedUsers[userId] ??= [];
+            for (const nodeId of userNodes[userId]) {
                 const node = nodes.find((node) => node.id === nodeId);
                 if (!node) {
                     throw new Error('Unable to retrieve node from ram');
@@ -689,16 +524,17 @@ export class SecrecyCloudClient {
                     throw new Error(`Can't share a node without data (${node.id})!`);
                 }
                 const nameKey = node.access?.nameKey;
-                nodesMappedUsers[pubKey].push({
+                const publicKey = userPublicKeys[userId];
+                nodesMappedUsers[userId].push({
                     id: node.id,
                     nameKey: nameKey !== null
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), pubKey, this.#client.uaPrivateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
                         : null,
                     data: 'history' in node
                         ? node.history.map((f) => ({
                             id: f.id,
                             key: f.key
-                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), pubKey, this.#client.uaPrivateKey))
+                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey))
                                 : null,
                         }))
                         : [],
@@ -709,15 +545,15 @@ export class SecrecyCloudClient {
     };
     async reportData({ id, reasons, }) {
         const [rawData, secrecy] = await Promise.all([
-            this.#client.apiClient.cloud.dataById.query({ id }),
-            this.#client.apiClient.misc.publicKey.query(),
+            this.#apiClient.cloud.dataById.query({ id }),
+            this.#apiClient.misc.publicKey.query(),
         ]);
-        const data = apiDataToInternal(rawData, this.#client.keyPairs);
-        return this.#client.apiClient.cloud.reportData.mutate({
+        const data = apiDataToInternal(rawData, this.#keys);
+        return this.#apiClient.cloud.reportData.mutate({
             id: id,
             reasons: reasons,
             encryptedDataKey: data.key
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#client.uaPrivateKey))
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#keys.privateKey))
                 : null,
         });
     }
@@ -731,95 +567,47 @@ export class SecrecyCloudClient {
                 throw new Error("It's not possible to transfer a cold stored data to a lite storage!");
             }
         }
-        return this.#client.apiClient.cloud.moveToStorageType.mutate(input);
+        return this.#apiClient.cloud.moveToStorageType.mutate(input);
     }
     getPublicDataLink(input) {
-        return this.#client.apiClient.cloud.dataLink.query(input);
+        return this.#apiClient.cloud.dataLink.query(input);
     }
     getPublicDataLinks(input) {
-        return this.#client.apiClient.cloud.dataLinks.query(input);
+        return this.#apiClient.cloud.dataLinks.query(input);
     }
     checkAccesses(input) {
-        return this.#client.apiClient.cloud.checkAccesses.query(input);
+        return this.#apiClient.cloud.checkAccesses.query(input);
     }
     createPublicDataLink(input) {
-        if (input.expireAt && input.expireAt <= new Date()) {
-            throw new Error('Unable to create public link using a past expireAt date!');
-        }
-        return this.#client.apiClient.cloud.createDataLink.mutate(input);
+        return createPublicDataLink({ ...input, apiClient: this.#apiClient });
     }
     updatePublicDataLink(input) {
-        return this.#client.apiClient.cloud.updateDataLink.mutate(input);
+        return this.#apiClient.cloud.updateDataLink.mutate(input);
     }
     deletePublicDataLink(input) {
-        return this.#client.apiClient.cloud.deleteDataLink.mutate(input);
+        return this.#apiClient.cloud.deleteDataLink.mutate(input);
+    }
+    downloadDataFromLink(input) {
+        return downloadDataFromLink({
+            ...input,
+            dataUrl: this.#client.secrecyUrls.data,
+        });
     }
     async _handleDataContent({ dataContent, totalBytes, progressParts, onDownloadProgress, progressDecrypt, signal, }) {
-        const onProgress = (key, progressEvent) => {
-            progressParts[key] = progressEvent;
-            const transferredBytes = Object.values(progressParts).reduce((prv, cur) => prv + cur.transferredBytes, 0);
-            onDownloadProgress?.({
-                percent: transferredBytes / totalBytes,
-                totalBytes,
-                transferredBytes,
-            });
-        };
-        const encryptedContentFromParts = async (arg) => {
-            const parts = {};
-            const byPart = async (part) => {
-                const buf = new Uint8Array(await ky
-                    .get(part.contentUrl, {
-                    timeout: false,
-                    onDownloadProgress: (pr) => {
-                        onProgress(`${arg.dataId}-${part.order}`, pr);
-                    },
-                    signal,
-                })
-                    .arrayBuffer());
-                const md5Part = await md5(buf);
-                if (md5Part !== part.md5) {
-                    throw new Error(`Invalid md5 for part ${part.order} of data ${arg.dataId}`);
-                }
-                if (typeof parts[arg.dataId] === 'undefined') {
-                    parts[arg.dataId] = [{ data: buf, order: part.order }];
-                }
-                else {
-                    parts[arg.dataId].push({ data: buf, order: part.order });
-                }
-            };
-            await promiseAllLimit(3, arg.dataParts.map((p) => async () => byPart(p)));
-            return concatenate(...parts[arg.dataId]
-                .sort((a, b) => a.order - b.order)
-                .map((p) => p.data));
-        };
-        const encryptedContent = dataContent.type === 'lite'
-            ? new Uint8Array(dataContent.content)
-            : dataContent.type === 'cloud'
-                ? await encryptedContentFromParts({
-                    dataId: dataContent.id,
-                    dataParts: dataContent.parts,
-                })
-                : dataContent.maybeContent !== null
-                    ? new Uint8Array(dataContent.maybeContent)
-                    : dataContent.maybeParts !== null
-                        ? await encryptedContentFromParts({
-                            dataId: dataContent.id,
-                            dataParts: dataContent.maybeParts,
-                        })
-                        : null;
-        if (encryptedContent === null) {
-            throw `Can't find content for data ${dataContent.id}`;
-        }
-        const md5Encrypted = await md5(encryptedContent);
-        if (md5Encrypted !== dataContent.md5Encrypted) {
-            throw new Error(`Encrypted content does not match`);
-        }
+        const { encryptedContent } = await buildBytesFromApiData({
+            dataContent,
+            totalBytes,
+            progressParts,
+            onDownloadProgress,
+            progressDecrypt,
+            signal,
+        });
         const key = dataContent.key
             ? decryptCryptoBox(sodium.from_hex(dataContent.key), dataContent.type === 'received_mail'
                 ? dataContent.senderPublicKey
                 : dataContent.type === 'cloud' || dataContent.type === 'lite'
                     ? dataContent.publicKey
-                    : this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
+                    : this.#keys.publicKey, this.#keys.privateKey)
             : null;
         const src = key
             ? await decrypt(key, encryptedContent, progressDecrypt, signal)