fix(sync): re-upload an attachment whose Dropbox or self-hosted blob is gone from the device that still holds it, and answer HEAD on cloud attachments (#1119)

Author: dongdongbh

apps/cloud/src/server-attachments.test.ts

@@ -578,3 +578,76 @@ describe('handleAttachmentPathRequest DELETE', () => {
         }
     });
 });
+
+// #1119 attachment presence pass: a client that cannot stop a response body early must be
+// able to ask whether a blob is still there without downloading it.
+describe('handleAttachmentPathRequest HEAD', () => {
+    const withSandbox = async (
+        run: (paths: { rootRealPath: string; filePath: string }) => Promise<void>,
+    ): Promise<void> => {
+        const sandbox = mkdtempSync(join(tmpdir(), 'mindwtr-cloud-attachment-head-'));
+        try {
+            const rootRealPath = join(sandbox, 'attachments');
+            mkdirSync(rootRealPath, { recursive: true });
+            await run({ rootRealPath, filePath: join(rootRealPath, 'file.bin') });
+        } finally {
+            rmSync(sandbox, { recursive: true, force: true });
+        }
+    };
+
+    const head = (paths: { rootRealPath: string; filePath: string }) => handleAttachmentPathRequest(
+        new Request('http://localhost/v1/attachments/file.bin', { method: 'HEAD' }),
+        '/v1/attachments/file.bin',
+        paths,
+        { maxAttachmentBytes: 1024, abortSignal: new AbortController().signal },
+    );
+
+    test('reports a stored attachment with its size and no body', async () => {
+        await withSandbox(async (paths) => {
+            writeFileSync(paths.filePath, 'attachment');
+
+            const response = await head(paths);
+
+            expect(response.status).toBe(200);
+            expect(response.headers.get('content-length')).toBe(String('attachment'.length));
+            expect(response.headers.get('content-type')).toBe('application/octet-stream');
+            expect(await response.arrayBuffer()).toHaveLength(0);
+        });
+    });
+
+    test('answers 404 for an attachment that is not there', async () => {
+        await withSandbox(async (paths) => {
+            const response = await head(paths);
+            expect(response.status).toBe(404);
+        });
+    });
+
+    test('agrees with GET about status and size', async () => {
+        await withSandbox(async (paths) => {
+            writeFileSync(paths.filePath, 'attachment');
+            const getResponse = await handleAttachmentPathRequest(
+                new Request('http://localhost/v1/attachments/file.bin'),
+                '/v1/attachments/file.bin',
+                paths,
+                { maxAttachmentBytes: 1024, abortSignal: new AbortController().signal },
+            );
+            const headResponse = await head(paths);
+
+            expect(headResponse.status).toBe(getResponse.status);
+            expect(headResponse.headers.get('content-length'))
+                .toBe(String((await getResponse.arrayBuffer()).byteLength));
+        });
+    });
+
+    test('never leaves the attachment root, even through a symlink', async () => {
+        await withSandbox(async (paths) => {
+            const outside = join(paths.rootRealPath, '..', 'outside.bin');
+            writeFileSync(outside, 'secret');
+            symlinkSync(outside, paths.filePath);
+
+            const response = await head(paths);
+
+            expect(response.status).toBe(400);
+        });
+    });
+});

apps/cloud/src/server-attachments.ts

@@ -268,10 +268,15 @@ const getBlockedAttachmentSignature = (bytes: Uint8Array): string | null => {
 };
 
 /**
- * Route body for GET/PUT/DELETE /v1/attachments/:path, once withNamespace has already
+ * Route body for HEAD/GET/PUT/DELETE /v1/attachments/:path, once withNamespace has already
  * resolved and validated the on-disk path (see resolveAttachmentPath in
  * server-storage.ts). Takes the resolved path rather than resolving it itself, so it
  * can be exercised directly against a temp directory without a live server.
+ *
+ * HEAD shares GET's body below and drops the bytes at the end. It exists for the #1119
+ * attachment presence pass: a client that cannot stop a response body early (React Native's
+ * XHR transport buffers the whole reply before resolving) would otherwise have to download
+ * every attachment to learn whether it is still there.
  */
 export async function handleAttachmentPathRequest(
     req: Request,
@@ -286,7 +291,7 @@ export async function handleAttachmentPathRequest(
 ): Promise<Response> {
     const { rootRealPath, filePath } = resolved;
 
-    if (req.method === 'GET') {
+    if (req.method === 'GET' || req.method === 'HEAD') {
         options.assertStorageRoot?.();
         if (!existsSync(filePath)) {
             options.assertStorageRoot?.();
@@ -303,6 +308,12 @@ export async function handleAttachmentPathRequest(
             const headers = new Headers();
             headers.set('Access-Control-Allow-Origin', corsOrigin);
             headers.set('Content-Type', 'application/octet-stream');
+            // ponytail: HEAD still reads the file, so its status and Content-Length cannot
+            // disagree with GET's. Stat instead of read if presence checks ever get hot.
+            if (req.method === 'HEAD') {
+                headers.set('Content-Length', String(file.byteLength));
+                return new Response(null, { status: 200, headers });
+            }
             return new Response(file, { status: 200, headers });
         } catch {
             options.assertStorageRoot?.();

apps/cloud/src/server.test.ts

@@ -3758,6 +3758,20 @@ describe('cloud server api', () => {
         const downloaded = new Uint8Array(await getResponse.arrayBuffer());
         expect(Array.from(downloaded)).toEqual(Array.from(payload));
 
+        // #1119 presence pass: HEAD answers the same question without the bytes.
+        const headResponse = await fetch(`${baseUrl}/v1/attachments/folder/file.bin`, {
+            method: 'HEAD',
+            headers: authHeaders,
+        });
+        expect(headResponse.status).toBe(200);
+        expect(headResponse.headers.get('content-length')).toBe(String(payload.byteLength));
+        expect(new Uint8Array(await headResponse.arrayBuffer())).toHaveLength(0);
+
+        const unauthorizedHead = await fetch(`${baseUrl}/v1/attachments/folder/file.bin`, {
+            method: 'HEAD',
+        });
+        expect(unauthorizedHead.status).toBe(401);
+
         const deleteResponse = await fetch(`${baseUrl}/v1/attachments/folder/file.bin`, {
             method: 'DELETE',
             headers: authHeaders,
@@ -3768,6 +3782,12 @@ describe('cloud server api', () => {
             headers: authHeaders,
         });
         expect(missingResponse.status).toBe(404);
+
+        const missingHead = await fetch(`${baseUrl}/v1/attachments/folder/file.bin`, {
+            method: 'HEAD',
+            headers: authHeaders,
+        });
+        expect(missingHead.status).toBe(404);
     });
 
     test('fails a partial attachment upload when the configured storage root is replaced', async () => {

apps/desktop/src/lib/dropbox-sync.ts

@@ -9,6 +9,7 @@ export {
     getDropboxAppDataMetadata,
     getDropboxFileMetadata,
     isDropboxUnauthorizedError,
+    listDropboxFolderFiles,
     testDropboxAccess,
     uploadDropboxAppData,
     uploadDropboxFile,