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

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

@@ -23,39 +23,39 @@ 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((d) => d.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, }) {
+    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 uploadFile = await this.#apiClient.cloud.uploadFile.mutate({
-            fileSize: BigInt(encryptedFile.byteLength),
-            fileSizeBefore: BigInt(fileBuffer.byteLength),
-            fileKey: sodium.to_hex(encryptedFileKey),
+        const uploadData = await this.#apiClient.cloud.uploadData.mutate({
+            dataSize: BigInt(encryptedFile.byteLength),
+            dataSizeBefore: BigInt(fileBuffer.byteLength),
+            dataKey: sodium.to_hex(encryptedFileKey),
             md5Encrypted,
             md5: md5File,
         });
@@ -64,30 +64,30 @@ export class SecrecyCloudClient {
             current: 0,
             percent: 0,
         });
-        if (uploadFile.parts.length === 0) {
+        if (uploadData.parts.length === 0) {
             await uploadProgress?.({
                 total: encryptedFile.byteLength,
                 current: encryptedFile.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 uploadDataPartEnd = async (md5, order) => {
+            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(encryptedFile, Number(uploadData.dataPartSize)))) {
             chunkParts.push({
                 order: index + 1,
                 data: chunk,
@@ -113,31 +113,31 @@ 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('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, 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;
+        dataCache.set(uploadData.dataId, fileBuffer);
+        return uploadData.dataId;
     }
-    async uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }) {
-        const fileId = await this.uploadFile({
+    async uploadDataInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }) {
+        const dataId = await this.uploadData({
             file,
             encryptProgress,
             uploadProgress,
             signal,
         });
         return await this.saveInCloud({
-            fileId,
+            dataId,
             name,
             nodeId,
         });
@@ -221,7 +221,7 @@ export class SecrecyCloudClient {
         return await apiNodeToExternalNodeFull(node, this.#keys);
     }
     async fileMetadata({ id }) {
-        const file = await this.#apiClient.cloud.fileById.query({
+        const file = await this.#apiClient.cloud.dataById.query({
             id,
         });
         return apiFileToExternal(file, this.#keys);
@@ -275,7 +275,7 @@ export class SecrecyCloudClient {
         if (cached !== undefined) {
             return cached;
         }
-        const fileContent = await this.#apiClient.cloud.fileContentById.query({
+        const fileContent = await this.#apiClient.cloud.dataContentById.query({
             id: fileId,
         });
         const progressParts = {};
@@ -347,13 +347,13 @@ export class SecrecyCloudClient {
         if (encryptedContent === null) {
             throw `Can't find content for file ${fileId}`;
         }
-        const data = await finalize(encryptedContent);
+        const data = await finalize(new Uint8Array(encryptedContent));
         dataCache.set(fileId, data);
         return data;
     }
-    async deleteFile({ fileId, nodeId, }) {
-        const { isDeleted } = await this.#apiClient.cloud.deleteFile.mutate({
-            fileId,
+    async deleteFile({ 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,27 +394,27 @@ export class SecrecyCloudClient {
             }
         }
         let key = '';
-        const file = filesCache.get(fileId);
+        const file = filesCache.get(dataId);
         if (file === undefined) {
-            await this.fileMetadata({ id: fileId });
-            const file = filesCache.get(fileId);
+            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.files.some((f) => f.id === fileId));
+                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 file ${fileId}`,
+                        message: `Can't find mail with the file ${dataId}`,
                     };
                     throw err;
                 }
-                const fileMail = mail.files.find((f) => f.id === fileId);
+                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 file ${fileId}`,
+                        message: `Can't find mail with the file ${dataId}`,
                     };
                     throw err;
                 }
@@ -434,10 +434,10 @@ export class SecrecyCloudClient {
         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

@@ -173,7 +173,16 @@ export class SecrecyMailClient {
                     }
                     await this.#apiClient.mail.sendOne.mutate({
                         id: mail.mailIntegrityId,
-                        recipient: input,
+                        recipient: {
+                            ...input,
+                            attachments: input.attachments.map(({ dataId, key, name }) => {
+                                return {
+                                    id: dataId,
+                                    key,
+                                    name,
+                                };
+                            }),
+                        },
                     });
                 }
                 catch {
@@ -272,7 +281,7 @@ export class SecrecyMailClient {
             recipientsFiles.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)),
+                key: sodium.to_hex(encryptCryptoBox(sodium.from_hex(key), pubKey, this.#keys.privateKey)),
             });
         }
         return {
@@ -280,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)),
-            files: recipientsFiles,
+            attachments: recipientsFiles,
         };
     };
 }

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));
+        files: mail.attachments.map((attachment) => {
+            const name = sodium.to_string(decryptCryptoBox(sodium.from_hex(attachment.name), pubKey, privateKey));
             return {
-                id: f.fileId,
+                id: attachment.dataId,
                 name,
-                key: f.fileKey,
+                key: attachment.key,
             };
         }),
     };

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

@@ -23,7 +23,7 @@ export async function apiNodeToInternal(apiNode, keyPair) {
         deletedAt: apiNode.deletedAt,
         users: apiNode.users,
         parentId: apiNode.parentId ?? null,
-        currentFileId: apiNode.currentFileId ?? null,
+        currentFileId: apiNode.currentDataId ?? null,
     };
     internal.access = { ...apiNode.access };
     if (apiNode.access.nameKey !== null) {

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

@@ -5,17 +5,17 @@ import { type DownloadProgress } from '../types.js';
 export declare class SecrecyCloudClient {
     #private;
     constructor(client: SecrecyClient, keys: KeyPair, apiClient: ApiClient);
-    addFileToHistory({ fileId, nodeId, }: {
-        fileId: string;
+    addDataToHistory({ dataId, nodeId, }: {
+        dataId: string;
         nodeId: string;
     }): Promise<NodeFull>;
-    uploadFile({ file, encryptProgress, uploadProgress, signal, }: {
+    uploadData({ file, encryptProgress, uploadProgress, signal, }: {
         file: globalThis.File | Uint8Array;
         encryptProgress?: ProgressCallback;
         uploadProgress?: ProgressCallback;
         signal?: AbortSignal;
     }): Promise<string>;
-    uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }: {
+    uploadDataInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal, }: {
         file: globalThis.File | Uint8Array;
         name: string;
         nodeId?: string;
@@ -66,8 +66,8 @@ export declare class SecrecyCloudClient {
         progressDecrypt?: ProgressCallback;
         signal?: AbortSignal;
     }): Promise<Uint8Array>;
-    deleteFile({ fileId, nodeId, }: {
-        fileId: string;
+    deleteFile({ dataId, nodeId, }: {
+        dataId: string;
         nodeId: string;
     }): Promise<boolean>;
     deleteNode({ nodeId }: {
@@ -79,8 +79,8 @@ export declare class SecrecyCloudClient {
         nodeIds: string[];
         parentNodeId?: string | null | undefined;
     }): Promise<boolean>;
-    saveInCloud({ fileId, name, nodeId, }: {
-        fileId: string;
+    saveInCloud({ dataId, name, nodeId, }: {
+        dataId: string;
         name: string;
         nodeId?: string;
     }): Promise<NodeFull>;

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

@@ -3,4 +3,4 @@ export type FileMetadata = Pick<ApiFile, 'id' | 'size' | 'sizeBefore' | 'md5' |
 export type InternalFile = FileMetadata & {
     key: string;
 };
-export type ApiFile = NonNullable<RouterOutputs['cloud']['fileById']>;
+export type ApiFile = NonNullable<RouterOutputs['cloud']['dataById']>;