feat: Make davRootPath and davRemoteURL support public shares

Signed-off-by: Ferdinand Thiessen <opensource@fthiessen.de>

__tests__/dav/dav.spec.ts

@@ -2,7 +2,7 @@
  * SPDX-FileCopyrightText: 2023-2024 Nextcloud GmbH and Nextcloud contributors
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { afterAll, afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 import { readFile } from 'node:fs/promises'
 
 import { File, Folder, davRemoteURL, davGetFavoritesReport, davRootPath, getFavoriteNodes, davResultToNode, NodeStatus } from '../../lib'
@@ -15,10 +15,6 @@ import { URL as FileURL } from 'node:url'
 vi.mock('@nextcloud/auth')
 vi.mock('@nextcloud/router')
 
-afterAll(() => {
- vi.resetAllMocks()
-})
-
 describe('DAV functions', () => {
  test('root path is correct', () => {
  expect(davRootPath).toBe('/files/test')

__tests__/dav/public-shares.spec.ts

@@ -0,0 +1,185 @@
+/**
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type { ArgumentsType } from 'vitest'
+import type { FileStat } from 'webdav'
+import type { davResultToNode } from '../../lib/dav/dav'
+import { beforeEach, describe, expect, test, vi } from 'vitest'
+
+const initialState = vi.hoisted(() => ({ loadState: vi.fn() }))
+const router = vi.hoisted(() => ({ generateRemoteUrl: vi.fn() }))
+const auth = vi.hoisted(() => ({ getCurrentUser: vi.fn() }))
+
+vi.mock('@nextcloud/auth', () => auth)
+vi.mock('@nextcloud/initial-state', () => initialState)
+vi.mock('@nextcloud/router', () => router)
+
+const restoreMocks = () => {
+ vi.resetAllMocks()
+ router.generateRemoteUrl.mockImplementation((service) => `https://example.com/remote.php/${service}`)
+}
+
+const mockPublicShare = () => {
+ auth.getCurrentUser.mockImplementationOnce(() => null)
+ initialState.loadState.mockImplementation((app, key) => {
+ if (key === 'isPublic') {
+ return true
+ } else if (key === 'sharingToken') {
+ return 'token-1234'
+ }
+ throw new Error('Unexpected loadState')
+ })
+}
+
+const mockLegacyPublicShare = () => {
+ initialState.loadState.mockImplementationOnce(() => null)
+ auth.getCurrentUser.mockImplementationOnce(() => null)
+
+ const input = document.createElement('input')
+ input.id = 'isPublic'
+ input.name = 'isPublic'
+ input.type = 'hidden'
+ input.value = '1'
+ document.body.appendChild(input)
+
+ const token = document.createElement('input')
+ token.id = 'sharingToken'
+ token.type = 'hidden'
+ token.value = 'legacy-token'
+ document.body.appendChild(token)
+}
+
+describe('DAV path functions', () => {
+
+ beforeEach(() => {
+ vi.resetModules()
+ restoreMocks()
+ })
+
+ test('root path is correct on public shares', async () => {
+ mockPublicShare()
+
+ const { davGetRootPath } = await import('../../lib/dav/dav')
+ expect(davGetRootPath()).toBe('/files/token-1234')
+ })
+
+ test('root path is correct on legacy public shares', async () => {
+ mockLegacyPublicShare()
+
+ const { davGetRootPath } = await import('../../lib/dav/dav')
+ expect(davGetRootPath()).toBe('/files/legacy-token')
+ })
+
+ test('remote URL is correct on public shares', async () => {
+ mockPublicShare()
+
+ const { davGetRemoteURL } = await import('../../lib/dav/dav')
+ expect(davGetRemoteURL()).toBe('https://example.com/public.php/dav')
+ })
+
+ test('remote URL is correct on public shares', async () => {
+ mockLegacyPublicShare()
+
+ const { davGetRemoteURL } = await import('../../lib/dav/dav')
+ expect(davGetRemoteURL()).toBe('https://example.com/public.php/dav')
+ })
+})
+
+describe('on public shares', () => {
+ beforeEach(() => {
+ vi.resetAllMocks()
+ vi.resetModules()
+ })
+
+ // Wrapper function as we can not static import the function to allow mocking the modules
+ const resultToNode = async (...rest: ArgumentsType<typeof davResultToNode>) => {
+ const { davResultToNode } = await import('../../lib/dav/dav')
+ return davResultToNode(...rest)
+ }
+
+ const isPublicShare = async () => {
+ const { isPublicShare: publicShare } = await import('../../lib')
+ return publicShare()
+ }
+
+ /*
+ * Result of:
+ * davGetClient().getDirectoryContents(`${davRootPath}${path}`, { details: true })
+ */
+ const result: FileStat = {
+ filename: '/files/test/New folder/Neue Textdatei.md',
+ basename: 'Neue Textdatei.md',
+ lastmod: 'Tue, 25 Jul 2023 12:29:34 GMT',
+ size: 123,
+ type: 'file',
+ etag: '7a27142de0a62ed27a7293dbc16e93bc',
+ mime: 'text/markdown',
+ props: {
+ resourcetype: { collection: false },
+ displayname: 'New File',
+ getcontentlength: '123',
+ getcontenttype: 'text/markdown',
+ getetag: '"7a27142de0a62ed27a7293dbc16e93bc"',
+ getlastmodified: 'Tue, 25 Jul 2023 12:29:34 GMT',
+ },
+ }
+
+ describe('isPublicShare', () => {
+ beforeEach(() => {
+ vi.resetModules()
+ restoreMocks()
+ // reset JSDom
+ document.body.innerHTML = ''
+ })
+
+ test('no public share', async () => {
+ initialState.loadState.mockImplementation(() => null)
+
+ expect(await isPublicShare()).toBe(false)
+ expect(initialState.loadState).toBeCalledWith('files_sharing', 'isPublic', null)
+ })
+
+ test('public share', async () => {
+ mockPublicShare()
+
+ expect(await isPublicShare()).toBe(true)
+ expect(initialState.loadState).toBeCalledWith('files_sharing', 'isPublic', null)
+ })
+
+ test('legacy public share', async () => {
+ mockLegacyPublicShare()
+
+ expect(await isPublicShare()).toBe(true)
+ })
+ })
+
+ describe('davResultToNode', () => {
+ beforeEach(() => {
+ vi.resetModules()
+ restoreMocks()
+ })
+
+ test('has correct owner set on public shares', async () => {
+ mockPublicShare()
+
+ const remoteResult = { ...result, filename: '/root/New folder/Neue Textdatei.md' }
+ const node = await resultToNode(remoteResult, '/root', 'http://example.com/remote.php/dav')
+
+ expect(node.isDavRessource).toBe(true)
+ expect(node.owner).toBe('anonymous')
+ expect(initialState.loadState).toBeCalledWith('files_sharing', 'isPublic', null)
+ })
+
+ test('has correct owner set on legacy public shares', async () => {
+ mockLegacyPublicShare()
+
+ const remoteResult = { ...result, filename: '/root/New folder/Neue Textdatei.md' }
+ const node = await resultToNode(remoteResult, '/root', 'http://example.com/remote.php/dav')
+
+ expect(node.isDavRessource).toBe(true)
+ expect(node.owner).toBe('anonymous')
+ })
+ })
+})

lib/dav/dav.ts

@@ -16,7 +16,7 @@ import { getCurrentUser, getRequestToken, onRequestTokenUpdate } from '@nextclou
 import { generateRemoteUrl } from '@nextcloud/router'
 import { CancelablePromise } from 'cancelable-promise'
 import { createClient, getPatcher } from 'webdav'
-import { isPublicShare } from '../utils/isPublic'
+import { getSharingToken, isPublicShare } from '../utils/isPublic'
 
 /**
  * Nextcloud DAV result response
@@ -29,15 +29,39 @@ interface ResponseProps extends DAVResultResponseProps {
  'owner-id': string | number
 }
 
+/**
+ * Get the DAV root path for the current user or public share
+ */
+export function davGetRootPath(): string {
+ if (isPublicShare()) {
+ return `/files/${getSharingToken()}`
+ }
+ return `/files/${getCurrentUser()?.uid}`
+}
+
 /**
  * The DAV root path for the current user
+ * This is a cached version of `davGetRemoteURL`
  */
-export const davRootPath = `/files/${getCurrentUser()?.uid}`
+export const davRootPath = davGetRootPath()
+
+/**
+ * Get the DAV remote URL used as base URL for the WebDAV client
+ * It also handles public shares
+ */
+export function davGetRemoteURL(): string {
+ const url = generateRemoteUrl('dav')
+ if (isPublicShare()) {
+ return url.replace('remote.php', 'public.php')
+ }
+ return url
+}
 
 /**
  * The DAV remote URL used as base URL for the WebDAV client
+ * This is a cached version of `davGetRemoteURL`
  */
-export const davRemoteURL = generateRemoteUrl('dav')
+export const davRemoteURL = davGetRemoteURL()
 
 /**
  * Get a WebDAV client configured to include the Nextcloud request token

lib/utils/isPublic.ts

@@ -4,6 +4,8 @@
  */
 import { loadState } from '@nextcloud/initial-state'
 
+// TODO: Maybe move this to @nextcloud/sharing ?
+
 /**
  * Check if the current page is on a public share
  */
@@ -12,3 +14,12 @@ export function isPublicShare(): boolean {
  return loadState<boolean | null>('files_sharing', 'isPublic', null)
  ?? document.querySelector('input#isPublic[type="hidden"][name="isPublic"][value="1"]') !== null
 }
+
+/**
+ * Get the sharing token for the current public share
+ */
+export function getSharingToken(): string | null {
+ return loadState<string | null>('files_sharing', 'sharingToken', null)
+ ?? document.querySelector<HTMLInputElement>('input#sharingToken[type="hidden"]')?.value
+ ?? null
+}