@zjlab-fe/data-hub-ui 0.21.7 → 0.23.0

package/es/components/file-uploader/context/use-upload-engine.js

@@ -0,0 +1,440 @@
+import { __awaiter } from 'tslib';
+import { useCallback } from 'react';
+import { useUploadContext } from './upload-context.js';
+import { UploadStatus } from '../constants.js';
+import { createUploadError, UPLOAD_ERROR_CODE, parseError } from '../utils/error-handler.js';
+import { handlerRegistry } from './handler-registry.js';
+import { actionRegistry } from './action-registry.js';
+import { resetInterruptedChunks, getChunksForResume } from '../utils/upload-controllers.js';
+import { fileStateStore } from './file-state-store.js';
+import { ensureHandlers } from '../utils/ensure-handlers.js';
+
+/**
+ * Get fresh handler context from the action registry.
+ * Returns a fallback empty context if not yet initialized.
+ */
+function getHandlerContext() {
+    const ctx = actionRegistry.getContext();
+    if (!ctx) {
+        // Return a minimal fallback context
+        // This can happen during initial render before useUpload updates the registry
+        return {
+            files: [],
+            removeFile: () => __awaiter(this, void 0, void 0, function* () { }),
+            start: () => __awaiter(this, void 0, void 0, function* () { }),
+            pause: () => { },
+            resume: () => __awaiter(this, void 0, void 0, function* () { }),
+            cancel: () => { },
+            getFileById: () => undefined,
+        };
+    }
+    return ctx;
+}
+function applyUploadUrlsToChunks(chunks, uploadUrls) {
+    // Assign partNum and uploadUrl based on server's response
+    // This ensures we respect the server's numbering scheme (0-indexed or 1-indexed)
+    return chunks.map((chunk, index) => {
+        const urlInfo = uploadUrls[index]; // Match chunk index to URL index
+        if (!urlInfo)
+            return chunk; // Skip if no corresponding URL
+        return Object.assign(Object.assign({}, chunk), { partNum: urlInfo.partNum, uploadUrl: urlInfo.uploadUrl });
+    });
+}
+function collectPendingUrlsFromChunks(file, pendingPartNums) {
+    const pendingSet = new Set(pendingPartNums);
+    return file.chunks
+        .filter((chunk) => chunk.partNum !== undefined && pendingSet.has(chunk.partNum) && !!chunk.uploadUrl)
+        .map((chunk) => ({ partNum: chunk.partNum, uploadUrl: chunk.uploadUrl }));
+}
+/**
+ * Hook that integrates QueueManager with React context.
+ *
+ * This hook bridges the imperative QueueManager with React's declarative state.
+ * It provides functions to control uploads while keeping UI state in sync.
+ *
+ * Global config (chunk sizes, concurrency) comes from context.
+ * Handlers are provided per-file via addFiles().
+ *
+ * @returns Upload control functions: startUpload, pauseUpload, resumeUpload, cancelUpload
+ */
+function useUploadEngine() {
+    // QueueManager instance is initialized and managed by UploadProvider
+    // File state is accessed via fileStateStore.getFile() for fresh data without stale closures
+    const { dispatch, getQueueManager } = useUploadContext();
+    // ─────────────────────────────────────────────────────────────────────────────
+    // UPLOAD CONTROLS
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Start uploading a file.
+     *
+     * Flow:
+     * 1. Call onBeforeUpload (can cancel)
+     * 2. Get upload URLs from server
+     * 3. Add file to QueueManager
+     * 4. Call onUploadStart
+     */
+    const startUpload = useCallback((uploadFile) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const h = ensureHandlers(uploadFile, dispatch);
+        if (!h)
+            return;
+        try {
+            // Step 1: Set preparing status
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: uploadFile.id,
+                updates: { status: UploadStatus.PREPARING },
+            });
+            // Step 2: Check onBeforeUpload (can cancel upload)
+            if (h.onBeforeUpload) {
+                const ctx = getHandlerContext();
+                const beforeResult = yield h.onBeforeUpload(uploadFile, ctx);
+                if (!beforeResult.success) {
+                    dispatch({
+                        type: 'UPDATE_FILE',
+                        id: uploadFile.id,
+                        updates: {
+                            status: UploadStatus.CANCELLED,
+                            error: beforeResult.reason,
+                        },
+                    });
+                    return;
+                }
+            }
+            // Step 3: Get upload URLs from server
+            const urlResult = yield h.onGetUploadUrls(uploadFile.fileName, uploadFile.chunks.length, uploadFile);
+            if (!urlResult.success) {
+                const error = createUploadError(UPLOAD_ERROR_CODE.URL_REQUEST_FAILED, (_a = urlResult.reason) !== null && _a !== void 0 ? _a : 'Failed to get upload URLs');
+                dispatch({
+                    type: 'UPDATE_FILE',
+                    id: uploadFile.id,
+                    updates: {
+                        status: UploadStatus.FAILED,
+                        error: error.message,
+                        errorCode: error.code,
+                    },
+                });
+                const ctx = getHandlerContext();
+                (_b = h.onError) === null || _b === void 0 ? void 0 : _b.call(h, uploadFile, new Error(error.message), ctx);
+                return;
+            }
+            // Step 4: Update file with uploadId and start uploading
+            const { uploadId, uploadUrls } = urlResult.uploadInfo;
+            const chunksWithUrls = applyUploadUrlsToChunks(uploadFile.chunks, uploadUrls);
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: uploadFile.id,
+                updates: { uploadId, status: UploadStatus.UPLOADING, chunks: chunksWithUrls },
+            });
+            // Step 5: Add to queue and notify
+            const qm = getQueueManager();
+            const updatedFile = Object.assign(Object.assign({}, uploadFile), { uploadId, chunks: chunksWithUrls });
+            qm.addFile(updatedFile);
+            const ctx = getHandlerContext();
+            (_c = h.onUploadStart) === null || _c === void 0 ? void 0 : _c.call(h, updatedFile, ctx);
+        }
+        catch (error) {
+            // Catch unexpected errors during upload preparation
+            const uploadError = parseError(error, 'Failed to start upload');
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: uploadFile.id,
+                updates: {
+                    status: UploadStatus.FAILED,
+                    error: uploadError.message,
+                    errorCode: uploadError.code,
+                },
+            });
+            const ctx = getHandlerContext();
+            (_d = h === null || h === void 0 ? void 0 : h.onError) === null || _d === void 0 ? void 0 : _d.call(h, uploadFile, (_e = uploadError.originalError) !== null && _e !== void 0 ? _e : new Error(uploadError.message), ctx);
+        }
+    }), [dispatch, getQueueManager]);
+    /**
+     * Pause an uploading file.
+     * Active chunk uploads are aborted, uploading chunks are reset to pending.
+     */
+    const pauseUpload = useCallback((fileId) => {
+        var _a, _b;
+        const file = fileStateStore.getFile(fileId);
+        if (!file)
+            return;
+        // Abort active uploads and mark file as paused in queue
+        getQueueManager().pauseFile(fileId);
+        // Reset any uploading chunks to pending (they were interrupted)
+        const updatedChunks = resetInterruptedChunks(file.chunks);
+        dispatch({
+            type: 'UPDATE_FILE',
+            id: fileId,
+            updates: {
+                status: UploadStatus.PAUSED,
+                chunks: updatedChunks,
+            },
+        });
+        const ctx = getHandlerContext();
+        (_b = (_a = handlerRegistry.get(fileId)) === null || _a === void 0 ? void 0 : _a.onPause) === null || _b === void 0 ? void 0 : _b.call(_a, file, ctx);
+    }, [dispatch, getQueueManager]);
+    /**
+     * Resume a paused file.
+     * Reuses stored upload URLs for pending chunks and re-adds them to queue.
+     * TODO: When backend supports URL refresh, fetch fresh URLs here instead of reusing cached ones.
+     */
+    const resumeUpload = useCallback((fileId) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const file = fileStateStore.getFile(fileId);
+        if (!file || !file.file) {
+            const error = createUploadError(UPLOAD_ERROR_CODE.MISSING_FILE, 'File is missing, cannot resume');
+            console.error(error.message);
+            return;
+        }
+        const h = ensureHandlers(file, dispatch);
+        if (!h)
+            return;
+        try {
+            // Get pending chunks that need to be uploaded
+            const { pendingPartNums, pendingCount } = getChunksForResume(file);
+            if (pendingCount === 0)
+                return;
+            // Update status to uploading
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: fileId,
+                updates: { status: UploadStatus.UPLOADING },
+            });
+            const pendingUrls = collectPendingUrlsFromChunks(file, pendingPartNums);
+            if (!file.uploadId || pendingUrls.length < pendingCount) {
+                const error = createUploadError(UPLOAD_ERROR_CODE.URL_REQUEST_FAILED, 'Missing stored upload URLs; URL refresh flow not yet implemented');
+                dispatch({
+                    type: 'UPDATE_FILE',
+                    id: fileId,
+                    updates: {
+                        status: UploadStatus.FAILED,
+                        error: error.message,
+                        errorCode: error.code,
+                    },
+                });
+                const ctx = getHandlerContext();
+                (_a = h.onError) === null || _a === void 0 ? void 0 : _a.call(h, file, new Error(error.message), ctx);
+                return;
+            }
+            // Re-register handlers for background upload support
+            handlerRegistry.register(fileId, h, 'resumeUpload');
+            // Clear any stale queue items and unpause
+            const qm = getQueueManager();
+            qm.clearFileFromQueue(fileId);
+            qm.resumeFile(fileId);
+            // Re-add file with only pending chunks to queue
+            const fileWithUrls = Object.assign({}, file);
+            qm.addFile(fileWithUrls);
+            const ctx = getHandlerContext();
+            (_b = h.onResume) === null || _b === void 0 ? void 0 : _b.call(h, file, ctx);
+        }
+        catch (error) {
+            const uploadError = parseError(error, 'Failed to resume upload');
+            dispatch({
+                type: 'UPDATE_FILE',
+                id: fileId,
+                updates: {
+                    status: UploadStatus.FAILED,
+                    error: uploadError.message,
+                    errorCode: uploadError.code,
+                },
+            });
+            const ctx = getHandlerContext();
+            (_c = h === null || h === void 0 ? void 0 : h.onError) === null || _c === void 0 ? void 0 : _c.call(h, file, (_d = uploadError.originalError) !== null && _d !== void 0 ? _d : new Error(uploadError.message), ctx);
+        }
+    }), [dispatch, getQueueManager]);
+    /**
+     * Cancel a file upload with complete cleanup.
+     * Steps:
+     * 1. Abort all active chunk uploads and clear queue state
+     * 2. Notify server (with error handling)
+     * 3. Update status to CANCELLED
+     */
+    const cancelUpload = useCallback((fileId) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const file = fileStateStore.getFile(fileId);
+        if (!file)
+            return;
+        // 1. Abort active uploads and remove from queue
+        getQueueManager().cancelFile(fileId);
+        // 2. Notify server (don't block on failure)
+        try {
+            if (file.uploadId) {
+                const handlers = handlerRegistry.get(fileId);
+                const result = yield ((_a = handlers === null || handlers === void 0 ? void 0 : handlers.onUploadCancel) === null || _a === void 0 ? void 0 : _a.call(handlers, file.fileName, file.uploadId, file));
+                if (result && !result.success) {
+                    console.warn(`Cancel notification failed for ${file.fileName}:`, result.reason);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Cancel notification error for ${file.fileName}:`, error);
+        }
+        // 3. Update status to CANCELLED
+        dispatch({
+            type: 'UPDATE_FILE',
+            id: fileId,
+            updates: { status: UploadStatus.CANCELLED },
+        });
+    }), [dispatch, getQueueManager]);
+    /**
+     * Retry a failed upload using smart retry strategy.
+     *
+     * Strategy:
+     * 1. First attempt: Smart retry - only retry failed chunks
+     * 2. If URL error occurs: Fallback to full retry - reset all chunks
+     *
+     * Smart retry is more efficient for large files with partial failures.
+     * Full retry ensures compatibility when server state is lost.
+     *
+     * @param fileId - ID of the failed file to retry
+     * @param forceFullRetry - Skip smart retry and do full retry immediately
+     * @returns Object with success status and retry type used
+     */
+    // const retryUpload = useCallback(
+    //   async (
+    //     fileId: string,
+    //     forceFullRetry: boolean = false,
+    //   ): Promise<{ success: boolean; retryType: 'smart' | 'full' }> => {
+    //     const file = stateRef.current.files.find((f) => f.id === fileId);
+    //     if (!file || !file.file) {
+    //       const error = createUploadError(UPLOAD_ERROR_CODE.MISSING_FILE, 'File is missing, cannot retry');
+    //       console.error(error.message);
+    //       return { success: false, retryType: 'smart' };
+    //     }
+    //     const h = ensureHandlers(fileId, file);
+    //     if (!h) {
+    //       return { success: false, retryType: 'smart' };
+    //     }
+    //     // Increment retry count
+    //     const retryCount = (file.retryCount ?? 0) + 1;
+    //     const failedChunksResult = getFailedChunks(file);
+    //     // If forcing full retry or no failed chunks, do full retry
+    //     if (forceFullRetry || !failedChunksResult.hasFailed) {
+    //       return performFullRetry(file, h, retryCount);
+    //     }
+    //     // ─────────────────────────────────────────────────────────────────────────
+    //     // SMART RETRY: Retry only failed chunks
+    //     // ─────────────────────────────────────────────────────────────────────────
+    //     try {
+    //       // Reset only failed chunks to pending
+    //       const updatedChunks = resetFailedChunks(file.chunks);
+    //       dispatch({
+    //         type: 'UPDATE_FILE',
+    //         id: fileId,
+    //         updates: {
+    //           status: UploadStatus.UPLOADING,
+    //           chunks: updatedChunks,
+    //           error: undefined,
+    //           errorCode: undefined,
+    //           retryCount,
+    //         },
+    //       });
+    //       // Get fresh URLs for all chunks (server needs full chunk count)
+    //       const urlResult = await h.onGetUploadUrls(file.fileName, file.chunks.length);
+    //       if (!urlResult.status) {
+    //         // URL request failed - try full retry as fallback
+    //         console.warn('Smart retry URL fetch failed, falling back to full retry');
+    //         return performFullRetry(file, h, retryCount);
+    //       }
+    //       // Filter URLs to only failed chunks
+    //       const failedUrls = filterUrlsForPendingChunks(
+    //         urlResult.uploadInfo.uploadUrls,
+    //         failedChunksResult.failedPartNums,
+    //       );
+    //       // Re-register handlers for background upload support
+    //       handlerRegistry.register(fileId, h, 'retryUpload:smart');
+    //       // Clear stale queue items and re-add with failed chunks only
+    //       const qm = getQueueManager();
+    //       qm.clearFileFromQueue(fileId);
+    //       const fileWithUrls = {
+    //         ...file,
+    //         uploadId: urlResult.uploadInfo.uploadId,
+    //         chunks: updatedChunks,
+    //         retryCount,
+    //       };
+    //       qm.addFile(fileWithUrls, failedUrls);
+    //       h.onRetry?.(file, 'smart');
+    //       return { success: true, retryType: 'smart' };
+    //     } catch (error) {
+    //       // Smart retry failed - fallback to full retry
+    //       const uploadError = parseError(error, 'Smart retry failed');
+    //       console.warn('Smart retry failed, falling back to full retry:', uploadError.message);
+    //       return performFullRetry(file, h, retryCount);
+    //     }
+    //     // ─────────────────────────────────────────────────────────────────────────
+    //     // FULL RETRY: Reset all chunks and start from beginning
+    //     // ─────────────────────────────────────────────────────────────────────────
+    //     async function performFullRetry(
+    //       uploadFile: UploadFile,
+    //       handlers: UploadHandlers,
+    //       retryAttempt: number,
+    //     ): Promise<{ success: boolean; retryType: 'full' }> {
+    //       try {
+    //         // Reset all chunks to pending
+    //         const resetChunks = resetAllChunks(uploadFile.chunks);
+    //         dispatch({
+    //           type: 'UPDATE_FILE',
+    //           id: fileId,
+    //           updates: {
+    //             status: UploadStatus.PENDING,
+    //             progress: 0,
+    //             error: undefined,
+    //             errorCode: undefined,
+    //             uploadId: '',
+    //             chunks: resetChunks,
+    //             retryCount: retryAttempt,
+    //           },
+    //         });
+    //         // Use startUpload for full retry
+    //         const resetFile: UploadFile = {
+    //           ...uploadFile,
+    //           status: UploadStatus.PENDING,
+    //           progress: 0,
+    //           error: undefined,
+    //           errorCode: undefined,
+    //           uploadId: '',
+    //           chunks: resetChunks,
+    //           retryCount: retryAttempt,
+    //         };
+    //         await startUpload(resetFile);
+    //         handlers.onRetry?.(uploadFile, 'full');
+    //         return { success: true, retryType: 'full' };
+    //       } catch (error) {
+    //         const uploadError = parseError(error, 'Retry failed');
+    //         console.error('Full retry failed:', uploadError.message);
+    //         dispatch({
+    //           type: 'UPDATE_FILE',
+    //           id: fileId,
+    //           updates: {
+    //             status: UploadStatus.FAILED,
+    //             error: uploadError.message,
+    //             errorCode: uploadError.code,
+    //             retryCount: retryAttempt,
+    //           },
+    //         });
+    //         handlers.onError?.(uploadFile, uploadError.originalError ?? new Error(uploadError.message));
+    //         return { success: false, retryType: 'full' };
+    //       }
+    //     }
+    //   },
+    //   [dispatch, getQueueManager, startUpload, ensureHandlers],
+    // );
+    // ─────────────────────────────────────────────────────────────────────────────
+    // PUBLIC API
+    // ─────────────────────────────────────────────────────────────────────────────
+    return {
+        /** Start uploading a file */
+        startUpload,
+        /** Pause an uploading file */
+        pauseUpload,
+        /** Resume a paused file */
+        resumeUpload,
+        /** Cancel a file upload */
+        cancelUpload,
+        /** Retry a failed upload (smart retry with full retry fallback) */
+        // retryUpload,
+    };
+}
+
+export { useUploadEngine };