@secrecy/lib 1.29.0-feat-manage-user-data.2 → 1.29.0-feat-rename-file.3

package/dist/lib/cache.js

@@ -1,10 +1,10 @@
 import { LRUCache } from 'lru-cache';
 import { gigaToBytes } from './utils.js';
-export const filesCache = new Map();
+export const dataCache = new Map();
 export const nodesCache = new Map();
 export const usersCache = new Map();
 export const publicKeysCache = new Map();
-export const dataCache = new LRUCache({
+export const lruCache = new LRUCache({
     max: 500,
     maxSize: gigaToBytes(0.5),
     sizeCalculation: (value) => {

package/dist/lib/client/SecrecyAppClient.js

@@ -82,8 +82,8 @@ export class SecrecyAppClient {
     async updateSettings(settings) {
         const updateAppSettings = await this.#apiClient.application.updateSettings.mutate({
             cloudNodeDaysForDelete: settings.cloudNodeDaysForDelete,
-            historyFileDaysForDelete: settings.historyFileDaysForDelete,
-            historyMaxFileCount: settings.historyMaxFileCount,
+            historyFileDaysForDelete: settings.historyDataDaysForDelete,
+            historyMaxFileCount: settings.historyDataMaxCount,
         });
         return updateAppSettings;
     }

package/dist/lib/client/SecrecyCloudClient.js

@@ -1,15 +1,15 @@
 import axios from 'axios';
 import ky from 'ky';
 import { encryptName } from '../index.js';
-import { nodesCache, filesCache, dataCache } from '../cache.js';
-import { secretStreamKeygen } from '../crypto/file.js';
+import { nodesCache, dataCache, lruCache } from '../cache.js';
+import { secretStreamKeygen } from '../crypto/data.js';
 import { decryptCryptoBox, encryptCryptoBox } from '../crypto/index.js';
 import { compress, 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 { apiFileToExternal } from './convert/file.js';
+import { apiDataToExternal } from './convert/data.js';
 import { apiNodeFullToInternalFull, apiNodeToExternal, apiNodeToExternalNodeFull, internalNodeFullToNodeFull, } from './convert/node.js';
 import { promiseAllLimit } from '../utils/promise.js';
 // import { md5 } from "../worker/index.js";
@@ -23,71 +23,71 @@ export class SecrecyCloudClient {
         this.#keys = keys;
         this.#apiClient = apiClient;
     }
-    async addFileToHistory({ fileId, nodeId, }) {
-        const addFileToHistory = await this.#apiClient.cloud.addFileToHistory.mutate({
-            fileId,
+    async addDataToHistory({ dataId, nodeId, }) {
+        const addDataToHistory = await this.#apiClient.cloud.addDataToHistory.mutate({
+            dataId,
             nodeId,
         });
-        const node = await apiNodeFullToInternalFull(addFileToHistory, this.#keys);
-        const file = node.history.find((f) => f.id === fileId);
-        if (file !== undefined) {
+        const node = await apiNodeFullToInternalFull(addDataToHistory, this.#keys);
+        const data = node.history.find((f) => f.id === dataId);
+        if (data !== undefined) {
             const users = node.users.filter(([u]) => u.id !== this.#client.app.userId);
-            await this.#apiClient.cloud.shareFileInHistory.mutate({
-                fileId: file.id,
+            await this.#apiClient.cloud.shareDataInHistory.mutate({
+                dataId: data.id,
                 nodeId,
                 users: await Promise.all(users.map(async ([u]) => {
                     const userPubKey = await this.#client.app.userPublicKey(u.id);
                     return {
                         id: u.id,
-                        key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(file.key), userPubKey, this.#keys.privateKey)),
+                        key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), userPubKey, this.#keys.privateKey)),
                     };
                 })),
             });
         }
         return internalNodeFullToNodeFull(node);
     }
-    async uploadFile({ file, encryptProgress, uploadProgress, signal, }) {
-        const fileKey = secretStreamKeygen();
-        const fileBuffer = file instanceof File ? new Uint8Array(await file.arrayBuffer()) : file;
-        const compressed = compress(fileBuffer);
-        const { data: encryptedFile, md5: md5File, md5Encrypted, } = await encrypt(fileKey, compressed, encryptProgress, signal);
-        const encryptedFileKey = encryptCryptoBox(fileKey, this.#keys.publicKey, this.#keys.privateKey);
-        const uploadFile = await this.#apiClient.cloud.uploadFile.mutate({
-            fileSize: BigInt(encryptedFile.byteLength),
-            fileSizeBefore: BigInt(fileBuffer.byteLength),
-            fileKey: sodium.to_hex(encryptedFileKey),
+    async uploadData({ data, encryptProgress, uploadProgress, signal, }) {
+        const dataKey = secretStreamKeygen();
+        const dataBuffer = data instanceof File ? new Uint8Array(await data.arrayBuffer()) : data;
+        const compressed = compress(dataBuffer);
+        const { data: encryptedData, md5: md5Data, md5Encrypted, } = await encrypt(dataKey, compressed, encryptProgress, signal);
+        const encryptedDataKey = encryptCryptoBox(dataKey, this.#keys.publicKey, this.#keys.privateKey);
+        const uploadData = await this.#apiClient.cloud.uploadData.mutate({
+            dataSize: BigInt(encryptedData.byteLength),
+            dataSizeBefore: BigInt(dataBuffer.byteLength),
+            dataKey: sodium.to_hex(encryptedDataKey),
             md5Encrypted,
-            md5: md5File,
+            md5: md5Data,
         });
         await uploadProgress?.({
-            total: encryptedFile.byteLength,
+            total: encryptedData.byteLength,
             current: 0,
             percent: 0,
         });
-        if (uploadFile.parts.length === 0) {
+        if (uploadData.parts.length === 0) {
             await uploadProgress?.({
-                total: encryptedFile.byteLength,
-                current: encryptedFile.byteLength,
+                total: encryptedData.byteLength,
+                current: encryptedData.byteLength,
                 percent: 1,
             });
-            return uploadFile.fileId;
+            return uploadData.dataId;
         }
         const uploadPartEnded = async (md5, order) => {
-            const { isUploadPartEnded } = await this.#apiClient.cloud.uploadFilePartEnd.mutate({
-                fileId: uploadFile.fileId,
+            const { isUploadPartEnded } = await this.#apiClient.cloud.uploadDataPartEnd.mutate({
+                dataId: uploadData.dataId,
                 md5,
                 order,
             });
             return isUploadPartEnded;
         };
         const uploadEnded = async () => {
-            const { isUploadEnded } = await this.#apiClient.cloud.uploadFileEnd.mutate({
-                fileId: uploadFile.fileId,
+            const { isUploadEnded } = await this.#apiClient.cloud.uploadDataEnd.mutate({
+                dataId: uploadData.dataId,
             });
             return isUploadEnded;
         };
         const chunkParts = new Array();
-        for (const [index, chunk] of enumerate(chunks(encryptedFile, Number(uploadFile.filePartSize)))) {
+        for (const [index, chunk] of enumerate(chunks(encryptedData, Number(uploadData.dataPartSize)))) {
             chunkParts.push({
                 order: index + 1,
                 data: chunk,
@@ -99,8 +99,8 @@ export class SecrecyCloudClient {
             progressParts[part] = progressEvent;
             const current = Object.values(progressParts).reduce((prv, cur) => prv + cur.loaded, 0);
             void uploadProgress?.({
-                percent: current / encryptedFile.byteLength,
-                total: encryptedFile.byteLength,
+                percent: current / encryptedData.byteLength,
+                total: encryptedData.byteLength,
                 current,
             });
         };
@@ -113,7 +113,7 @@ export class SecrecyCloudClient {
             for (const [key, value] of Object.entries(part.fields)) {
                 formData.append(key, value);
             }
-            formData.append('file', new Blob([chunk.data]), `${uploadFile.fileId}-${chunk.order}`);
+            formData.append('data', new Blob([chunk.data]), `${uploadData.dataId}-${chunk.order}`);
             await axios.post(part.url, formData, {
                 onUploadProgress: (progressEvent) => {
                     onProgress(part.order, progressEvent);
@@ -122,22 +122,22 @@ export class SecrecyCloudClient {
             });
             await uploadPartEnded(chunk.md5, chunk.order);
         };
-        await promiseAllLimit(3, uploadFile.parts.map((p) => async () => {
+        await promiseAllLimit(3, uploadData.parts.map((p) => async () => {
             await byPart(p);
         }));
         await uploadEnded();
-        dataCache.set(uploadFile.fileId, fileBuffer);
-        return uploadFile.fileId;
+        lruCache.set(uploadData.dataId, dataBuffer);
+        return uploadData.dataId;
     }
-    async uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }) {
-        const fileId = await this.uploadFile({
-            file,
+    async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, signal, }) {
+        const dataId = await this.uploadData({
+            data,
             encryptProgress,
             uploadProgress,
             signal,
         });
         return await this.saveInCloud({
-            fileId,
+            dataId,
             name,
             nodeId,
         });
@@ -220,11 +220,11 @@ export class SecrecyCloudClient {
         });
         return await apiNodeToExternalNodeFull(node, this.#keys);
     }
-    async fileMetadata({ id }) {
-        const file = await this.#apiClient.cloud.fileById.query({
+    async dataMetadata({ id }) {
+        const data = await this.#apiClient.cloud.dataById.query({
             id,
         });
-        return apiFileToExternal(file, this.#keys);
+        return apiDataToExternal(data, this.#keys);
     }
     async shareNode({ nodeId, userId, rights, }) {
         const publicKey = await this.#client.app.userPublicKey(userId);
@@ -270,26 +270,26 @@ export class SecrecyCloudClient {
         });
         return await apiNodeToExternalNodeFull(updateNode, this.#keys);
     }
-    async fileContent({ fileId, onDownloadProgress, progressDecrypt, signal, }) {
-        const cached = dataCache.get(fileId);
+    async dataContent({ dataId, onDownloadProgress, progressDecrypt, signal, }) {
+        const cached = lruCache.get(dataId);
         if (cached !== undefined) {
             return cached;
         }
-        const fileContent = await this.#apiClient.cloud.fileContentById.query({
-            id: fileId,
+        const dataContent = await this.#apiClient.cloud.dataContentById.query({
+            id: dataId,
         });
         const progressParts = {};
         const onProgress = (part, progressEvent) => {
             progressParts[part] = progressEvent;
             const transferredBytes = Object.values(progressParts).reduce((prv, cur) => prv + cur.transferredBytes, 0);
-            const totalBytes = Number(fileContent.totalSize);
+            const totalBytes = Number(dataContent.totalSize);
             onDownloadProgress?.({
                 percent: transferredBytes / totalBytes,
                 totalBytes,
                 transferredBytes,
             });
         };
-        const encryptedContentFromParts = async (fileParts) => {
+        const encryptedContentFromParts = async (dataParts) => {
             const parts = new Array();
             const byPart = async (part) => {
                 const buf = new Uint8Array(await ky
@@ -303,14 +303,14 @@ export class SecrecyCloudClient {
                     .arrayBuffer());
                 const md5Part = await md5(buf);
                 if (md5Part !== part.md5) {
-                    throw new Error(`Invalid md5 for part ${part.order} of file ${fileId}`);
+                    throw new Error(`Invalid md5 for part ${part.order} of data ${dataId}`);
                 }
                 parts.push({
                     data: buf,
                     order: part.order,
                 });
             };
-            await promiseAllLimit(3, fileParts.map((p) => async () => {
+            await promiseAllLimit(3, dataParts.map((p) => async () => {
                 await byPart(p);
             }));
             return concatenate(...parts.sort((a, b) => a.order - b.order).map((p) => p.data));
@@ -318,42 +318,42 @@ export class SecrecyCloudClient {
         const finalize = async (encryptedContent) => {
             // const md5Encrypted = await firstValueFrom(md5(of(encryptedContent)));
             const md5Encrypted = await md5(encryptedContent);
-            if (md5Encrypted !== fileContent.md5Encrypted) {
+            if (md5Encrypted !== dataContent.md5Encrypted) {
                 throw new Error(`Encrypted content does not match`);
             }
-            const key = decryptCryptoBox(sodium.from_hex(fileContent.key), fileContent.type === 'received_mail'
-                ? fileContent.senderPublicKey
-                : fileContent.type === 'cloud'
-                    ? fileContent.publicKey
+            const key = decryptCryptoBox(sodium.from_hex(dataContent.key), dataContent.type === 'received_mail'
+                ? dataContent.senderPublicKey
+                : dataContent.type === 'cloud'
+                    ? dataContent.publicKey
                     : this.#keys.publicKey, this.#keys.privateKey);
             const src = await decrypt(key, encryptedContent, progressDecrypt, signal);
             // const md5Content = await firstValueFrom(md5(of(src)));
             const md5Content = await md5(src);
-            if (md5Content !== fileContent.md5) {
+            if (md5Content !== dataContent.md5) {
                 throw new Error(`Content does not match`);
             }
             return decompress(src);
         };
-        const encryptedContent = fileContent.type === 'lite'
-            ? fileContent.content
-            : fileContent.type === 'cloud'
-                ? await encryptedContentFromParts(fileContent.parts)
+        const encryptedContent = dataContent.type === 'lite'
+            ? dataContent.content
+            : dataContent.type === 'cloud'
+                ? await encryptedContentFromParts(dataContent.parts)
                 : // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-                    fileContent.maybeContent !== null
-                        ? fileContent.maybeContent
-                        : fileContent.maybeParts !== null
-                            ? await encryptedContentFromParts(fileContent.maybeParts)
+                    dataContent.maybeContent !== null
+                        ? dataContent.maybeContent
+                        : dataContent.maybeParts !== null
+                            ? await encryptedContentFromParts(dataContent.maybeParts)
                             : null;
         if (encryptedContent === null) {
-            throw `Can't find content for file ${fileId}`;
+            throw `Can't find content for data ${dataId}`;
         }
         const data = await finalize(encryptedContent);
-        dataCache.set(fileId, data);
+        lruCache.set(dataId, data);
         return data;
     }
-    async deleteFile({ fileId, nodeId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteFile.mutate({
-            fileId,
+    async deleteData({ dataId, nodeId, }) {
+        const { isDeleted } = await this.#apiClient.cloud.deleteData.mutate({
+            dataId,
             nodeId,
         });
         return isDeleted;
@@ -381,7 +381,7 @@ export class SecrecyCloudClient {
         });
         return isMoved;
     }
-    async saveInCloud({ fileId, name, nodeId, }) {
+    async saveInCloud({ dataId, name, nodeId, }) {
         if (nodeId !== undefined && !nodesCache.has(nodeId)) {
             await this.node({ id: nodeId });
             if (!nodesCache.has(nodeId)) {
@@ -394,50 +394,50 @@ export class SecrecyCloudClient {
             }
         }
         let key = '';
-        const file = filesCache.get(fileId);
-        if (file === undefined) {
-            await this.fileMetadata({ id: fileId });
-            const file = filesCache.get(fileId);
-            if (file === undefined) {
+        const data = dataCache.get(dataId);
+        if (data === undefined) {
+            await this.dataMetadata({ id: dataId });
+            const data = dataCache.get(dataId);
+            if (data === undefined) {
                 const receivedMails = await this.#client.mail.receivedMails();
-                const mail = receivedMails.find((m) => m.files.some((f) => f.id === fileId));
+                const mail = receivedMails.find((m) => m.data.some((f) => f.id === dataId));
                 if (mail === undefined) {
                     const err = {
                         name: 'ClientError',
                         code: 'NOT_FOUND',
-                        message: `Can't find mail with the file ${fileId}`,
+                        message: `Can't find mail with the data ${dataId}`,
                     };
                     throw err;
                 }
-                const fileMail = mail.files.find((f) => f.id === fileId);
-                if (fileMail === undefined) {
+                const dataMail = mail.data.find((f) => f.id === dataId);
+                if (dataMail === undefined) {
                     const err = {
                         name: 'ClientError',
                         code: 'NOT_FOUND',
-                        message: `Can't find mail with the file ${fileId}`,
+                        message: `Can't find mail with the data ${dataId}`,
                     };
                     throw err;
                 }
                 const senderPubKey = await this.#client.app.userPublicKey(mail.sender.id);
-                const fileKey = decryptCryptoBox(sodium.from_hex(fileMail.key), senderPubKey, this.#keys.privateKey);
-                key = sodium.to_hex(fileKey);
+                const dataKey = decryptCryptoBox(sodium.from_hex(dataMail.key), senderPubKey, this.#keys.privateKey);
+                key = sodium.to_hex(dataKey);
             }
             else {
-                key = file.key;
+                key = data.key;
             }
         }
         else {
-            key = file.key;
+            key = data.key;
         }
         key = sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), this.#keys.publicKey, this.#keys.privateKey));
         const nameKey = secretStreamKeygen();
         const encryptedName = await encryptName(name, sodium.to_hex(nameKey));
         const encryptedNameKey = sodium.to_hex(encryptCryptoBox(nameKey, this.#keys.publicKey, this.#keys.privateKey));
         const saveInCloud = await this.#apiClient.cloud.saveInCloud.mutate({
-            fileId,
+            dataId,
             key,
             nodeId: nodeId ?? null,
-            filename: encryptedName,
+            fileName: encryptedName,
             nameKey: encryptedNameKey,
         });
         const node = await apiNodeToExternalNodeFull(saveInCloud, this.#keys);
@@ -468,7 +468,7 @@ export class SecrecyCloudClient {
             nameKey: nameKey !== null
                 ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
                 : null,
-            files: 'history' in node
+            data: 'history' in node
                 ? node.history.map((f) => ({
                     id: f.id,
                     key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey)),

package/dist/lib/client/SecrecyMailClient.js

@@ -1,4 +1,4 @@
-import { filesCache } from '../cache.js';
+import { dataCache } from '../cache.js';
 import { encryptCryptoBox, sodium } from '../index.js';
 import { convertInternalMailToExternal } from './convert/mail.js';
 export class SecrecyMailClient {
@@ -67,11 +67,11 @@ export class SecrecyMailClient {
         }
         if (senderFiles !== undefined) {
             for (const f of senderFiles) {
-                let file = filesCache.get(f.id);
-                if (file === undefined) {
-                    await this.#client.cloud.fileMetadata({ id: f.id });
-                    file = filesCache.get(f.id);
-                    if (file === undefined) {
+                let data = dataCache.get(f.id);
+                if (data === undefined) {
+                    await this.#client.cloud.dataMetadata({ id: f.id });
+                    data = dataCache.get(f.id);
+                    if (data === undefined) {
                         throw new Error(`File ${f.name} (${f.id}) does not exists`);
                     }
                 }
@@ -132,7 +132,7 @@ export class SecrecyMailClient {
             if (email === undefined) {
                 continue;
             }
-            const input = await this._eachUser(draft.files, draft.subject, draft.body, email);
+            const input = await this._eachUser(draft.data, draft.subject, draft.body, email);
             if (input === null) {
                 temporaryRecipients.push(email);
             }
@@ -141,7 +141,7 @@ export class SecrecyMailClient {
             }
         }
         for (const { id } of draft.recipients) {
-            const input = await this._eachUser(draft.files, draft.subject, draft.body, id);
+            const input = await this._eachUser(draft.data, draft.subject, draft.body, id);
             if (input === null) {
                 temporaryRecipients.push(id);
             }
@@ -167,13 +167,20 @@ export class SecrecyMailClient {
                     continue;
                 }
                 try {
-                    const input = await this._eachUser(mail.files, mail.subject, mail.body, email);
+                    const input = await this._eachUser(mail.data, mail.subject, mail.body, email);
                     if (input === null) {
                         continue;
                     }
                     await this.#apiClient.mail.sendOne.mutate({
                         id: mail.mailIntegrityId,
-                        recipient: input,
+                        recipient: {
+                            ...input,
+                            attachments: input.attachments.map((attachment) => ({
+                                id: attachment.dataId,
+                                key: attachment.key,
+                                name: attachment.name,
+                            })),
+                        },
                     });
                 }
                 catch {
@@ -186,16 +193,16 @@ export class SecrecyMailClient {
         const hashKey = sodium.randombytes_buf(sodium.crypto_generichash_KEYBYTES, 'hex');
         const hash = sodium.crypto_generichash(sodium.crypto_generichash_BYTES, JSON.stringify({ body, subject }), hashKey, 'hex');
         for (const f of senderFiles) {
-            let file = filesCache.get(f.id);
-            if (file === undefined) {
-                await this.#client.cloud.fileMetadata({ id: f.id });
-                file = filesCache.get(f.id);
-                if (file === undefined) {
+            let data = dataCache.get(f.id);
+            if (data === undefined) {
+                await this.#client.cloud.dataMetadata({ id: f.id });
+                data = dataCache.get(f.id);
+                if (data === undefined) {
                     throw new Error(`File ${f.name} (${f.id}) does not exists`);
                 }
             }
             senderFiles.push({
-                id: file.id,
+                id: data.id,
                 name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#keys.publicKey, this.#keys.privateKey)),
             });
         }
@@ -254,25 +261,25 @@ export class SecrecyMailClient {
         const unreadReceivedMailsCount = await this.#apiClient.mail.unreadReceivedCount.query({});
         return unreadReceivedMailsCount;
     }
-    _eachUser = async (files, subject, body, idOrMail) => {
+    _eachUser = async (data, subject, body, idOrMail) => {
         // const pubKey = await this.#client.app.userPublicKey(userId)
         const pubKey = await this.#client.app.userPublicKey(idOrMail);
-        // const recipientsFiles = new Array<MailFileInput>()
-        const recipientsFiles = new Array();
-        for (const f of files) {
-            let fileInHistory = filesCache.get(f.id);
-            if (fileInHistory === undefined) {
-                await this.#client.cloud.fileMetadata({ id: f.id });
-                fileInHistory = filesCache.get(f.id);
-                if (fileInHistory === undefined) {
+        // const attachments = new Array<MailFileInput>()
+        const attachments = new Array();
+        for (const f of data) {
+            let dataInHistory = dataCache.get(f.id);
+            if (dataInHistory === undefined) {
+                await this.#client.cloud.dataMetadata({ id: f.id });
+                dataInHistory = dataCache.get(f.id);
+                if (dataInHistory === undefined) {
                     throw new Error(`File ${f.name} (${f.id}) does not exists`);
                 }
             }
-            const key = fileInHistory.key;
-            recipientsFiles.push({
+            const key = dataInHistory.key;
+            attachments.push({
                 id: f.id,
                 name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), pubKey, this.#keys.privateKey)),
-                fileKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
+                dataKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
             });
         }
         return {
@@ -280,7 +287,7 @@ export class SecrecyMailClient {
             recipientId: idOrMail,
             body: sodium.to_hex(encryptCryptoBox(sodium.from_string(body), pubKey, this.#keys.privateKey)),
             subject: sodium.to_hex(encryptCryptoBox(sodium.from_string(subject), pubKey, this.#keys.privateKey)),
-            files: recipientsFiles,
+            attachments,
         };
     };
 }

package/dist/lib/client/convert/data.js

@@ -0,0 +1,29 @@
+import { dataCache } from '../../cache.js';
+import { decryptCryptoBox } from '../../crypto/index.js';
+import { sodium } from '../../sodium.js';
+export function apiDataToInternal(apiData, keyPair) {
+    const data = {
+        id: apiData.id,
+        md5: apiData.md5,
+        md5Encrypted: apiData.md5Encrypted,
+        createdAt: apiData.createdAt,
+        size: apiData.size,
+        sizeBefore: apiData.sizeBefore,
+        key: sodium.to_hex(decryptCryptoBox(sodium.from_hex(apiData.access.key), apiData.access.sharedByPubKey, keyPair.privateKey)),
+    };
+    dataCache.set(data.id, data);
+    return data;
+}
+export function internalDataToExternalData(internal) {
+    return {
+        id: internal.id,
+        md5: internal.md5,
+        md5Encrypted: internal.md5Encrypted,
+        createdAt: internal.createdAt,
+        size: internal.size,
+        sizeBefore: internal.sizeBefore,
+    };
+}
+export function apiDataToExternal(apiData, keyPair) {
+    return internalDataToExternalData(apiDataToInternal(apiData, keyPair));
+}

package/dist/lib/client/convert/mail.js

@@ -30,12 +30,12 @@ export async function convertInternalMailToExternal({ client, mail, keyPair, })
         temporaryRecipients: [], // TODO
         recipients: mI.recipients,
         sender: mail.sender,
-        files: mail.files.map((f) => {
-            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(f.filename), pubKey, privateKey));
+        data: mail.attachments.map((f) => {
+            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(f.name), pubKey, privateKey));
             return {
-                id: f.fileId,
+                id: f.dataId,
                 name,
-                key: f.fileKey,
+                key: f.key,
             };
         }),
     };

package/dist/lib/client/convert/node.js

@@ -1,8 +1,8 @@
 import { sodium } from '../../sodium.js';
 import { decryptCryptoBox } from '../../crypto/index.js';
 import { nodesCache } from '../../cache.js';
-import { decryptSecretStream } from '../../crypto/file.js';
-import { apiFileToInternal, internalFileToFile } from './file.js';
+import { decryptSecretStream } from '../../crypto/data.js';
+import { apiDataToInternal, internalDataToExternalData } from './data.js';
 export async function apiNodeToInternal(apiNode, keyPair) {
     const internal = {
         id: apiNode.id,
@@ -23,7 +23,7 @@ export async function apiNodeToInternal(apiNode, keyPair) {
         deletedAt: apiNode.deletedAt,
         users: apiNode.users,
         parentId: apiNode.parentId ?? null,
-        currentFileId: apiNode.currentFileId ?? null,
+        currentDataId: apiNode.currentDataId ?? null,
     };
     internal.access = { ...apiNode.access };
     if (apiNode.access.nameKey !== null) {
@@ -47,13 +47,13 @@ export async function apiNodeFullToInternalFull(apiNodeFull, keyPair) {
     return {
         ...f,
         current: apiNodeFull.current !== null
-            ? apiFileToInternal(apiNodeFull.current, keyPair)
+            ? apiDataToInternal(apiNodeFull.current, keyPair)
             : undefined,
         parent: apiNodeFull.parent !== null
             ? await apiNodeToInternal(apiNodeFull.parent, keyPair)
             : null,
         children: await Promise.all(apiNodeFull.children.map(async (s) => await apiNodeToInternal(s, keyPair))),
-        history: apiNodeFull.history.map((f) => apiFileToInternal(f, keyPair)),
+        history: apiNodeFull.history.map((f) => apiDataToInternal(f, keyPair)),
     };
 }
 export function internalNodeToNode(internal) {
@@ -76,9 +76,9 @@ export function internalNodeFullToNodeFull(internal) {
         ...internalNodeToNode(internal),
         parent: internal.parent !== null ? internalNodeToNode(internal.parent) : null,
         children: internal.children.map(internalNodeToNode),
-        history: internal.history.map((f) => internalFileToFile(f)),
+        history: internal.history.map((f) => internalDataToExternalData(f)),
         current: internal.current !== null && internal.current !== undefined
-            ? internalFileToFile(internal.current)
+            ? internalDataToExternalData(internal.current)
             : undefined,
     };
 }