@secrecy/lib 1.62.0-feat-node-sharing.3 → 1.62.0-feat-node-sharing.5

package/dist/lib/client/SecrecyAppClient.js

@@ -76,12 +76,12 @@ export class SecrecyAppClient {
             ...new Set(userIds.filter((userId) => publicKeys[userId] === undefined)),
         ];
         if (missingKeys.length > 0) {
-            const userKeysMap = await this.#apiClient.application.userPublicKey.query(userIds);
+            const userKeysMap = await this.#apiClient.application.userPublicKey.query(missingKeys);
             if ('publicKey' in userKeysMap) {
                 throw Error('Should not happen!');
             }
             if (Object.keys(userKeysMap).length !== missingKeys.length) {
-                throw new Error("Unable to load some user's  public keys!");
+                throw new Error("Unable to load some user's public keys!");
             }
             for (const userId in userKeysMap) {
                 publicKeys[userId] = userKeysMap[userId];

package/dist/lib/client/SecrecyCloudClient.js

@@ -14,6 +14,7 @@ import { promiseAllLimit } from '../utils/promise.js';
 import { kiloToBytes } from '../utils.js';
 import { fileTypeFromBuffer } from 'file-type';
 import { encryptName, generateAndEncryptNameAndKey } from '../crypto/domain.js';
+import { chunkByTotalItems } from '../utils/object.js';
 export class SecrecyCloudClient {
     #client;
     #keys;
@@ -32,18 +33,24 @@ export class SecrecyCloudClient {
         const data = node.history.find((d) => d.id === dataId);
         if (data !== undefined) {
             const users = node.users.filter(([u]) => u.id !== this.#client.app.userId);
+            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 retreive share by public key!');
+                }
+                return {
+                    id: user.id,
+                    key: data.key
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), publicKey, this.#keys.privateKey))
+                        : null,
+                };
+            });
             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: data.key
-                            ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(data.key), userPubKey, this.#keys.privateKey))
-                            : null,
-                    };
-                })),
+                users: shares,
             });
         }
         return internalNodeFullToNodeFull(node);
@@ -318,7 +325,7 @@ export class SecrecyCloudClient {
         });
         return apiDataToExternal(data, this.#keys);
     }
-    async shareNode(input) {
+    async shareNode(input, progress) {
         const userIds = 'rights' in input
             ? Array.isArray(input.nodes)
                 ? input.nodes.map(({ userId }) => userId)
@@ -326,27 +333,70 @@ export class SecrecyCloudClient {
                     ? input.nodes.userIds
                     : [input.nodes.userId]
             : input.users.map(({ id }) => id);
-        const nodesToShare = 'nodes' in input
-            ? input.nodes
-            : {
-                nodeId: input.nodeId,
-                userIds: input.users.map(({ id }) => id),
-            };
         const [publicKeysMap, nodesIdsMap] = await Promise.all([
             this.#client.app.userPublicKey(userIds),
-            this.#apiClient.cloud.shareNode.mutate(nodesToShare),
+            this.#apiClient.cloud.shareNode.mutate('nodes' in input
+                ? input.nodes
+                : {
+                    nodeId: input.nodeId,
+                    userIds: input.users.map(({ id }) => id),
+                }),
         ]);
-        const nodesInfos = await this.encryptNodesForUsers(nodesIdsMap, publicKeysMap);
-        const sharingState = await this.#apiClient.cloud.shareNodeFinish.mutate(Object.entries(nodesInfos).map('rights' in input
-            ? ([userId, nodes]) => ({ userId, nodes, rights: input.rights })
-            : ([userId, nodes]) => {
-                const user = input.users.find((user) => user.id === userId);
-                if (!user) {
-                    throw new Error(`Unable to find rights for user: ${userId}`);
-                }
-                return { userId, nodes, rights: user.rights };
-            }));
-        return sharingState;
+        const maxNodesBatchSize = 1000;
+        const totalNodesToShare = Object.values(nodesIdsMap).reduce((size, ids) => size + ids.length, 0);
+        const chunks = totalNodesToShare > maxNodesBatchSize
+            ? chunkByTotalItems(nodesIdsMap, maxNodesBatchSize)
+            : [nodesIdsMap];
+        const details = await chunks.reduce(async (pendingState, nodesMap, index) => {
+            const state = await pendingState;
+            const infos = await this.encryptNodesForUsers(nodesMap, publicKeysMap);
+            const subState = await this.#apiClient.cloud.shareNodeFinish.mutate(Object.entries(infos).map('rights' in input
+                ? ([userId, nodes]) => ({ userId, nodes, rights: input.rights })
+                : ([userId, nodes]) => {
+                    const user = input.users.find((user) => user.id === userId);
+                    if (!user) {
+                        throw new Error(`Unable to find rights for user: ${userId}`);
+                    }
+                    return { userId, nodes, rights: user.rights };
+                }));
+            const currentProgress = Math.min((index + 1) * maxNodesBatchSize, totalNodesToShare);
+            progress?.({
+                total: totalNodesToShare,
+                current: currentProgress,
+                percent: Math.round((currentProgress / totalNodesToShare) * 100),
+            });
+            return {
+                missingNodeAccesses: [
+                    ...state.missingNodeAccesses,
+                    ...(subState.isFinished
+                        ? []
+                        : subState.details.missingNodeAccesses),
+                ],
+                missingDataAccesses: [
+                    ...state.missingDataAccesses,
+                    ...(subState.isFinished
+                        ? []
+                        : subState.details.missingDataAccesses),
+                ],
+                invalidRightsAccesses: [
+                    ...state.invalidRightsAccesses,
+                    ...(subState.isFinished
+                        ? []
+                        : subState.details.invalidRightsAccesses),
+                ],
+            };
+        }, Promise.resolve({
+            missingNodeAccesses: [],
+            missingDataAccesses: [],
+            invalidRightsAccesses: [],
+        }));
+        const errorDetailsLength = details.invalidRightsAccesses.length +
+            details.missingDataAccesses.length +
+            details.missingNodeAccesses.length;
+        return {
+            isFinished: errorDetailsLength === 0,
+            details: details,
+        };
     }
     async updateNode({ nodeId, name, isFavorite, deletedAt, }) {
         let node = nodesCache.get(nodeId);

package/dist/lib/utils/object.js

@@ -0,0 +1,29 @@
+export function chunkByTotalItems(input, maxItemsPerChunk = 1000) {
+    const entries = Object.entries(input);
+    const chunks = [];
+    let currentChunk = {};
+    let currentCount = 0;
+    for (const [key, values] of entries) {
+        let i = 0;
+        while (i < values.length) {
+            const remaining = maxItemsPerChunk - currentCount;
+            const take = Math.min(remaining, values.length - i);
+            if (!currentChunk[key]) {
+                currentChunk[key] = [];
+            }
+            currentChunk[key].push(...values.slice(i, i + take));
+            currentCount += take;
+            i += take;
+            if (currentCount === maxItemsPerChunk) {
+                chunks.push(currentChunk);
+                currentChunk = {};
+                currentCount = 0;
+            }
+        }
+    }
+    // Last chunk
+    if (currentCount > 0) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}

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

@@ -75,7 +75,7 @@ export declare class SecrecyCloudClient {
             id: string;
             rights: Rights;
         }[];
-    }): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
+    }, progress?: ProgressCallback): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
     updateNode({ nodeId, name, isFavorite, deletedAt, }: {
         nodeId: string;
         name?: string | null | undefined;

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

@@ -70,4 +70,21 @@ export type EncryptedNodeInfos = {
         key: string | null;
     }[];
 };
+export type ShareNodeDetails = {
+    missingNodeAccesses: {
+        userId: string;
+        nodeId: string;
+    }[];
+    missingDataAccesses: {
+        userId: string;
+        dataId: string;
+        nodeId: string;
+    }[];
+    invalidRightsAccesses: {
+        userId: string;
+        current: Rights;
+        nodeId: string;
+        expect: Rights;
+    }[];
+};
 export {};

package/dist/types/utils/object.d.ts

@@ -0,0 +1 @@
+export declare function chunkByTotalItems<T>(input: Record<string, T[]>, maxItemsPerChunk?: number): Record<string, T[]>[];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@secrecy/lib",
   "author": "Anonymize <anonymize@gmail.com>",
   "description": "Anonymize Secrecy Library",
-  "version": "1.62.0-feat-node-sharing.3",
+  "version": "1.62.0-feat-node-sharing.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"

package/dist/lib/worker/workerDependencies.js

@@ -1,140 +0,0 @@
-// @ts-nocheck
-function* chunks(arr, n) {
-    for (let i = 0; i < arr.length; i += n) {
-        yield arr.slice(i, i + n);
-    }
-}
-function assert(c, message) {
-    if (!c) {
-        throw new Error(message);
-    }
-}
-function encrypt(key) {
-    let destroyed = false;
-    const { state, header } = sodium.crypto_secretstream_xchacha20poly1305_init_push(key);
-    const encrypt = (tag, plaintext) => {
-        assert(destroyed === false, 'state already destroyed');
-        return sodium.crypto_secretstream_xchacha20poly1305_push(state, plaintext, null, tag);
-    };
-    function destroy() {
-        assert(destroyed === false, 'state already destroyed');
-        destroyed = true;
-    }
-    return {
-        encrypt,
-        destroy,
-        header,
-    };
-}
-function decrypt(header, key) {
-    assert(header.byteLength >=
-        sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES, 'header must be at least HEADERBYTES (' +
-        sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES +
-        ') long');
-    assert(key.byteLength >= sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES, 'key must be at least KEYBYTES (' +
-        sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES +
-        ') long');
-    let destroyed = false;
-    const state = sodium.crypto_secretstream_xchacha20poly1305_init_pull(header, key);
-    const decrypt = (ciphertext) => {
-        assert(destroyed === false, 'state already destroyed');
-        return sodium.crypto_secretstream_xchacha20poly1305_pull(state, ciphertext);
-    };
-    function destroy() {
-        assert(destroyed === false, 'state already destroyed');
-        destroyed = true;
-    }
-    return {
-        decrypt,
-        destroy,
-    };
-}
-const CHUNK_SIZE = 8192;
-export async function encryptSecretstream(key, data, progress) {
-    const { encrypt: crypt, destroy, header } = encrypt(key);
-    const cryptedChunk = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
-    const max = Math.ceil(data.byteLength / CHUNK_SIZE) * cryptedChunk + header.byteLength;
-    progress?.({
-        percent: 0,
-        total: max,
-        current: 0,
-    });
-    const final = new Uint8Array(max);
-    const sparkEncrypted = new SparkMD5.ArrayBuffer();
-    const spark = new SparkMD5.ArrayBuffer();
-    final.set(header);
-    sparkEncrypted.append(header);
-    let total = header.byteLength;
-    progress?.({
-        percent: total / max,
-        total: max,
-        current: total,
-    });
-    let lastPercent = total / max;
-    for (const chunk of chunks(data, CHUNK_SIZE)) {
-        spark.append(chunk);
-        const tag = chunk.length < CHUNK_SIZE
-            ? sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL
-            : sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE;
-        const crypted = crypt(tag, chunk);
-        sparkEncrypted.append(crypted);
-        final.set(crypted, total);
-        total += crypted.byteLength;
-        const percent = total / max;
-        if (percent > lastPercent + 0.01) {
-            progress?.({
-                percent,
-                total: max,
-                current: total,
-            });
-            lastPercent = percent;
-        }
-    }
-    destroy();
-    progress?.({
-        percent: 1,
-        total,
-        current: total,
-    });
-    return {
-        data: final.slice(0, total),
-        md5Encrypted: sparkEncrypted.end(),
-        md5: spark.end(),
-    };
-}
-export async function decryptSecretstream(key, data, progress) {
-    const header = data.slice(0, sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
-    data = data.slice(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES);
-    const { decrypt: decryptt, destroy } = decrypt(header, key);
-    const chunkSize = CHUNK_SIZE + sodium.crypto_secretstream_xchacha20poly1305_ABYTES;
-    const max = Math.ceil(data.byteLength / chunkSize) * CHUNK_SIZE;
-    progress?.({
-        percent: 0,
-        total: max,
-        current: 0,
-    });
-    const final = new Uint8Array(max);
-    let total = 0;
-    let lastPercent = total / max;
-    for (const chunk of chunks(data, chunkSize)) {
-        const tmp = decryptt(chunk);
-        final.set(tmp.message, total);
-        total += tmp.message.byteLength;
-        const percent = total / max;
-        if (percent > lastPercent + 0.01) {
-            progress?.({
-                percent,
-                total: max,
-                current: total,
-            });
-            lastPercent = percent;
-        }
-    }
-    destroy();
-    progress?.({
-        percent: 1,
-        total,
-        current: total,
-    });
-    return final.slice(0, total);
-}

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

@@ -1,6 +0,0 @@
-export declare function encryptSecretstream(key: any, data: any, progress: any): Promise<{
-    data: Uint8Array<ArrayBuffer>;
-    md5Encrypted: any;
-    md5: any;
-}>;
-export declare function decryptSecretstream(key: any, data: any, progress: any): Promise<Uint8Array<ArrayBuffer>>;