fix(lock): fetch parent blocks for edge protection checks and consistent tooltip

- Fixed edge operations to fetch parent blocks before checking lock status
  - Previously, isBlockProtected checked if parent was locked, but the parent
    wasn't in blocksById because only source/target blocks were fetched
  - Now fetches parent blocks for all four edge operations: ADD, REMOVE,
    BATCH_ADD_EDGES, BATCH_REMOVE_EDGES
- Fixed tooltip inconsistency: changed "Run previous blocks first" to
  "Run upstream blocks first" in action-bar to match workflow.tsx

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/action-bar/action-bar.tsx

@@ -194,7 +194,7 @@ export const ActionBar = memo(
               {(() => {
                 if (disabled) return getTooltipMessage('Run from block')
                 if (isExecuting) return 'Execution in progress'
-                if (!dependenciesSatisfied) return 'Run previous blocks first'
+                if (!dependenciesSatisfied) return 'Run upstream blocks first'
                 return 'Run from block'
               })()}
             </Tooltip.Content>

apps/sim/socket/database/operations.ts

@@ -1133,12 +1133,10 @@ async function handleBlocksOperationTx(
 async function handleEdgeOperationTx(tx: any, workflowId: string, operation: string, payload: any) {
   switch (operation) {
     case EDGE_OPERATIONS.ADD: {
-      // Validate required fields
       if (!payload.id || !payload.source || !payload.target) {
         throw new Error('Missing required fields for add edge operation')
       }
 
-      // Check if source or target blocks are protected (locked or inside locked parent)
       const edgeBlocks = await tx
         .select({
           id: workflowBlocks.id,
@@ -1158,6 +1156,36 @@ async function handleEdgeOperationTx(tx: any, workflowId: string, operation: str
         edgeBlocks.map((b: EdgeBlockRecord) => [b.id, b])
       )
 
+      const parentIds = new Set<string>()
+      for (const block of edgeBlocks) {
+        const parentId = (block.data as Record<string, unknown> | null)?.parentId as
+          | string
+          | undefined
+        if (parentId && !blocksById[parentId]) {
+          parentIds.add(parentId)
+        }
+      }
+
+      // Fetch parent blocks if needed
+      if (parentIds.size > 0) {
+        const parentBlocks = await tx
+          .select({
+            id: workflowBlocks.id,
+            locked: workflowBlocks.locked,
+            data: workflowBlocks.data,
+          })
+          .from(workflowBlocks)
+          .where(
+            and(
+              eq(workflowBlocks.workflowId, workflowId),
+              inArray(workflowBlocks.id, Array.from(parentIds))
+            )
+          )
+        for (const b of parentBlocks) {
+          blocksById[b.id] = b
+        }
+      }
+
       const isBlockProtected = (blockId: string): boolean => {
         const block = blocksById[blockId]
         if (!block) return false
@@ -1226,6 +1254,37 @@ async function handleEdgeOperationTx(tx: any, workflowId: string, operation: str
         connectedBlocks.map((b: RemoveEdgeBlockRecord) => [b.id, b])
       )
 
+      // Collect parent IDs that need to be fetched
+      const parentIds = new Set<string>()
+      for (const block of connectedBlocks) {
+        const parentId = (block.data as Record<string, unknown> | null)?.parentId as
+          | string
+          | undefined
+        if (parentId && !blocksById[parentId]) {
+          parentIds.add(parentId)
+        }
+      }
+
+      // Fetch parent blocks if needed
+      if (parentIds.size > 0) {
+        const parentBlocks = await tx
+          .select({
+            id: workflowBlocks.id,
+            locked: workflowBlocks.locked,
+            data: workflowBlocks.data,
+          })
+          .from(workflowBlocks)
+          .where(
+            and(
+              eq(workflowBlocks.workflowId, workflowId),
+              inArray(workflowBlocks.id, Array.from(parentIds))
+            )
+          )
+        for (const b of parentBlocks) {
+          blocksById[b.id] = b
+        }
+      }
+
       const isBlockProtected = (blockId: string): boolean => {
         const block = blocksById[blockId]
         if (!block) return false
@@ -1319,6 +1378,37 @@ async function handleEdgesOperationTx(
         connectedBlocks.map((b: EdgeBlockRecord) => [b.id, b])
       )
 
+      // Collect parent IDs that need to be fetched
+      const parentIds = new Set<string>()
+      for (const block of connectedBlocks) {
+        const parentId = (block.data as Record<string, unknown> | null)?.parentId as
+          | string
+          | undefined
+        if (parentId && !blocksById[parentId]) {
+          parentIds.add(parentId)
+        }
+      }
+
+      // Fetch parent blocks if needed
+      if (parentIds.size > 0) {
+        const parentBlocks = await tx
+          .select({
+            id: workflowBlocks.id,
+            locked: workflowBlocks.locked,
+            data: workflowBlocks.data,
+          })
+          .from(workflowBlocks)
+          .where(
+            and(
+              eq(workflowBlocks.workflowId, workflowId),
+              inArray(workflowBlocks.id, Array.from(parentIds))
+            )
+          )
+        for (const b of parentBlocks) {
+          blocksById[b.id] = b
+        }
+      }
+
       const isBlockProtected = (blockId: string): boolean => {
         const block = blocksById[blockId]
         if (!block) return false
@@ -1388,6 +1478,37 @@ async function handleEdgesOperationTx(
         connectedBlocks.map((b: AddEdgeBlockRecord) => [b.id, b])
       )
 
+      // Collect parent IDs that need to be fetched
+      const parentIds = new Set<string>()
+      for (const block of connectedBlocks) {
+        const parentId = (block.data as Record<string, unknown> | null)?.parentId as
+          | string
+          | undefined
+        if (parentId && !blocksById[parentId]) {
+          parentIds.add(parentId)
+        }
+      }
+
+      // Fetch parent blocks if needed
+      if (parentIds.size > 0) {
+        const parentBlocks = await tx
+          .select({
+            id: workflowBlocks.id,
+            locked: workflowBlocks.locked,
+            data: workflowBlocks.data,
+          })
+          .from(workflowBlocks)
+          .where(
+            and(
+              eq(workflowBlocks.workflowId, workflowId),
+              inArray(workflowBlocks.id, Array.from(parentIds))
+            )
+          )
+        for (const b of parentBlocks) {
+          blocksById[b.id] = b
+        }
+      }
+
       const isBlockProtected = (blockId: string): boolean => {
         const block = blocksById[blockId]
         if (!block) return false