@secrecy/lib 1.62.0-feat-node-sharing.1 → 1.62.0-feat-node-sharing.2

package/dist/lib/client/SecrecyAppClient.js

@@ -72,12 +72,17 @@ export class SecrecyAppClient {
             publicKeysCache.get(`userPublicKey:${userId}-${appId}`),
         ])
             .filter(([_, key]) => !!key));
-        const missingKeys = userIds.filter((userId) => publicKeys[userId] === undefined);
+        const missingKeys = [
+            ...new Set(userIds.filter((userId) => publicKeys[userId] === undefined)),
+        ];
         if (missingKeys.length > 0) {
             const userKeysMap = await this.#apiClient.application.userPublicKey.query(userIds);
             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!");
+            }
             for (const userId in userKeysMap) {
                 publicKeys[userId] = userKeysMap[userId];
                 publicKeysCache.set(`userPublicKey:${userId}-${appId}`, userKeysMap[userId]);

package/dist/lib/client/SecrecyCloudClient.js

@@ -296,15 +296,10 @@ export class SecrecyCloudClient {
         const users = folder.parent?.users?.filter(([u]) => u.id !== this.#client.app.userId) ??
             [];
         if (users.length > 0) {
-            await Promise.all(users.map(async ([u, rights]) => await this.shareNode({
-                rights,
-                nodes: [
-                    {
-                        userId: u.id,
-                        nodeId: folder.id,
-                    },
-                ],
-            })));
+            await this.shareNode({
+                nodeId: folder.id,
+                users: users.map(([user, rights]) => ({ id: user.id, rights })),
+            });
         }
         return folder;
     }
@@ -322,23 +317,33 @@ export class SecrecyCloudClient {
         return apiDataToExternal(data, this.#keys);
     }
     async shareNode(input) {
-        const userIds = Array.isArray(input.nodes)
-            ? input.nodes.map(({ userId }) => userId)
-            : 'userIds' in input.nodes
-                ? input.nodes.userIds
-                : [input.nodes.userId];
+        const userIds = 'rights' in input
+            ? Array.isArray(input.nodes)
+                ? input.nodes.map(({ userId }) => userId)
+                : 'userIds' in input.nodes
+                    ? 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(input.nodes),
+            this.#apiClient.cloud.shareNode.mutate(nodesToShare),
         ]);
-        const nodesInfos = await this.perNodes(nodesIdsMap, publicKeysMap);
-        const sharingState = await this.#apiClient.cloud.shareNodeFinish.mutate(Object.entries(nodesInfos).map(([userId, nodes]) => {
-            return {
-                userId,
-                nodes,
-                rights: input.rights,
-            };
-        }));
+        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;
     }
     async updateNode({ nodeId, name, isFavorite, deletedAt, }) {
@@ -524,19 +529,16 @@ export class SecrecyCloudClient {
         if (me !== undefined && ['admin', 'write'].includes(me[1])) {
             const others = node.parent?.users.filter(([u]) => u.id !== this.#client.app.userId) ??
                 [];
-            await Promise.all(others.map(async ([u, rights]) => await this.shareNode({
-                rights,
-                nodes: [
-                    {
-                        nodeId: node.id,
-                        userId: u.id,
-                    },
-                ],
-            })));
+            if (others.length > 0) {
+                await this.shareNode({
+                    nodeId: node.id,
+                    users: others.map(([user, rights]) => ({ id: user.id, rights })),
+                });
+            }
         }
         return node;
     }
-    perNodes = async (userNodes, // { [userId]: nodeIds[] }
+    encryptNodesForUsers = async (userNodes, // { [userId]: nodeIds[] }
     userPublicKeys) => {
         const userIds = Object.keys(userNodes).map((userId) => userId);
         const nodeIds = Object.values(userNodes).flatMap((nodeIds) => nodeIds);

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

@@ -3,15 +3,6 @@ import { decryptCryptoBox } from '../../crypto/index.js';
 import { nodesCache } from '../../cache.js';
 import { decryptSecretStream } from '../../crypto/data.js';
 import { apiDataToInternal, internalDataToExternalData } from './data.js';
-async function readName({ encryptedName, encryptedNameKey, sharedByPubKey, privateKey, }) {
-    const nameKeyBuffer = decryptCryptoBox(sodium.from_hex(encryptedNameKey), sharedByPubKey, privateKey);
-    const nameKey = sodium.to_hex(nameKeyBuffer);
-    const name = sodium.to_string(await decryptSecretStream(nameKeyBuffer, sodium.from_hex(encryptedName)));
-    return {
-        name,
-        nameKey,
-    };
-}
 async function apiNodeToInternal(apiNode, keyPair) {
     const internal = {
         id: apiNode.id,
@@ -34,6 +25,7 @@ async function apiNodeToInternal(apiNode, keyPair) {
         parentId: apiNode.parentId ?? null,
         currentDataId: apiNode.currentDataId ?? null,
     };
+    internal.access = { ...apiNode.access };
     if (apiNode.access.nameKey !== null) {
         const key = decryptCryptoBox(sodium.from_hex(apiNode.access.nameKey), apiNode.access.sharedByPubKey, keyPair.privateKey);
         internal.name = sodium.to_string(await decryptSecretStream(key, sodium.from_hex(internal.name)));

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

@@ -56,7 +56,25 @@ export declare class SecrecyCloudClient {
     }): Promise<DataMetadata>;
     shareNode(input: {
         rights: Rights;
-        nodes: RouterInputs['cloud']['shareNode'];
+        nodes: {
+            nodeId: string;
+            userId: string;
+        }[] | {
+            nodeId: string;
+            userIds: string[];
+        } | {
+            nodeIds: string[];
+            userId: string;
+        } | {
+            nodeIds: string[];
+            userIds: string[];
+        };
+    } | {
+        nodeId: string;
+        users: {
+            id: string;
+            rights: Rights;
+        }[];
     }): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
     updateNode({ nodeId, name, isFavorite, deletedAt, }: {
         nodeId: string;
@@ -99,7 +117,7 @@ export declare class SecrecyCloudClient {
         name: string;
         nodeId?: string;
     }): Promise<NodeFull>;
-    private readonly perNodes;
+    private readonly encryptNodesForUsers;
     reportData({ id, reasons, }: Omit<RouterInputs['cloud']['reportData'], 'encryptedDataKey'>): Promise<RouterOutputs['cloud']['reportData']>;
     updateDataStorageType(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
         isMoved: boolean;

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

@@ -61,4 +61,12 @@ export type ApiNode = RouterOutputs['cloud']['nodeById'];
 export type ApiNodeFull = RouterOutputs['cloud']['nodeFullById'];
 export type ApiNodeParent = NonNullable<RouterOutputs['cloud']['nodeFullById']['parent']>;
 export type NodeType = ApiNode['type'];
+export type EncryptedNodeInfos = {
+    id: string;
+    nameKey: string | null;
+    data: {
+        id: string;
+        key: string | null;
+    }[];
+};
 export {};

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.1",
+  "version": "1.62.0-feat-node-sharing.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/anonymize-org/lib.git"