cozy-sharing 28.5.0 → 28.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-sharing",
-  "version": "28.5.0",
+  "version": "28.6.0",
   "description": "Provides sharing login for React applications.",
   "main": "dist/index.js",
   "author": "Cozy",
@@ -83,5 +83,5 @@
   "sideEffects": [
     "*.css"
   ],
-  "gitHead": "598f2e27b115ca69eda056332c6ab91fa92096d3"
+  "gitHead": "64311a9d08372224b5214cbf49f7d658d93f9af9"
 }

package/src/SharingProvider.jsx

@@ -94,7 +94,8 @@ export class SharingProvider extends Component {
       revokeAllRecipients: this.revokeAllRecipients,
       refresh: this.fetchAllSharings,
       hasWriteAccess: this.hasWriteAccess,
-      renameSharedDrive: this.renameSharedDrive
+      renameSharedDrive: this.renameSharedDrive,
+      updateSharingMemberType: this.updateSharingMemberType
     }
     this.isPublic = props.isPublic ?? false
     this.realtime = null
@@ -339,6 +340,55 @@ export class SharingProvider extends Component {
     this.dispatch(revokeSelf(sharing))
   }
 
+  /**
+   * Update a sharing member's read_only field to change permission type
+   * @param {string} sharingId - The ID of the sharing
+   * @param {number} memberIndex - The index of the member in the sharing members array
+   * @param {string} newType - 'one-way' for read-only, 'two-way' for read-write
+   */
+  updateSharingMemberType = async (sharingId, memberIndex, newType) => {
+    const sharing = getSharingById(this.state, sharingId)
+    if (!sharing) throw new Error('Sharing not found')
+
+    const member = sharing.attributes.members[memberIndex]
+    if (!member) throw new Error('Member not found')
+
+    // Find the contact by email (same pattern as helpers/contacts.js)
+    const matchedContacts = await this.props.client
+      .collection('io.cozy.contacts')
+      .find(
+        {
+          email: { $elemMatch: { address: member.email } },
+          _id: { $gt: null }
+        },
+        { indexedFields: ['_id'] }
+      )
+
+    if (!matchedContacts.data.length) {
+      throw new Error(`Contact not found for member ${member.email}`)
+    }
+    const contact = matchedContacts.data[0]
+
+    // Revoke (API call only, no state dispatch to avoid UI flickering)
+    await this.sharingCol.revokeRecipient(sharing, memberIndex)
+
+    // Re-add with the new permission type
+    const readOnly = newType === 'one-way'
+    try {
+      await this.addRecipients({
+        document: sharing,
+        recipients: readOnly ? [] : [contact],
+        readOnlyRecipients: readOnly ? [contact] : []
+      })
+    } catch (error) {
+      log.error(
+        `Failed to re-add member ${member.email} after revocation. The member has been revoked but could not be re-added with the new permission type.`,
+        error
+      )
+      throw error
+    }
+  }
+
   shareByLink = async (document, options) => {
     const resp = document.driveId
       ? await this.createSharedDriveSharingLink(document, options)

package/src/SharingProvider.spec.jsx

@@ -234,6 +234,100 @@ describe('updateDocumentPermissions', () => {
   })
 })
 
+describe('updateSharingMemberType', () => {
+  const mockContact = { _id: 'contact-1', email: [{ address: 'bob@bob.cozy' }] }
+  const mockSharing = {
+    id: 'sharing-123',
+    type: 'io.cozy.sharings',
+    attributes: {
+      members: [
+        { status: 'owner', email: 'owner@cozy.local' },
+        { status: 'ready', email: 'bob@bob.cozy' }
+      ]
+    }
+  }
+
+  let instance
+  let mockContactsCollection
+
+  beforeEach(() => {
+    mockContactsCollection = {
+      find: jest.fn().mockResolvedValue({ data: [mockContact] })
+    }
+
+    const mockClient = {
+      getStackClient: () => ({ uri: 'http://cozy.local' }),
+      collection: jest.fn().mockReturnValue(mockContactsCollection)
+    }
+
+    instance = new SharingProvider({ client: mockClient })
+    instance.state = {
+      ...instance.state,
+      sharings: [mockSharing]
+    }
+    instance.sharingCol = {
+      revokeRecipient: jest.fn().mockResolvedValue({})
+    }
+    jest.spyOn(instance, 'addRecipients').mockResolvedValue({})
+  })
+
+  it('should throw when sharing is not found', async () => {
+    await expect(
+      instance.updateSharingMemberType('unknown-id', 1, 'one-way')
+    ).rejects.toThrow('Sharing not found')
+  })
+
+  it('should throw when member is not found', async () => {
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 99, 'one-way')
+    ).rejects.toThrow('Member not found')
+  })
+
+  it('should throw when contact is not found', async () => {
+    mockContactsCollection.find.mockResolvedValue({ data: [] })
+
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+    ).rejects.toThrow('Contact not found')
+  })
+
+  it('should revoke and re-add with readOnly when switching to one-way', async () => {
+    await instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+
+    expect(instance.sharingCol.revokeRecipient).toHaveBeenCalledWith(
+      mockSharing,
+      1
+    )
+    expect(instance.addRecipients).toHaveBeenCalledWith({
+      document: mockSharing,
+      recipients: [],
+      readOnlyRecipients: [mockContact]
+    })
+  })
+
+  it('should revoke and re-add as read-write when switching to two-way', async () => {
+    await instance.updateSharingMemberType('sharing-123', 1, 'two-way')
+
+    expect(instance.sharingCol.revokeRecipient).toHaveBeenCalledWith(
+      mockSharing,
+      1
+    )
+    expect(instance.addRecipients).toHaveBeenCalledWith({
+      document: mockSharing,
+      recipients: [mockContact],
+      readOnlyRecipients: []
+    })
+  })
+
+  it('should rethrow error if addRecipients fails after revocation', async () => {
+    instance.addRecipients.mockRejectedValue(new Error('Network error'))
+
+    await expect(
+      instance.updateSharingMemberType('sharing-123', 1, 'one-way')
+    ).rejects.toThrow('Network error')
+  })
+})
+
 // TODO Convert with react-testing-library
 // describe('hasWriteAccess', () => {
 //   it('tells if a doc is writtable', () => {

package/src/components/Recipient/LinkRecipient.jsx

@@ -26,8 +26,7 @@ const LinkRecipient = props => {
   const { isMobile } = useBreakpoints()
   const { getDocumentPermissions } = useSharingContext()
 
-  const { recipientConfirmationData, verifyRecipient, link, fadeIn, document } =
-    props
+  const { recipientConfirmationData, verifyRecipient, fadeIn, document } = props
 
   const permissions = getDocumentPermissions(document?._id)
   const hasPassword = checkIsPermissionHasPassword(permissions)
@@ -44,7 +43,7 @@ const LinkRecipient = props => {
     ? t('Share.recipients.expires', {
         date: dateFormatted
       })
-    : link
+    : ''
 
   const RightPart = recipientConfirmationData ? (
     <RecipientConfirm
@@ -74,7 +73,14 @@ const LinkRecipient = props => {
 }
 
 LinkRecipient.propTypes = {
-  link: PropTypes.string.isRequired
+  recipientConfirmationData: PropTypes.oneOfType([
+    PropTypes.bool,
+    PropTypes.object
+  ]),
+  verifyRecipient: PropTypes.func,
+  fadeIn: PropTypes.bool,
+  document: PropTypes.object,
+  permissions: PropTypes.arrayOf(PropTypes.object)
 }
 
 export default LinkRecipient

package/src/components/Recipient/LinkRecipient.stories.jsx

@@ -5,7 +5,6 @@ const meta = {
   args: {
     recipientConfirmationData: false,
     verifyRecipient: () => true,
-    link: 'test',
     fadeIn: false
   }
 }

package/src/components/Recipient/MemberRecipient.spec.jsx

@@ -6,6 +6,17 @@ import { createMockClient } from 'cozy-client'
 import MemberRecipient from './MemberRecipient'
 import AppLike from '../../../test/AppLike'
 
+const mockUpdateDocumentPermissions = jest.fn()
+const mockUpdateSharingMemberType = jest.fn()
+
+jest.mock('../../hooks/useSharingContext', () => ({
+  // eslint-disable-next-line react/display-name
+  useSharingContext: () => ({
+    updateDocumentPermissions: mockUpdateDocumentPermissions,
+    updateSharingMemberType: mockUpdateSharingMemberType
+  })
+}))
+
 describe('MemberRecipient component', () => {
   const client = createMockClient({})
   client.options = {

package/src/components/Recipient/MemberRecipientPermissions.jsx

@@ -2,6 +2,7 @@ import React, { useState, useRef, useCallback } from 'react'
 import { useI18n } from 'twake-i18n'
 
 import { useClient } from 'cozy-client'
+import minilog from 'cozy-minilog'
 import ActionsMenu from 'cozy-ui/transpiled/react/ActionsMenu'
 import {
   makeActions,
@@ -10,9 +11,14 @@ import {
 import DropdownButton from 'cozy-ui/transpiled/react/DropdownButton'
 import Spinner from 'cozy-ui/transpiled/react/Spinner'
 import Typography from 'cozy-ui/transpiled/react/Typography'
+import { useAlert } from 'cozy-ui/transpiled/react/providers/Alert'
 
-import { permission } from './actions/permission'
 import { revokeMember } from './actions/revokeMember'
+import { setReadOnlySharedPermission } from './actions/setReadOnlySharedPermission'
+import { setReadWriteSharedPermission } from './actions/setReadWriteSharedPermission'
+import { useSharingContext } from '../../hooks/useSharingContext'
+
+const log = minilog('MemberRecipientPermissions')
 
 const MemberRecipientPermissions = ({
   isOwner,
@@ -30,6 +36,8 @@ const MemberRecipientPermissions = ({
   const { t } = useI18n()
   const buttonRef = useRef()
   const client = useClient()
+  const { updateSharingMemberType } = useSharingContext()
+  const { showAlert } = useAlert()
 
   const [revoking, setRevoking] = useState(false)
   const [isMenuDisplayed, setMenuDisplayed] = useState(false)
@@ -42,27 +50,72 @@ const MemberRecipientPermissions = ({
     !contactIsOwner &&
     ((instanceMatchesClient && !isOwner) || isOwner)
 
-  const toggleMenu = () => setMenuDisplayed(!isMenuDisplayed)
-  const hideMenu = () => setMenuDisplayed(false)
+  const toggleMenu = useCallback(() => {
+    setMenuDisplayed(displayed => !displayed)
+  }, [])
+  const hideMenu = useCallback(() => {
+    setMenuDisplayed(false)
+  }, [])
 
   const handleRevocation = useCallback(async () => {
     setRevoking(true)
-    if (isOwner) {
-      await onRevoke(document, sharingId, memberIndex)
-    } else {
-      await onRevokeSelf(document)
+    try {
+      if (isOwner) {
+        await onRevoke(document, sharingId, memberIndex)
+      } else {
+        await onRevokeSelf(document)
+      }
+    } finally {
+      setRevoking(false)
     }
-    setRevoking(false)
   }, [isOwner, onRevoke, onRevokeSelf, document, sharingId, memberIndex])
 
-  const actions = makeActions([permission, divider, revokeMember], {
-    client,
-    t,
-    type: type ?? 'one-way',
-    isOwner,
-    isSharedDrive,
-    handleRevocation
-  })
+  const setType = useCallback(
+    async newType => {
+      if (newType === type) {
+        hideMenu()
+        return
+      }
+      try {
+        await updateSharingMemberType(sharingId, memberIndex, newType)
+      } catch (error) {
+        log.error('Failed to change member permission type', error)
+        showAlert({
+          message: t('Share.members.error.changePermission'),
+          severity: 'error',
+          variant: 'filled'
+        })
+      }
+      hideMenu()
+    },
+    [
+      hideMenu,
+      memberIndex,
+      sharingId,
+      showAlert,
+      t,
+      type,
+      updateSharingMemberType
+    ]
+  )
+
+  const actions = makeActions(
+    [
+      setReadOnlySharedPermission,
+      setReadWriteSharedPermission,
+      divider,
+      revokeMember
+    ],
+    {
+      client,
+      t,
+      type: type ?? 'one-way',
+      isOwner,
+      isSharedDrive,
+      setType,
+      handleRevocation
+    }
+  )
 
   return (
     <div className={className}>

package/src/components/Recipient/MemberRecipientPermissions.spec.jsx

@@ -0,0 +1,165 @@
+import { render, fireEvent, screen, act, waitFor } from '@testing-library/react'
+import React from 'react'
+
+import { createMockClient } from 'cozy-client'
+
+import MemberRecipientPermissions from './MemberRecipientPermissions'
+import AppLike from '../../../test/AppLike'
+
+const mockUpdateSharingMemberType = jest.fn()
+const mockShowAlert = jest.fn()
+
+jest.mock('../../hooks/useSharingContext', () => ({
+  useSharingContext: () => ({
+    updateSharingMemberType: mockUpdateSharingMemberType
+  })
+}))
+
+jest.mock('cozy-ui/transpiled/react/providers/Alert', () => ({
+  __esModule: true,
+  default: ({ children }) => children,
+  useAlert: () => ({
+    showAlert: mockShowAlert
+  })
+}))
+
+describe('MemberRecipientPermissions component', () => {
+  const client = createMockClient({})
+  client.options = {
+    uri: 'http://cozy.local:8080'
+  }
+
+  const defaultProps = {
+    isOwner: true,
+    isSharedDrive: false,
+    status: 'ready',
+    instance: 'http://cozy.local:8080',
+    type: 'two-way',
+    document: { id: 'doc-123', type: 'io.cozy.files', path: '/test' },
+    sharingId: 'sharing-123',
+    memberIndex: 1,
+    onRevoke: jest.fn(),
+    onRevokeSelf: jest.fn()
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  const setup = props => {
+    return render(
+      <AppLike client={client}>
+        <MemberRecipientPermissions {...defaultProps} {...props} />
+      </AppLike>
+    )
+  }
+
+  let createRangeBackup
+
+  beforeAll(() => {
+    createRangeBackup = global.document.createRange
+    global.document.createRange = jest.fn(() => ({
+      setStart: () => {},
+      setEnd: () => {},
+      commonAncestorContainer: {
+        nodeName: 'BODY',
+        ownerDocument: document
+      }
+    }))
+  })
+
+  afterAll(() => {
+    global.document.createRange = createRangeBackup
+  })
+
+  it('should render the current permission type', () => {
+    setup()
+    expect(screen.getByText('can change')).toBeInTheDocument()
+  })
+
+  it('should call updateSharingMemberType when changing to one-way', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    fireEvent.click(getByText('can change'))
+    fireEvent.click(getByText('Can view'))
+
+    expect(mockUpdateSharingMemberType).toHaveBeenCalledWith(
+      'sharing-123',
+      1,
+      'one-way'
+    )
+  })
+
+  it('should call updateSharingMemberType when changing to two-way', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'one-way' })
+
+    fireEvent.click(getByText('can view'))
+    fireEvent.click(getByText('Can change'))
+
+    expect(mockUpdateSharingMemberType).toHaveBeenCalledWith(
+      'sharing-123',
+      1,
+      'two-way'
+    )
+  })
+
+  it('should show error alert when updateSharingMemberType fails', async () => {
+    mockUpdateSharingMemberType.mockRejectedValue(new Error('Network error'))
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    await act(async () => {
+      fireEvent.click(getByText('can change'))
+      fireEvent.click(getByText('Can view'))
+    })
+
+    await waitFor(() => {
+      expect(mockShowAlert).toHaveBeenCalledWith({
+        message:
+          'An error occurred while changing the permissions. Please try again.',
+        severity: 'error',
+        variant: 'filled'
+      })
+    })
+  })
+
+  it('should not call updateSharingMemberType when selecting same type', async () => {
+    mockUpdateSharingMemberType.mockResolvedValue(undefined)
+
+    const { getByText } = setup({ type: 'two-way' })
+
+    fireEvent.click(getByText('can change'))
+    fireEvent.click(getByText('Can change'))
+
+    expect(mockUpdateSharingMemberType).not.toHaveBeenCalled()
+  })
+
+  it('should not render menu when user is not owner and not the shared drive contact', () => {
+    const { queryByText } = setup({
+      isOwner: false,
+      instance: 'http://other-cozy.local:8080'
+    })
+
+    expect(queryByText('can change')).not.toBeInTheDocument()
+    expect(queryByText('can view')).not.toBeInTheDocument()
+  })
+
+  it('should render menu for owner', () => {
+    const { getByText } = setup({ isOwner: true })
+
+    expect(getByText('can change')).toBeInTheDocument()
+  })
+
+  it('should render menu for the user themselves', () => {
+    const { getByText } = setup({
+      isOwner: false,
+      instance: 'http://cozy.local:8080'
+    })
+
+    expect(getByText('can change')).toBeInTheDocument()
+  })
+})

package/src/components/Recipient/actions/setReadOnlySharedPermission.js

@@ -8,7 +8,7 @@ import Radios from 'cozy-ui/transpiled/react/Radios'
 const makeComponent = ({ label, type, onClick }) => {
   const Component = forwardRef((props, ref) => {
     return (
-      <ActionsMenuItem {...props} ref={ref} button={false} onClick={onClick}>
+      <ActionsMenuItem {...props} ref={ref} onClick={onClick}>
         <ListItemIcon>
           <Radios checked={type === 'one-way'} />
         </ListItemIcon>

package/src/components/Recipient/actions/setReadOnlySharedPermission.spec.jsx

@@ -0,0 +1,95 @@
+import { render, screen, fireEvent } from '@testing-library/react'
+import React from 'react'
+
+import { setReadOnlySharedPermission } from './setReadOnlySharedPermission'
+import AppLike from '../../../../test/AppLike'
+
+const mockT = key => {
+  const translations = {
+    'Share.type.one-way': 'Can view',
+    'Share.type.two-way': 'Can change'
+  }
+  return translations[key] || key
+}
+
+describe('setReadOnlySharedPermission', () => {
+  let setType
+
+  beforeEach(() => {
+    setType = jest.fn()
+  })
+
+  it('should return correct action structure', () => {
+    const action = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType
+    })
+
+    expect(action.name).toBe('setReadOnlySharedPermission')
+    expect(action.label).toBe('Can view')
+    expect(action.icon).toBeNull()
+  })
+
+  it('should call setType with one-way when action is triggered', () => {
+    const action = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType
+    })
+
+    action.action()
+
+    expect(setType).toHaveBeenCalledWith('one-way')
+  })
+
+  it('should render radio as checked when type is one-way', () => {
+    const { Component } = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'one-way',
+      setType
+    })
+
+    render(
+      <AppLike>
+        <Component />
+      </AppLike>
+    )
+
+    expect(screen.getByRole('radio')).toBeChecked()
+  })
+
+  it('should render radio as unchecked when type is two-way', () => {
+    const { Component } = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType
+    })
+
+    render(
+      <AppLike>
+        <Component />
+      </AppLike>
+    )
+
+    expect(screen.getByRole('radio')).not.toBeChecked()
+  })
+
+  it('should call setType with one-way when the component is clicked', () => {
+    const { Component } = setReadOnlySharedPermission({
+      t: mockT,
+      type: 'two-way',
+      setType
+    })
+
+    render(
+      <AppLike>
+        <Component />
+      </AppLike>
+    )
+
+    fireEvent.click(screen.getByText('Can view'))
+
+    expect(setType).toHaveBeenCalledWith('one-way')
+  })
+})

package/src/components/Recipient/actions/setReadWriteSharedPermission.js

@@ -8,7 +8,7 @@ import Radios from 'cozy-ui/transpiled/react/Radios'
 const makeComponent = ({ label, type, onClick }) => {
   const Component = forwardRef((props, ref) => {
     return (
-      <ActionsMenuItem {...props} ref={ref} button={false} onClick={onClick}>
+      <ActionsMenuItem {...props} ref={ref} onClick={onClick}>
         <ListItemIcon>
           <Radios checked={type === 'two-way'} />
         </ListItemIcon>