cozy-sharing 33.4.1 → 33.4.3

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [33.4.3](https://github.com/cozy/cozy-libs/compare/cozy-sharing@33.4.2...cozy-sharing@33.4.3) (2026-06-16)
+
+### Bug Fixes
+
+- **cozy-sharing:** Remove revoked sharing after last recipient ([e0f486c](https://github.com/cozy/cozy-libs/commit/e0f486cd9b7805e8214c5586f0d7b2c7aed50491))
+
+## [33.4.2](https://github.com/cozy/cozy-libs/compare/cozy-sharing@33.4.1...cozy-sharing@33.4.2) (2026-06-16)
+
+### Bug Fixes
+
+- **cozy-sharing:** Preserve sharing updates on rollback ([7c6db1a](https://github.com/cozy/cozy-libs/commit/7c6db1ad63f3997f01bdfee7140f9dad36dde2c2))
+- **sharing:** Update member permissions optimistically ([5c1ac86](https://github.com/cozy/cozy-libs/commit/5c1ac8631e4598ac6d2bc08761d2064c9b396f66))
+
 ## [33.4.1](https://github.com/cozy/cozy-libs/compare/cozy-sharing@33.4.0...cozy-sharing@33.4.1) (2026-06-15)
 
 ### Bug Fixes

package/dist/SharingProvider.js

@@ -471,7 +471,7 @@ export var SharingProvider = /*#__PURE__*/function (_Component) {
      */
     _defineProperty(_this2, "updateSharingMemberType", /*#__PURE__*/function () {
       var _ref12 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10(sharingId, memberIndex, newType) {
-        var sharing, member, makeReadOnly;
+        var sharing, member, makeReadOnly, optimisticSharing, currentSharing, rollbackSharing;
         return _regeneratorRuntime.wrap(function _callee10$(_context10) {
           while (1) switch (_context10.prev = _context10.next) {
             case 0:
@@ -505,39 +505,64 @@ export var SharingProvider = /*#__PURE__*/function (_Component) {
               throw new Error('Unsupported sharing type: ' + newType);
 
             case 9:
-              _context10.prev = 9;
+              optimisticSharing = _objectSpread(_objectSpread({}, sharing), {}, {
+                attributes: _objectSpread(_objectSpread({}, sharing.attributes), {}, {
+                  members: sharing.attributes.members.map(function (member, index) {
+                    return index === memberIndex ? _objectSpread(_objectSpread({}, member), {}, {
+                      read_only: makeReadOnly
+                    }) : member;
+                  })
+                })
+              });
+
+              _this2.dispatch(updateSharing(optimisticSharing));
+
+              _context10.prev = 11;
 
               if (!makeReadOnly) {
-                _context10.next = 15;
+                _context10.next = 17;
                 break;
               }
 
-              _context10.next = 13;
+              _context10.next = 15;
               return _this2.sharingCol.setReadOnly(sharing, memberIndex);
 
-            case 13:
-              _context10.next = 17;
+            case 15:
+              _context10.next = 19;
               break;
 
-            case 15:
-              _context10.next = 17;
+            case 17:
+              _context10.next = 19;
               return _this2.sharingCol.setReadWrite(sharing, memberIndex);
 
-            case 17:
-              _context10.next = 23;
+            case 19:
+              _context10.next = 28;
               break;
 
-            case 19:
-              _context10.prev = 19;
-              _context10.t0 = _context10["catch"](9);
+            case 21:
+              _context10.prev = 21;
+              _context10.t0 = _context10["catch"](11);
+              currentSharing = _getSharingById(_this2.state, sharingId) || sharing;
+              rollbackSharing = _objectSpread(_objectSpread({}, currentSharing), {}, {
+                attributes: _objectSpread(_objectSpread({}, currentSharing.attributes), {}, {
+                  members: currentSharing.attributes.members.map(function (member, index) {
+                    return index === memberIndex ? _objectSpread(_objectSpread({}, member), {}, {
+                      read_only: !makeReadOnly
+                    }) : member;
+                  })
+                })
+              });
+
+              _this2.dispatch(updateSharing(rollbackSharing));
+
               log.error("Failed to change member ".concat(member.email, " permission type to ").concat(newType), _context10.t0);
               throw _context10.t0;
 
-            case 23:
+            case 28:
             case "end":
               return _context10.stop();
           }
-        }, _callee10, null, [[9, 19]]);
+        }, _callee10, null, [[11, 21]]);
       }));
 
       return function (_x16, _x17, _x18) {

package/dist/SharingProvider.spec.js

@@ -744,7 +744,9 @@ describe('updateSharingMemberType', function () {
       setReadOnly: jest.fn().mockResolvedValue({}),
       setReadWrite: jest.fn().mockResolvedValue({})
     };
-    jest.spyOn(instance, 'setState');
+    instance.dispatch = jest.fn(function (action) {
+      instance.state = _objectSpread(_objectSpread({}, instance.state), reducer(instance.state, action));
+    });
   });
   it('should throw when sharing is not found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
     return _regeneratorRuntime.wrap(function _callee15$(_context15) {
@@ -806,7 +808,7 @@ describe('updateSharingMemberType', function () {
       }
     }, _callee18);
   })));
-  it('should not dispatch a state update — realtime refreshes the store', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
+  it('should optimistically dispatch a state update when switching to one-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee19() {
     return _regeneratorRuntime.wrap(function _callee19$(_context19) {
       while (1) switch (_context19.prev = _context19.next) {
         case 0:
@@ -814,7 +816,16 @@ describe('updateSharingMemberType', function () {
           return instance.updateSharingMemberType('sharing-123', 1, 'one-way');
 
         case 2:
-          expect(instance.setState).not.toHaveBeenCalled();
+          expect(instance.dispatch).toHaveBeenCalledWith({
+            type: 'UPDATE_SHARING',
+            sharing: _objectSpread(_objectSpread({}, mockSharing), {}, {
+              attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
+                members: [mockSharing.attributes.members[0], _objectSpread(_objectSpread({}, mockSharing.attributes.members[1]), {}, {
+                  read_only: true
+                })]
+              })
+            })
+          });
 
         case 3:
         case "end":
@@ -822,7 +833,7 @@ describe('updateSharingMemberType', function () {
       }
     }, _callee19);
   })));
-  it('should not dispatch a state update for two-way — realtime refreshes the store', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
+  it('should optimistically dispatch a state update when switching to two-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee20() {
     return _regeneratorRuntime.wrap(function _callee20$(_context20) {
       while (1) switch (_context20.prev = _context20.next) {
         case 0:
@@ -830,7 +841,16 @@ describe('updateSharingMemberType', function () {
           return instance.updateSharingMemberType('sharing-123', 1, 'two-way');
 
         case 2:
-          expect(instance.setState).not.toHaveBeenCalled();
+          expect(instance.dispatch).toHaveBeenCalledWith({
+            type: 'UPDATE_SHARING',
+            sharing: _objectSpread(_objectSpread({}, mockSharing), {}, {
+              attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
+                members: [mockSharing.attributes.members[0], _objectSpread(_objectSpread({}, mockSharing.attributes.members[1]), {}, {
+                  read_only: false
+                })]
+              })
+            })
+          });
 
         case 3:
         case "end":
@@ -866,7 +886,7 @@ describe('updateSharingMemberType', function () {
       }
     }, _callee22);
   })));
-  it('should not dispatch state update if API call fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+  it('should rollback optimistic state update if API call fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
     return _regeneratorRuntime.wrap(function _callee23$(_context23) {
       while (1) switch (_context23.prev = _context23.next) {
         case 0:
@@ -875,14 +895,86 @@ describe('updateSharingMemberType', function () {
           return expect(instance.updateSharingMemberType('sharing-123', 1, 'one-way')).rejects.toThrow('Network error');
 
         case 3:
-          expect(instance.setState).not.toHaveBeenCalled();
+          expect(instance.dispatch).toHaveBeenNthCalledWith(1, {
+            type: 'UPDATE_SHARING',
+            sharing: _objectSpread(_objectSpread({}, mockSharing), {}, {
+              attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
+                members: [mockSharing.attributes.members[0], _objectSpread(_objectSpread({}, mockSharing.attributes.members[1]), {}, {
+                  read_only: true
+                })]
+              })
+            })
+          });
+          expect(instance.dispatch).toHaveBeenNthCalledWith(2, {
+            type: 'UPDATE_SHARING',
+            sharing: _objectSpread(_objectSpread({}, mockSharing), {}, {
+              attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
+                members: [mockSharing.attributes.members[0], _objectSpread(_objectSpread({}, mockSharing.attributes.members[1]), {}, {
+                  read_only: false
+                })]
+              })
+            })
+          });
 
-        case 4:
+        case 5:
         case "end":
           return _context23.stop();
       }
     }, _callee23);
   })));
+  it('should preserve realtime changes when rolling back an API failure', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+    var realtimeSharing;
+    return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+      while (1) switch (_context25.prev = _context25.next) {
+        case 0:
+          realtimeSharing = _objectSpread(_objectSpread({}, mockSharing), {}, {
+            attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
+              description: 'updated by realtime',
+              members: [_objectSpread(_objectSpread({}, mockSharing.attributes.members[0]), {}, {
+                status: 'seen'
+              }), _objectSpread(_objectSpread({}, mockSharing.attributes.members[1]), {}, {
+                read_only: true
+              })]
+            })
+          });
+          instance.sharingCol.setReadOnly.mockImplementation( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+            return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+              while (1) switch (_context24.prev = _context24.next) {
+                case 0:
+                  instance.state = _objectSpread(_objectSpread({}, instance.state), {}, {
+                    sharings: instance.state.sharings.map(function (sharing) {
+                      return sharing.id === realtimeSharing.id ? realtimeSharing : sharing;
+                    })
+                  });
+                  throw new Error('Network error');
+
+                case 2:
+                case "end":
+                  return _context24.stop();
+              }
+            }, _callee24);
+          })));
+          _context25.next = 4;
+          return expect(instance.updateSharingMemberType('sharing-123', 1, 'one-way')).rejects.toThrow('Network error');
+
+        case 4:
+          expect(instance.dispatch).toHaveBeenNthCalledWith(2, {
+            type: 'UPDATE_SHARING',
+            sharing: _objectSpread(_objectSpread({}, realtimeSharing), {}, {
+              attributes: _objectSpread(_objectSpread({}, realtimeSharing.attributes), {}, {
+                members: [realtimeSharing.attributes.members[0], _objectSpread(_objectSpread({}, realtimeSharing.attributes.members[1]), {}, {
+                  read_only: false
+                })]
+              })
+            })
+          });
+
+        case 5:
+        case "end":
+          return _context25.stop();
+      }
+    }, _callee25);
+  })));
 }); // TODO Convert with react-testing-library
 // describe('hasWriteAccess', () => {
 //   it('tells if a doc is writtable', () => {

package/dist/components/Recipient/MemberRecipientPermissions.js

@@ -112,17 +112,18 @@ var MemberRecipientPermissions = function MemberRecipientPermissions(_ref) {
             return _context2.abrupt("return");
 
           case 3:
-            _context2.prev = 3;
-            _context2.next = 6;
+            hideMenu();
+            _context2.prev = 4;
+            _context2.next = 7;
             return updateSharingMemberType(sharingId, memberIndex, newType);
 
-          case 6:
-            _context2.next = 12;
+          case 7:
+            _context2.next = 13;
             break;
 
-          case 8:
-            _context2.prev = 8;
-            _context2.t0 = _context2["catch"](3);
+          case 9:
+            _context2.prev = 9;
+            _context2.t0 = _context2["catch"](4);
             log.error('Failed to change member permission type', _context2.t0);
             showAlert({
               message: t('Share.members.error.changePermission'),
@@ -130,14 +131,11 @@ var MemberRecipientPermissions = function MemberRecipientPermissions(_ref) {
               variant: 'filled'
             });
 
-          case 12:
-            hideMenu();
-
           case 13:
           case "end":
             return _context2.stop();
         }
-      }, _callee2, null, [[3, 8]]);
+      }, _callee2, null, [[4, 9]]);
     }));
 
     return function (_x) {

package/dist/state.js

@@ -337,6 +337,12 @@ var sharings = function sharings() {
     case UPDATE_SHARING:
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
+      if (!isSharingADrive(action.sharing) && areAllRecipientsRevoked(action.sharing)) {
+        return state.filter(function (s) {
+          return s.id !== action.sharing.id;
+        });
+      }
+
       return state.map(function (s) {
         return s.id !== action.sharing.id ? s : action.sharing;
       });

package/dist/state.spec.js

@@ -254,6 +254,18 @@ describe('Sharing state', function () {
     expect(state.sharings[0].attributes.members[1].status).toEqual('revoked');
     expect(state.sharings[0].attributes.members[2].id).toEqual(SHARING_1.attributes.members[2].id);
   });
+  it('should forget a sharing when revoking the last recipient', function () {
+    var state = reducer(reducer(undefined, receiveSharings({
+      sharings: [SHARING_1, SHARING_2]
+    })), revokeRecipient(SHARING_2, 1));
+    expect(state.byDocId).toEqual({
+      folder_1: {
+        sharings: [SHARING_1.id],
+        permissions: []
+      }
+    });
+    expect(state.sharings).toEqual([SHARING_1]);
+  });
   it('should revoke self', function () {
     var state = reducer(reducer(undefined, receiveSharings({
       sharings: [SHARING_1, SHARING_2]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "33.4.1",
+  "version": "33.4.3",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -83,5 +83,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "a2e29d6c728ebf0fdc890666a9ec3505e90551ed"
+  "gitHead": "832c42dbcfdc5db673a0b225163b953031def5de"
 }

package/src/SharingProvider.jsx

@@ -358,6 +358,24 @@ export class SharingProvider extends Component {
     if (newType !== 'one-way' && newType !== 'two-way') {
       throw new Error('Unsupported sharing type: ' + newType)
     }
+
+    const optimisticSharing = {
+      ...sharing,
+      attributes: {
+        ...sharing.attributes,
+        members: sharing.attributes.members.map((member, index) =>
+          index === memberIndex
+            ? {
+                ...member,
+                read_only: makeReadOnly
+              }
+            : member
+        )
+      }
+    }
+
+    this.dispatch(updateSharing(optimisticSharing))
+
     try {
       if (makeReadOnly) {
         await this.sharingCol.setReadOnly(sharing, memberIndex)
@@ -365,6 +383,23 @@ export class SharingProvider extends Component {
         await this.sharingCol.setReadWrite(sharing, memberIndex)
       }
     } catch (error) {
+      const currentSharing = getSharingById(this.state, sharingId) || sharing
+      const rollbackSharing = {
+        ...currentSharing,
+        attributes: {
+          ...currentSharing.attributes,
+          members: currentSharing.attributes.members.map((member, index) =>
+            index === memberIndex
+              ? {
+                  ...member,
+                  read_only: !makeReadOnly
+                }
+              : member
+          )
+        }
+      }
+
+      this.dispatch(updateSharing(rollbackSharing))
       log.error(
         `Failed to change member ${member.email} permission type to ${newType}`,
         error

package/src/SharingProvider.spec.jsx

@@ -524,7 +524,9 @@ describe('updateSharingMemberType', () => {
       setReadOnly: jest.fn().mockResolvedValue({}),
       setReadWrite: jest.fn().mockResolvedValue({})
     }
-    jest.spyOn(instance, 'setState')
+    instance.dispatch = jest.fn(action => {
+      instance.state = { ...instance.state, ...reducer(instance.state, action) }
+    })
   })
 
   it('should throw when sharing is not found', async () => {
@@ -556,16 +558,46 @@ describe('updateSharingMemberType', () => {
     expect(instance.sharingCol.setReadOnly).not.toHaveBeenCalled()
   })
 
-  it('should not dispatch a state update — realtime refreshes the store', async () => {
+  it('should optimistically dispatch a state update when switching to one-way', async () => {
     await instance.updateSharingMemberType('sharing-123', 1, 'one-way')
 
-    expect(instance.setState).not.toHaveBeenCalled()
+    expect(instance.dispatch).toHaveBeenCalledWith({
+      type: 'UPDATE_SHARING',
+      sharing: {
+        ...mockSharing,
+        attributes: {
+          ...mockSharing.attributes,
+          members: [
+            mockSharing.attributes.members[0],
+            {
+              ...mockSharing.attributes.members[1],
+              read_only: true
+            }
+          ]
+        }
+      }
+    })
   })
 
-  it('should not dispatch a state update for two-way — realtime refreshes the store', async () => {
+  it('should optimistically dispatch a state update when switching to two-way', async () => {
     await instance.updateSharingMemberType('sharing-123', 1, 'two-way')
 
-    expect(instance.setState).not.toHaveBeenCalled()
+    expect(instance.dispatch).toHaveBeenCalledWith({
+      type: 'UPDATE_SHARING',
+      sharing: {
+        ...mockSharing,
+        attributes: {
+          ...mockSharing.attributes,
+          members: [
+            mockSharing.attributes.members[0],
+            {
+              ...mockSharing.attributes.members[1],
+              read_only: false
+            }
+          ]
+        }
+      }
+    })
   })
 
   it('should rethrow error if setReadOnly fails', async () => {
@@ -588,7 +620,7 @@ describe('updateSharingMemberType', () => {
     ).rejects.toThrow('Network error')
   })
 
-  it('should not dispatch state update if API call fails', async () => {
+  it('should rollback optimistic state update if API call fails', async () => {
     instance.sharingCol.setReadOnly.mockRejectedValue(
       new Error('Network error')
     )
@@ -597,7 +629,89 @@ describe('updateSharingMemberType', () => {
       instance.updateSharingMemberType('sharing-123', 1, 'one-way')
     ).rejects.toThrow('Network error')
 
-    expect(instance.setState).not.toHaveBeenCalled()
+    expect(instance.dispatch).toHaveBeenNthCalledWith(1, {
+      type: 'UPDATE_SHARING',
+      sharing: {
+        ...mockSharing,
+        attributes: {
+          ...mockSharing.attributes,
+          members: [
+            mockSharing.attributes.members[0],
+            {
+              ...mockSharing.attributes.members[1],
+              read_only: true
+            }
+          ]
+        }
+      }
+    })
+    expect(instance.dispatch).toHaveBeenNthCalledWith(2, {
+      type: 'UPDATE_SHARING',
+      sharing: {
+        ...mockSharing,
+        attributes: {
+          ...mockSharing.attributes,
+          members: [
+            mockSharing.attributes.members[0],
+            {
+              ...mockSharing.attributes.members[1],
+              read_only: false
+            }
+          ]
+        }
+      }
+    })
+  })
+
+  it('should preserve realtime changes when rolling back an API failure', async () => {
+    const realtimeSharing = {
+      ...mockSharing,
+      attributes: {
+        ...mockSharing.attributes,
+        description: 'updated by realtime',
+        members: [
+          {
+            ...mockSharing.attributes.members[0],
+            status: 'seen'
+          },
+          {
+            ...mockSharing.attributes.members[1],
+            read_only: true
+          }
+        ]
+      }
+    }
+
+    instance.sharingCol.setReadOnly.mockImplementation(async () => {
+      instance.state = {
+        ...instance.state,
+        sharings: instance.state.sharings.map(sharing =>
+          sharing.id === realtimeSharing.id ? realtimeSharing : sharing
+        )
+      }
+      throw new Error('Network error')
+    })
+
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+    ).rejects.toThrow('Network error')
+
+    expect(instance.dispatch).toHaveBeenNthCalledWith(2, {
+      type: 'UPDATE_SHARING',
+      sharing: {
+        ...realtimeSharing,
+        attributes: {
+          ...realtimeSharing.attributes,
+          members: [
+            realtimeSharing.attributes.members[0],
+            {
+              ...realtimeSharing.attributes.members[1],
+              read_only: false
+            }
+          ]
+        }
+      }
+    })
   })
 })
 

package/src/components/Recipient/MemberRecipientPermissions.jsx

@@ -74,6 +74,7 @@ const MemberRecipientPermissions = ({
         hideMenu()
         return
       }
+      hideMenu()
       try {
         await updateSharingMemberType(sharingId, memberIndex, newType)
       } catch (error) {
@@ -84,7 +85,6 @@ const MemberRecipientPermissions = ({
           variant: 'filled'
         })
       }
-      hideMenu()
     },
     [
       hideMenu,

package/src/state.js

@@ -258,6 +258,12 @@ const sharings = (state = [], action) => {
     case UPDATE_SHARING:
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
+      if (
+        !isSharingADrive(action.sharing) &&
+        areAllRecipientsRevoked(action.sharing)
+      ) {
+        return state.filter(s => s.id !== action.sharing.id)
+      }
       return state.map(s => {
         return s.id !== action.sharing.id ? s : action.sharing
       })

package/src/state.spec.js

@@ -343,6 +343,22 @@ describe('Sharing state', () => {
     )
   })
 
+  it('should forget a sharing when revoking the last recipient', () => {
+    const state = reducer(
+      reducer(
+        undefined,
+        receiveSharings({
+          sharings: [SHARING_1, SHARING_2]
+        })
+      ),
+      revokeRecipient(SHARING_2, 1)
+    )
+    expect(state.byDocId).toEqual({
+      folder_1: { sharings: [SHARING_1.id], permissions: [] }
+    })
+    expect(state.sharings).toEqual([SHARING_1])
+  })
+
   it('should revoke self', () => {
     const state = reducer(
       reducer(