chore: use flow type instead of whole url

web/app/components/workflow-app/components/workflow-main.tsx

   useWorkflowRun,
   useWorkflowStartRun,
 } from '../hooks'
-import { useStore, useWorkflowStore } from '@/app/components/workflow/store'
+import { useWorkflowStore } from '@/app/components/workflow/store'
 
 type WorkflowMainProps = Pick<WorkflowProps, 'nodes' | 'edges' | 'viewport'>
 const WorkflowMain = ({
     handleWorkflowStartRunInChatflow,
     handleWorkflowStartRunInWorkflow,
   } = useWorkflowStartRun()
-  const appId = useStore(s => s.appId)
   const availableNodesMetaData = useAvailableNodesMetaData()
   const { getWorkflowRunAndTraceUrl } = useGetRunAndTraceUrl()
   const {
     handleExportDSL,
   } = useDSL()
   const { fetchInspectVars } = useSetWorkflowVarsWithValue({
-    flowId: appId,
     ...useConfigsMap(),
   })
   const {

web/app/components/workflow-app/hooks/use-configs-map.ts

     return {
       flowId: appId!,
       flowType: FlowType.appFlow,
-      conversationVarsUrl: `apps/${appId}/workflows/draft/conversation-variables`,
-      systemVarsUrl: `apps/${appId}/workflows/draft/system-variables`,
     }
   }, [appId])
 }

web/app/components/workflow/hooks-store/store.ts

   configsMap?: {
     flowId: string
     flowType: FlowType
-    conversationVarsUrl: string
-    systemVarsUrl: string
   }
 }
 

web/app/components/workflow/hooks/use-fetch-workflow-inspect-vars.ts

 type Params = {
   flowType: FlowType
   flowId: string
-  conversationVarsUrl: string
-  systemVarsUrl: string
 }
 
 export const useSetWorkflowVarsWithValue = ({
   flowType,
   flowId,
-  conversationVarsUrl,
-  systemVarsUrl,
 }: Params) => {
   const workflowStore = useWorkflowStore()
   const store = useStoreApi()
-  const invalidateConversationVarValues = useInvalidateConversationVarValues(conversationVarsUrl)
-  const invalidateSysVarValues = useInvalidateSysVarValues(systemVarsUrl)
+  const invalidateConversationVarValues = useInvalidateConversationVarValues(flowType, flowId)
+  const invalidateSysVarValues = useInvalidateSysVarValues(flowType, flowId)
   const { handleCancelAllNodeSuccessStatus } = useNodesInteractionsWithoutSync()
 
   const setInspectVarsToStore = useCallback((inspectVars: VarInInspect[]) => {

web/app/components/workflow/hooks/use-inspect-vars-crud-common.ts

 import type { ValueSelector } from '@/app/components/workflow/types'
 import type { VarInInspect } from '@/types/workflow'
 import { VarInInspectType } from '@/types/workflow'
-import {
-  useInvalidateConversationVarValues,
-  useInvalidateSysVarValues,
-} from '@/service/use-workflow'
+
 import { useCallback } from 'react'
 import { isConversationVar, isENV, isSystemVar } from '@/app/components/workflow/nodes/_base/components/variable/utils'
 import produce from 'immer'
 type Params = {
   flowId: string
   flowType: FlowType
-  conversationVarsUrl: string
-  systemVarsUrl: string
 }
 export const useInspectVarsCrudCommon = ({
   flowId,
   flowType,
-  conversationVarsUrl,
-  systemVarsUrl,
 }: Params) => {
   const workflowStore = useWorkflowStore()
   const {
+    useInvalidateConversationVarValues,
+    useInvalidateSysVarValues,
     useResetConversationVar,
     useResetToLastRunValue,
     useDeleteAllInspectorVars,
     useDeleteInspectVar,
     useEditInspectorVar,
   } = useFLow({ flowType })
-  const invalidateConversationVarValues = useInvalidateConversationVarValues(conversationVarsUrl!)
+  const invalidateConversationVarValues = useInvalidateConversationVarValues(flowId)
   const { mutateAsync: doResetConversationVar } = useResetConversationVar(flowId)
   const { mutateAsync: doResetToLastRunValue } = useResetToLastRunValue(flowId)
-  const invalidateSysVarValues = useInvalidateSysVarValues(systemVarsUrl!)
+  const invalidateSysVarValues = useInvalidateSysVarValues(flowId)
 
   const { mutateAsync: doDeleteAllInspectorVars } = useDeleteAllInspectorVars(flowId)
   const { mutate: doDeleteNodeInspectorVars } = useDeleteNodeInspectorVars(flowId)

web/app/components/workflow/hooks/use-inspect-vars-crud.ts

 const useInspectVarsCrud = () => {
   const nodesWithInspectVars = useStore(s => s.nodesWithInspectVars)
   const configsMap = useHooksStore(s => s.configsMap)
-  const { data: conversationVars } = useConversationVarValues(configsMap?.conversationVarsUrl)
-  const { data: systemVars } = useSysVarValues(configsMap?.systemVarsUrl)
+  const { data: conversationVars } = useConversationVarValues(configsMap?.flowType, configsMap?.flowId)
+  const { data: systemVars } = useSysVarValues(configsMap?.flowType, configsMap?.flowId)
   const hasNodeInspectVars = useHooksStore(s => s.hasNodeInspectVars)
   const hasSetInspectVar = useHooksStore(s => s.hasSetInspectVar)
   const fetchInspectVarValue = useHooksStore(s => s.fetchInspectVarValue)

web/service/use-flow.ts

   useDeleteInspectVar as useDeleteInspectVarInner,
   useDeleteNodeInspectorVars as useDeleteNodeInspectorVarsInner,
   useEditInspectorVar as useEditInspectorVarInner,
+  useInvalidateConversationVarValues as useInvalidateConversationVarValuesInner,
+  useInvalidateSysVarValues as useInvalidateSysVarValuesInner,
   useResetConversationVar as useResetConversationVarInner,
   useResetToLastRunValue as useResetToLastRunValueInner,
 } from './use-workflow'
   flowType,
 }: Params) => {
   return {
+    useInvalidateConversationVarValues: curry(useInvalidateConversationVarValuesInner)(flowType),
+    useInvalidateSysVarValues: curry(useInvalidateSysVarValuesInner)(flowType),
     useResetConversationVar: curry(useResetConversationVarInner)(flowType),
     useResetToLastRunValue: curry(useResetToLastRunValueInner)(flowType),
     useDeleteAllInspectorVars: curry(useDeleteAllInspectorVarsInner)(flowType),

web/service/use-workflow.ts

   return useInvalid([NAME_SPACE, flowType, 'last-run', flowId])
 }
 
-const useConversationVarValuesKey = [NAME_SPACE, 'conversation-variable']
-
-export const useConversationVarValues = (url?: string) => {
+export const useConversationVarValues = (flowType?: FlowType, flowId?: string) => {
   return useQuery({
-    enabled: !!url,
-    queryKey: [...useConversationVarValuesKey, url],
+    enabled: !!flowId,
+    queryKey: [NAME_SPACE, flowType, 'conversation var values', flowId],
     queryFn: async () => {
-      const { items } = (await get(url || '')) as { items: VarInInspect[] }
+      const { items } = (await get(`${getFlowPrefix(flowType)}/${flowId}/workflows/draft/conversation-variables`)) as { items: VarInInspect[] }
       return items
     },
   })
 }
 
-export const useInvalidateConversationVarValues = (url: string) => {
-  return useInvalid([...useConversationVarValuesKey, url])
+export const useInvalidateConversationVarValues = (flowType: FlowType, flowId: string) => {
+  return useInvalid([NAME_SPACE, flowType, 'conversation var values', flowId])
 }
 
 export const useResetConversationVar = (flowType: FlowType, flowId: string) => {
 }
 
 export const useSysVarValuesKey = [NAME_SPACE, 'sys-variable']
-export const useSysVarValues = (url?: string) => {
+export const useSysVarValues = (flowType?: FlowType, flowId?: string) => {
   return useQuery({
-    enabled: !!url,
-    queryKey: [...useSysVarValuesKey, url],
+    enabled: !!flowId,
+    queryKey: [NAME_SPACE, flowType, 'sys var values', flowId],
     queryFn: async () => {
-      const { items } = (await get(url || '')) as { items: VarInInspect[] }
+      const { items } = (await get(`${getFlowPrefix(flowType)}/${flowId}/workflows/draft/system-variables`)) as { items: VarInInspect[] }
       return items
     },
   })
 }
 
-export const useInvalidateSysVarValues = (url: string) => {
-  return useInvalid([...useSysVarValuesKey, url])
+export const useInvalidateSysVarValues = (flowType: FlowType, flowId: string) => {
+  return useInvalid([NAME_SPACE, flowType, 'sys var values', flowId])
 }
 
 export const useDeleteAllInspectorVars = (flowType: FlowType, flowId: string) => {

web/service/utils.ts

   [FlowType.ragFlow]: 'rag/pipelines',
 }
 
-export const getFlowPrefix = (type: FlowType) => {
-  return flowPrefixMap[type] || flowPrefixMap[FlowType.appFlow]
+export const getFlowPrefix = (type?: FlowType) => {
+  return flowPrefixMap[type!] || flowPrefixMap[FlowType.appFlow]
 }