ensure duplicated blocks have unique '<Base> N' names using normalized comparison; unify client naming via shared helper and wire into duplicate flows; keep server unchanged (#1273)

Author: waleedlatif1

apps/sim/hooks/use-collaborative-workflow.ts

@@ -2,6 +2,7 @@ import { useCallback, useEffect, useRef } from 'react'
 import type { Edge } from 'reactflow'
 import { useSession } from '@/lib/auth-client'
 import { createLogger } from '@/lib/logs/console/logger'
+import { generateUniqueBlockDuplicateName } from '@/lib/naming'
 import { getBlock } from '@/blocks'
 import { resolveOutputType } from '@/blocks/utils'
 import { useSocket } from '@/contexts/socket-context'
@@ -960,10 +961,8 @@ export function useCollaborativeWorkflow() {
         y: sourceBlock.position.y + 20,
       }
 
-      const match = sourceBlock.name.match(/(.*?)(\d+)?$/)
-      const newName = match?.[2]
-        ? `${match[1]}${Number.parseInt(match[2]) + 1}`
-        : `${sourceBlock.name} 1`
+      const existingNames = Object.values(workflowStore.blocks).map((b) => b.name)
+      const newName = generateUniqueBlockDuplicateName(existingNames, sourceBlock.name)
 
       // Get subblock values from the store
       const subBlockValues = subBlockStore.workflowValues[activeWorkflowId || '']?.[sourceId] || {}

apps/sim/lib/naming.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest'
+import { generateUniqueBlockDuplicateName, normalizeBlockName } from '@/lib/naming'
+
+describe('block naming helpers', () => {
+  it('normalizes names by lowercasing and removing spaces only', () => {
+    expect(normalizeBlockName('My Agent')).toBe('myagent')
+    expect(normalizeBlockName(' My   Agent ')).toBe('myagent')
+    expect(normalizeBlockName('My__Agent')).toBe('my__agent')
+  })
+
+  it('duplicates base without suffix as "Base 1"', () => {
+    const existing = ['Agent']
+    expect(generateUniqueBlockDuplicateName(existing, 'Agent')).toBe('Agent 1')
+  })
+
+  it('skips to next available when immediate next collides (normalized)', () => {
+    const existing = ['Agent', 'agent1']
+    expect(generateUniqueBlockDuplicateName(existing, 'Agent')).toBe('Agent 2')
+  })
+
+  it('increments numeric suffix when present and finds next free', () => {
+    const existing = ['Agent', 'Agent 5', 'Agent 6']
+    expect(generateUniqueBlockDuplicateName(existing, 'Agent 5')).toBe('Agent 7')
+  })
+
+  it('handles names with no whitespace before digits as new base', () => {
+    const existing = ['Agent5']
+    expect(generateUniqueBlockDuplicateName(existing, 'Agent5')).toBe('Agent5 1')
+  })
+
+  it('handles multiple spaces and prevents normalized collisions', () => {
+    const existing = ['myagent1', 'My Agent']
+    expect(generateUniqueBlockDuplicateName(existing, 'My  Agent')).toBe('My  Agent 2')
+  })
+
+  it('fills gaps by choosing the next available number', () => {
+    const existing = ['Agent', 'Agent 1', 'Agent 3', 'Agent 4']
+    expect(generateUniqueBlockDuplicateName(existing, 'Agent')).toBe('Agent 2')
+  })
+
+  it('falls back to "Block" base for empty or whitespace-only names', () => {
+    const existing1: string[] = []
+    expect(generateUniqueBlockDuplicateName(existing1, '')).toBe('Block 1')
+
+    const existing2 = ['Block 1']
+    expect(generateUniqueBlockDuplicateName(existing2, '   ')).toBe('Block 2')
+  })
+})

apps/sim/lib/naming.ts

@@ -159,6 +159,32 @@ const NOUNS = [
   'Crumpet',
 ]
 
+export function normalizeBlockName(name: string): string {
+  return name.toLowerCase().replace(/\s+/g, '')
+}
+
+export function generateUniqueBlockDuplicateName(
+  existingNames: string[],
+  sourceName: string
+): string {
+  const normalizedSet = new Set(
+    (existingNames || []).filter((n) => typeof n === 'string').map((n) => normalizeBlockName(n))
+  )
+
+  const trimmed = (sourceName || '').trim()
+  const match = trimmed.match(/^(.*?)(?:\s+(\d+))?$/)
+  const baseRaw = match ? match[1] || '' : trimmed
+  const base = baseRaw.trim() || 'Block'
+  const start = match?.[2] ? Number.parseInt(match[2], 10) + 1 : 1
+
+  let n = start
+  while (true) {
+    const candidate = `${base} ${n}`
+    if (!normalizedSet.has(normalizeBlockName(candidate))) return candidate
+    n += 1
+  }
+}
+
 /**
  * Generates the next incremental name for entities following pattern: "{prefix} {number}"
  *
@@ -170,67 +196,41 @@ export function generateIncrementalName<T extends NameableEntity>(
   existingEntities: T[],
   prefix: string
 ): string {
-  // Create regex pattern for the prefix (e.g., /^Workspace (\d+)$/)
   const pattern = new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')} (\\d+)$`)
-
-  // Extract numbers from existing entities that match the pattern
   const existingNumbers = existingEntities
     .map((entity) => entity.name.match(pattern))
     .filter((match) => match !== null)
     .map((match) => Number.parseInt(match![1], 10))
-
-  // Find next available number (highest + 1, or 1 if none exist)
   const nextNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) + 1 : 1
-
   return `${prefix} ${nextNumber}`
 }
 
-/**
- * Generates the next workspace name
- */
 export async function generateWorkspaceName(): Promise<string> {
   const response = await fetch('/api/workspaces')
   const data = (await response.json()) as WorkspacesApiResponse
   const workspaces = data.workspaces || []
-
   return generateIncrementalName(workspaces, 'Workspace')
 }
 
-/**
- * Generates the next folder name for a workspace
- */
 export async function generateFolderName(workspaceId: string): Promise<string> {
   const response = await fetch(`/api/folders?workspaceId=${workspaceId}`)
   const data = (await response.json()) as FoldersApiResponse
   const folders = data.folders || []
-
-  // Filter to only root-level folders (parentId is null)
   const rootFolders = folders.filter((folder) => folder.parentId === null)
-
   return generateIncrementalName(rootFolders, 'Folder')
 }
 
-/**
- * Generates the next subfolder name for a parent folder
- */
 export async function generateSubfolderName(
   workspaceId: string,
   parentFolderId: string
 ): Promise<string> {
   const response = await fetch(`/api/folders?workspaceId=${workspaceId}`)
   const data = (await response.json()) as FoldersApiResponse
   const folders = data.folders || []
-
-  // Filter to only subfolders of the specified parent
   const subfolders = folders.filter((folder) => folder.parentId === parentFolderId)
-
   return generateIncrementalName(subfolders, 'Subfolder')
 }
 
-/**
- * Generates a creative workflow name using random adjectives and nouns
- * @returns A creative workflow name like "blazing-phoenix" or "crystal-dragon"
- */
 export function generateCreativeWorkflowName(): string {
   const adjective = ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]
   const noun = NOUNS[Math.floor(Math.random() * NOUNS.length)]

apps/sim/stores/workflows/workflow/store.ts

@@ -2,6 +2,7 @@ import type { Edge } from 'reactflow'
 import { create } from 'zustand'
 import { devtools } from 'zustand/middleware'
 import { createLogger } from '@/lib/logs/console/logger'
+import { generateUniqueBlockDuplicateName, normalizeBlockName } from '@/lib/naming'
 import { getBlock } from '@/blocks'
 import { resolveOutputType } from '@/blocks/utils'
 import {
@@ -521,11 +522,8 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           y: block.position.y + 20,
         }
 
-        // More efficient name handling
-        const match = block.name.match(/(.*?)(\d+)?$/)
-        const newName = match?.[2]
-          ? `${match[1]}${Number.parseInt(match[2]) + 1}`
-          : `${block.name} 1`
+        const existingNames = Object.values(get().blocks).map((b: any) => b.name)
+        const newName = generateUniqueBlockDuplicateName(existingNames, block.name)
 
         // Get merged state to capture current subblock values
         const mergedBlock = mergeSubblockState(get().blocks, id)[id]
@@ -602,11 +600,6 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         const oldBlock = get().blocks[id]
         if (!oldBlock) return false
 
-        // Helper function to normalize block names (same as resolver)
-        const normalizeBlockName = (blockName: string): string => {
-          return blockName.toLowerCase().replace(/\s+/g, '')
-        }
-
         // Check for normalized name collisions
         const normalizedNewName = normalizeBlockName(name)
         const currentBlocks = get().blocks