- {/* Processing Status column */}
-
-
- |
-
- {/* Active Status column */}
+ {/* Status column */}
|
@@ -113,17 +108,16 @@ export function DocumentTableSkeleton({
{/* Table header - fixed */}
-
+
-
+
-
-
-
+
+
@@ -145,9 +139,6 @@ export function DocumentTableSkeleton({
|
Uploaded
|
-
- Processing
- |
Status
|
@@ -161,17 +152,16 @@ export function DocumentTableSkeleton({
{/* Table body - scrollable */}
-
+
-
+
-
-
-
+
+
{Array.from({ length: rowCount }).map((_, i) => (
diff --git a/apps/sim/hooks/use-knowledge.ts b/apps/sim/hooks/use-knowledge.ts
index 055d4aea53..dfd2d5f0a4 100644
--- a/apps/sim/hooks/use-knowledge.ts
+++ b/apps/sim/hooks/use-knowledge.ts
@@ -10,19 +10,27 @@ export function useKnowledgeBase(id: string) {
const isLoading = loadingKnowledgeBases.has(id)
useEffect(() => {
+ if (!id || knowledgeBase || isLoading) return
+
+ let isMounted = true
+
const loadData = async () => {
try {
setError(null)
await getKnowledgeBase(id)
} catch (err) {
- setError(err instanceof Error ? err.message : 'Failed to load knowledge base')
+ if (isMounted) {
+ setError(err instanceof Error ? err.message : 'Failed to load knowledge base')
+ }
}
}
- if (id && !knowledgeBase && !isLoading) {
- loadData()
+ loadData()
+
+ return () => {
+ isMounted = false
}
- }, [id, knowledgeBase, isLoading, getKnowledgeBase])
+ }, [id, knowledgeBase, isLoading]) // Removed getKnowledgeBase from dependencies
return {
knowledgeBase,
@@ -41,19 +49,27 @@ export function useKnowledgeBaseDocuments(knowledgeBaseId: string) {
const isLoading = loadingDocuments.has(knowledgeBaseId)
useEffect(() => {
+ if (!knowledgeBaseId || documents.length > 0 || isLoading) return
+
+ let isMounted = true
+
const loadData = async () => {
try {
setError(null)
await getDocuments(knowledgeBaseId)
} catch (err) {
- setError(err instanceof Error ? err.message : 'Failed to load documents')
+ if (isMounted) {
+ setError(err instanceof Error ? err.message : 'Failed to load documents')
+ }
}
}
- if (knowledgeBaseId && documents.length === 0 && !isLoading) {
- loadData()
+ loadData()
+
+ return () => {
+ isMounted = false
}
- }, [knowledgeBaseId, documents.length, isLoading, getDocuments])
+ }, [knowledgeBaseId, documents.length, isLoading]) // Removed getDocuments from dependencies
const refreshDocumentsData = async () => {
try {
@@ -88,29 +104,95 @@ export function useKnowledgeBasesList() {
} = useKnowledgeStore()
const [error, setError] = useState(null)
+ const [retryCount, setRetryCount] = useState(0)
+ const maxRetries = 3
useEffect(() => {
- const loadData = async () => {
+ if (knowledgeBasesList.length > 0 || loadingKnowledgeBasesList) return
+
+ let isMounted = true
+ let retryTimeoutId: NodeJS.Timeout | null = null
+
+ const loadData = async (attempt = 0) => {
+ // Don't proceed if component is unmounted
+ if (!isMounted) return
+
try {
setError(null)
await getKnowledgeBasesList()
+
+ // Reset retry count on success
+ if (isMounted) {
+ setRetryCount(0)
+ }
} catch (err) {
- setError(err instanceof Error ? err.message : 'Failed to load knowledge bases')
+ if (!isMounted) return
+
+ const errorMessage = err instanceof Error ? err.message : 'Failed to load knowledge bases'
+
+ // Only set error and retry if we haven't exceeded max retries
+ if (attempt < maxRetries) {
+ console.warn(`Knowledge bases load attempt ${attempt + 1} failed, retrying...`, err)
+ setRetryCount(attempt + 1)
+
+ // Exponential backoff: 1s, 2s, 4s
+ const delay = 2 ** attempt * 1000
+ retryTimeoutId = setTimeout(() => {
+ if (isMounted) {
+ loadData(attempt + 1)
+ }
+ }, delay)
+ } else {
+ console.error('All retry attempts failed for knowledge bases list:', err)
+ setError(errorMessage)
+ setRetryCount(maxRetries)
+ }
}
}
- if (knowledgeBasesList.length === 0 && !loadingKnowledgeBasesList) {
- loadData()
+ // Always start from attempt 0
+ loadData(0)
+
+ // Cleanup function
+ return () => {
+ isMounted = false
+ if (retryTimeoutId) {
+ clearTimeout(retryTimeoutId)
+ }
}
- }, [knowledgeBasesList.length, loadingKnowledgeBasesList, getKnowledgeBasesList])
+ }, [knowledgeBasesList.length, loadingKnowledgeBasesList]) // Removed getKnowledgeBasesList from dependencies
const refreshList = async () => {
try {
setError(null)
+ setRetryCount(0)
clearKnowledgeBasesList()
await getKnowledgeBasesList()
} catch (err) {
- setError(err instanceof Error ? err.message : 'Failed to refresh knowledge bases')
+ const errorMessage = err instanceof Error ? err.message : 'Failed to refresh knowledge bases'
+ setError(errorMessage)
+ console.error('Error refreshing knowledge bases list:', err)
+ }
+ }
+
+ // Force refresh function that bypasses cache and resets everything
+ const forceRefresh = async () => {
+ setError(null)
+ setRetryCount(0)
+ clearKnowledgeBasesList()
+
+ // Force reload by clearing cache and loading state
+ useKnowledgeStore.setState({
+ knowledgeBasesList: [],
+ loadingKnowledgeBasesList: false,
+ })
+
+ try {
+ await getKnowledgeBasesList()
+ } catch (err) {
+ const errorMessage = err instanceof Error ? err.message : 'Failed to refresh knowledge bases'
+ setError(errorMessage)
+ console.error('Error force refreshing knowledge bases list:', err)
}
}
@@ -119,8 +201,11 @@ export function useKnowledgeBasesList() {
isLoading: loadingKnowledgeBasesList,
error,
refreshList,
+ forceRefresh,
addKnowledgeBase,
removeKnowledgeBase,
+ retryCount,
+ maxRetries,
}
}
@@ -140,79 +225,86 @@ export function useDocumentChunks(knowledgeBaseId: string, documentId: string) {
offset: 0,
hasMore: false,
})
+ const [initialLoadDone, setInitialLoadDone] = useState(false)
const isStoreLoading = isChunksLoading(documentId)
const combinedIsLoading = isLoading || isStoreLoading
+ // Single effect to handle all data loading and syncing
useEffect(() => {
if (!knowledgeBaseId || !documentId) return
- const cached = getCachedChunks(documentId)
- if (cached) {
- setChunks(cached.chunks)
- setPagination(cached.pagination)
- setIsLoading(false)
- }
- }, [knowledgeBaseId, documentId, getCachedChunks])
+ let isMounted = true
- // Initial load
- useEffect(() => {
- if (!knowledgeBaseId || !documentId) return
-
- const loadChunks = async () => {
+ const loadAndSyncData = async () => {
try {
- setIsLoading(true)
- setError(null)
-
- // Try to get cached chunks first
+ // Check cache first
const cached = getCachedChunks(documentId)
if (cached) {
- setChunks(cached.chunks)
- setPagination(cached.pagination)
- setIsLoading(false)
+ if (isMounted) {
+ setChunks(cached.chunks)
+ setPagination(cached.pagination)
+ setIsLoading(false)
+ setInitialLoadDone(true)
+ }
return
}
- // If not cached, fetch from API
- const fetchedChunks = await getChunks(knowledgeBaseId, documentId, {
- limit: pagination.limit,
- offset: pagination.offset,
- })
+ // If not cached and we haven't done initial load, fetch from API
+ if (!initialLoadDone && !isStoreLoading) {
+ setIsLoading(true)
+ setError(null)
- setChunks(fetchedChunks)
+ const fetchedChunks = await getChunks(knowledgeBaseId, documentId, {
+ limit: 50, // Use fixed initial values to avoid dependency issues
+ offset: 0,
+ })
- // Update pagination from cache after fetch
- const updatedCache = getCachedChunks(documentId)
- if (updatedCache) {
- setPagination(updatedCache.pagination)
+ if (isMounted) {
+ setChunks(fetchedChunks)
+
+ // Update pagination from cache after fetch
+ const updatedCache = getCachedChunks(documentId)
+ if (updatedCache) {
+ setPagination(updatedCache.pagination)
+ }
+
+ setInitialLoadDone(true)
+ }
}
} catch (err) {
- setError(err instanceof Error ? err.message : 'Failed to load chunks')
+ if (isMounted) {
+ setError(err instanceof Error ? err.message : 'Failed to load chunks')
+ }
} finally {
- setIsLoading(false)
+ if (isMounted) {
+ setIsLoading(false)
+ }
}
}
- loadChunks()
- }, [knowledgeBaseId, documentId, getChunks, getCachedChunks])
+ loadAndSyncData()
- // Sync with store state changes
+ return () => {
+ isMounted = false
+ }
+ }, [knowledgeBaseId, documentId, isStoreLoading, initialLoadDone]) // Removed getCachedChunks and getChunks from dependencies
+
+ // Separate effect to sync with store state changes (no API calls)
useEffect(() => {
+ if (!documentId || !initialLoadDone) return
+
const cached = getCachedChunks(documentId)
if (cached) {
setChunks(cached.chunks)
setPagination(cached.pagination)
}
- }, [documentId, getCachedChunks])
- useEffect(() => {
+ // Update loading state based on store
if (!isStoreLoading && isLoading) {
- const cached = getCachedChunks(documentId)
- if (cached) {
- setIsLoading(false)
- }
+ setIsLoading(false)
}
- }, [isStoreLoading, isLoading, documentId, getCachedChunks])
+ }, [documentId, isStoreLoading, isLoading, initialLoadDone]) // Removed getCachedChunks from dependencies
const refreshChunksData = async (options?: {
search?: string
diff --git a/apps/sim/stores/knowledge/knowledge.ts b/apps/sim/stores/knowledge/knowledge.ts
index 272e8ec07b..29644c2ed6 100644
--- a/apps/sim/stores/knowledge/knowledge.ts
+++ b/apps/sim/stores/knowledge/knowledge.ts
@@ -373,13 +373,29 @@ export const useKnowledgeStore = create((set, get) => ({
return state.knowledgeBasesList
}
+ // Create an AbortController for request cancellation
+ const abortController = new AbortController()
+ const timeoutId = setTimeout(() => {
+ abortController.abort()
+ }, 10000) // 10 second timeout
+
try {
set({ loadingKnowledgeBasesList: true })
- const response = await fetch('/api/knowledge')
+ const response = await fetch('/api/knowledge', {
+ signal: abortController.signal,
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ })
+
+ // Clear the timeout since request completed
+ clearTimeout(timeoutId)
if (!response.ok) {
- throw new Error(`Failed to fetch knowledge bases: ${response.statusText}`)
+ throw new Error(
+ `Failed to fetch knowledge bases: ${response.status} ${response.statusText}`
+ )
}
const result = await response.json()
@@ -388,7 +404,7 @@ export const useKnowledgeStore = create((set, get) => ({
throw new Error(result.error || 'Failed to fetch knowledge bases')
}
- const knowledgeBasesList = result.data
+ const knowledgeBasesList = result.data || []
set({
knowledgeBasesList,
@@ -398,9 +414,20 @@ export const useKnowledgeStore = create((set, get) => ({
logger.info(`Knowledge bases list loaded: ${knowledgeBasesList.length} items`)
return knowledgeBasesList
} catch (error) {
+ // Clear the timeout in case of error
+ clearTimeout(timeoutId)
+
logger.error('Error fetching knowledge bases list:', error)
+ // Always set loading to false, even on error
set({ loadingKnowledgeBasesList: false })
+
+ // Don't throw on AbortError (timeout or cancellation)
+ if (error instanceof Error && error.name === 'AbortError') {
+ logger.warn('Knowledge bases list request was aborted (timeout or cancellation)')
+ return state.knowledgeBasesList // Return whatever we have cached
+ }
+
throw error
}
},