fix(files): address the paged file reads' third review round

- Type labels and extension MIME types read their tables by own key only, so a type or extension
  such as `constructor` or `__proto__` never resolves to an `Object.prototype` member; the
  parity test covers them.
- A serve URL's fragment, like its query, is no part of its storage key.
- Workflow search-replace offers only files answering what is typed now — the recent files with
  nothing typed, else the settled matches for the current query — never a previous query's
  (`currentFiles`).

Author: waleedlatif1

apps/sim/hooks/queries/workflow-search-replace.ts

@@ -712,10 +712,15 @@ export function useWorkflowSearchFileReplacementOptions(
     [matches]
   )
   const enabled = Boolean(workspaceId && fileGroups.length > 0)
-  const { files: offered } = useWorkspaceFilePickerOptions(workspaceId ?? '', options.query, {
-    limit: RECENT_REPLACEMENT_FILE_LIMIT,
-    enabled,
-  })
+  /** Never a previous query's matches: a choice offered must answer what is typed now. */
+  const { currentFiles: offered } = useWorkspaceFilePickerOptions(
+    workspaceId ?? '',
+    options.query,
+    {
+      limit: RECENT_REPLACEMENT_FILE_LIMIT,
+      enabled,
+    }
+  )
   const chosenKeys = useMemo(
     () =>
       options.chosen.flatMap((value) => {

apps/sim/hooks/queries/workspace-files.test.tsx

@@ -850,6 +850,7 @@ describe('useWorkspaceFilePickerOptions', () => {
       await vi.waitFor(() => expect(hook.result().files?.map((file) => file.id)).toEqual(['match']))
       expect(hook.result().matchedQuery).toBe('mat')
       expect(hook.result().isPending).toBe(false)
+      expect(hook.result().currentFiles?.map((file) => file.id)).toEqual(['match'])
     } finally {
       hook.unmount()
     }
@@ -873,6 +874,8 @@ describe('useWorkspaceFilePickerOptions', () => {
       await vi.waitFor(() => expect(mockRequestJson).toHaveBeenCalledTimes(3))
       expect(hook.result().files?.map((file) => file.id)).toEqual(['match'])
       expect(hook.result().matchedQuery).toBe('')
+      /** What is offered as-is never holds the previous query's matches. */
+      expect(hook.result().currentFiles).toBeUndefined()
     } finally {
       hook.unmount()
     }

apps/sim/hooks/queries/workspace-files.ts

@@ -499,6 +499,13 @@ export interface WorkspaceFilePickerOptions {
    * `files` are the recent files, or a previous query's matches held while the next loads.
    */
   matchedQuery: string
+  /**
+   * `files` only while they answer exactly what is typed now: the recent files with nothing
+   * typed, the server's matches once they are in for the current query — never a previous
+   * query's matches, nor the recent files while a query settles. For a caller that offers the
+   * files as they are rather than filtering them.
+   */
+  currentFiles: WorkspaceFileRecord[] | undefined
   /** True until `files` answers what was typed: a menu still empty here is not "no match" yet. */
   isPending: boolean
 }
@@ -526,9 +533,13 @@ export function useWorkspaceFilePickerOptions(
     { q: settledQuery, limit: WORKSPACE_FILE_PICKER_LIMIT },
     { enabled }
   )
+  const files = settledQuery ? matching.data : recent.data?.pages[0]?.files
+  const matchedQuery =
+    settledQuery && matching.data && !matching.isPlaceholderData ? settledQuery : ''
   return {
-    files: settledQuery ? matching.data : recent.data?.pages[0]?.files,
-    matchedQuery: settledQuery && matching.data && !matching.isPlaceholderData ? settledQuery : '',
+    files,
+    matchedQuery,
+    currentFiles: !typed || matchedQuery === typed ? files : undefined,
     isPending: settledQuery
       ? typed !== settledQuery || matching.isFetching
       : recent.isPending || typed.length > 0,

apps/sim/lib/uploads/utils/file.test.ts

@@ -196,6 +196,15 @@ describe('storageKeyOfStoredValue', () => {
     )
   })
 
+  it("drops a serve URL's fragment as well as its query", () => {
+    expect(storageKeyOfStoredValue('/api/files/serve/workspace%2Fws-1%2Fa.png#page=2')).toBe(
+      'workspace/ws-1/a.png'
+    )
+    expect(
+      storageKeyOfStoredValue('/api/files/serve/workspace%2Fws-1%2Fa.png?context=workspace#x')
+    ).toBe('workspace/ws-1/a.png')
+  })
+
   it('keeps any other value whole, `?` and `#` included', () => {
     expect(storageKeyOfStoredValue('workspace/ws-1/what?.md')).toBe('workspace/ws-1/what?.md')
     expect(storageKeyOfStoredValue('notes #1?.md')).toBe('notes #1?.md')

apps/sim/lib/uploads/utils/file.ts

@@ -413,7 +413,9 @@ function identifiesFormat(declared: string | undefined): declared is string {
  * Get MIME type from file extension (fallback if not provided)
  */
 export function getMimeTypeFromExtension(extension: string): string {
-  return EXTENSION_TO_MIME[extension.toLowerCase()] || GENERIC_MIME_TYPE
+  const key = extension.toLowerCase()
+  // Own keys only: an extension such as `constructor` must not read an `Object.prototype` member.
+  return (Object.hasOwn(EXTENSION_TO_MIME, key) && EXTENSION_TO_MIME[key]) || GENERIC_MIME_TYPE
 }
 
 /**
@@ -435,7 +437,9 @@ export function resolveEffectiveMimeType(
   if (identifiesFormat(declared)) return declared
 
   const extension = getFileExtension(filename)
-  return DUAL_CONTAINER_MIME[extension] ?? getMimeTypeFromExtension(extension)
+  return Object.hasOwn(DUAL_CONTAINER_MIME, extension)
+    ? DUAL_CONTAINER_MIME[extension]
+    : getMimeTypeFromExtension(extension)
 }
 
 const MEDIA_FALLBACK_MIME = { audio: 'audio/mpeg', video: 'video/mp4' } as const
@@ -694,7 +698,8 @@ export function extractStorageKey(filePath: string): string {
 export function storageKeyOfStoredValue(value: string): string | undefined {
   if (!isInternalFileUrl(value)) return value
   try {
-    return extractStorageKey(value)
+    // The key is the path alone: a URL's query and fragment are no part of it.
+    return extractStorageKey(value.split(/[?#]/, 1)[0])
   } catch {
     return undefined
   }

apps/sim/lib/workspace-files/__integration__/file-listing.integration.ts

@@ -704,6 +704,10 @@ describe('bounded workspace file reads in PostgreSQL', () => {
         { name: 'clip.bin', contentType: 'video/ogg' },
         { name: 'song.bin', contentType: 'Audio/X-Unlisted; rate=44100' },
         { name: 'clip.vid', contentType: 'video/x-unlisted' },
+        { name: 'file.constructor', contentType: '' },
+        { name: 'file.__proto__', contentType: 'application/octet-stream' },
+        { name: 'noext', contentType: 'constructor' },
+        { name: 'noext', contentType: 'toString' },
         { name: 'file.foo', contentType: 'application/octet-stream' },
         { name: 'file.foo', contentType: '' },
       ]

apps/sim/lib/workspace-files/browser.test.ts

@@ -31,3 +31,12 @@ describe('fileBrowserKinds', () => {
     expect(fileBrowserKinds('application/octet-stream', 'notes.md').has('document')).toBe(true)
   })
 })
+
+describe('table lookups by name', () => {
+  it('never reads an Object.prototype member as a label or a MIME type', () => {
+    expect(fileBrowserTypeLabel('constructor', 'noext')).toBe('constructor')
+    expect(fileBrowserTypeLabel('toString', 'noext')).toBe('toString')
+    expect(fileBrowserMimeType('', 'file.constructor')).toBe(fileBrowserMimeType('', 'file.zzz'))
+    expect(fileBrowserTypeLabel('', 'file.__proto__')).toBe('__PROTO__')
+  })
+})

apps/sim/lib/workspace-files/browser.ts

@@ -98,8 +98,8 @@ export function fileBrowserKinds(storedType: string, filename: string): Set<File
  */
 export function fileBrowserTypeLabel(storedType: string, filename: string): string {
   const mimeType = fileBrowserMimeType(storedType, filename)
-  const label = FILE_BROWSER_MIME_LABELS[mimeType]
-  if (label) return label
+  // Own keys only, as the SQL twin's `jsonb ->>` reads them: `constructor` is no label.
+  if (Object.hasOwn(FILE_BROWSER_MIME_LABELS, mimeType)) return FILE_BROWSER_MIME_LABELS[mimeType]
   if (mimeType.startsWith('audio/')) return 'Audio'
   if (mimeType.startsWith('video/')) return 'Video'
   if (mimeType.startsWith('image/')) return 'Image'

packages/testing/src/mocks/file-utils.mock.ts

@@ -377,7 +377,8 @@ function extractStorageKey(filePath: string): string {
 function storageKeyOfStoredValue(value: string): string | undefined {
   if (!isInternalFileUrl(value)) return value
   try {
-    return extractStorageKey(value)
+    // The key is the path alone: a URL's query and fragment are no part of it.
+    return extractStorageKey(value.split(/[?#]/, 1)[0])
   } catch {
     return undefined
   }