fix(files): stop a content save from resurrecting a stale contentType

updateWorkspaceFileContent read the row before taking the FOR UPDATE lock, then
wrote that read's contentType back inside the transaction. A save overlapping a
type change therefore restored the pre-change type, leaving the file named .txt
while still stored as text/markdown.

A content write carries no opinion about the file's type unless the caller says
so, so the column is now only written when a contentType is supplied. The
live-doc markdown gate reads the committed row for the same reason.

Author: mzxchandra

apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts

@@ -1389,7 +1389,12 @@ export async function updateWorkspaceFileContent(
           .set({
             key: uploadResult.key,
             size: content.length,
-            contentType: nextContentType,
+            // Only written when the caller actually declared a type. `nextContentType` falls back to
+            // a read taken BEFORE this row was locked, so writing it unconditionally lets a content
+            // save that overlaps a retype resurrect the pre-retype type — the file ends up named
+            // `.txt` while still stored as `text/markdown`. A content write carries no opinion about
+            // the file's type unless it says so, so leave the committed value alone.
+            ...(contentType ? { contentType } : {}),
             // Replaced bytes: drop the old image's dimensions so the row never describes stale content.
             // The next view reserves nothing (the baseline first-load reflow) rather than a wrong-sized
             // box, then the browser's measurement backfills the correct value. No server-side decode here
@@ -1479,7 +1484,7 @@ export async function updateWorkspaceFileContent(
     // persist and empty-shell creates pass `syncLiveDoc: false` to stay out of it.
     if (
       options?.syncLiveDoc !== false &&
-      isMarkdownFile({ type: nextContentType, name: finalized.file.originalName })
+      isMarkdownFile({ type: finalized.file.contentType, name: finalized.file.originalName })
     ) {
       // Pass the new CONTENT version this write produced, so the relay records that its live doc now
       // incorporates this durable version — the collab persist's optimistic-concurrency guard then won't

apps/sim/lib/uploads/contexts/workspace/workspace-file-storage-accounting.test.ts

@@ -407,6 +407,45 @@ describe('workspace file metadata and storage accounting', () => {
     expect(dbChainMockFns.transaction).not.toHaveBeenCalled()
   })
 
+  /**
+   * A content write reads the row BEFORE taking the FOR UPDATE lock. If it wrote that stale
+   * `contentType` back, a save overlapping a type change would resurrect the pre-change type and
+   * leave the file named `.txt` while stored as `text/markdown`.
+   */
+  it('leaves contentType alone when the caller declares none', async () => {
+    const retypedFile = { ...FILE_ROW, originalName: 'note.md', contentType: 'text/markdown' }
+    dbChainMockFns.limit.mockResolvedValueOnce([FILE_ROW]).mockResolvedValueOnce([retypedFile])
+    dbChainMockFns.returning.mockResolvedValueOnce([{ ...retypedFile, size: 10 }])
+    mockUploadFile.mockResolvedValueOnce({ key: `${FILE_ROW.key}-replacement` })
+
+    const updated = await updateWorkspaceFileContent(
+      FILE_ROW.workspaceId,
+      FILE_ROW.id,
+      FILE_ROW.userId,
+      Buffer.alloc(10)
+    )
+
+    const written = dbChainMockFns.set.mock.calls.at(-1)?.[0] as Record<string, unknown>
+    expect(written).not.toHaveProperty('contentType')
+    expect(updated.type).toBe('text/markdown')
+  })
+
+  it('writes contentType when the caller declares one', async () => {
+    dbChainMockFns.limit.mockResolvedValueOnce([FILE_ROW]).mockResolvedValueOnce([FILE_ROW])
+    dbChainMockFns.returning.mockResolvedValueOnce([{ ...FILE_ROW, contentType: 'text/csv' }])
+    mockUploadFile.mockResolvedValueOnce({ key: `${FILE_ROW.key}-replacement` })
+
+    await updateWorkspaceFileContent(
+      FILE_ROW.workspaceId,
+      FILE_ROW.id,
+      FILE_ROW.userId,
+      Buffer.alloc(10),
+      'text/csv'
+    )
+
+    expect(dbChainMockFns.set.mock.calls.at(-1)?.[0]).toMatchObject({ contentType: 'text/csv' })
+  })
+
   it('uploads an overwrite before atomically swapping the locked row and exact delta', async () => {
     const concurrentFile = { ...FILE_ROW, size: 7 }
     const replacementKey = `${FILE_ROW.key}-replacement`