cozy-sharing 33.6.0 → 33.6.1

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [33.6.1](https://github.com/cozy/cozy-libs/compare/cozy-sharing@33.6.0...cozy-sharing@33.6.1) (2026-06-22)
+
+### Bug Fixes
+
+- Forget owner-only shared drive sharings ([795eff2](https://github.com/cozy/cozy-libs/commit/795eff246218780d6315ae49d4b55dbe732c450b))
+
 # [33.6.0](https://github.com/cozy/cozy-libs/compare/cozy-sharing@33.5.1...cozy-sharing@33.6.0) (2026-06-17)
 
 ### Features

package/dist/SharingProvider.spec.js

@@ -11,7 +11,7 @@ import React from 'react';
 import { createMockClient } from 'cozy-client';
 import { SharingProvider } from './SharingProvider';
 import SharingContext from './context';
-import reducer, { addSharingLink, getDocumentPermissions } from './state';
+import reducer, { addSharingLink, getDocumentPermissions, getDocumentSharing, receiveSharings } from './state';
 import AppLike from '../test/AppLike';
 
 var AppWrapper = function AppWrapper(_ref) {
@@ -411,6 +411,135 @@ describe('updateDocumentPermissions', function () {
     }, _callee7);
   })));
 });
+describe('shared drive recipient revocation', function () {
+  var SHARED_DRIVE = {
+    _id: 'sharing_123',
+    id: 'sharing_123',
+    type: 'io.cozy.sharings',
+    attributes: {
+      drive: true,
+      owner: true,
+      description: 'Shared folder',
+      rules: [{
+        title: 'Shared folder',
+        doctype: 'io.cozy.files',
+        values: ['folder_123'],
+        add: 'none',
+        update: 'none',
+        remove: 'none'
+      }],
+      members: [{
+        status: 'owner',
+        email: 'owner@cozy.local',
+        instance: 'http://cozy.local'
+      }, {
+        status: 'pending',
+        email: 'recipient@cozy.local',
+        instance: 'http://recipient.cozy.local'
+      }]
+    }
+  };
+
+  var NEW_SHARING = _objectSpread(_objectSpread({}, SHARED_DRIVE), {}, {
+    _id: 'sharing_456',
+    id: 'sharing_456'
+  });
+
+  var document = {
+    _id: 'folder_123',
+    id: 'folder_123',
+    path: '/Shared folder'
+  };
+  var recipient = {
+    _id: 'contact_123',
+    id: 'contact_123',
+    _type: 'io.cozy.contacts',
+    email: 'recipient@cozy.local'
+  };
+  var provider;
+  var sharingCol;
+  beforeEach(function () {
+    var mockClient = createMockClient({});
+
+    mockClient.getStackClient = function () {
+      return {
+        uri: 'http://cozy.local'
+      };
+    };
+
+    mockClient.collection = jest.fn().mockReturnValue({});
+    provider = new SharingProvider({
+      client: mockClient
+    });
+    provider.state = _objectSpread(_objectSpread({}, provider.state), reducer(undefined, receiveSharings({
+      sharings: [SHARED_DRIVE]
+    })));
+    provider.dispatch = jest.fn(function (action) {
+      provider.state = _objectSpread(_objectSpread({}, provider.state), reducer(provider.state, action));
+    });
+    sharingCol = {
+      addRecipients: jest.fn(),
+      create: jest.fn().mockResolvedValue({
+        data: NEW_SHARING
+      }),
+      revokeRecipient: jest.fn().mockResolvedValue({})
+    };
+    provider.sharingCol = sharingCol;
+  });
+  it('forgets the shared drive when revoking its last recipient', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _context8.next = 2;
+          return provider.revoke(document, SHARED_DRIVE.id, 1);
+
+        case 2:
+          expect(sharingCol.revokeRecipient).toHaveBeenCalledWith(SHARED_DRIVE, 1);
+          expect(getDocumentSharing(provider.state, document.id)).toBeNull();
+
+        case 4:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('creates a new sharing when re-adding after the last recipient was revoked', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+    return _regeneratorRuntime.wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          _context9.next = 2;
+          return provider.revoke(document, SHARED_DRIVE.id, 1);
+
+        case 2:
+          _context9.next = 4;
+          return provider.share({
+            document: document,
+            recipients: [recipient],
+            readOnlyRecipients: [],
+            description: 'Shared folder',
+            openSharing: true,
+            sharedDrive: true
+          });
+
+        case 4:
+          expect(sharingCol.addRecipients).not.toHaveBeenCalled();
+          expect(sharingCol.create).toHaveBeenCalledWith({
+            document: document,
+            recipients: [recipient],
+            readOnlyRecipients: [],
+            description: 'Shared folder',
+            previewPath: '/preview',
+            openSharing: true,
+            sharedDrive: true
+          });
+
+        case 6:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+});
 describe('fetchSharedDriveSharingLinks', function () {
   var PERM_DRIVE_FILE = {
     type: 'io.cozy.permissions',
@@ -434,10 +563,10 @@ describe('fetchSharedDriveSharingLinks', function () {
     id: 'file_in_drive',
     driveId: 'drive_123'
   };
-  it('fetches shared drive sharing links by file id', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+  it('fetches shared drive sharing links by file id', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
     var mockFindLinksByIds, mockClient, provider, result, permissions;
-    return _regeneratorRuntime.wrap(function _callee8$(_context8) {
-      while (1) switch (_context8.prev = _context8.next) {
+    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
         case 0:
           mockFindLinksByIds = jest.fn().mockResolvedValue({
             data: [PERM_DRIVE_FILE]
@@ -453,11 +582,11 @@ describe('fetchSharedDriveSharingLinks', function () {
           provider.dispatch = jest.fn(function (action) {
             provider.state = reducer(provider.state, action);
           });
-          _context8.next = 8;
+          _context10.next = 8;
           return provider.fetchSharedDriveSharingLinks(driveFile);
 
         case 8:
-          result = _context8.sent;
+          result = _context10.sent;
           expect(mockClient.collection).toHaveBeenCalledWith('io.cozy.permissions', {
             driveId: 'drive_123'
           });
@@ -470,14 +599,14 @@ describe('fetchSharedDriveSharingLinks', function () {
 
         case 16:
         case "end":
-          return _context8.stop();
+          return _context10.stop();
       }
-    }, _callee8);
+    }, _callee10);
   })));
-  it('returns an empty array and skips the API call for non-shared-drive documents', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
+  it('returns an empty array and skips the API call for non-shared-drive documents', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
     var mockClient, findLinksByIds, provider, result;
-    return _regeneratorRuntime.wrap(function _callee9$(_context9) {
-      while (1) switch (_context9.prev = _context9.next) {
+    return _regeneratorRuntime.wrap(function _callee11$(_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
         case 0:
           mockClient = createMockClient({});
           findLinksByIds = jest.fn();
@@ -488,27 +617,27 @@ describe('fetchSharedDriveSharingLinks', function () {
             client: mockClient
           });
           provider.dispatch = jest.fn();
-          _context9.next = 7;
+          _context11.next = 7;
           return provider.fetchSharedDriveSharingLinks({
             _id: 'regular_file'
           });
 
         case 7:
-          result = _context9.sent;
+          result = _context11.sent;
           expect(result).toEqual([]);
           expect(findLinksByIds).not.toHaveBeenCalled();
           expect(provider.dispatch).not.toHaveBeenCalled();
 
         case 11:
         case "end":
-          return _context9.stop();
+          return _context11.stop();
       }
-    }, _callee9);
+    }, _callee11);
   })));
-  it('uses document.id as a fallback when _id is missing', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee10() {
+  it('uses document.id as a fallback when _id is missing', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
     var mockFindLinksByIds, mockClient, provider;
-    return _regeneratorRuntime.wrap(function _callee10$(_context10) {
-      while (1) switch (_context10.prev = _context10.next) {
+    return _regeneratorRuntime.wrap(function _callee12$(_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
         case 0:
           mockFindLinksByIds = jest.fn().mockResolvedValue({
             data: [PERM_DRIVE_FILE]
@@ -524,7 +653,7 @@ describe('fetchSharedDriveSharingLinks', function () {
           provider.dispatch = jest.fn(function (action) {
             provider.state = reducer(provider.state, action);
           });
-          _context10.next = 8;
+          _context12.next = 8;
           return provider.fetchSharedDriveSharingLinks({
             id: 'file_in_drive',
             driveId: 'drive_123'
@@ -535,14 +664,14 @@ describe('fetchSharedDriveSharingLinks', function () {
 
         case 9:
         case "end":
-          return _context10.stop();
+          return _context12.stop();
       }
-    }, _callee10);
+    }, _callee12);
   })));
-  it('does not dispatch when the response has no data', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee11() {
+  it('does not dispatch when the response has no data', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
     var mockFindLinksByIds, mockClient, provider, result;
-    return _regeneratorRuntime.wrap(function _callee11$(_context11) {
-      while (1) switch (_context11.prev = _context11.next) {
+    return _regeneratorRuntime.wrap(function _callee13$(_context13) {
+      while (1) switch (_context13.prev = _context13.next) {
         case 0:
           mockFindLinksByIds = jest.fn().mockResolvedValue({
             data: []
@@ -555,19 +684,19 @@ describe('fetchSharedDriveSharingLinks', function () {
             client: mockClient
           });
           provider.dispatch = jest.fn();
-          _context11.next = 7;
+          _context13.next = 7;
           return provider.fetchSharedDriveSharingLinks(driveFile);
 
         case 7:
-          result = _context11.sent;
+          result = _context13.sent;
           expect(result).toEqual([]);
           expect(provider.dispatch).not.toHaveBeenCalled();
 
         case 10:
         case "end":
-          return _context11.stop();
+          return _context13.stop();
       }
-    }, _callee11);
+    }, _callee13);
   })));
 });
 describe('shareByLink shared drive 409 recovery', function () {
@@ -593,10 +722,10 @@ describe('shareByLink shared drive 409 recovery', function () {
     id: 'file_in_drive',
     driveId: 'drive_123'
   };
-  it('falls back to fetching existing links when create returns 409', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee12() {
+  it('falls back to fetching existing links when create returns 409', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
     var conflict, mockCreateSharingLink, mockFindLinksByIds, mockClient, provider, resp;
-    return _regeneratorRuntime.wrap(function _callee12$(_context12) {
-      while (1) switch (_context12.prev = _context12.next) {
+    return _regeneratorRuntime.wrap(function _callee14$(_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
         case 0:
           conflict = Object.assign(new Error('Conflict'), {
             status: 409
@@ -617,27 +746,27 @@ describe('shareByLink shared drive 409 recovery', function () {
           provider.dispatch = jest.fn(function (action) {
             provider.state = reducer(provider.state, action);
           });
-          _context12.next = 10;
+          _context14.next = 10;
           return provider.shareByLink(driveFile, {
             verbs: ['GET']
           });
 
         case 10:
-          resp = _context12.sent;
+          resp = _context14.sent;
           expect(mockCreateSharingLink).toHaveBeenCalled();
           expect(mockFindLinksByIds).toHaveBeenCalledWith(['file_in_drive']);
           expect(resp.data.id).toBe(PERM_DRIVE_FILE.id);
 
         case 14:
         case "end":
-          return _context12.stop();
+          return _context14.stop();
       }
-    }, _callee12);
+    }, _callee14);
   })));
-  it('does not duplicate existing links when 409 recovery refetches them', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee13() {
+  it('does not duplicate existing links when 409 recovery refetches them', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee15() {
     var conflict, mockCreateSharingLink, mockFindLinksByIds, mockClient, provider, resp, permissions;
-    return _regeneratorRuntime.wrap(function _callee13$(_context13) {
-      while (1) switch (_context13.prev = _context13.next) {
+    return _regeneratorRuntime.wrap(function _callee15$(_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
         case 0:
           conflict = Object.assign(new Error('Conflict'), {
             status: 409
@@ -658,13 +787,13 @@ describe('shareByLink shared drive 409 recovery', function () {
           provider.dispatch = jest.fn(function (action) {
             provider.state = reducer(provider.state, action);
           });
-          _context13.next = 10;
+          _context15.next = 10;
           return provider.shareByLink(driveFile, {
             verbs: ['GET']
           });
 
         case 10:
-          resp = _context13.sent;
+          resp = _context15.sent;
           permissions = getDocumentPermissions(provider.state, 'file_in_drive');
           expect(resp.data.id).toBe(PERM_DRIVE_FILE.id);
           expect(provider.dispatch).not.toHaveBeenCalled();
@@ -672,14 +801,14 @@ describe('shareByLink shared drive 409 recovery', function () {
 
         case 15:
         case "end":
-          return _context13.stop();
+          return _context15.stop();
       }
-    }, _callee13);
+    }, _callee15);
   })));
-  it('rethrows the original error when 409 happens and no link is found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee14() {
+  it('rethrows the original error when 409 happens and no link is found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
     var conflict, mockCreateSharingLink, mockFindLinksByIds, mockClient, provider;
-    return _regeneratorRuntime.wrap(function _callee14$(_context14) {
-      while (1) switch (_context14.prev = _context14.next) {
+    return _regeneratorRuntime.wrap(function _callee16$(_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
         case 0:
           conflict = Object.assign(new Error('Conflict'), {
             status: 409
@@ -698,16 +827,16 @@ describe('shareByLink shared drive 409 recovery', function () {
           });
           provider.state = reducer();
           provider.dispatch = jest.fn();
-          _context14.next = 10;
+          _context16.next = 10;
           return expect(provider.shareByLink(driveFile, {
             verbs: ['GET']
           })).rejects.toBe(conflict);
 
         case 10:
         case "end":
-          return _context14.stop();
+          return _context16.stop();
       }
-    }, _callee14);
+    }, _callee16);
   })));
 });
 describe('updateSharingMemberType', function () {
@@ -748,37 +877,37 @@ describe('updateSharingMemberType', function () {
       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) {
-      while (1) switch (_context15.prev = _context15.next) {
+  it('should throw when sharing is not found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
+    return _regeneratorRuntime.wrap(function _callee17$(_context17) {
+      while (1) switch (_context17.prev = _context17.next) {
         case 0:
-          _context15.next = 2;
+          _context17.next = 2;
           return expect(instance.updateSharingMemberType('unknown-id', 1, 'one-way')).rejects.toThrow('Sharing not found');
 
         case 2:
         case "end":
-          return _context15.stop();
+          return _context17.stop();
       }
-    }, _callee15);
+    }, _callee17);
   })));
-  it('should throw when member is not found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee16() {
-    return _regeneratorRuntime.wrap(function _callee16$(_context16) {
-      while (1) switch (_context16.prev = _context16.next) {
+  it('should throw when member is not found', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
+    return _regeneratorRuntime.wrap(function _callee18$(_context18) {
+      while (1) switch (_context18.prev = _context18.next) {
         case 0:
-          _context16.next = 2;
+          _context18.next = 2;
           return expect(instance.updateSharingMemberType('sharing-123', 99, 'one-way')).rejects.toThrow('Member not found');
 
         case 2:
         case "end":
-          return _context16.stop();
+          return _context18.stop();
       }
-    }, _callee16);
+    }, _callee18);
   })));
-  it('should call setReadOnly when switching to one-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee17() {
-    return _regeneratorRuntime.wrap(function _callee17$(_context17) {
-      while (1) switch (_context17.prev = _context17.next) {
+  it('should call setReadOnly 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:
-          _context17.next = 2;
+          _context19.next = 2;
           return instance.updateSharingMemberType('sharing-123', 1, 'one-way');
 
         case 2:
@@ -787,15 +916,15 @@ describe('updateSharingMemberType', function () {
 
         case 4:
         case "end":
-          return _context17.stop();
+          return _context19.stop();
       }
-    }, _callee17);
+    }, _callee19);
   })));
-  it('should call setReadWrite when switching to two-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee18() {
-    return _regeneratorRuntime.wrap(function _callee18$(_context18) {
-      while (1) switch (_context18.prev = _context18.next) {
+  it('should call setReadWrite 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:
-          _context18.next = 2;
+          _context20.next = 2;
           return instance.updateSharingMemberType('sharing-123', 1, 'two-way');
 
         case 2:
@@ -804,15 +933,15 @@ describe('updateSharingMemberType', function () {
 
         case 4:
         case "end":
-          return _context18.stop();
+          return _context20.stop();
       }
-    }, _callee18);
+    }, _callee20);
   })));
-  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) {
+  it('should optimistically dispatch a state update when switching to one-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
+    return _regeneratorRuntime.wrap(function _callee21$(_context21) {
+      while (1) switch (_context21.prev = _context21.next) {
         case 0:
-          _context19.next = 2;
+          _context21.next = 2;
           return instance.updateSharingMemberType('sharing-123', 1, 'one-way');
 
         case 2:
@@ -829,15 +958,15 @@ describe('updateSharingMemberType', function () {
 
         case 3:
         case "end":
-          return _context19.stop();
+          return _context21.stop();
       }
-    }, _callee19);
+    }, _callee21);
   })));
-  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) {
+  it('should optimistically dispatch a state update when switching to two-way', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
+    return _regeneratorRuntime.wrap(function _callee22$(_context22) {
+      while (1) switch (_context22.prev = _context22.next) {
         case 0:
-          _context20.next = 2;
+          _context22.next = 2;
           return instance.updateSharingMemberType('sharing-123', 1, 'two-way');
 
         case 2:
@@ -854,44 +983,44 @@ describe('updateSharingMemberType', function () {
 
         case 3:
         case "end":
-          return _context20.stop();
+          return _context22.stop();
       }
-    }, _callee20);
+    }, _callee22);
   })));
-  it('should rethrow error if setReadOnly fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee21() {
-    return _regeneratorRuntime.wrap(function _callee21$(_context21) {
-      while (1) switch (_context21.prev = _context21.next) {
+  it('should rethrow error if setReadOnly fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee23() {
+    return _regeneratorRuntime.wrap(function _callee23$(_context23) {
+      while (1) switch (_context23.prev = _context23.next) {
         case 0:
           instance.sharingCol.setReadOnly.mockRejectedValue(new Error('Network error'));
-          _context21.next = 3;
+          _context23.next = 3;
           return expect(instance.updateSharingMemberType('sharing-123', 1, 'one-way')).rejects.toThrow('Network error');
 
         case 3:
         case "end":
-          return _context21.stop();
+          return _context23.stop();
       }
-    }, _callee21);
+    }, _callee23);
   })));
-  it('should rethrow error if setReadWrite fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee22() {
-    return _regeneratorRuntime.wrap(function _callee22$(_context22) {
-      while (1) switch (_context22.prev = _context22.next) {
+  it('should rethrow error if setReadWrite fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
+    return _regeneratorRuntime.wrap(function _callee24$(_context24) {
+      while (1) switch (_context24.prev = _context24.next) {
         case 0:
           instance.sharingCol.setReadWrite.mockRejectedValue(new Error('Network error'));
-          _context22.next = 3;
+          _context24.next = 3;
           return expect(instance.updateSharingMemberType('sharing-123', 1, 'two-way')).rejects.toThrow('Network error');
 
         case 3:
         case "end":
-          return _context22.stop();
+          return _context24.stop();
       }
-    }, _callee22);
+    }, _callee24);
   })));
-  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) {
+  it('should rollback optimistic state update if API call fails', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+    return _regeneratorRuntime.wrap(function _callee25$(_context25) {
+      while (1) switch (_context25.prev = _context25.next) {
         case 0:
           instance.sharingCol.setReadOnly.mockRejectedValue(new Error('Network error'));
-          _context23.next = 3;
+          _context25.next = 3;
           return expect(instance.updateSharingMemberType('sharing-123', 1, 'one-way')).rejects.toThrow('Network error');
 
         case 3:
@@ -918,14 +1047,14 @@ describe('updateSharingMemberType', function () {
 
         case 5:
         case "end":
-          return _context23.stop();
+          return _context25.stop();
       }
-    }, _callee23);
+    }, _callee25);
   })));
-  it('should preserve realtime changes when rolling back an API failure', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee25() {
+  it('should preserve realtime changes when rolling back an API failure', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee27() {
     var realtimeSharing;
-    return _regeneratorRuntime.wrap(function _callee25$(_context25) {
-      while (1) switch (_context25.prev = _context25.next) {
+    return _regeneratorRuntime.wrap(function _callee27$(_context27) {
+      while (1) switch (_context27.prev = _context27.next) {
         case 0:
           realtimeSharing = _objectSpread(_objectSpread({}, mockSharing), {}, {
             attributes: _objectSpread(_objectSpread({}, mockSharing.attributes), {}, {
@@ -937,9 +1066,9 @@ describe('updateSharingMemberType', function () {
               })]
             })
           });
-          instance.sharingCol.setReadOnly.mockImplementation( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee24() {
-            return _regeneratorRuntime.wrap(function _callee24$(_context24) {
-              while (1) switch (_context24.prev = _context24.next) {
+          instance.sharingCol.setReadOnly.mockImplementation( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee26() {
+            return _regeneratorRuntime.wrap(function _callee26$(_context26) {
+              while (1) switch (_context26.prev = _context26.next) {
                 case 0:
                   instance.state = _objectSpread(_objectSpread({}, instance.state), {}, {
                     sharings: instance.state.sharings.map(function (sharing) {
@@ -950,11 +1079,11 @@ describe('updateSharingMemberType', function () {
 
                 case 2:
                 case "end":
-                  return _context24.stop();
+                  return _context26.stop();
               }
-            }, _callee24);
+            }, _callee26);
           })));
-          _context25.next = 4;
+          _context27.next = 4;
           return expect(instance.updateSharingMemberType('sharing-123', 1, 'one-way')).rejects.toThrow('Network error');
 
         case 4:
@@ -971,9 +1100,9 @@ describe('updateSharingMemberType', function () {
 
         case 5:
         case "end":
-          return _context25.stop();
+          return _context27.stop();
       }
-    }, _callee25);
+    }, _callee27);
   })));
 }); // TODO Convert with react-testing-library
 // describe('hasWriteAccess', () => {

package/dist/state.js

@@ -237,7 +237,7 @@ var byDocId = function byDocId() {
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
     case UPDATE_SHARING:
-      if (!isSharingADrive(action.sharing) && areAllRecipientsRevoked(action.sharing)) {
+      if (areAllRecipientsRevoked(action.sharing)) {
         return forgetSharing(state, action.sharing);
       }
 
@@ -337,7 +337,7 @@ var sharings = function sharings() {
     case UPDATE_SHARING:
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
-      if (!isSharingADrive(action.sharing) && areAllRecipientsRevoked(action.sharing)) {
+      if (areAllRecipientsRevoked(action.sharing)) {
         return state.filter(function (s) {
           return s.id !== action.sharing.id;
         });
@@ -374,7 +374,8 @@ var sharedPaths = function sharedPaths() {
 
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
-      if (!isSharingADrive(action.sharing) && areAllRecipientsRevoked(action.sharing)) {
+    case UPDATE_SHARING:
+      if (areAllRecipientsRevoked(action.sharing)) {
         return state.filter(function (p) {
           return p !== action.path;
         });

package/dist/state.spec.js

@@ -4,7 +4,7 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
-import reducer, { receiveSharings, addSharing, addSharingLink, updateSharingLink, revokeSharingLink, getRecipients, getRecipientsFromSharing, revokeRecipient, revokeSelf, updateSharing, matchingInstanceName, getSharingLink, hasSharedParent, hasSharedChild, getSharedDocIdsBySharings, getSharingType, getPermissionDocIds, getDocumentSharingType, getSharedParentPath, getExternalSharingIds, getRecipientsWithGroups } from './state';
+import reducer, { receiveSharings, addSharing, addSharingLink, updateSharingLink, revokeSharingLink, getRecipients, getRecipientsFromSharing, revokeGroup, revokeRecipient, revokeSelf, updateSharing, matchingInstanceName, getSharingLink, hasSharedParent, hasSharedChild, getSharedDocIdsBySharings, getSharingType, getPermissionDocIds, getDocumentSharingType, getSharedParentPath, getExternalSharingIds, getRecipientsWithGroups } from './state';
 import { SHARING_1, SHARING_2, SHARING_3, SHARING_READ_ONLY, PERM_1, PERM_2, PERM_WITHOUT_DOC, SHARING_NO_ACTIVE, SHARING_WITH_SHORTCUT, APPS } from '../__tests__/fixtures';
 describe('Sharing state', function () {
   it('should have a default state', function () {
@@ -106,7 +106,7 @@ describe('Sharing state', function () {
     });
     expect(state.sharings).toEqual([SHARING_1, SHARED_DRIVE_WITHOUT_RECIPIENTS]);
   });
-  it('should not forget shared drives without recipients when updating', function () {
+  it('should forget shared drives without recipients when updating', function () {
     var SHARED_DRIVE_WITHOUT_RECIPIENTS = _objectSpread(_objectSpread({}, SHARING_1), {}, {
       id: 'shared_drive_no_recipients',
       attributes: _objectSpread(_objectSpread({}, SHARING_1.attributes), {}, {
@@ -139,15 +139,45 @@ describe('Sharing state', function () {
     });
 
     var state = reducer(initialState, updateSharing(updatedSharing));
-    expect(state.byDocId).toEqual({
-      shared_drive_folder: {
-        sharings: [SHARED_DRIVE_WITHOUT_RECIPIENTS.id],
-        permissions: []
-      }
-    });
-    expect(state.sharings).toEqual([updatedSharing]);
+    expect(state.byDocId).toEqual({});
+    expect(state.sharings).toEqual([]);
   });
-  it('should not remove shared drive path when revoking last recipient', function () {
+  it('should forget a shared drive when revoking its last group', function () {
+    var SHARED_DRIVE_WITH_GROUP = _objectSpread(_objectSpread({}, SHARING_1), {}, {
+      id: 'shared_drive_group',
+      attributes: _objectSpread(_objectSpread({}, SHARING_1.attributes), {}, {
+        drive: true,
+        members: [{
+          status: 'owner',
+          name: 'Jane Doe',
+          email: 'jane@doe.com',
+          instance: 'http://cozy.tools:8080'
+        }],
+        groups: [{
+          name: 'Last group',
+          addedBy: 0
+        }],
+        rules: [{
+          title: 'My Shared Drive',
+          doctype: 'io.cozy.files',
+          values: ['shared_drive_group_folder'],
+          add: 'sync',
+          update: 'sync',
+          remove: 'sync'
+        }]
+      })
+    });
+
+    var sharedDrivePath = '/shared_drive_group_folder';
+    var initialState = reducer(reducer(undefined, receiveSharings({
+      sharings: [SHARED_DRIVE_WITH_GROUP]
+    })), addSharing(SHARED_DRIVE_WITH_GROUP, sharedDrivePath));
+    var state = reducer(initialState, revokeGroup(SHARED_DRIVE_WITH_GROUP, 0, sharedDrivePath));
+    expect(state.byDocId).toEqual({});
+    expect(state.sharings).toEqual([]);
+    expect(state.sharedPaths).toEqual([]);
+  });
+  it('should forget a shared drive when revoking last recipient', function () {
     var SHARED_DRIVE_WITH_ONE_RECIPIENT = _objectSpread(_objectSpread({}, SHARING_1), {}, {
       id: 'shared_drive_one_recipient',
       attributes: _objectSpread(_objectSpread({}, SHARING_1.attributes), {}, {
@@ -178,23 +208,10 @@ describe('Sharing state', function () {
     var initialState = reducer(reducer(undefined, receiveSharings({
       sharings: [SHARED_DRIVE_WITH_ONE_RECIPIENT]
     })), addSharing(SHARED_DRIVE_WITH_ONE_RECIPIENT, sharedDrivePath));
-
-    var sharingAfterRevoke = _objectSpread(_objectSpread({}, SHARED_DRIVE_WITH_ONE_RECIPIENT), {}, {
-      attributes: _objectSpread(_objectSpread({}, SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes), {}, {
-        members: [SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes.members[0], _objectSpread(_objectSpread({}, SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes.members[1]), {}, {
-          status: 'revoked'
-        })]
-      })
-    });
-
-    var state = reducer(initialState, revokeRecipient(sharingAfterRevoke, 1, sharedDrivePath));
-    expect(state.sharedPaths).toContain(sharedDrivePath);
-    expect(state.byDocId).toEqual({
-      shared_drive_folder: {
-        sharings: [SHARED_DRIVE_WITH_ONE_RECIPIENT.id],
-        permissions: []
-      }
-    });
+    var state = reducer(initialState, revokeRecipient(SHARED_DRIVE_WITH_ONE_RECIPIENT, 1, sharedDrivePath));
+    expect(state.byDocId).toEqual({});
+    expect(state.sharings).toEqual([]);
+    expect(state.sharedPaths).toEqual([]);
   });
   it('should index received permissions', function () {
     var state = reducer(undefined, receiveSharings({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "33.6.0",
+  "version": "33.6.1",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -83,5 +83,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "fc451fb2e649fffe6bfc8f16ff812ba4c31531cf"
+  "gitHead": "10aa2298384087fd396bbfce29c1198d80244361"
 }

package/src/SharingProvider.spec.jsx

@@ -5,7 +5,12 @@ import { createMockClient } from 'cozy-client'
 
 import { SharingProvider } from './SharingProvider'
 import SharingContext from './context'
-import reducer, { addSharingLink, getDocumentPermissions } from './state'
+import reducer, {
+  addSharingLink,
+  getDocumentPermissions,
+  getDocumentSharing,
+  receiveSharings
+} from './state'
 import AppLike from '../test/AppLike'
 
 const AppWrapper = ({ children, client, isPublic }) => {
@@ -291,6 +296,115 @@ describe('updateDocumentPermissions', () => {
   })
 })
 
+describe('shared drive recipient revocation', () => {
+  const SHARED_DRIVE = {
+    _id: 'sharing_123',
+    id: 'sharing_123',
+    type: 'io.cozy.sharings',
+    attributes: {
+      drive: true,
+      owner: true,
+      description: 'Shared folder',
+      rules: [
+        {
+          title: 'Shared folder',
+          doctype: 'io.cozy.files',
+          values: ['folder_123'],
+          add: 'none',
+          update: 'none',
+          remove: 'none'
+        }
+      ],
+      members: [
+        {
+          status: 'owner',
+          email: 'owner@cozy.local',
+          instance: 'http://cozy.local'
+        },
+        {
+          status: 'pending',
+          email: 'recipient@cozy.local',
+          instance: 'http://recipient.cozy.local'
+        }
+      ]
+    }
+  }
+  const NEW_SHARING = {
+    ...SHARED_DRIVE,
+    _id: 'sharing_456',
+    id: 'sharing_456'
+  }
+  const document = {
+    _id: 'folder_123',
+    id: 'folder_123',
+    path: '/Shared folder'
+  }
+  const recipient = {
+    _id: 'contact_123',
+    id: 'contact_123',
+    _type: 'io.cozy.contacts',
+    email: 'recipient@cozy.local'
+  }
+
+  let provider
+  let sharingCol
+
+  beforeEach(() => {
+    const mockClient = createMockClient({})
+    mockClient.getStackClient = () => ({ uri: 'http://cozy.local' })
+    mockClient.collection = jest.fn().mockReturnValue({})
+
+    provider = new SharingProvider({ client: mockClient })
+    provider.state = {
+      ...provider.state,
+      ...reducer(undefined, receiveSharings({ sharings: [SHARED_DRIVE] }))
+    }
+    provider.dispatch = jest.fn(action => {
+      provider.state = {
+        ...provider.state,
+        ...reducer(provider.state, action)
+      }
+    })
+    sharingCol = {
+      addRecipients: jest.fn(),
+      create: jest.fn().mockResolvedValue({ data: NEW_SHARING }),
+      revokeRecipient: jest.fn().mockResolvedValue({})
+    }
+    provider.sharingCol = sharingCol
+  })
+
+  it('forgets the shared drive when revoking its last recipient', async () => {
+    await provider.revoke(document, SHARED_DRIVE.id, 1)
+
+    expect(sharingCol.revokeRecipient).toHaveBeenCalledWith(SHARED_DRIVE, 1)
+    expect(getDocumentSharing(provider.state, document.id)).toBeNull()
+  })
+
+  it('creates a new sharing when re-adding after the last recipient was revoked', async () => {
+    await provider.revoke(document, SHARED_DRIVE.id, 1)
+
+    await provider.share({
+      document,
+      recipients: [recipient],
+      readOnlyRecipients: [],
+      description: 'Shared folder',
+      openSharing: true,
+      sharedDrive: true
+    })
+
+    expect(sharingCol.addRecipients).not.toHaveBeenCalled()
+    expect(sharingCol.create).toHaveBeenCalledWith({
+      document,
+      recipients: [recipient],
+      readOnlyRecipients: [],
+      description: 'Shared folder',
+      previewPath: '/preview',
+      openSharing: true,
+      sharedDrive: true
+    })
+  })
+})
+
 describe('fetchSharedDriveSharingLinks', () => {
   const PERM_DRIVE_FILE = {
     type: 'io.cozy.permissions',

package/src/state.js

@@ -184,10 +184,7 @@ const byDocId = (state = {}, action) => {
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
     case UPDATE_SHARING:
-      if (
-        !isSharingADrive(action.sharing) &&
-        areAllRecipientsRevoked(action.sharing)
-      ) {
+      if (areAllRecipientsRevoked(action.sharing)) {
         return forgetSharing(state, action.sharing)
       }
       return state
@@ -258,10 +255,7 @@ const sharings = (state = [], action) => {
     case UPDATE_SHARING:
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
-      if (
-        !isSharingADrive(action.sharing) &&
-        areAllRecipientsRevoked(action.sharing)
-      ) {
+      if (areAllRecipientsRevoked(action.sharing)) {
         return state.filter(s => s.id !== action.sharing.id)
       }
       return state.map(s => {
@@ -287,10 +281,8 @@ const sharedPaths = (state = [], action) => {
       return newState
     case REVOKE_GROUP:
     case REVOKE_RECIPIENT:
-      if (
-        !isSharingADrive(action.sharing) &&
-        areAllRecipientsRevoked(action.sharing)
-      ) {
+    case UPDATE_SHARING:
+      if (areAllRecipientsRevoked(action.sharing)) {
         return state.filter(p => p !== action.path)
       }
       return state

package/src/state.spec.js

@@ -6,6 +6,7 @@ import reducer, {
   revokeSharingLink,
   getRecipients,
   getRecipientsFromSharing,
+  revokeGroup,
   revokeRecipient,
   revokeSelf,
   updateSharing,
@@ -143,7 +144,7 @@ describe('Sharing state', () => {
     expect(state.sharings).toEqual([SHARING_1, SHARED_DRIVE_WITHOUT_RECIPIENTS])
   })
 
-  it('should not forget shared drives without recipients when updating', () => {
+  it('should forget shared drives without recipients when updating', () => {
     const SHARED_DRIVE_WITHOUT_RECIPIENTS = {
       ...SHARING_1,
       id: 'shared_drive_no_recipients',
@@ -184,16 +185,65 @@ describe('Sharing state', () => {
       }
     }
     const state = reducer(initialState, updateSharing(updatedSharing))
-    expect(state.byDocId).toEqual({
-      shared_drive_folder: {
-        sharings: [SHARED_DRIVE_WITHOUT_RECIPIENTS.id],
-        permissions: []
+
+    expect(state.byDocId).toEqual({})
+    expect(state.sharings).toEqual([])
+  })
+
+  it('should forget a shared drive when revoking its last group', () => {
+    const SHARED_DRIVE_WITH_GROUP = {
+      ...SHARING_1,
+      id: 'shared_drive_group',
+      attributes: {
+        ...SHARING_1.attributes,
+        drive: true,
+        members: [
+          {
+            status: 'owner',
+            name: 'Jane Doe',
+            email: 'jane@doe.com',
+            instance: 'http://cozy.tools:8080'
+          }
+        ],
+        groups: [
+          {
+            name: 'Last group',
+            addedBy: 0
+          }
+        ],
+        rules: [
+          {
+            title: 'My Shared Drive',
+            doctype: 'io.cozy.files',
+            values: ['shared_drive_group_folder'],
+            add: 'sync',
+            update: 'sync',
+            remove: 'sync'
+          }
+        ]
       }
-    })
-    expect(state.sharings).toEqual([updatedSharing])
+    }
+    const sharedDrivePath = '/shared_drive_group_folder'
+    const initialState = reducer(
+      reducer(
+        undefined,
+        receiveSharings({
+          sharings: [SHARED_DRIVE_WITH_GROUP]
+        })
+      ),
+      addSharing(SHARED_DRIVE_WITH_GROUP, sharedDrivePath)
+    )
+    const state = reducer(
+      initialState,
+      revokeGroup(SHARED_DRIVE_WITH_GROUP, 0, sharedDrivePath)
+    )
+
+    expect(state.byDocId).toEqual({})
+    expect(state.sharings).toEqual([])
+    expect(state.sharedPaths).toEqual([])
   })
 
-  it('should not remove shared drive path when revoking last recipient', () => {
+  it('should forget a shared drive when revoking last recipient', () => {
     const SHARED_DRIVE_WITH_ONE_RECIPIENT = {
       ...SHARING_1,
       id: 'shared_drive_one_recipient',
@@ -236,30 +286,14 @@ describe('Sharing state', () => {
       ),
       addSharing(SHARED_DRIVE_WITH_ONE_RECIPIENT, sharedDrivePath)
     )
-    const sharingAfterRevoke = {
-      ...SHARED_DRIVE_WITH_ONE_RECIPIENT,
-      attributes: {
-        ...SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes,
-        members: [
-          SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes.members[0],
-          {
-            ...SHARED_DRIVE_WITH_ONE_RECIPIENT.attributes.members[1],
-            status: 'revoked'
-          }
-        ]
-      }
-    }
     const state = reducer(
       initialState,
-      revokeRecipient(sharingAfterRevoke, 1, sharedDrivePath)
+      revokeRecipient(SHARED_DRIVE_WITH_ONE_RECIPIENT, 1, sharedDrivePath)
     )
-    expect(state.sharedPaths).toContain(sharedDrivePath)
-    expect(state.byDocId).toEqual({
-      shared_drive_folder: {
-        sharings: [SHARED_DRIVE_WITH_ONE_RECIPIENT.id],
-        permissions: []
-      }
-    })
+
+    expect(state.byDocId).toEqual({})
+    expect(state.sharings).toEqual([])
+    expect(state.sharedPaths).toEqual([])
   })
 
   it('should index received permissions', () => {