fix(lifecycle): preserve empty upload attribution through handoff

Author: mzxchandra

apps/sim/lib/uploads/contexts/workspace/__integration__/file-versions.integration.ts

@@ -13,6 +13,7 @@ import {
   workspaceFiles,
   workspaceFileVersion,
 } from '@sim/db/schema'
+import { sha256Hex } from '@sim/security/hash'
 import { createDeferred } from '@sim/testing/helpers/deferred'
 import { generateId } from '@sim/utils/id'
 import { and, asc, eq, inArray, sql } from 'drizzle-orm'
@@ -240,12 +241,149 @@ describe('workspace file version history in PostgreSQL', () => {
     ])
   })
 
-  it('keeps an empty shell unversioned until its first content write after handoff', async () => {
+  it.each([false, true])(
+    'preserves empty history across handoff and first-write version one (unknown=%s)',
+    async (unknown) => {
+      const fixture = await seedFile('')
+      if (unknown)
+        await db
+          .update(workspaceFiles)
+          .set({ contentUpdatedAt: new Date(Date.now() + 5000) })
+          .where(eq(workspaceFiles.id, fixture.fileId))
+      const before = await getWorkspaceFile(fixture.workspaceId, fixture.fileId)
+      if (!before) throw new Error('file missing')
+      const [accounting] = await db
+        .select({ bytes: workspace.storageUsedBytes })
+        .from(workspace)
+        .where(eq(workspace.id, fixture.workspaceId))
+      const historyBefore = await queryWorkspaceFileVersions(before, {
+        sortOrder: 'asc',
+        limit: 10,
+      })
+      expect(historyBefore.versions).toMatchObject([
+        {
+          version: 1,
+          source: unknown ? 'unknown' : 'upload',
+          authorUserIds: unknown ? [] : [fixture.aliceId],
+          size: 0,
+        },
+      ])
+      for (const successor of [fixture.bobId, fixture.aliceId, fixture.bobId]) {
+        await db.transaction((tx) =>
+          handoffFileCreatorsInTx(tx, eq(workspaceFiles.id, fixture.fileId), successor)
+        )
+      }
+      const after = await getWorkspaceFile(fixture.workspaceId, fixture.fileId)
+      if (!after) throw new Error('file missing')
+      expect(after.uploadedBy).toBe(fixture.bobId)
+      const historyAfter = await queryWorkspaceFileVersions(after, { sortOrder: 'asc', limit: 10 })
+      expect(historyAfter.versions).toEqual(historyBefore.versions)
+      expect(
+        await db
+          .select({ bytes: workspace.storageUsedBytes })
+          .from(workspace)
+          .where(eq(workspace.id, fixture.workspaceId))
+      ).toEqual([accounting])
+      expect(await objectExists(fixture.firstKey)).toBe(true)
+      await updateWorkspaceFileContent(
+        fixture.workspaceId,
+        fixture.fileId,
+        fixture.bobId,
+        Buffer.from('first'),
+        undefined,
+        {
+          version: { source: 'api', authorUserId: fixture.bobId },
+          secretProvenancePolicy: { mode: 'replace', provenance: { status: 'unknown' } },
+        }
+      )
+      expect(await versionRows(fixture.fileId)).toMatchObject([
+        {
+          version: 1,
+          source: 'api',
+          authorUserIds: [fixture.bobId],
+          contentHash: sha256Hex('first'),
+          restoredFromVersion: null,
+          secretProvenanceStatus: 'unknown',
+          secretProvenanceEntries: [],
+        },
+      ])
+      const [written] = await versionRows(fixture.fileId)
+      expect(written.createdAt).toEqual(written.updatedAt)
+      expect(written.createdAt).not.toEqual(historyBefore.versions[0].createdAt)
+      expect(await objectExists(fixture.firstKey)).toBe(false)
+      expect(await readVersionBytes(fixture.workspaceId, fixture.fileId, written.key)).toBe('first')
+    }
+  )
+
+  it.each(['api', 'revert'] as const)(
+    'keeps an explicitly recorded empty %s version through handoff and a later write',
+    async (source) => {
+      const fixture = await seedFile('')
+      await updateWorkspaceFileContent(
+        fixture.workspaceId,
+        fixture.fileId,
+        fixture.aliceId,
+        Buffer.alloc(0),
+        undefined,
+        {
+          version: {
+            source: 'api',
+            authorUserId: fixture.aliceId,
+          },
+        }
+      )
+      if (source === 'revert') {
+        await updateWorkspaceFileContent(
+          fixture.workspaceId,
+          fixture.fileId,
+          fixture.aliceId,
+          Buffer.from('intermediate'),
+          undefined,
+          { version: { source: 'api', authorUserId: fixture.aliceId } }
+        )
+        await revertWorkspaceFileVersion.execute({
+          principal: { kind: 'session', userId: fixture.aliceId, sessionId: generateId() },
+          input: { fileId: fixture.fileId, assertedWorkspaceId: fixture.workspaceId, version: 1 },
+        })
+      }
+      const previousRows = await versionRows(fixture.fileId)
+      const recorded = previousRows[previousRows.length - 1]
+      await db.transaction((tx) =>
+        handoffFileCreatorsInTx(tx, eq(workspaceFiles.id, fixture.fileId), fixture.bobId)
+      )
+      await updateWorkspaceFileContent(
+        fixture.workspaceId,
+        fixture.fileId,
+        fixture.bobId,
+        Buffer.from('later'),
+        undefined,
+        { version: { source: 'api', authorUserId: fixture.bobId } }
+      )
+      const rows = await versionRows(fixture.fileId)
+      expect(rows.map((row) => [row.version, row.source, row.authorUserIds])).toEqual([
+        ...previousRows.map((row) => [row.version, row.source, row.authorUserIds]),
+        [recorded.version + 1, 'api', [fixture.bobId]],
+      ])
+      expect(rows[recorded.version - 1]).toMatchObject({
+        key: recorded.key,
+        contentHash: recorded.contentHash,
+        restoredFromVersion: source === 'revert' ? 1 : null,
+      })
+      expect(await objectExists(recorded.key)).toBe(true)
+      expect(await readVersionBytes(fixture.workspaceId, fixture.fileId, recorded.key)).toBe('')
+    }
+  )
+
+  it('keeps an empty storage object still referenced by a retained file after the first write', async () => {
     const fixture = await seedFile('')
+    const [original] = await db
+      .select()
+      .from(workspaceFiles)
+      .where(eq(workspaceFiles.id, fixture.fileId))
+    await db.insert(workspaceFiles).values({ ...original, id: generateId(), deletedAt: new Date() })
     await db.transaction((tx) =>
       handoffFileCreatorsInTx(tx, eq(workspaceFiles.id, fixture.fileId), fixture.bobId)
     )
-    expect(await versionRows(fixture.fileId)).toEqual([])
     await updateWorkspaceFileContent(
       fixture.workspaceId,
       fixture.fileId,
@@ -254,15 +392,19 @@ describe('workspace file version history in PostgreSQL', () => {
       undefined,
       { version: { source: 'api', authorUserId: fixture.bobId } }
     )
-    expect(await versionRows(fixture.fileId)).toMatchObject([
-      { version: 1, source: 'api', authorUserIds: [fixture.bobId] },
-    ])
+    expect(await objectExists(fixture.firstKey)).toBe(true)
+    expect((await versionRows(fixture.fileId)).map((row) => row.version)).toEqual([1])
   })
 
-  it.each(['handoff', 'write'] as const)(
-    'serializes creator handoff with a content write when %s waits first',
-    async (first) => {
-      const fixture = await seedFile('original')
+  it.each([
+    { first: 'handoff', content: 'original' },
+    { first: 'write', content: 'original' },
+    { first: 'handoff', content: '' },
+    { first: 'write', content: '' },
+  ] as const)(
+    'serializes creator handoff with a content write ($first first, original=$content)',
+    async ({ first, content }) => {
+      const fixture = await seedFile(content)
       const ready = createDeferred<number>()
       const release = createDeferred<void>()
       const blocker = db.transaction(async (tx) => {
@@ -319,13 +461,17 @@ describe('workspace file version history in PostgreSQL', () => {
         await Promise.all(pending)
       }
       const rows = await versionRows(fixture.fileId)
-      expect(rows.map((row) => [row.version, row.authorUserIds])).toEqual([
-        [1, [fixture.aliceId]],
-        [2, [fixture.aliceId]],
-      ])
+      expect(rows.map((row) => [row.version, row.authorUserIds])).toEqual(
+        content
+          ? [
+              [1, [fixture.aliceId]],
+              [2, [fixture.aliceId]],
+            ]
+          : [[1, [fixture.aliceId]]]
+      )
       expect(rows.filter((row) => row.supersededAt === null)).toHaveLength(1)
       expect(await readVersionBytes(fixture.workspaceId, fixture.fileId, rows[0].key)).toBe(
-        'original'
+        content || 'second'
       )
       expect((await getWorkspaceFile(fixture.workspaceId, fixture.fileId))?.uploadedBy).toBe(
         fixture.bobId

apps/sim/lib/uploads/contexts/workspace/creator-handoff.ts

@@ -7,7 +7,6 @@ import {
   loadWorkspaceFileVersionHead,
   materializeWorkspaceFileVersionInTx,
 } from '@/lib/uploads/contexts/workspace/workspace-file-versions'
-import { getWorkspaceFileSize } from '@/lib/uploads/shared/types'
 
 /** Freezes implicit history under the writer lock before replacing a shared file's live creator. */
 export async function handoffFileCreatorsInTx(
@@ -25,7 +24,7 @@ export async function handoffFileCreatorsInTx(
   for (const file of files) {
     if (file.context !== 'workspace' || !file.workspaceId) continue
     const head = await loadWorkspaceFileVersionHead(file.id, tx)
-    if (isVersionHeadCurrent(head, file) || (!head && getWorkspaceFileSize(file) === 0)) continue
+    if (isVersionHeadCurrent(head, file)) continue
     const provenance = await snapshotWorkspaceFileSecretProvenanceInTx(
       tx,
       file.id,

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

@@ -219,13 +219,34 @@ export async function materializeWorkspaceFileVersionInTx(
   return materialized
 }
 
+/** Identifies an implicit empty first version frozen by handoff, never an explicit write or restore. */
+function isMaterializedEmptyInitialVersion(
+  head: WorkspaceFileVersionSummaryRow | undefined,
+  file: WorkspaceFileRow
+): head is WorkspaceFileVersionSummaryRow {
+  return (
+    head !== undefined &&
+    head.fileId === file.id &&
+    head.version === INITIAL_WORKSPACE_FILE_VERSION &&
+    isVersionHeadCurrent(head, file) &&
+    getWorkspaceFileSize(file) === 0 &&
+    head.sizeBytes === 0 &&
+    head.contentHash === null &&
+    (head.source === 'upload' || head.source === 'unknown') &&
+    head.restoredFromVersion === null &&
+    head.createdAt.getTime() === file.contentUpdatedAt.getTime() &&
+    head.updatedAt.getTime() === file.contentUpdatedAt.getTime()
+  )
+}
+
 /**
  * Records a committed content write in the file's history. Runs inside the content-write
  * transaction, under the file row's lock, which serializes version numbering and coalescing
  * decisions per file.
  *
  * An empty file with no history is a shell whose content arrives in this write (a create followed
- * by its first content), so the shell is not kept as a version of its own.
+ * by its first content), so the shell is not kept as a version of its own. A handoff may have
+ * materialized that implicit shell to freeze attribution; its first write still replaces version 1.
  */
 export async function recordWorkspaceFileVersionInTx(
   tx: DbTransaction,
@@ -239,6 +260,29 @@ export async function recordWorkspaceFileVersionInTx(
     return { version: 1, releasedKeys: [previous.key] }
   }
 
+  if (isMaterializedEmptyInitialVersion(head, previous)) {
+    await tx
+      .update(workspaceFileVersion)
+      .set({
+        ...contentColumns(next, params.nextProvenance),
+        contentHash: params.contentHash,
+        source: write.source,
+        authorUserIds: write.authorUserId ? [write.authorUserId] : [],
+        restoredFromVersion: write.restoredFromVersion ?? null,
+        createdAt: now,
+        updatedAt: now,
+      })
+      .where(eq(workspaceFileVersion.id, head.id))
+    const [references] = await tx.execute<{ referenced: boolean }>(sql`
+      SELECT EXISTS(SELECT 1 FROM ${workspaceFiles} WHERE ${workspaceFiles.key} = ${previous.key})
+        OR EXISTS(SELECT 1 FROM ${workspaceFileVersion} WHERE ${workspaceFileVersion.key} = ${previous.key}) AS referenced
+    `)
+    return {
+      version: INITIAL_WORKSPACE_FILE_VERSION,
+      releasedKeys: references.referenced ? [] : [previous.key],
+    }
+  }
+
   if (!head || !isVersionHeadCurrent(head, previous)) {
     if (!params.previousProvenance) {
       throw new Error('Outgoing workspace file content needs a provenance snapshot to be versioned')