fix(uploads): idempotent register skips duplicate audit/posthog; add edge-case tests

- registerUploadedWorkspaceFile now returns { file, created } so the route can skip captureServerEvent and recordAudit on idempotent re-register (existing metadata reused). Previously a re-register fired duplicate analytics + audit log entries.
- Add tests covering: idempotent re-register skips audit/analytics, isNetworkError matches econnreset/timeout/etc keywords, multipart complete failure fires action=abort cleanup.

Author: waleedlatif1

apps/sim/app/api/workspaces/[id]/files/register/route.test.ts

@@ -5,6 +5,7 @@
  */
 import {
   auditMock,
+  auditMockFns,
   authMockFns,
   permissionsMock,
   permissionsMockFns,
@@ -72,13 +73,16 @@ describe('POST /api/workspaces/[id]/files/register', () => {
       return match ? match[1] : null
     })
     mockRegisterUploadedWorkspaceFile.mockResolvedValue({
-      id: 'wf_123',
-      name: 'video.mp4',
-      size: 10 * 1024 * 1024,
-      type: 'video/mp4',
-      url: '/api/files/serve/...',
-      key: VALID_KEY,
-      context: 'workspace',
+      file: {
+        id: 'wf_123',
+        name: 'video.mp4',
+        size: 10 * 1024 * 1024,
+        type: 'video/mp4',
+        url: '/api/files/serve/...',
+        key: VALID_KEY,
+        context: 'workspace',
+      },
+      created: true,
     })
   })
 
@@ -134,6 +138,26 @@ describe('POST /api/workspaces/[id]/files/register', () => {
     expect(body.isDuplicate).toBe(true)
   })
 
+  it('skips audit + analytics on idempotent re-register (created=false)', async () => {
+    mockRegisterUploadedWorkspaceFile.mockResolvedValueOnce({
+      file: {
+        id: 'wf_123',
+        name: 'video.mp4',
+        size: 10 * 1024 * 1024,
+        type: 'video/mp4',
+        url: '/api/files/serve/...',
+        key: VALID_KEY,
+        context: 'workspace',
+      },
+      created: false,
+    })
+
+    const res = await POST(makeRequest(validBody), params())
+    expect(res.status).toBe(200)
+    expect(posthogServerMockFns.mockCaptureServerEvent).not.toHaveBeenCalled()
+    expect(auditMockFns.mockRecordAudit).not.toHaveBeenCalled()
+  })
+
   it('finalizes upload, records audit and analytics', async () => {
     const res = await POST(makeRequest(validBody), params())
     const body = await res.json()

apps/sim/app/api/workspaces/[id]/files/register/route.ts

@@ -50,7 +50,7 @@ export const POST = withRouteHandler(
     }
 
     try {
-      const userFile = await registerUploadedWorkspaceFile({
+      const { file: userFile, created } = await registerUploadedWorkspaceFile({
         workspaceId,
         userId,
         key,
@@ -59,28 +59,32 @@ export const POST = withRouteHandler(
         size,
       })
 
-      logger.info(`Registered direct upload ${name} -> ${key}`)
+      if (created) {
+        logger.info(`Registered direct upload ${name} -> ${key}`)
 
-      captureServerEvent(
-        userId,
-        'file_uploaded',
-        { workspace_id: workspaceId, file_type: contentType },
-        { groups: { workspace: workspaceId } }
-      )
+        captureServerEvent(
+          userId,
+          'file_uploaded',
+          { workspace_id: workspaceId, file_type: contentType },
+          { groups: { workspace: workspaceId } }
+        )
 
-      recordAudit({
-        workspaceId,
-        actorId: userId,
-        actorName: session.user.name,
-        actorEmail: session.user.email,
-        action: AuditAction.FILE_UPLOADED,
-        resourceType: AuditResourceType.FILE,
-        resourceId: userFile.id,
-        resourceName: name,
-        description: `Uploaded file "${name}"`,
-        metadata: { fileSize: size, fileType: contentType },
-        request,
-      })
+        recordAudit({
+          workspaceId,
+          actorId: userId,
+          actorName: session.user.name,
+          actorEmail: session.user.email,
+          action: AuditAction.FILE_UPLOADED,
+          resourceType: AuditResourceType.FILE,
+          resourceId: userFile.id,
+          resourceName: name,
+          description: `Uploaded file "${name}"`,
+          metadata: { fileSize: size, fileType: contentType },
+          request,
+        })
+      } else {
+        logger.info(`Idempotent re-register for existing upload ${name} -> ${key}`)
+      }
 
       return NextResponse.json({ success: true, file: userFile })
     } catch (error) {

apps/sim/lib/uploads/client/direct-upload.test.ts

@@ -175,6 +175,52 @@ describe('runUploadStrategy', () => {
     ).rejects.toMatchObject({ name: 'DirectUploadError', code: 'ABORTED' })
   })
 
+  it('fires action=abort when the multipart complete call fails', async () => {
+    const file = makeFile(LARGE_THRESHOLD + ONE_MB)
+    const calls: Array<{ url: string }> = []
+
+    const fetchMock = vi.fn(async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      calls.push({ url })
+
+      if (url.includes('action=initiate')) {
+        return new Response(
+          JSON.stringify({ uploadId: 'u1', key: 'workspace/ws-1/big.bin', uploadToken: 't' }),
+          { status: 200 }
+        )
+      }
+      if (url.includes('action=get-part-urls')) {
+        return new Response(
+          JSON.stringify({
+            presignedUrls: [
+              { partNumber: 1, url: 'https://s3/part1' },
+              { partNumber: 2, url: 'https://s3/part2' },
+            ],
+          }),
+          { status: 200 }
+        )
+      }
+      if (url.startsWith('https://s3/part')) {
+        return new Response(null, { status: 200, headers: { ETag: '"etag-x"' } })
+      }
+      if (url.includes('action=complete')) {
+        return new Response(JSON.stringify({ error: 'kaboom' }), { status: 500 })
+      }
+      if (url.includes('action=abort')) {
+        return new Response(null, { status: 200 })
+      }
+      throw new Error(`unexpected url ${url}`)
+    })
+
+    vi.stubGlobal('fetch', fetchMock)
+
+    await expect(
+      runUploadStrategy({ file, workspaceId: 'ws-1', context: 'workspace' })
+    ).rejects.toBeInstanceOf(DirectUploadError)
+
+    expect(calls.some((c) => c.url.includes('action=abort'))).toBe(true)
+  })
+
   it('throws when neither presignedEndpoint nor presignedOverride is supplied', async () => {
     const file = makeFile(ONE_MB)
     await expect(

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

@@ -278,6 +278,12 @@ export async function uploadWorkspaceFile(
  * Throws if the object is missing in storage, quota is exceeded, or the
  * caller cannot resolve a unique name within the retry budget.
  */
+export interface RegisterUploadedWorkspaceFileResult {
+  file: UserFile
+  /** True when a new metadata row was inserted; false when an existing row was reused. */
+  created: boolean
+}
+
 export async function registerUploadedWorkspaceFile(params: {
   workspaceId: string
   userId: string
@@ -286,7 +292,7 @@ export async function registerUploadedWorkspaceFile(params: {
   contentType: string
   /** Caller-supplied size; verified against storage HEAD when cloud storage is configured. */
   size: number
-}): Promise<UserFile> {
+}): Promise<RegisterUploadedWorkspaceFileResult> {
   const { workspaceId, userId, key, originalName, contentType, size } = params
 
   if (parseWorkspaceFileKey(key) !== workspaceId) {
@@ -324,12 +330,14 @@ export async function registerUploadedWorkspaceFile(params: {
 
   let fileId = `wf_${generateShortId()}`
   let displayName: string
+  let created = false
   const existing = await getFileMetadataByKey(key, 'workspace')
   if (existing) {
     fileId = existing.id
     displayName = existing.originalName
     logger.info(`Using existing metadata record for direct upload: ${key}`)
   } else {
+    created = true
     displayName = await allocateUniqueWorkspaceFileName(workspaceId, originalName)
     try {
       await insertFileMetadata({
@@ -362,13 +370,16 @@ export async function registerUploadedWorkspaceFile(params: {
   const serveUrl = `${pathPrefix}${encodeURIComponent(key)}?context=workspace`
 
   return {
-    id: fileId,
-    name: displayName,
-    size: verifiedSize,
-    type: contentType,
-    url: serveUrl,
-    key,
-    context: 'workspace',
+    file: {
+      id: fileId,
+      name: displayName,
+      size: verifiedSize,
+      type: contentType,
+      url: serveUrl,
+      key,
+      context: 'workspace',
+    },
+    created,
   }
 }
 

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

@@ -0,0 +1,39 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { isAbortError, isNetworkError } from '@/lib/uploads/utils/file-utils'
+
+describe('isAbortError', () => {
+  it('returns true for AbortError-named errors', () => {
+    const err = new Error('aborted')
+    err.name = 'AbortError'
+    expect(isAbortError(err)).toBe(true)
+  })
+
+  it('returns false for generic Errors', () => {
+    expect(isAbortError(new Error('boom'))).toBe(false)
+    expect(isAbortError(null)).toBe(false)
+    expect(isAbortError('AbortError')).toBe(false)
+  })
+})
+
+describe('isNetworkError', () => {
+  it.each([
+    'fetch failed',
+    'Network request failed',
+    'connection reset',
+    'request timeout',
+    'operation timed out',
+    'ECONNRESET while reading body',
+  ])('matches transient message %s', (msg) => {
+    expect(isNetworkError(new Error(msg))).toBe(true)
+  })
+
+  it('does not match deterministic errors', () => {
+    expect(isNetworkError(new Error('Forbidden'))).toBe(false)
+    expect(isNetworkError(new Error('Validation failed: name is required'))).toBe(false)
+    expect(isNetworkError('not an error')).toBe(false)
+    expect(isNetworkError(null)).toBe(false)
+  })
+})