chore: import upstream snapshot with attribution

apps/sim/lib/copilot/vfs/resource-writer.test.ts

@@ -0,0 +1,314 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => {
+  class FileConflictError extends Error {
+    readonly code = 'FILE_EXISTS' as const
+  }
+
+  return {
+    FileConflictError,
+    ensureWorkflowAliasBacking: vi.fn(),
+    ensureWorkspacePlanBacking: vi.fn(),
+    resolveWorkflowAliasForWorkspace: vi.fn(),
+    ensureWorkspaceFileFolderPath: vi.fn(),
+    findWorkspaceFileFolderIdByPath: vi.fn(),
+    normalizeWorkspaceFileItemName: vi.fn((name: string) => name.trim()),
+    getWorkspaceFileByName: vi.fn(),
+    resolveWorkspaceFileReference: vi.fn(),
+    updateWorkspaceFileContent: vi.fn(),
+    uploadWorkspaceFile: vi.fn(),
+  }
+})
+
+vi.mock('@/lib/copilot/vfs/workflow-alias-backing', () => ({
+  ensureWorkflowAliasBacking: mocks.ensureWorkflowAliasBacking,
+  ensureWorkspacePlanBacking: mocks.ensureWorkspacePlanBacking,
+}))
+
+vi.mock('@/lib/copilot/vfs/workflow-alias-resolver', () => ({
+  resolveWorkflowAliasForWorkspace: mocks.resolveWorkflowAliasForWorkspace,
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-folder-manager', () => ({
+  ensureWorkspaceFileFolderPath: mocks.ensureWorkspaceFileFolderPath,
+  findWorkspaceFileFolderIdByPath: mocks.findWorkspaceFileFolderIdByPath,
+  normalizeWorkspaceFileItemName: mocks.normalizeWorkspaceFileItemName,
+}))
+
+vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
+  FileConflictError: mocks.FileConflictError,
+  getWorkspaceFileByName: mocks.getWorkspaceFileByName,
+  resolveWorkspaceFileReference: mocks.resolveWorkspaceFileReference,
+  updateWorkspaceFileContent: mocks.updateWorkspaceFileContent,
+  uploadWorkspaceFile: mocks.uploadWorkspaceFile,
+}))
+
+import { validateWorkspaceFileWriteTarget, writeWorkspaceFileByPath } from './resource-writer'
+
+describe('resource writer workflow aliases', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.ensureWorkflowAliasBacking.mockResolvedValue({})
+    mocks.ensureWorkspacePlanBacking.mockResolvedValue({})
+    mocks.ensureWorkspaceFileFolderPath.mockResolvedValue('folder-id')
+  })
+
+  it('creates workflow plan aliases through backing workspace files', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue({
+      kind: 'plan_file',
+      scope: 'workflow',
+      workflowId: 'wf_1',
+      workflowName: 'My Workflow',
+      workflowPath: 'workflows/My%20Workflow',
+      aliasPath: 'workflows/My%20Workflow/.plans/launch.md',
+      backingPath: 'files/.plans/wf_1/launch.md',
+      backingFolderPath: 'files/.plans/wf_1',
+      planRelativePath: 'launch.md',
+    })
+    mocks.getWorkspaceFileByName.mockResolvedValue(null)
+    mocks.uploadWorkspaceFile.mockResolvedValue({
+      id: 'file-plan',
+      name: 'launch.md',
+      size: 7,
+      type: 'text/markdown',
+      url: '/download',
+    })
+
+    const result = await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      target: {
+        path: 'workflows/My%20Workflow/.plans/launch.md',
+        mode: 'create',
+      },
+      buffer: Buffer.from('content'),
+      inferredMimeType: 'text/markdown',
+    })
+
+    expect(mocks.uploadWorkspaceFile).toHaveBeenCalledWith(
+      'workspace-1',
+      'user-1',
+      Buffer.from('content'),
+      'launch.md',
+      'text/markdown',
+      { folderId: 'folder-id', exactName: true }
+    )
+    expect(result).toMatchObject({
+      id: 'file-plan',
+      vfsPath: 'workflows/My%20Workflow/.plans/launch.md',
+      backingVfsPath: 'files/.plans/wf_1/launch.md',
+      mode: 'create',
+    })
+  })
+
+  it('overwrites workflow changelog aliases through backing workspace files', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue({
+      kind: 'changelog',
+      scope: 'workflow',
+      workflowId: 'wf_1',
+      workflowName: 'My Workflow',
+      workflowPath: 'workflows/My%20Workflow',
+      aliasPath: 'workflows/My%20Workflow/changelog.md',
+      backingPath: 'files/.changelogs/wf_1.md',
+      backingFolderPath: 'files/.changelogs',
+    })
+    mocks.getWorkspaceFileByName.mockResolvedValue({
+      id: 'file-changelog',
+      name: 'wf_1.md',
+      type: 'text/markdown',
+      folderPath: '.changelogs',
+    })
+    mocks.updateWorkspaceFileContent.mockResolvedValue({
+      id: 'file-changelog',
+      name: 'wf_1.md',
+      size: 7,
+      type: 'text/markdown',
+      url: '/download',
+      folderPath: '.changelogs',
+    })
+
+    const result = await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      target: {
+        path: 'workflows/My%20Workflow/changelog.md',
+        mode: 'overwrite',
+      },
+      buffer: Buffer.from('updated'),
+      inferredMimeType: 'text/markdown',
+    })
+
+    expect(mocks.updateWorkspaceFileContent).toHaveBeenCalledWith(
+      'workspace-1',
+      'file-changelog',
+      'user-1',
+      Buffer.from('updated'),
+      'text/markdown'
+    )
+    expect(result).toMatchObject({
+      id: 'file-changelog',
+      vfsPath: 'workflows/My%20Workflow/changelog.md',
+      backingVfsPath: 'files/.changelogs/wf_1.md',
+      mode: 'overwrite',
+    })
+  })
+
+  it('creates root workspace plan aliases through workspace backing files', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue({
+      kind: 'plan_file',
+      scope: 'workspace',
+      aliasPath: '.plans/root.md',
+      backingPath: 'files/.plans/workspace/root.md',
+      backingFolderPath: 'files/.plans/workspace',
+      planRelativePath: 'root.md',
+    })
+    mocks.getWorkspaceFileByName.mockResolvedValue(null)
+    mocks.uploadWorkspaceFile.mockResolvedValue({
+      id: 'file-root-plan',
+      name: 'root.md',
+      size: 7,
+      type: 'text/markdown',
+      url: '/download',
+    })
+
+    const result = await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      target: {
+        path: '.plans/root.md',
+        mode: 'create',
+      },
+      buffer: Buffer.from('content'),
+      inferredMimeType: 'text/markdown',
+    })
+
+    expect(mocks.ensureWorkspacePlanBacking).toHaveBeenCalledWith({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+    })
+    expect(mocks.ensureWorkspaceFileFolderPath).toHaveBeenCalledWith({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      pathSegments: ['.plans', 'workspace'],
+    })
+    expect(result).toMatchObject({
+      id: 'file-root-plan',
+      vfsPath: '.plans/root.md',
+      backingVfsPath: 'files/.plans/workspace/root.md',
+      mode: 'create',
+    })
+  })
+
+  it('rejects direct writes to reserved workflow alias backing paths', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue(null)
+
+    await expect(
+      writeWorkspaceFileByPath({
+        workspaceId: 'workspace-1',
+        userId: 'user-1',
+        target: {
+          path: 'files/.plans/wf_1/launch.md',
+          mode: 'create',
+        },
+        buffer: Buffer.from('content'),
+        inferredMimeType: 'text/markdown',
+      })
+    ).rejects.toThrow(
+      'Reserved workflow alias backing paths must be accessed through their alias path'
+    )
+
+    expect(mocks.uploadWorkspaceFile).not.toHaveBeenCalled()
+  })
+
+  it('rejects validation of reserved workflow alias backing paths', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue(null)
+
+    await expect(
+      validateWorkspaceFileWriteTarget({
+        workspaceId: 'workspace-1',
+        userId: 'user-1',
+        target: {
+          path: 'files/.changelogs/wf_1.md',
+          mode: 'overwrite',
+        },
+      })
+    ).rejects.toThrow(
+      'Reserved workflow alias backing paths must be accessed through their alias path'
+    )
+
+    expect(mocks.resolveWorkspaceFileReference).not.toHaveBeenCalled()
+  })
+
+  it('uses exact-name creates for alias backing files', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue({
+      kind: 'plan_file',
+      scope: 'workflow',
+      workflowId: 'wf_1',
+      workflowName: 'My Workflow',
+      workflowPath: 'workflows/My%20Workflow',
+      aliasPath: 'workflows/My%20Workflow/.plans/launch.md',
+      backingPath: 'files/.plans/wf_1/launch.md',
+      backingFolderPath: 'files/.plans/wf_1',
+      planRelativePath: 'launch.md',
+    })
+    mocks.getWorkspaceFileByName.mockResolvedValue(null)
+    mocks.uploadWorkspaceFile.mockResolvedValue({
+      id: 'file-plan',
+      name: 'launch.md',
+      size: 7,
+      type: 'text/markdown',
+      url: '/download',
+    })
+
+    await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      userId: 'user-1',
+      target: {
+        path: 'workflows/My%20Workflow/.plans/launch.md',
+        mode: 'create',
+      },
+      buffer: Buffer.from('content'),
+      inferredMimeType: 'text/markdown',
+    })
+
+    expect(mocks.uploadWorkspaceFile).toHaveBeenCalledWith(
+      'workspace-1',
+      'user-1',
+      Buffer.from('content'),
+      'launch.md',
+      'text/markdown',
+      { folderId: 'folder-id', exactName: true }
+    )
+  })
+
+  it('reports alias path when exact-name alias backing creation conflicts', async () => {
+    mocks.resolveWorkflowAliasForWorkspace.mockResolvedValue({
+      kind: 'plan_file',
+      scope: 'workflow',
+      workflowId: 'wf_1',
+      workflowName: 'My Workflow',
+      workflowPath: 'workflows/My%20Workflow',
+      aliasPath: 'workflows/My%20Workflow/.plans/launch.md',
+      backingPath: 'files/.plans/wf_1/launch.md',
+      backingFolderPath: 'files/.plans/wf_1',
+      planRelativePath: 'launch.md',
+    })
+    mocks.getWorkspaceFileByName.mockResolvedValue(null)
+    mocks.uploadWorkspaceFile.mockRejectedValue(new mocks.FileConflictError('launch.md'))
+
+    await expect(
+      writeWorkspaceFileByPath({
+        workspaceId: 'workspace-1',
+        userId: 'user-1',
+        target: {
+          path: 'workflows/My%20Workflow/.plans/launch.md',
+          mode: 'create',
+        },
+        buffer: Buffer.from('content'),
+        inferredMimeType: 'text/markdown',
+      })
+    ).rejects.toThrow(
+      'File already exists at workflows/My%20Workflow/.plans/launch.md. Use mode "overwrite" to update it.'
+    )
+  })
+})