@secrecy/lib 1.64.0 → 1.64.1

package/dist/lib/client/SecrecyCloudClient.js

@@ -305,10 +305,14 @@ export class SecrecyCloudClient {
         const users = folder.parent?.users?.filter(([u]) => u.id !== this.#client.app.userId) ??
             [];
         if (users.length > 0) {
-            await this.shareNode(users.map(([user, rights]) => ({
+            await this.shareNode(users.map(([user, permissions]) => ({
                 userId: user.id,
-                rights,
                 nodeId: folder.id,
+                rights: permissions.rights,
+                addAccess: permissions.addAccess,
+                delAccess: permissions.delAccess,
+                sharingAddAccess: permissions.sharingAddAccess,
+                sharingDelAccess: permissions.sharingDelAccess,
             })));
         }
         return folder;
@@ -328,7 +332,7 @@ export class SecrecyCloudClient {
     }
     async shareNode(input, progress) {
         // TODO: Validate input
-        const nodesMap = await this.#apiClient.cloud.shareNode.query(input);
+        const nodesMap = await this.#apiClient.cloud.shareNode.mutate(input);
         const neededUserKey = Object.entries(nodesMap)
             .filter(([, nodes]) => nodes.some((node) => node.includeKeys))
             .map(([userId]) => userId);
@@ -355,21 +359,49 @@ export class SecrecyCloudClient {
                 .filter((entry) => entry !== null));
             const infos = await this.encryptNodesForUsers(nodesToEncrypt, publicKeysMap);
             const shares = Array.isArray(input)
-                ? input
+                ? input.map((opt) => ({
+                    nodeId: opt.nodeId,
+                    userId: opt.userId,
+                    permissions: {
+                        rights: opt.rights,
+                        addAccess: opt.addAccess,
+                        delAccess: opt.delAccess,
+                        sharingAddAccess: opt.sharingAddAccess,
+                        sharingDelAccess: opt.sharingDelAccess,
+                    },
+                }))
                 : 'userIds' in input
                     ? 'nodeIds' in input
                         ? input.userIds.flatMap((userId) => input.nodeIds.map((nodeId) => ({
-                            rights: input.rights,
+                            permissions: {
+                                rights: input.rights,
+                                addAccess: input.addAccess,
+                                delAccess: input.delAccess,
+                                sharingAddAccess: input.sharingAddAccess,
+                                sharingDelAccess: input.sharingDelAccess,
+                            },
                             userId,
                             nodeId,
                         })))
                         : input.userIds.map((userId) => ({
-                            rights: input.rights,
+                            permissions: {
+                                rights: input.rights,
+                                addAccess: input.addAccess,
+                                delAccess: input.delAccess,
+                                sharingAddAccess: input.sharingAddAccess,
+                                sharingDelAccess: input.sharingDelAccess,
+                            },
                             userId,
                             nodeId: input.nodeId,
                         }))
                     : input.nodeIds.map((nodeId) => ({
-                        rights: input.rights,
+                        permissions: {
+                            rights: input.rights,
+                            addAccess: input.addAccess,
+                            delAccess: input.delAccess,
+                            sharingAddAccess: input.sharingAddAccess,
+                            sharingDelAccess: input.sharingDelAccess,
+                        },
                         nodeId,
                         userId: input.userId,
                     }));
@@ -385,21 +417,24 @@ export class SecrecyCloudClient {
                     return {
                         nodeId: node.nodeId,
                         userId: userId,
-                        rights: share.rights,
+                        permissions: share.permissions,
                     };
                 }),
             ]));
             const withKeys = Object.fromEntries(Object.entries(infos).map('rights' in input
                 ? ([userId, nodes]) => [
                     userId,
-                    { userId, nodes, rights: input.rights },
+                    { userId, nodes, permissions: input },
                 ]
                 : ([userId, nodes]) => {
                     const share = shares.find((share) => share.userId === userId && share.nodeId === nodes[0].id);
                     if (!share) {
                         throw new Error('Unable to retrieve rights!');
                     }
-                    return [userId, { userId, nodes, rights: share.rights }];
+                    return [
+                        userId,
+                        { userId, nodes, permissions: share.permissions },
+                    ];
                 }));
             const finishInput = [];
             for (const [userId, nodes] of Object.entries(withKeys)) {
@@ -407,7 +442,7 @@ export class SecrecyCloudClient {
                     userId,
                     nodes: nodes.nodes.map((node) => ({
                         id: node.id,
-                        rights: nodes.rights,
+                        ...nodes.permissions,
                         nameKey: node.nameKey,
                         data: node.data.map((d) => ({
                             id: d.id,
@@ -422,8 +457,8 @@ export class SecrecyCloudClient {
                     nodes: [
                         {
                             id: node.nodeId,
-                            rights: node.rights,
                             data: [],
+                            ...node.permissions,
                         },
                     ],
                 })));
@@ -650,14 +685,15 @@ export class SecrecyCloudClient {
         });
         const node = await apiNodeToExternalNodeFull(saveInCloud, this.#keys);
         const me = node.parent?.users.find(([u]) => u.id === this.#client.app.userId);
-        if (me !== undefined && ['admin', 'write'].includes(me[1])) {
+        // TODO: Rights
+        if (me !== undefined && ['admin', 'write'].includes(me[1]['rights'])) {
             const others = node.parent?.users.filter(([u]) => u.id !== this.#client.app.userId) ??
                 [];
             if (others.length > 0) {
-                await this.shareNode(others.map(([user, rights]) => ({
+                await this.shareNode(others.map(([user, permissions]) => ({
                     userId: user.id,
-                    rights,
                     nodeId: node.id,
+                    ...permissions,
                 })));
             }
         }

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

@@ -11,7 +11,7 @@ async function apiNodeToInternal(apiNode, keyPair) {
         name: apiNode.name,
         isFavorite: apiNode.isFavorite,
         breadcrumb: 'breadcrumb' in apiNode ? apiNode.breadcrumb : [],
-        createdBy: apiNode.createdBy,
+        owner: apiNode.owner,
         sizes: 'sizes' in apiNode
             ? apiNode.sizes
             : {
@@ -25,7 +25,6 @@ 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/base-client.d.ts

@@ -24,7 +24,7 @@ export declare class BaseClient {
     static getUser(userId: string, opts?: CreateTrpcClientOptions): Promise<PublicUser>;
     getUser(userId: string): Promise<PublicUser>;
     searchUsers(search: string): Promise<PublicUser[]>;
-    updateProfile(data: RouterInputs['user']['updateProfile']): Promise<Omit<SelfUser, 'account'>>;
+    updateProfile(data: RouterInputs['user']['updateProfile']): Promise<RouterOutputs['user']['updateProfile']>;
     static isCryptoTransactionDone({ idOrHash, network, opts, }: {
         idOrHash: string;
         network?: InfuraNetwork;

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

@@ -132,9 +132,23 @@ export declare class SecrecyCloudClient {
             }[];
             invalidRightsAccesses: {
                 userId: string;
-                current: "admin" | "write" | "read";
+                current: {
+                    rights: "delete" | "read" | "write";
+                } & {
+                    addAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
+                    delAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
+                };
                 nodeId: string;
-                expect: "admin" | "write" | "read";
+                expect: {
+                    rights: "delete" | "read" | "write";
+                } & {
+                    addAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingAddAccess?: "delete" | "read" | "write" | null | undefined;
+                    delAccess?: "delete" | "read" | "write" | null | undefined;
+                    sharingDelAccess?: "delete" | "read" | "write" | null | undefined;
+                };
             }[];
         };
         isMatching: false;

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

@@ -1,8 +1,8 @@
 import { type RouterOutputs } from '../../client.js';
 import type { DataMetadata, InternalData, 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;
+export type NodePermissions = ApiNode['users'][number][1];
+export type Rights = NodePermissions['rights'];
+export type NodeAccess<T extends Record<string, unknown> = Record<string, unknown>> = T & NodePermissions & {
     isRoot: boolean;
     sharedByPubKey: string;
 };
@@ -31,9 +31,9 @@ export interface Node<T extends NodeBreadcrumbItem = NodeBreadcrumbItem, U exten
     sizes: NodeSize;
     name: string;
     breadcrumb: T[];
-    createdBy: PublicUser;
+    owner: PublicUser;
     access: NodeAccess<U>;
-    users: Array<[PublicUser, Rights]>;
+    users: Array<[PublicUser, NodePermissions]>;
     currentDataId: string | null;
     parentId: string | null;
 }
@@ -82,9 +82,9 @@ export type ShareNodeDetails = {
     }[];
     invalidRightsAccesses: {
         userId: string;
-        current: Rights;
+        current: NodePermissions;
         nodeId: string;
-        expect: Rights;
+        expect: NodePermissions;
     }[];
 };
 export {};