perf improvements

Author: icecrasher321

apps/sim/app/api/workspaces/[id]/fork/lineage/route.ts

@@ -8,7 +8,7 @@ import { parseRequest } from '@/lib/api/server'
 import { getSession } from '@/lib/auth'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { assertWorkspaceAdminAccess } from '@/lib/workspaces/fork/lineage/authz'
-import { getForkLineage } from '@/lib/workspaces/fork/lineage/lineage'
+import { getForkParent } from '@/lib/workspaces/fork/lineage/lineage'
 import { getUndoableRunForTarget } from '@/lib/workspaces/fork/promote/promote-run-store'
 
 export const GET = withRouteHandler(
@@ -24,8 +24,8 @@ export const GET = withRouteHandler(
 
     await assertWorkspaceAdminAccess(workspaceId, session.user.id)
 
-    const [{ parent, children }, run] = await Promise.all([
-      getForkLineage(workspaceId),
+    const [parent, run] = await Promise.all([
+      getForkParent(workspaceId),
       getUndoableRunForTarget(db, workspaceId),
     ])
 
@@ -50,8 +50,6 @@ export const GET = withRouteHandler(
     return NextResponse.json({
       workspaceId,
       parent,
-      children,
-      hasUndoableRun: Boolean(run),
       undoableRun,
     })
   }

apps/sim/app/api/workspaces/[id]/fork/mapping/route.ts

@@ -8,6 +8,7 @@ import { parseRequest } from '@/lib/api/server'
 import { getSession } from '@/lib/auth'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { assertCanPromote } from '@/lib/workspaces/fork/lineage/authz'
+import { acquireForkEdgeLock, setForkLockTimeout } from '@/lib/workspaces/fork/lineage/lineage'
 import {
   applyForkMappingEntries,
   getForkMappingView,
@@ -60,9 +61,14 @@ export const PUT = withRouteHandler(
 
     await validateForkMappingTargets(auth.sourceWorkspaceId, auth.targetWorkspaceId, entries)
 
-    const updated = await db.transaction((tx) =>
-      applyForkMappingEntries(tx, auth.edge, session.user.id, direction, entries)
-    )
+    // Serialize concurrent mapping saves on this edge so a push (keyed child-side, deleted
+    // then re-upserted parent-side) can't leave duplicate rows for the same source. Same
+    // edge lock promote/rollback use, with a bounded wait.
+    const updated = await db.transaction(async (tx) => {
+      await setForkLockTimeout(tx)
+      await acquireForkEdgeLock(tx, auth.edge.childWorkspaceId)
+      return applyForkMappingEntries(tx, auth.edge, session.user.id, direction, entries)
+    })
 
     return NextResponse.json({ success: true as const, updated })
   }

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

@@ -142,7 +142,11 @@ export function usePromoteFork() {
     mutationFn: (vars: { workspaceId: string; body: PromoteForkBody }) =>
       requestJson(promoteForkContract, { params: { id: vars.workspaceId }, body: vars.body }),
     onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: forkKeys.all })
+      // A sync changes lineage (undoable run), mappings, and the diff - not the
+      // workspace's copyable resource inventory, so leave `resources` cached.
+      queryClient.invalidateQueries({ queryKey: forkKeys.lineages() })
+      queryClient.invalidateQueries({ queryKey: forkKeys.mappings() })
+      queryClient.invalidateQueries({ queryKey: forkKeys.diffs() })
       queryClient.invalidateQueries({ queryKey: backgroundWorkKeys.lists() })
     },
   })
@@ -154,7 +158,11 @@ export function useRollbackFork() {
     mutationFn: (vars: { workspaceId: string; body: RollbackForkBody }) =>
       requestJson(rollbackForkContract, { params: { id: vars.workspaceId }, body: vars.body }),
     onSettled: () => {
-      queryClient.invalidateQueries({ queryKey: forkKeys.all })
+      // Rollback changes lineage, mappings, and the diff - not the copyable resource
+      // inventory, so leave `resources` cached (mirrors usePromoteFork).
+      queryClient.invalidateQueries({ queryKey: forkKeys.lineages() })
+      queryClient.invalidateQueries({ queryKey: forkKeys.mappings() })
+      queryClient.invalidateQueries({ queryKey: forkKeys.diffs() })
       queryClient.invalidateQueries({ queryKey: backgroundWorkKeys.lists() })
     },
   })

apps/sim/lib/api/contracts/workspace-fork.ts

@@ -57,8 +57,6 @@ export const getForkLineageContract = defineRouteContract({
     schema: z.object({
       workspaceId: z.string(),
       parent: forkLineageNodeSchema.nullable(),
-      children: z.array(forkLineageNodeSchema),
-      hasUndoableRun: z.boolean(),
       /** The most recent undoable promote into this workspace, for the rollback UI. */
       undoableRun: z
         .object({

apps/sim/lib/workspaces/fork/copy/content-copy-runner.ts

@@ -15,9 +15,9 @@ export interface ForkContentCopyPayload {
   contentPlan: ForkContentPlan
   blobTasks: BlobCopyTask[]
   /**
-   * `background_work_status` row to finish when the copy ends, so the child
-   * workspace's "copying in the background" banner clears (or shows a warning/error).
-   * Started in the fork transaction so it's visible the moment the user opens the fork.
+   * `background_work_status` row to finish when the copy ends, so the source workspace's
+   * Manage Forks -> Activity entry resolves (completed / warning / error). Started right
+   * after the fork commits so it's visible immediately.
    */
   statusId?: string
   requestId?: string

apps/sim/lib/workspaces/fork/copy/copy-resources.ts

@@ -137,9 +137,10 @@ export async function copyForkResourceContainers(
           eq(customTools.workspaceId, sourceWorkspaceId)
         )
       )
+    const inserts: (typeof customTools.$inferInsert)[] = []
     for (const row of rows) {
       const childId = generateId()
-      await tx.insert(customTools).values({
+      inserts.push({
         ...row,
         id: childId,
         workspaceId: childWorkspaceId,
@@ -150,16 +151,18 @@ export async function copyForkResourceContainers(
       record('custom_tool', row.id, childId)
       names.customTools.push(row.title)
     }
+    if (inserts.length > 0) await tx.insert(customTools).values(inserts)
   }
 
   if (selection.skills.length > 0) {
     const rows = await tx
       .select()
       .from(skill)
       .where(and(inArray(skill.id, selection.skills), eq(skill.workspaceId, sourceWorkspaceId)))
+    const inserts: (typeof skill.$inferInsert)[] = []
     for (const row of rows) {
       const childId = generateId()
-      await tx.insert(skill).values({
+      inserts.push({
         ...row,
         id: childId,
         workspaceId: childWorkspaceId,
@@ -170,6 +173,7 @@ export async function copyForkResourceContainers(
       record('skill', row.id, childId)
       names.skills.push(row.name)
     }
+    if (inserts.length > 0) await tx.insert(skill).values(inserts)
   }
 
   if (selection.mcpServers.length > 0) {
@@ -186,32 +190,34 @@ export async function copyForkResourceContainers(
     // `generateMcpServerId` is deterministic on (workspace, url), so two selected
     // servers with the same normalized URL derive the same child id. Insert once
     // and map both source ids to the surviving child rather than aborting the fork.
-    const insertedMcpIds = new Set<string>()
+    const insertsByChildId = new Map<string, typeof mcpServers.$inferInsert>()
     for (const row of rows) {
       const childId = row.url ? generateMcpServerId(childWorkspaceId, row.url) : generateId()
       record('mcp_server', row.id, childId)
-      if (insertedMcpIds.has(childId)) continue
-      insertedMcpIds.add(childId)
+      if (insertsByChildId.has(childId)) continue
       names.mcpServers.push(row.name)
+      insertsByChildId.set(childId, {
+        ...row,
+        id: childId,
+        workspaceId: childWorkspaceId,
+        createdBy: userId,
+        // Secrets are never copied across workspaces: drop the registered OAuth
+        // client + any auth headers so the child re-authenticates from scratch.
+        oauthClientId: null,
+        oauthClientSecret: null,
+        headers: {},
+        connectionStatus: 'disconnected',
+        lastConnected: null,
+        lastError: null,
+        deletedAt: null,
+        createdAt: now,
+        updatedAt: now,
+      })
+    }
+    if (insertsByChildId.size > 0) {
       await tx
         .insert(mcpServers)
-        .values({
-          ...row,
-          id: childId,
-          workspaceId: childWorkspaceId,
-          createdBy: userId,
-          // Secrets are never copied across workspaces: drop the registered OAuth
-          // client + any auth headers so the child re-authenticates from scratch.
-          oauthClientId: null,
-          oauthClientSecret: null,
-          headers: {},
-          connectionStatus: 'disconnected',
-          lastConnected: null,
-          lastError: null,
-          deletedAt: null,
-          createdAt: now,
-          updatedAt: now,
-        })
+        .values([...insertsByChildId.values()])
         .onConflictDoNothing()
     }
   }
@@ -227,13 +233,14 @@ export async function copyForkResourceContainers(
           isNull(userTableDefinitions.archivedAt)
         )
       )
+    const inserts: (typeof userTableDefinitions.$inferInsert)[] = []
     for (const definition of definitions) {
       const childTableId = generateId()
       const remappedSchema = remapForkTableWorkflowGroups(
         definition.schema as TableSchema,
         workflowIdMap
       )
-      await tx.insert(userTableDefinitions).values({
+      inserts.push({
         ...definition,
         id: childTableId,
         workspaceId: childWorkspaceId,
@@ -251,6 +258,7 @@ export async function copyForkResourceContainers(
       contentPlan.tables.push({ sourceId: definition.id, childId: childTableId })
       names.tables.push(definition.name)
     }
+    if (inserts.length > 0) await tx.insert(userTableDefinitions).values(inserts)
   }
 
   if (selection.knowledgeBases.length > 0) {
@@ -264,9 +272,10 @@ export async function copyForkResourceContainers(
           isNull(knowledgeBase.deletedAt)
         )
       )
+    const inserts: (typeof knowledgeBase.$inferInsert)[] = []
     for (const base of bases) {
       const childKbId = generateId()
-      await tx.insert(knowledgeBase).values({
+      inserts.push({
         ...base,
         id: childKbId,
         workspaceId: childWorkspaceId,
@@ -279,6 +288,7 @@ export async function copyForkResourceContainers(
       contentPlan.knowledgeBases.push({ sourceId: base.id, childId: childKbId })
       names.knowledgeBases.push(base.name)
     }
+    if (inserts.length > 0) await tx.insert(knowledgeBase).values(inserts)
   }
 
   return { idMap, mappingEntries, contentPlan, names }

apps/sim/lib/workspaces/fork/copy/copy-workflows.test.ts

@@ -0,0 +1,62 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { buildWorkflowNameRegistry } from '@/lib/workspaces/fork/copy/copy-workflows'
+
+describe('buildWorkflowNameRegistry', () => {
+  it('reports a name as taken by another workflow in the same folder', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: 'f1', name: 'Onboarding' }])
+    expect(reg.isTaken('f1', 'Onboarding', null)).toBe(true)
+    expect(reg.isTaken('f1', 'Onboarding', 'w2')).toBe(true)
+  })
+
+  it('excludes the workflow itself so a replace can keep its own name', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: 'f1', name: 'Onboarding' }])
+    expect(reg.isTaken('f1', 'Onboarding', 'w1')).toBe(false)
+  })
+
+  it('is folder-scoped: the same name in another folder is free', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: 'f1', name: 'Onboarding' }])
+    expect(reg.isTaken('f2', 'Onboarding', null)).toBe(false)
+    expect(reg.isTaken(null, 'Onboarding', null)).toBe(false)
+  })
+
+  it('treats the root (null) folder distinctly, matching coalesce(folderId, "")', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: null, name: 'Root WF' }])
+    expect(reg.isTaken(null, 'Root WF', null)).toBe(true)
+    expect(reg.isTaken('f1', 'Root WF', null)).toBe(false)
+  })
+
+  it('claims a new name so a later workflow in the same copy loop sees it taken', () => {
+    const reg = buildWorkflowNameRegistry([])
+    expect(reg.isTaken('f1', 'Report', null)).toBe(false)
+    reg.claim('f1', 'Report', 'wA')
+    expect(reg.isTaken('f1', 'Report', null)).toBe(true)
+    expect(reg.isTaken('f1', 'Report', 'wA')).toBe(false)
+  })
+
+  it('releases the prior name when a workflow is renamed (claim moves keys)', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: 'f1', name: 'Old' }])
+    reg.claim('f1', 'New', 'w1')
+    expect(reg.isTaken('f1', 'Old', null)).toBe(false)
+    expect(reg.isTaken('f1', 'New', null)).toBe(true)
+  })
+
+  it('re-claiming the same (folder, name) is a no-op', () => {
+    const reg = buildWorkflowNameRegistry([{ id: 'w1', folderId: 'f1', name: 'Same' }])
+    reg.claim('f1', 'Same', 'w1')
+    expect(reg.isTaken('f1', 'Same', 'w1')).toBe(false)
+    expect(reg.isTaken('f1', 'Same', null)).toBe(true)
+  })
+
+  it('handles multiple holders (legacy duplicates) and partial release', () => {
+    const reg = buildWorkflowNameRegistry([
+      { id: 'w1', folderId: 'f1', name: 'Dup' },
+      { id: 'w2', folderId: 'f1', name: 'Dup' },
+    ])
+    expect(reg.isTaken('f1', 'Dup', 'w1')).toBe(true)
+    reg.claim('f1', 'Other', 'w2')
+    expect(reg.isTaken('f1', 'Dup', 'w1')).toBe(false)
+  })
+})