@secrecy/lib 1.74.6 → 1.75.0-feat-groups-identity.2

package/dist/lib/client/SecrecyCloudClient.js

@@ -8,41 +8,32 @@ import { apiDataToExternal, apiDataToInternal } from './convert/data.js';
 import { apiNodeForEncryptionToInternal, apiNodeFullToInternalFull, apiNodeToExternal, apiNodeToExternalNodeFull, internalNodeFullToNodeFull, } from './convert/node.js';
 import { buildBytesFromApiData } from '../crypto/domain.js';
 import { chunkByTotalItems } from '../utils/object.js';
-import { createPublicDataLink, uploadData } from './upload.js';
+import { uploadData } from './upload.js';
 import { encryptName, generateAndEncryptNameAndKey } from '../crypto/helpers.js';
 import { downloadDataFromLink, } from './data-link.js';
 export class SecrecyCloudClient {
     #client;
-    #keys;
-    #apiClient;
-    constructor(client, keys, apiClient) {
+    constructor(client) {
         this.#client = client;
-        this.#keys = keys;
-        this.#apiClient = apiClient;
     }
     async addDataToHistory({ dataId, nodeId, }) {
-        const addDataToHistory = await this.#apiClient.cloud.addDataToHistory.mutate({ dataId, nodeId });
-        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#keys);
+        const addDataToHistory = await this.#client.apiClient.cloud.addDataToHistory.mutate({
+            dataId,
+            nodeId,
+        });
+        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#client.keyPairs);
         const data = node.history.find((d) => d.id === dataId);
         if (data !== undefined) {
-            // 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!');
-                }
+            const othersIdentities = Object.entries(node.identities).filter(([id]) => id !== this.#client.uaIdentity.identityPubKey);
+            const shares = othersIdentities.map(([publicKey]) => {
                 return {
-                    id: user.id,
+                    pubKey: publicKey,
                     key: data.key
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#keys.privateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#client.uaPrivateKey))
                         : null,
                 };
             });
-            await this.#apiClient.cloud.shareDataInHistory.mutate({
+            await this.#client.apiClient.cloud.shareDataInHistory.mutate({
                 dataId: data.id,
                 nodeId,
                 users: shares,
@@ -53,8 +44,9 @@ export class SecrecyCloudClient {
     async uploadData(opts) {
         return uploadData({
             ...opts,
-            keyPair: this.#keys,
-            apiClient: this.#apiClient,
+            uaIdentity: this.#client.uaIdentity,
+            keyPairs: this.#client.keyPairs,
+            apiClient: this.#client.apiClient,
         });
     }
     async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType = 's3', signal, }) {
@@ -68,21 +60,21 @@ export class SecrecyCloudClient {
         return await this.saveInCloud({ dataId: uploadedData.id, name, nodeId });
     }
     async deletedNodes() {
-        const deletedNodes = await this.#apiClient.cloud.nodesDeleted.query({});
-        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const deletedNodes = await this.#client.apiClient.cloud.nodesDeleted.query({});
+        return await Promise.all(deletedNodes.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async sharedNodes() {
-        const nodesShared = await this.#apiClient.cloud.nodesShared.query();
-        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const nodesShared = await this.#client.apiClient.cloud.nodesShared.query({});
+        return await Promise.all(nodesShared.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
     async nodesSharedWithMe(type = 'FOLDER') {
-        const nodesSharedWithMe = await this.#apiClient.cloud.nodesSharedWithMe.query({ type });
-        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#keys)));
+        const nodesSharedWithMe = await this.#client.apiClient.cloud.nodesSharedWithMe.query({ type });
+        return await Promise.all(nodesSharedWithMe.map(async (node) => await apiNodeToExternal(node, this.#client.keyPairs)));
     }
-    async deleteNodeSharing({ nodeId, userId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNodeSharing.mutate({
+    async deleteNodeSharing({ nodeId, destPubKey, }) {
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeSharing.mutate({
             nodeId,
-            userId,
+            destPubKey,
         });
         return isDeleted;
     }
@@ -95,14 +87,14 @@ export class SecrecyCloudClient {
                 throw new Error(`Node (${nodeId}) does not exists`);
             }
         }
-        if (node.access?.nameKey === undefined) {
-            throw new Error(`Can't have access to node ${nodeId}`);
+        if (!node.accesses[0]) {
+            throw new Error(`No access found for node ${nodeId}`);
         }
         name =
-            typeof name === 'string' && node.access.nameKey !== null
-                ? await encryptName(name, node.access.nameKey)
+            typeof name === 'string' && node.accesses[0].nameKey !== null
+                ? await encryptName(name, node.accesses[0].nameKey)
                 : null;
-        const { isDuplicated } = await this.#apiClient.cloud.duplicateNode.mutate({
+        const { isDuplicated } = await this.#client.apiClient.cloud.duplicateNode.mutate({
             nodeId,
             folderId: folderId ?? null,
             name,
@@ -110,50 +102,54 @@ export class SecrecyCloudClient {
         return isDuplicated;
     }
     async deleteNodeCloudTrash({ ids }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNodeCloudTrash.mutate({ ids });
         return isDeleted;
     }
     async createFolder({ name, parentFolderId, }) {
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#keys.privateKey,
-            publicKey: this.#keys.publicKey,
+            privateKey: this.#client.uaPrivateKey,
+            publicKey: this.#client.uaIdentity.identityPubKey,
         });
-        const createdFolder = await this.#apiClient.cloud.createFolder.mutate({
+        const createdFolder = await this.#client.apiClient.cloud.createFolder.mutate({
             name: encryptedName,
             parentId: parentFolderId ?? null,
             nameKey: encryptedNameKey,
         });
-        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,
-            })));
+        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,
+                })));
+            }
         }
         return folder;
     }
     async node({ id, deleted, } = {}) {
-        const node = await this.#apiClient.cloud.nodeFullById.query({ id, deleted });
-        return await apiNodeToExternalNodeFull(node, this.#keys);
+        const node = await this.#client.apiClient.cloud.nodeFullById.query({
+            id,
+            deleted,
+        });
+        return await apiNodeToExternalNodeFull(node, this.#client.keyPairs);
     }
     async dataMetadata({ id }) {
-        const data = await this.#apiClient.cloud.dataById.query({ id });
-        return apiDataToExternal(data, this.#keys);
+        const data = await this.#client.apiClient.cloud.dataById.query({ id });
+        return apiDataToExternal(data, this.#client.keyPairs);
     }
-    async shareNode(input, progress) {
+    async shareNode(accesses, progress) {
         // TODO: Validate input
-        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 nodesMap = await this.#client.apiClient.cloud.shareNode.mutate({
+            accesses,
+        });
         const maxNodesBatchSize = 1000;
         const totalNodesToShare = Object.values(nodesMap).reduce((size, ids) => size + ids.length, 0);
         progress?.({ total: totalNodesToShare, current: 0, percent: 0 });
@@ -170,9 +166,9 @@ export class SecrecyCloudClient {
                 return filtered.length > 0 ? [userId, filtered] : null;
             })
                 .filter((entry) => entry !== null));
-            const infos = await this.encryptNodesForUsers(nodesToEncrypt, publicKeysMap);
-            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([userId, nodes]) => [
-                userId,
+            const infos = await this.encryptNodesForIdentities(nodesToEncrypt);
+            const nodesToUpdateRights = Object.fromEntries(Object.entries(nodesMap).map(([pubKey, nodes]) => [
+                pubKey,
                 nodes
                     .filter((node) => !node.includeKeys)
                     .map((node) => {
@@ -188,13 +184,13 @@ export class SecrecyCloudClient {
                     };
                 }),
             ]));
-            const withKeys = Object.fromEntries(Object.entries(infos).map(([userId, nodes]) => {
+            const withKeys = Object.fromEntries(Object.entries(infos).map(([pubKey, nodes]) => {
                 return [
-                    userId,
+                    pubKey,
                     {
-                        userId,
+                        pubKey,
                         nodes: nodes.map((node) => {
-                            const map = nodesMap[userId];
+                            const map = nodesMap[pubKey];
                             if (!map) {
                                 throw new Error('Unable to retrieve mapped nodes!');
                             }
@@ -217,20 +213,22 @@ export class SecrecyCloudClient {
                 ];
             }));
             const finishInput = [];
-            for (const [userId, nodes] of Object.entries(withKeys)) {
+            for (const [pubKey, nodes] of Object.entries(withKeys)) {
                 if (nodes.nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ userId, nodes: nodes.nodes });
+                finishInput.push({ pubKey, nodes: nodes.nodes });
             }
-            for (const [userId, nodes] of Object.entries(nodesToUpdateRights)) {
+            for (const [pubKey, nodes] of Object.entries(nodesToUpdateRights)) {
                 if (nodes.length === 0) {
                     continue;
                 }
-                finishInput.push({ userId, nodes });
+                finishInput.push({ pubKey, nodes });
             }
             const subState = finishInput.length > 0
-                ? await this.#apiClient.cloud.shareNodeFinish.mutate(finishInput)
+                ? await this.#client.apiClient.cloud.shareNodeFinish.mutate({
+                    accesses: finishInput,
+                })
                 : { isFinished: true, details: {} };
             const currentProgress = Math.min((index + 1) * maxNodesBatchSize, totalNodesToShare);
             progress?.({
@@ -277,27 +275,31 @@ export class SecrecyCloudClient {
                 throw `Can't find Node ${nodeId}`;
             }
         }
-        if (node.access?.nameKey === undefined) {
-            throw new Error(`Can't have access to 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}`);
         }
         name =
-            typeof name === 'string' && node.access.nameKey !== null
-                ? await encryptName(name, node.access.nameKey)
+            typeof name === 'string' && node.accesses[0].nameKey !== null
+                ? await encryptName(name, node.accesses[0].nameKey)
                 : null;
-        const updateNode = await this.#apiClient.cloud.updateNode.mutate({
+        const updateNode = await this.#client.apiClient.cloud.updateNode.mutate({
             deletedAt: deletedAt ?? null,
             id: nodeId,
             isFavorite: isFavorite ?? null,
             name,
         });
-        return await apiNodeToExternalNodeFull(updateNode, this.#keys);
+        return await apiNodeToExternalNodeFull(updateNode, this.#client.keyPairs);
     }
     async dataContent({ dataId, onDownloadProgress, progressDecrypt, signal, }) {
         const cached = dataContentCache.get(dataId);
         if (cached !== undefined) {
             return cached;
         }
-        const dataContent = await this.#apiClient.cloud.dataContentById.query({
+        const dataContent = await this.#client.apiClient.cloud.dataContentById.query({
             id: dataId,
         });
         const totalBytes = Number(dataContent.sizeEncrypted ?? dataContent.size);
@@ -318,7 +320,7 @@ export class SecrecyCloudClient {
         if (cachedData.length === dataIds.length) {
             return cachedData;
         }
-        const missingContents = await this.#apiClient.cloud.dataContentByIds.query({
+        const missingContents = await this.#client.apiClient.cloud.dataContentByIds.query({
             ids: dataIds.filter((dataId) => !cachedData.some((datum) => datum.id === dataId)),
         });
         const allDataContents = [
@@ -349,33 +351,33 @@ export class SecrecyCloudClient {
         }));
     }
     async deleteNodes({ nodeIds, }) {
-        return this.#apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
+        return this.#client.apiClient.cloud.deleteNodes.mutate({ ids: nodeIds });
     }
     async deleteData({ dataId, nodeId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteData.mutate({
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteData.mutate({
             dataId,
             nodeId,
         });
         return isDeleted;
     }
     async deleteNode({ nodeId }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteNode.mutate({
+        const { isDeleted } = await this.#client.apiClient.cloud.deleteNode.mutate({
             id: nodeId,
         });
         return isDeleted;
     }
     async emptyTrash() {
-        const { isCleaned } = await this.#apiClient.cloud.emptyNodeCloudTrash.mutate({});
+        const { isCleaned } = await this.#client.apiClient.cloud.emptyNodeCloudTrash.mutate({});
         return isCleaned;
     }
     async recoverNode(id) {
-        const { isRecovered } = await this.#apiClient.cloud.recoverNode.mutate({
+        const { isRecovered } = await this.#client.apiClient.cloud.recoverNode.mutate({
             id,
         });
         return isRecovered;
     }
     async moveNodes({ nodeIds, parentNodeId, }) {
-        const { isMoved } = await this.#apiClient.cloud.moveNodes.mutate({
+        const { isMoved } = await this.#client.apiClient.cloud.moveNodes.mutate({
             ids: nodeIds,
             parentId: parentNodeId ?? null,
         });
@@ -420,7 +422,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.#keys.privateKey)
+                    ? decryptCryptoBox(sodium.from_hex(attachment.key), senderPubKey, this.#client.uaPrivateKey)
                     : null;
                 key = dataKey !== null ? sodium.to_hex(dataKey) : null;
             }
@@ -432,28 +434,27 @@ export class SecrecyCloudClient {
             key = data.key;
         }
         key = key
-            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#keys.publicKey, this.#keys.privateKey))
+            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey))
             : null;
         const { encryptedNameKey, encryptedName } = await generateAndEncryptNameAndKey({
             name,
-            privateKey: this.#keys.privateKey,
-            publicKey: this.#keys.publicKey,
+            privateKey: this.#client.uaPrivateKey,
+            publicKey: this.#client.uaIdentity.identityPubKey,
         });
-        const saveInCloud = await this.#apiClient.cloud.saveInCloud.mutate({
+        const saveInCloud = await this.#client.apiClient.cloud.saveInCloud.mutate({
             dataId,
             key,
             nodeId: nodeId ?? null,
             fileName: encryptedName,
             nameKey: encryptedNameKey,
         });
-        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,
+        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,
                     nodeId: node.id,
                     ...permissions,
                 })));
@@ -461,20 +462,12 @@ export class SecrecyCloudClient {
         }
         return node;
     }
-    encryptNodesForUsers = async (userNodes, // { [userId]: nodeIds[] }
-    userPublicKeys) => {
-        const userIds = Object.keys(userNodes).map((userId) => userId);
-        const nodeIds = Object.values(userNodes).flatMap((nodeIds) => nodeIds);
+    encryptNodesForIdentities = async (identityNodes) => {
+        const nodeIds = Object.values(identityNodes).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);
@@ -499,7 +492,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.#apiClient.cloud.nodesForEncryption.query({
+            ? await this.#client.apiClient.cloud.nodesForEncryption.query({
                 ids: missingNodeIds,
             })
             : [];
@@ -508,13 +501,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.#keys);
+            return apiNodeForEncryptionToInternal(node, this.#client.keyPairs);
         }));
         nodes.push(...finalNodes);
         const nodesMappedUsers = {};
-        for (const userId in userNodes) {
-            nodesMappedUsers[userId] ??= [];
-            for (const nodeId of userNodes[userId]) {
+        for (const pubKey in identityNodes) {
+            nodesMappedUsers[pubKey] ??= [];
+            for (const nodeId of identityNodes[pubKey]) {
                 const node = nodes.find((node) => node.id === nodeId);
                 if (!node) {
                     throw new Error('Unable to retrieve node from ram');
@@ -524,17 +517,16 @@ export class SecrecyCloudClient {
                     throw new Error(`Can't share a node without data (${node.id})!`);
                 }
                 const nameKey = node.access?.nameKey;
-                const publicKey = userPublicKeys[userId];
-                nodesMappedUsers[userId].push({
+                nodesMappedUsers[pubKey].push({
                     id: node.id,
                     nameKey: nameKey !== null
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), pubKey, this.#client.uaPrivateKey))
                         : null,
                     data: 'history' in node
                         ? node.history.map((f) => ({
                             id: f.id,
                             key: f.key
-                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey))
+                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), pubKey, this.#client.uaPrivateKey))
                                 : null,
                         }))
                         : [],
@@ -545,15 +537,15 @@ export class SecrecyCloudClient {
     };
     async reportData({ id, reasons, }) {
         const [rawData, secrecy] = await Promise.all([
-            this.#apiClient.cloud.dataById.query({ id }),
-            this.#apiClient.misc.publicKey.query(),
+            this.#client.apiClient.cloud.dataById.query({ id }),
+            this.#client.apiClient.misc.publicKey.query(),
         ]);
-        const data = apiDataToInternal(rawData, this.#keys);
-        return this.#apiClient.cloud.reportData.mutate({
+        const data = apiDataToInternal(rawData, this.#client.keyPairs);
+        return this.#client.apiClient.cloud.reportData.mutate({
             id: id,
             reasons: reasons,
             encryptedDataKey: data.key
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#keys.privateKey))
+                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), secrecy.publicKey, this.#client.uaPrivateKey))
                 : null,
         });
     }
@@ -567,25 +559,28 @@ export class SecrecyCloudClient {
                 throw new Error("It's not possible to transfer a cold stored data to a lite storage!");
             }
         }
-        return this.#apiClient.cloud.moveToStorageType.mutate(input);
+        return this.#client.apiClient.cloud.moveToStorageType.mutate(input);
     }
     getPublicDataLink(input) {
-        return this.#apiClient.cloud.dataLink.query(input);
+        return this.#client.apiClient.cloud.dataLink.query(input);
     }
     getPublicDataLinks(input) {
-        return this.#apiClient.cloud.dataLinks.query(input);
+        return this.#client.apiClient.cloud.dataLinks.query(input);
     }
     checkAccesses(input) {
-        return this.#apiClient.cloud.checkAccesses.query(input);
+        return this.#client.apiClient.cloud.checkAccesses.query(input);
     }
     createPublicDataLink(input) {
-        return createPublicDataLink({ ...input, apiClient: this.#apiClient });
+        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);
     }
     updatePublicDataLink(input) {
-        return this.#apiClient.cloud.updateDataLink.mutate(input);
+        return this.#client.apiClient.cloud.updateDataLink.mutate(input);
     }
     deletePublicDataLink(input) {
-        return this.#apiClient.cloud.deleteDataLink.mutate(input);
+        return this.#client.apiClient.cloud.deleteDataLink.mutate(input);
     }
     downloadDataFromLink(input) {
         return downloadDataFromLink({
@@ -606,8 +601,8 @@ export class SecrecyCloudClient {
             ? decryptCryptoBox(sodium.from_hex(dataContent.key), dataContent.type === 'received_mail'
                 ? dataContent.senderPublicKey
                 : dataContent.type === 'cloud' || dataContent.type === 'lite'
-                    ? dataContent.publicKey
-                    : this.#keys.publicKey, this.#keys.privateKey)
+                    ? dataContent.sharedByPublicKey
+                    : this.#client.uaIdentity.identityPubKey, this.#client.uaPrivateKey)
             : null;
         const src = key
             ? await decrypt(key, encryptedContent, progressDecrypt, signal)

package/dist/lib/client/SecrecyDbClient.js

@@ -1,10 +1,3 @@
 export class SecrecyDbClient {
-    // #client: SecrecyClient;
-    // #keys: KeyPair;
-    #apiClient;
-    constructor(_client, _keys, apiClient) {
-        // this.#client = client;
-        // this.#keys = keys;
-        this.#apiClient = apiClient;
-    }
+    constructor(_client) { }
 }