import { useCallback, useRef, useState } from "react"; import { useMutation, useQueryClient } from "@tanstack/react-query"; import { useI18n } from "@/i18n/i18n-context"; import { addDocuments, UPLOAD_TIMEOUT_MS, type AddDocumentItem, type DocumentOperationResult, } from "@/services/documents"; import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys"; export interface OssImportProgress { phase: "upload" | "done"; totalItems: number; completedItems: number; errors: string[]; } interface OssImportVariables { knowledgeBaseName: string; /** ossKeys for individually-checked files. Submitted as-is, no filters. */ fileKeys: string[]; /** Folder prefixes (ending with `/`). Server recurses; filters apply. */ folderPrefixes: string[]; /** Glob arrays produced by `lib/glob-filter.ts`. Sent to the server only * on folder items — file items don't carry filters. */ inclusionFilters?: string[]; exclusionFilters?: string[]; subspace?: string; metadata?: Record; } const SUBMISSION_BATCH_SIZE = 10; // matches services/documents.ts BATCH_SIZE /** * Submit an OSS-mode import to the KB. * * The KB API natively accepts a folder ossKey (`oss:///docs/2026/`) * and recurses on the server side, so the client doesn't need to expand * folders into individual keys. Each {@link OssSelection} item becomes one * `AddDocumentItem`: * * - file selection → `{ ossKey }` (no filters) * - folder selection → `{ ossKey, inclusionFilters?, exclusionFilters? }` * * The full document list is submitted via `addDocuments`, which already * handles `BATCH_SIZE` chunking internally. We re-batch here only because * we want incremental progress — `addDocuments` doesn't expose a callback. * * Per-batch failures are tolerated: surviving batches' results are kept and * the failed slice is recorded as `status: "failed"` per ossKey. This * mirrors `useUploadDocuments`'s tolerance for partial-failure import. */ export function useOssImport() { const queryClient = useQueryClient(); const { t } = useI18n(); const tRef = useRef(t); tRef.current = t; const [progress, setProgress] = useState(null); const resetProgress = useCallback(() => setProgress(null), []); const mutation = useMutation({ mutationFn: async (vars: OssImportVariables) => { // Build the AddDocumentItem list. Filters attach only to folder items — // a checked file is an explicit user intent and bypasses include/exclude // (matches the local-folder semantics). const items: AddDocumentItem[] = [ ...vars.fileKeys.map((ossKey) => ({ ossKey, ...(vars.metadata ? { metadata: vars.metadata } : {}), })), ...vars.folderPrefixes.map((ossKey) => ({ ossKey, ...(vars.metadata ? { metadata: vars.metadata } : {}), ...(vars.inclusionFilters ? { inclusionFilters: vars.inclusionFilters } : {}), ...(vars.exclusionFilters ? { exclusionFilters: vars.exclusionFilters } : {}), })), ]; if (items.length === 0) { setProgress({ phase: "done", totalItems: 0, completedItems: 0, errors: [], }); return { documentDetails: [] as DocumentOperationResult[] }; } setProgress({ phase: "upload", totalItems: items.length, completedItems: 0, errors: [], }); const allResults: DocumentOperationResult[] = []; const allErrors: string[] = []; for (let i = 0; i < items.length; i += SUBMISSION_BATCH_SIZE) { const slice = items.slice(i, i + SUBMISSION_BATCH_SIZE); try { const resp = await addDocuments( { knowledgeBaseName: vars.knowledgeBaseName, subspace: vars.subspace, documents: slice, }, { timeoutMs: UPLOAD_TIMEOUT_MS }, ); allResults.push(...resp.documentDetails); } catch (err) { const message = err instanceof Error ? err.message : String(err); allErrors.push( `${tRef.current("documents.upload.batchErrorPrefix", { n: Math.floor(i / SUBMISSION_BATCH_SIZE) + 1 })}${message}`, ); for (const item of slice) { allResults.push({ ossKey: item.ossKey, status: "failed", failureReason: message, }); } } setProgress((p) => p ? { ...p, completedItems: Math.min( p.totalItems, p.completedItems + slice.length, ), } : p, ); } setProgress({ phase: "done", totalItems: items.length, completedItems: items.length, errors: allErrors, }); return { documentDetails: allResults }; }, onSuccess: () => { invalidateKnowledgeBaseQueries(queryClient); }, onSettled: () => { // Match the local upload hook's "linger briefly so the user reads the // final state" gesture before clearing. setTimeout(resetProgress, 300); }, }); return { ...mutation, progress }; }