@secrecy/lib 1.29.0-feat-rename-file.3 → 1.29.0

package/dist/lib/cache.js

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

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

package/dist/lib/client/SecrecyMailClient.js

@@ -1,4 +1,4 @@
-import { dataCache } from '../cache.js';
+import { filesCache } 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 data = dataCache.get(f.id);
-                if (data === undefined) {
-                    await this.#client.cloud.dataMetadata({ id: f.id });
-                    data = dataCache.get(f.id);
-                    if (data === undefined) {
+                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) {
                         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.data, draft.subject, draft.body, email);
+            const input = await this._eachUser(draft.files, 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.data, draft.subject, draft.body, id);
+            const input = await this._eachUser(draft.files, draft.subject, draft.body, id);
             if (input === null) {
                 temporaryRecipients.push(id);
             }
@@ -167,7 +167,7 @@ export class SecrecyMailClient {
                     continue;
                 }
                 try {
-                    const input = await this._eachUser(mail.data, mail.subject, mail.body, email);
+                    const input = await this._eachUser(mail.files, mail.subject, mail.body, email);
                     if (input === null) {
                         continue;
                     }
@@ -175,11 +175,13 @@ export class SecrecyMailClient {
                         id: mail.mailIntegrityId,
                         recipient: {
                             ...input,
-                            attachments: input.attachments.map((attachment) => ({
-                                id: attachment.dataId,
-                                key: attachment.key,
-                                name: attachment.name,
-                            })),
+                            attachments: input.attachments.map(({ dataId, key, name }) => {
+                                return {
+                                    id: dataId,
+                                    key,
+                                    name,
+                                };
+                            }),
                         },
                     });
                 }
@@ -193,16 +195,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 data = dataCache.get(f.id);
-            if (data === undefined) {
-                await this.#client.cloud.dataMetadata({ id: f.id });
-                data = dataCache.get(f.id);
-                if (data === undefined) {
+            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) {
                     throw new Error(`File ${f.name} (${f.id}) does not exists`);
                 }
             }
             senderFiles.push({
-                id: data.id,
+                id: file.id,
                 name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), this.#keys.publicKey, this.#keys.privateKey)),
             });
         }
@@ -261,25 +263,25 @@ export class SecrecyMailClient {
         const unreadReceivedMailsCount = await this.#apiClient.mail.unreadReceivedCount.query({});
         return unreadReceivedMailsCount;
     }
-    _eachUser = async (data, subject, body, idOrMail) => {
+    _eachUser = async (files, subject, body, idOrMail) => {
         // const pubKey = await this.#client.app.userPublicKey(userId)
         const pubKey = await this.#client.app.userPublicKey(idOrMail);
-        // 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) {
+        // 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) {
                     throw new Error(`File ${f.name} (${f.id}) does not exists`);
                 }
             }
-            const key = dataInHistory.key;
-            attachments.push({
+            const key = fileInHistory.key;
+            recipientsFiles.push({
                 id: f.id,
                 name: sodium.to_hex(encryptCryptoBox(sodium.from_string(f.name), pubKey, this.#keys.privateKey)),
-                dataKey: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
+                key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
             });
         }
         return {
@@ -287,7 +289,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)),
-            attachments,
+            attachments: recipientsFiles,
         };
     };
 }

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

@@ -0,0 +1,29 @@
+import { filesCache } from '../../cache.js';
+import { decryptCryptoBox } from '../../crypto/index.js';
+import { sodium } from '../../sodium.js';
+export function apiFileToInternal(apiFile, keyPair) {
+    const file = {
+        id: apiFile.id,
+        md5: apiFile.md5,
+        md5Encrypted: apiFile.md5Encrypted,
+        createdAt: apiFile.createdAt,
+        size: apiFile.size,
+        sizeBefore: apiFile.sizeBefore,
+        key: sodium.to_hex(decryptCryptoBox(sodium.from_hex(apiFile.access.key), apiFile.access.sharedByPubKey, keyPair.privateKey)),
+    };
+    filesCache.set(file.id, file);
+    return file;
+}
+export function internalFileToFile(internal) {
+    return {
+        id: internal.id,
+        md5: internal.md5,
+        md5Encrypted: internal.md5Encrypted,
+        createdAt: internal.createdAt,
+        size: internal.size,
+        sizeBefore: internal.sizeBefore,
+    };
+}
+export function apiFileToExternal(apiFile, keyPair) {
+    return internalFileToFile(apiFileToInternal(apiFile, 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,
-        data: mail.attachments.map((f) => {
-            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(f.name), pubKey, privateKey));
+        files: mail.attachments.map((attachment) => {
+            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(attachment.name), pubKey, privateKey));
             return {
-                id: f.dataId,
+                id: attachment.dataId,
                 name,
-                key: f.key,
+                key: attachment.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/data.js';
-import { apiDataToInternal, internalDataToExternalData } from './data.js';
+import { decryptSecretStream } from '../../crypto/file.js';
+import { apiFileToInternal, internalFileToFile } from './file.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,
-        currentDataId: apiNode.currentDataId ?? null,
+        currentFileId: 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
-            ? apiDataToInternal(apiNodeFull.current, keyPair)
+            ? apiFileToInternal(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) => apiDataToInternal(f, keyPair)),
+        history: apiNodeFull.history.map((f) => apiFileToInternal(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) => internalDataToExternalData(f)),
+        history: internal.history.map((f) => internalFileToFile(f)),
         current: internal.current !== null && internal.current !== undefined
-            ? internalDataToExternalData(internal.current)
+            ? internalFileToFile(internal.current)
             : undefined,
     };
 }

package/dist/lib/client/index.js

@@ -1,10 +1,10 @@
 import { BaseClient } from '../base-client.js';
-import { encryptSecretStream } from '../crypto/data.js';
+import { encryptSecretStream } from '../crypto/file.js';
 import { sodium } from '../sodium.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';
-import { nodesCache, dataCache, publicKeysCache } from '../cache.js';
+import { nodesCache, filesCache, publicKeysCache } from '../cache.js';
 import { SecrecyDbClient } from './SecrecyDbClient.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
@@ -53,7 +53,7 @@ export class SecrecyClient extends BaseClient {
     }
     async logout(sessionId) {
         nodesCache.clear();
-        dataCache.clear();
+        filesCache.clear();
         publicKeysCache.clear();
         await super.logout(sessionId);
     }

package/dist/types/cache.d.ts

@@ -1,6 +1,6 @@
-import type { InternalNode, InternalData, InternalNodeFull } from './client/types/index.js';
+import type { InternalNode, InternalFile, InternalNodeFull } from './client/types/index.js';
 import { LRUCache } from 'lru-cache';
-export declare const dataCache: Map<string, InternalData>;
+export declare const filesCache: Map<string, InternalFile>;
 export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
 export declare const usersCache: Map<string, {
     id: string;
@@ -10,4 +10,4 @@ export declare const usersCache: Map<string, {
     isSearchable: boolean;
 }>;
 export declare const publicKeysCache: Map<string, string>;
-export declare const lruCache: LRUCache<string, Uint8Array, unknown>;
+export declare const dataCache: LRUCache<string, Uint8Array, unknown>;

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -1,5 +1,5 @@
 import type { ProgressCallback, SecrecyClient } from '../index.js';
-import type { DataMetadata, KeyPair, Node, NodeFull, NodeType, Rights } from './types/index.js';
+import type { FileMetadata, KeyPair, Node, NodeFull, NodeType, Rights } from './types/index.js';
 import { type ApiClient } from '../client.js';
 import { type DownloadProgress } from '../types.js';
 export declare class SecrecyCloudClient {
@@ -9,14 +9,14 @@ export declare class SecrecyCloudClient {
         dataId: string;
         nodeId: string;
     }): Promise<NodeFull>;
-    uploadData({ data, encryptProgress, uploadProgress, signal, }: {
-        data: globalThis.File | Uint8Array;
+    uploadData({ file, encryptProgress, uploadProgress, signal, }: {
+        file: globalThis.File | Uint8Array;
         encryptProgress?: ProgressCallback;
         uploadProgress?: ProgressCallback;
         signal?: AbortSignal;
     }): Promise<string>;
-    uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, signal, }: {
-        data: globalThis.File | Uint8Array;
+    uploadDataInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }: {
+        file: globalThis.File | Uint8Array;
         name: string;
         nodeId?: string;
         encryptProgress?: ProgressCallback;
@@ -46,9 +46,9 @@ export declare class SecrecyCloudClient {
         id?: string | null | undefined;
         deleted?: boolean | null | undefined;
     }): Promise<NodeFull>;
-    dataMetadata({ id }: {
+    fileMetadata({ id }: {
         id: string;
-    }): Promise<DataMetadata>;
+    }): Promise<FileMetadata>;
     shareNode({ nodeId, userId, rights, }: {
         nodeId: string;
         userId: string;
@@ -60,13 +60,13 @@ export declare class SecrecyCloudClient {
         isFavorite?: boolean | null | undefined;
         deletedAt?: Date | null | undefined;
     }): Promise<NodeFull>;
-    dataContent({ dataId, onDownloadProgress, progressDecrypt, signal, }: {
-        dataId: string;
+    fileContent({ fileId, onDownloadProgress, progressDecrypt, signal, }: {
+        fileId: string;
         onDownloadProgress?: (progress: DownloadProgress) => void;
         progressDecrypt?: ProgressCallback;
         signal?: AbortSignal;
     }): Promise<Uint8Array>;
-    deleteData({ dataId, nodeId, }: {
+    deleteFile({ dataId, nodeId, }: {
         dataId: string;
         nodeId: string;
     }): Promise<boolean>;

package/dist/types/client/convert/file.d.ts

@@ -0,0 +1,4 @@
+import type { ApiFile, InternalFile, FileMetadata, KeyPair } from '../types/index.js';
+export declare function apiFileToInternal(apiFile: ApiFile, keyPair: KeyPair): InternalFile;
+export declare function internalFileToFile(internal: InternalFile): FileMetadata;
+export declare function apiFileToExternal(apiFile: ApiFile, keyPair: KeyPair): FileMetadata;

package/dist/types/client/index.d.ts

@@ -1,5 +1,5 @@
 import { BaseClient } from '../base-client.js';
-import type { Progress } from '../crypto/data.js';
+import type { Progress } from '../crypto/file.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';

package/dist/types/client/types/file.d.ts

@@ -0,0 +1,6 @@
+import { type RouterOutputs } from '../../client.js';
+export type FileMetadata = Pick<ApiFile, 'id' | 'size' | 'sizeBefore' | 'md5' | 'md5Encrypted' | 'createdAt'>;
+export type InternalFile = FileMetadata & {
+    key: string;
+};
+export type ApiFile = NonNullable<RouterOutputs['cloud']['dataById']>;

package/dist/types/client/types/index.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export type * from './app.js';
-export type * from './data.js';
+export type * from './file.js';
 export type * from './node.js';
 export type * from './mail.js';
 export type * from './user.js';

package/dist/types/client/types/mail.d.ts

@@ -15,7 +15,7 @@ export interface BaseMail {
     isAltered: boolean;
     recipients: Array<Omit<PublicUser, 'publicKey'>>;
     temporaryRecipients: TemporaryMailUser[];
-    data: Array<{
+    files: Array<{
         id: string;
         name: string;
         key: string;
@@ -74,10 +74,10 @@ export interface WaitingReceivedMail {
     recipients: PublicUser[];
     temporaryRecipients: TemporaryMailUser[];
 }
-export interface MailData {
-    dataKey: string;
-    dataName: string;
-    data: {
+export interface MailFile {
+    fileKey: string;
+    filename: string;
+    file: {
         id: string;
     };
 }

package/dist/types/client/types/node.d.ts

@@ -1,5 +1,5 @@
 import { type RouterOutputs } from '../../client.js';
-import type { DataMetadata, InternalData, PublicUser } from './index.js';
+import type { FileMetadata, InternalFile, PublicUser } from './index.js';
 export type Rights = ApiNode['users'][number][1];
 export type NodeAccess<T extends Record<string, unknown> = Record<string, unknown>> = T & {
     rights: Rights;
@@ -34,17 +34,17 @@ export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U exten
     createdBy: PublicUser;
     access: NodeAccess<U>;
     users: Array<[PublicUser, Rights]>;
-    currentDataId: string | null;
+    currentFileId: string | null;
     parentId: string | null;
 }
-export type NodeFull<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>, V extends DataMetadata = DataMetadata> = Node<T, U> & {
+export type NodeFull<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U extends Record<string, unknown> = Record<string, unknown>, V extends FileMetadata = FileMetadata> = Node<T, U> & {
     parent: Node<T, U> | null;
     children: Array<Node<T, U>>;
     current?: V;
     history: V[];
 };
 export type InternalNode = Node<InternalNodeBreadcrumbItem, NameKey>;
-export type InternalNodeFull = NodeFull<InternalNodeBreadcrumbItem, NameKey, InternalData>;
+export type InternalNodeFull = NodeFull<InternalNodeBreadcrumbItem, NameKey, InternalFile>;
 export type ApiNode = RouterOutputs['cloud']['nodeById'];
 export type ApiNodeFull = RouterOutputs['cloud']['nodeFullById'];
 export type ApiNodeParent = NonNullable<RouterOutputs['cloud']['nodeFullById']['parent']>;

package/dist/types/index.d.ts

@@ -1,8 +1,8 @@
 export * from './client/index.js';
 export * from './crypto/index.js';
-export type { Progress } from './crypto/data.js';
+export type { Progress } from './crypto/file.js';
 export { BaseClient } from './base-client.js';
-export type { Node, NodeFull, DataMetadata, SecrecyUserApp, BaseMail, ReceivedMail, SentMail, PublicUser, SelfUser, NodeSize, MailData, MailIntegrity, DraftMail, Mail, WaitingReceivedMail, KeyPair, } from './client/types/index.js';
+export type { Node, NodeFull, FileMetadata, SecrecyUserApp, BaseMail, ReceivedMail, SentMail, PublicUser, SelfUser, NodeSize, MailFile, MailIntegrity, DraftMail, Mail, WaitingReceivedMail, KeyPair, } from './client/types/index.js';
 export * from './client/helpers.js';
 export * from './sodium.js';
 export * from './utils/store-buddy.js';

package/dist/types/worker/sodium.d.ts

@@ -1,3 +1,3 @@
-import type { EncryptedFile, Progress } from '../crypto/data.js';
+import type { EncryptedFile, Progress } from '../crypto/file.js';
 export declare function encrypt(key: Uint8Array, dataToEncrypt: Uint8Array, progress?: (progress: Progress) => Promise<void>, signal?: AbortSignal): Promise<EncryptedFile>;
 export declare function decrypt(key: Uint8Array, dataToDecrypt: Uint8Array, progress?: (progress: Progress) => Promise<void>, signal?: AbortSignal): Promise<Uint8Array>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@secrecy/lib",
   "author": "Anonymize <anonymize@gmail.com>",
   "description": "Anonymize Secrecy Library",
-  "version": "1.29.0-feat-rename-file.3",
+  "version": "1.29.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"
@@ -74,7 +74,7 @@
   },
   "dependencies": {
     "@secrecy/lib-utils": "^1.0.18",
-    "@secrecy/trpc-api-types": "1.27.0-feat-rename-file.12",
+    "@secrecy/trpc-api-types": "1.27.0-feat-rename-file.11",
     "@trpc/client": "10.45.2",
     "@trpc/server": "10.45.2",
     "@types/libsodium-wrappers-sumo": "^0.7.8",

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

@@ -1,29 +0,0 @@
-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/types/client/convert/data.d.ts

@@ -1,4 +0,0 @@
-import type { ApiData, InternalData, DataMetadata, KeyPair } from '../types/index.js';
-export declare function apiDataToInternal(apiData: ApiData, keyPair: KeyPair): InternalData;
-export declare function internalDataToExternalData(internal: InternalData): DataMetadata;
-export declare function apiDataToExternal(apiData: ApiData, keyPair: KeyPair): DataMetadata;

package/dist/types/client/types/data.d.ts

@@ -1,6 +0,0 @@
-import { type RouterOutputs } from '../../client.js';
-export type DataMetadata = Pick<ApiData, 'id' | 'size' | 'sizeBefore' | 'md5' | 'md5Encrypted' | 'createdAt'>;
-export type InternalData = DataMetadata & {
-    key: string;
-};
-export type ApiData = NonNullable<RouterOutputs['cloud']['dataById']>;