Function usePermissionConfig

apps/sim/hooks/use-permission-config.ts:69–185

()

}

export function usePermissionConfig(): PermissionConfigResult {
  const params = useParams()
  const workspaceId = typeof params?.workspaceId === 'string' ? params.workspaceId : undefined

  const { data: permissionData, isLoading: isPermissionLoading } =
    useUserPermissionConfig(workspaceId)
  const { data: envAllowlistData, isLoading: isEnvAllowlistLoading } =
    useAllowedIntegrationsFromEnv()

  const isLoading = isPermissionLoading || isEnvAllowlistLoading

  const config = useMemo(() => {
    if (!permissionData?.config) {
      return DEFAULT_PERMISSION_GROUP_CONFIG
    }
    return permissionData.config
  }, [permissionData])

  const isInPermissionGroup = !!permissionData?.permissionGroupId

  const mergedAllowedIntegrations = useMemo(() => {
    const envAllowlist = envAllowlistData?.allowedIntegrations ?? null
    return intersectAllowlists(config.allowedIntegrations, envAllowlist)
  }, [config.allowedIntegrations, envAllowlistData])

  const isBlockAllowed = useMemo(() => {
    return (blockType: string) => {
      if (isBlockTypeAccessControlExempt(blockType)) return true
      if (mergedAllowedIntegrations === null) return true
      return mergedAllowedIntegrations.includes(blockType.toLowerCase())
    }
  }, [mergedAllowedIntegrations])

  const isProviderAllowed = useMemo(() => {
    return (providerId: string) => {
      if (config.allowedModelProviders === null) return true
      return config.allowedModelProviders.includes(providerId)
    }
  }, [config.allowedModelProviders])

  const isModelAllowed = useMemo(() => {
    return (model: string) => {
      if (config.deniedModels.length === 0) return true
      const normalized = model.toLowerCase()
      return !config.deniedModels.some((denied) => denied.toLowerCase() === normalized)
    }
  }, [config.deniedModels])

  const isToolAllowed = useMemo(() => {
    return (toolId: string) => {
      if (config.deniedTools.length === 0) return true
      return !config.deniedTools.includes(toolId)
    }
  }, [config.deniedTools])

  const filterBlocks = useMemo(() => {
    return <T extends { type: string }>(blocks: T[]): T[] => {
      if (mergedAllowedIntegrations === null) return blocks