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

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: 'admin' | 'write' | 'read';
+        nodeId: string;
+        expect: 'admin' | 'write' | 'read';
+    }[];
+};
 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.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"