address comments

Author: icecrasher321

apps/sim/app/api/folders/[id]/duplicate/route.ts

@@ -11,6 +11,7 @@ import { parseRequest } from '@/lib/api/server'
 import { getSession } from '@/lib/auth'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import type { DbOrTx } from '@/lib/db/types'
 import { duplicateWorkflow } from '@/lib/workflows/persistence/duplicate'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
@@ -216,10 +217,8 @@ export const POST = withRouteHandler(
   }
 )
 
-type FolderDuplicateTransaction = Parameters<Parameters<typeof db.transaction>[0]>[0]
-
 async function assertTargetParentFolderMutable(
-  tx: FolderDuplicateTransaction,
+  tx: DbOrTx,
   parentId: string | null,
   targetWorkspaceId: string,
   sourceFolderId: string
@@ -256,7 +255,7 @@ async function assertTargetParentFolderMutable(
 }
 
 async function deduplicateFolderName(
-  tx: FolderDuplicateTransaction,
+  tx: DbOrTx,
   workspaceId: string,
   parentId: string | null,
   requestedName: string
@@ -287,7 +286,7 @@ async function deduplicateFolderName(
 }
 
 async function duplicateFolderStructure(
-  tx: FolderDuplicateTransaction,
+  tx: DbOrTx,
   sourceFolderId: string,
   newParentFolderId: string,
   sourceWorkspaceId: string,
@@ -339,7 +338,7 @@ async function duplicateFolderStructure(
 }
 
 async function duplicateWorkflowsInFolderTree(
-  tx: FolderDuplicateTransaction,
+  tx: DbOrTx,
   sourceWorkspaceId: string,
   targetWorkspaceId: string,
   folderMapping: Map<string, string>,

apps/sim/app/api/workflows/[id]/deploy/route.ts

@@ -39,7 +39,6 @@ export const GET = withRouteHandler(
       if (error) {
         return createErrorResponse(error.message, error.status)
       }
-      await assertWorkflowMutable(id)
 
       if (!workflowData.isDeployed) {
         logger.info(`[${requestId}] Workflow is not deployed: ${id}`)

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/editor.tsx

@@ -49,7 +49,7 @@ import { PreviewWorkflow } from '@/app/workspace/[workspaceId]/w/components/prev
 import { getBlock } from '@/blocks/registry'
 import type { SubBlockType } from '@/blocks/types'
 import { useFolderMap } from '@/hooks/queries/folders'
-import { isFolderOrAncestorLocked } from '@/hooks/queries/utils/folder-locks'
+import { isFolderOrAncestorLocked } from '@/hooks/queries/utils/folder-tree'
 import { useWorkflowMap, useWorkflowState } from '@/hooks/queries/workflows'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { usePanelEditorStore } from '@/stores/panel'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/panel.tsx

@@ -73,7 +73,7 @@ import {
   useCopilotChats,
 } from '@/hooks/queries/copilot-chats'
 import { useFolderMap } from '@/hooks/queries/folders'
-import { isFolderOrAncestorLocked } from '@/hooks/queries/utils/folder-locks'
+import { isFolderOrAncestorLocked } from '@/hooks/queries/utils/folder-tree'
 import { useDuplicateWorkflowMutation, useWorkflowMap } from '@/hooks/queries/workflows'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { usePermissionConfig } from '@/hooks/use-permission-config'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx

@@ -80,7 +80,10 @@ import { isAnnotationOnlyBlock } from '@/executor/constants'
 import { useWorkspaceEnvironment } from '@/hooks/queries/environment'
 import { useFolderMap } from '@/hooks/queries/folders'
 import { useAutoConnect, useSnapToGridSize } from '@/hooks/queries/general-settings'
-import { isFolderOrAncestorLocked } from '@/hooks/queries/utils/folder-locks'
+import {
+  findLockedAncestorFolder,
+  isFolderOrAncestorLocked,
+} from '@/hooks/queries/utils/folder-tree'
 import { useUpdateWorkflow, useWorkflowMap } from '@/hooks/queries/workflows'
 import { useCanvasViewport } from '@/hooks/use-canvas-viewport'
 import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
@@ -1240,35 +1243,64 @@ const WorkflowContent = React.memo(
       }
     }, [activeWorkflowId, clearLockNotification])
 
+    /**
+     * Locate the folder ancestor that supplies the inherited lock so the
+     * notification can name it. Null when the lock is row/block-level instead.
+     */
+    const inheritedLockFolderName = useMemo(() => {
+      if (!workflowFolderLocked) return null
+      return findLockedAncestorFolder(workflowMetadata?.folderId, folders)?.name ?? null
+    }, [workflowFolderLocked, workflowMetadata?.folderId, folders])
+
     const prevCanAdminRef = useRef(effectivePermissions.canAdmin)
+    const prevLockSignatureRef = useRef<string | null>(null)
     useEffect(() => {
       if (!isWorkflowReady) return
 
       const canAdminChanged = prevCanAdminRef.current !== effectivePermissions.canAdmin
       prevCanAdminRef.current = effectivePermissions.canAdmin
 
-      // Clear stale notification when admin status changes so it recreates with correct message
-      if (canAdminChanged) {
+      const lockSignature = workflowReadOnly
+        ? `${workflowRowLocked ? 'row' : workflowFolderLocked ? `folder:${inheritedLockFolderName ?? ''}` : 'blocks'}`
+        : null
+      const lockSignatureChanged = prevLockSignatureRef.current !== lockSignature
+      prevLockSignatureRef.current = lockSignature
+
+      if (canAdminChanged || lockSignatureChanged) {
         clearLockNotification()
       }
 
       if (workflowReadOnly) {
         if (lockNotificationIdRef.current) return
 
         const isAdmin = effectivePermissions.canAdmin
+        const isFolderInherited = workflowFolderLocked && !workflowRowLocked
+        const message = isFolderInherited
+          ? inheritedLockFolderName
+            ? `This workflow is locked by folder "${inheritedLockFolderName}"`
+            : 'This workflow is locked by a parent folder'
+          : isAdmin
+            ? 'This workflow is locked'
+            : 'This workflow is locked. Ask an admin to unlock it.'
+
+        const showInlineUnlock = isAdmin && !isFolderInherited
+
         lockNotificationIdRef.current = addNotification({
           level: 'info',
-          message: isAdmin
-            ? 'This workflow is locked'
-            : 'This workflow is locked. Ask an admin to unlock it.',
+          message,
           workflowId: activeWorkflowId || undefined,
-          ...(isAdmin ? { action: { type: 'unlock-workflow' as const, message: '' } } : {}),
+          ...(showInlineUnlock
+            ? { action: { type: 'unlock-workflow' as const, message: '' } }
+            : {}),
         })
       } else {
         clearLockNotification()
       }
     }, [
       workflowReadOnly,
+      workflowRowLocked,
+      workflowFolderLocked,
+      inheritedLockFolderName,
       isWorkflowReady,
       effectivePermissions.canAdmin,
       addNotification,
@@ -1291,6 +1323,8 @@ const WorkflowContent = React.memo(
           return
         }
 
+        if (workflowFolderLocked) return
+
         const currentBlocks = useWorkflowStore.getState().blocks
         const ids = getWorkflowLockToggleIds(currentBlocks, false)
         if (ids.length > 0) collaborativeBatchToggleLocked(ids)
@@ -1302,6 +1336,7 @@ const WorkflowContent = React.memo(
       activeWorkflowId,
       collaborativeBatchToggleLocked,
       updateWorkflowMutation,
+      workflowFolderLocked,
       workflowRowLocked,
       workspaceId,
     ])

apps/sim/hooks/queries/utils/folder-locks.ts

@@ -0,0 +1,147 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  findLockedAncestorFolder,
+  getFolderPath,
+  isFolderOrAncestorLocked,
+} from '@/hooks/queries/utils/folder-tree'
+import type { WorkflowFolder } from '@/stores/folders/types'
+
+function makeFolder(overrides: Partial<WorkflowFolder> & { id: string }): WorkflowFolder {
+  return {
+    id: overrides.id,
+    name: overrides.name ?? overrides.id,
+    userId: 'user-1',
+    workspaceId: 'ws-1',
+    parentId: overrides.parentId ?? null,
+    color: '#000000',
+    isExpanded: false,
+    locked: overrides.locked ?? false,
+    sortOrder: 0,
+    createdAt: new Date(0),
+    updatedAt: new Date(0),
+    archivedAt: null,
+  }
+}
+
+describe('isFolderOrAncestorLocked', () => {
+  it('returns false for root', () => {
+    expect(isFolderOrAncestorLocked(null, {})).toBe(false)
+    expect(isFolderOrAncestorLocked(undefined, {})).toBe(false)
+  })
+
+  it('returns true when the folder itself is locked', () => {
+    const folders = { f1: makeFolder({ id: 'f1', locked: true }) }
+    expect(isFolderOrAncestorLocked('f1', folders)).toBe(true)
+  })
+
+  it('returns true when an ancestor is locked', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1', locked: true }),
+      f2: makeFolder({ id: 'f2', parentId: 'f1' }),
+      f3: makeFolder({ id: 'f3', parentId: 'f2' }),
+    }
+    expect(isFolderOrAncestorLocked('f3', folders)).toBe(true)
+  })
+
+  it('returns false when nothing in the chain is locked', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1' }),
+      f2: makeFolder({ id: 'f2', parentId: 'f1' }),
+    }
+    expect(isFolderOrAncestorLocked('f2', folders)).toBe(false)
+  })
+
+  it('short-circuits on cycles instead of looping forever', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1', parentId: 'f2' }),
+      f2: makeFolder({ id: 'f2', parentId: 'f1' }),
+    }
+    expect(isFolderOrAncestorLocked('f1', folders)).toBe(false)
+  })
+})
+
+describe('getFolderPath', () => {
+  it('returns null for root or unknown folders', () => {
+    expect(getFolderPath(null, {})).toBeNull()
+    expect(getFolderPath(undefined, {})).toBeNull()
+    expect(getFolderPath('missing', {})).toBeNull()
+  })
+
+  it('returns the leaf folder name when at top level', () => {
+    const folders = { f1: makeFolder({ id: 'f1', name: 'Engineering' }) }
+    expect(getFolderPath('f1', folders)).toBe('Engineering')
+  })
+
+  it('joins ancestor names from root to leaf', () => {
+    const folders = {
+      eng: makeFolder({ id: 'eng', name: 'Engineering' }),
+      be: makeFolder({ id: 'be', name: 'Backend', parentId: 'eng' }),
+      api: makeFolder({ id: 'api', name: 'API', parentId: 'be' }),
+    }
+    expect(getFolderPath('api', folders)).toBe('Engineering / Backend / API')
+  })
+
+  it('respects custom separators', () => {
+    const folders = {
+      eng: makeFolder({ id: 'eng', name: 'Engineering' }),
+      be: makeFolder({ id: 'be', name: 'Backend', parentId: 'eng' }),
+    }
+    expect(getFolderPath('be', folders, ' > ')).toBe('Engineering > Backend')
+  })
+
+  it('returns the partial path resolved before a missing ancestor', () => {
+    const folders = {
+      be: makeFolder({ id: 'be', name: 'Backend', parentId: 'missing' }),
+    }
+    expect(getFolderPath('be', folders)).toBe('Backend')
+  })
+
+  it('short-circuits on cycles instead of looping forever', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1', name: 'A', parentId: 'f2' }),
+      f2: makeFolder({ id: 'f2', name: 'B', parentId: 'f1' }),
+    }
+    expect(getFolderPath('f1', folders)).toBe('B / A')
+  })
+})
+
+describe('findLockedAncestorFolder', () => {
+  it('returns null for root or unknown folders', () => {
+    expect(findLockedAncestorFolder(null, {})).toBeNull()
+    expect(findLockedAncestorFolder(undefined, {})).toBeNull()
+    expect(findLockedAncestorFolder('missing', {})).toBeNull()
+  })
+
+  it('returns the folder itself when it is the locked one', () => {
+    const folders = { f1: makeFolder({ id: 'f1', name: 'Engineering', locked: true }) }
+    expect(findLockedAncestorFolder('f1', folders)?.name).toBe('Engineering')
+  })
+
+  it('returns the closest locked ancestor, not the root', () => {
+    const folders = {
+      root: makeFolder({ id: 'root', name: 'Root', locked: true }),
+      mid: makeFolder({ id: 'mid', name: 'Mid', parentId: 'root', locked: true }),
+      leaf: makeFolder({ id: 'leaf', name: 'Leaf', parentId: 'mid' }),
+    }
+    expect(findLockedAncestorFolder('leaf', folders)?.id).toBe('mid')
+  })
+
+  it('returns null when no folder in the chain is locked', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1', name: 'A' }),
+      f2: makeFolder({ id: 'f2', name: 'B', parentId: 'f1' }),
+    }
+    expect(findLockedAncestorFolder('f2', folders)).toBeNull()
+  })
+
+  it('short-circuits on cycles instead of looping forever', () => {
+    const folders = {
+      f1: makeFolder({ id: 'f1', name: 'A', parentId: 'f2' }),
+      f2: makeFolder({ id: 'f2', name: 'B', parentId: 'f1' }),
+    }
+    expect(findLockedAncestorFolder('f1', folders)).toBeNull()
+  })
+})