Consolidates upload submission logic

Removes the `useUploadQueue` composable and centralizes its responsibilities within `useUploadSubmission` and `useUploadBatchOperations`.

This refactoring provides clearer separation of concerns and streamlines the upload process:
- Item-level validation moves to `uploadItemTypes.ts`.
- Batch-specific operations, including a new `processDirectBatch` for atomic collection creation via `/api/tools/fetch`, are now handled by `useUploadBatchOperations`.
- `useUploadSubmission` now orchestrates the entire upload flow, clearly distinguishing between direct collection creation and two-step collection creation (for items like data library copies that require individual processing).

Author: davelopez

client/src/components/Panels/Upload/methods/CompositeFileUpload.vue

@@ -6,10 +6,15 @@ import { computed, ref, watch } from "vue";
 import { useUploadDefaults } from "@/composables/upload/uploadDefaults";
 import { useUploadStaging } from "@/composables/upload/useUploadStaging";
 import type { ExtensionDetails } from "@/composables/uploadConfigurations";
-import { useUploadQueue } from "@/composables/uploadQueue";
+import {
+    buildPreparedUploadWithOptions,
+    createFileUploadItem,
+    createPastedUploadItem,
+    createUrlUploadItem,
+} from "@/utils/upload";
 import { mapToCompositeFileUpload } from "@/utils/upload/itemMappers";
 
-import type { UploadMethodComponent, UploadMethodConfig } from "../types";
+import type { PreparedUpload, UploadMethodComponent, UploadMethodConfig } from "../types";
 import type { CompositeFileItem, CompositeSlot } from "../types/uploadItem";
 
 import UploadTableDbKeyCell from "../shared/UploadTableDbKeyCell.vue";
@@ -30,7 +35,6 @@ const emit = defineEmits<{
     (e: "ready", ready: boolean): void;
 }>();
 
-const uploadQueue = useUploadQueue();
 const { compositeExtensions, listDbKeys, configurationsReady, defaultDbKey } = useUploadDefaults();
 
 const compositeItems = ref<CompositeFileItem[]>([]);
@@ -146,20 +150,68 @@ function clearAll() {
     clearStaging();
 }
 
-function startUpload() {
+function prepareUpload(): PreparedUpload | null {
     const item = currentItem.value;
     if (!item) {
-        return;
+        return null;
+    }
+
+    const uploadItem = mapToCompositeFileUpload(item, props.targetHistoryId);
+    const baseOptions = {
+        dbkey: uploadItem.dbkey,
+        ext: uploadItem.extension,
+        space_to_tab: uploadItem.spaceToTab,
+        to_posix_lines: uploadItem.toPosixLines,
+        deferred: false,
+    };
+
+    const apiItems = uploadItem.slots
+        .filter((slot) => slot.src !== "files" || !!slot.file)
+        .map((slot) => {
+            const slotOptions = {
+                name: slot.slotName,
+                ...baseOptions,
+            };
+
+            if (slot.src === "files") {
+                return createFileUploadItem(slot.file!, uploadItem.targetHistoryId, {
+                    ...slotOptions,
+                    size: slot.fileSize ?? slot.file!.size,
+                });
+            }
+
+            if (slot.src === "url") {
+                return createUrlUploadItem(slot.url ?? "", uploadItem.targetHistoryId, {
+                    ...slotOptions,
+                    size: slot.fileSize ?? 0,
+                });
+            }
+
+            return createPastedUploadItem(slot.content ?? "", uploadItem.targetHistoryId, {
+                ...slotOptions,
+                size: slot.fileSize ?? (slot.content ?? "").length,
+            });
+        });
+
+    if (apiItems.length === 0) {
+        return null;
     }
 
-    const queueItem = mapToCompositeFileUpload(item, props.targetHistoryId);
-    uploadQueue.enqueue([queueItem]);
+    return buildPreparedUploadWithOptions([uploadItem], undefined, {
+        apiItems,
+        uploadOptions: {
+            composite: true,
+            compositeName: uploadItem.name,
+        },
+    });
+}
 
+function reset() {
     compositeItems.value = [];
     clearStaging();
 }
 
-defineExpose<UploadMethodComponent>({ startUpload });
+defineExpose<UploadMethodComponent>({ prepareUpload, reset });
 </script>
 
 <template>

client/src/components/Panels/Upload/types.ts

@@ -115,6 +115,13 @@ export interface PreparedUpload {
     collectionConfig?: UploadCollectionConfig;
     /** Items used for progress tracking in the upload state store. */
     uploadItems?: NewUploadItem[];
+    /** Optional upload behavior flags forwarded to uploadDatasets. */
+    uploadOptions?: {
+        /** Treat multiple API items as one composite dataset. */
+        composite?: boolean;
+        /** Display name for the composite dataset. */
+        compositeName?: string;
+    };
 }
 
 /**

client/src/composables/upload/uploadItemTypes.ts

@@ -128,6 +128,46 @@ export type UploadItem = NewUploadItem & UploadState;
 /** Sources returned for uploaded history contents. */
 export type UploadedDatasetSource = Extract<HistoryContentSource, "hda" | "hdca">;
 
+/**
+ * Validates a UI upload item before submission.
+ * Returns an error message if invalid, undefined if valid.
+ */
+export function validateUploadItem(item: NewUploadItem): string | undefined {
+    switch (item.uploadMode) {
+        case "local-file":
+            if (!item.fileData) {
+                return `No file selected for "${item.name}"`;
+            }
+            if (item.fileData.size === 0) {
+                return `File "${item.name}" is empty`;
+            }
+            break;
+
+        case "paste-content":
+            if (!item.content || item.content.trim().length === 0) {
+                return `No content provided for "${item.name}"`;
+            }
+            break;
+
+        case "paste-links":
+        case "remote-files":
+            if (!item.url || item.url.trim().length === 0) {
+                return `No URL provided for "${item.name}"`;
+            }
+            break;
+
+        case "data-library":
+            if (!item.lddaId) {
+                return `No library dataset ID provided for "${item.name}"`;
+            }
+            break;
+
+        default:
+            return `Unknown upload mode: ${(item as NewUploadItem).uploadMode}`;
+    }
+    return undefined;
+}
+
 /**
  * Represents a dataset that was successfully uploaded.
  */

client/src/composables/upload/useUploadBatchOperations.ts

@@ -1,8 +1,12 @@
 import { createHistoryDatasetCollectionInstanceFull } from "@/api/datasetCollections";
 import { useUploadState } from "@/components/Panels/Upload/uploadState";
 import { buildCollectionElements } from "@/composables/upload/collectionElements";
-import type { UploadItem } from "@/composables/upload/uploadItemTypes";
+import type { NewUploadItem, UploadItem } from "@/composables/upload/uploadItemTypes";
+import { validateUploadItem } from "@/composables/upload/uploadItemTypes";
+import { useHistoryStore } from "@/stores/historyStore";
+import { getHistoryUploadActionErrorMessage, getHistoryUploadBlockReason } from "@/utils/historyUpload";
 import { errorMessageAsString } from "@/utils/simple-error";
+import { toApiUploadItem, uploadCollectionDatasets } from "@/utils/upload";
 
 interface UploadBatchOperationsOptions {
     autoRecover?: boolean;
@@ -17,42 +21,58 @@ export function useUploadBatchOperations(options: UploadBatchOperationsOptions =
         return uploadState.activeItems.value.find((item) => item.id === id);
     }
 
+    async function validateTargetHistory(targetHistoryId: string): Promise<string | null> {
+        const historyStore = useHistoryStore();
+        let history = historyStore.getHistoryById(targetHistoryId, false) ?? null;
+        if (!history) {
+            await historyStore.loadHistoryById(targetHistoryId);
+            history = historyStore.getHistoryById(targetHistoryId, false) ?? null;
+        }
+        if (!history) {
+            return null;
+        }
+        const blockReason = getHistoryUploadBlockReason(history);
+        return blockReason ? getHistoryUploadActionErrorMessage(blockReason) : null;
+    }
+
     /**
      * Creates a dataset collection from uploaded datasets.
      *
      * @param batchId - Batch ID in upload state
+     * @throws {Error} If the batch is not found, has missing data, or collection creation fails
      */
     async function createCollection(batchId: string): Promise<void> {
         const batch = uploadState.getBatch(batchId);
         if (!batch) {
-            console.error(`Batch not found: ${batchId}`);
-            return;
+            const errorMsg = `Batch not found: ${batchId}`;
+            console.error(errorMsg);
+            throw new Error(errorMsg);
         }
 
         if (batch.collectionId) {
             return;
         }
 
         if (!batch.datasetIds || batch.datasetIds.length === 0) {
-            uploadState.setBatchError(batchId, "No dataset IDs available for collection creation");
-            return;
+            const errorMsg = "No dataset IDs available for collection creation";
+            uploadState.setBatchError(batchId, errorMsg);
+            throw new Error(errorMsg);
         }
 
         const items = batch.uploadIds
             .map((id) => findUploadItem(id))
             .filter((item): item is UploadItem => item !== undefined);
 
         if (items.length === 0) {
-            uploadState.setBatchError(batchId, "No upload items available for collection creation");
-            return;
+            const errorMsg = "No upload items available for collection creation";
+            uploadState.setBatchError(batchId, errorMsg);
+            throw new Error(errorMsg);
         }
 
         if (items.length !== batch.uploadIds.length) {
-            uploadState.setBatchError(
-                batchId,
-                `Cannot create collection: only ${items.length} of ${batch.uploadIds.length} upload items found. This can happen after a page refresh. Please re-upload the files or manually create the collection.`,
-            );
-            return;
+            const errorMsg = `Cannot create collection: only ${items.length} of ${batch.uploadIds.length} upload items found. This can happen after a page refresh. Please re-upload the files or manually create the collection.`;
+            uploadState.setBatchError(batchId, errorMsg);
+            throw new Error(errorMsg);
         }
 
         uploadState.updateBatchStatus(batchId, "creating-collection");
@@ -88,6 +108,68 @@ export function useUploadBatchOperations(options: UploadBatchOperationsOptions =
                     item.error = "Uploaded successfully, but collection creation failed";
                 }
             });
+
+            throw new Error(errorMsg);
+        }
+    }
+
+    /**
+     * Processes a collection batch using the direct HDCA creation path.
+     * All items are uploaded together in one /api/tools/fetch request that
+     * creates the collection atomically — no separate collection creation step.
+     *
+     * Used for non-library batches where all items can be fed to the upload API directly.
+     */
+    async function processDirectBatch(batchId: string, ids: string[], items: NewUploadItem[]): Promise<void> {
+        const batch = uploadState.getBatch(batchId);
+        if (!batch) {
+            console.error(`Batch not found: ${batchId}`);
+            return;
+        }
+
+        ids.forEach((id) => uploadState.setStatus(id, "uploading"));
+        uploadState.updateBatchStatus(batchId, "uploading");
+
+        try {
+            const historyError = await validateTargetHistory(batch.historyId);
+            if (historyError) {
+                throw new Error(historyError);
+            }
+
+            for (const item of items) {
+                const validationError = validateUploadItem(item);
+                if (validationError) {
+                    throw new Error(validationError);
+                }
+            }
+
+            const apiItems = items.map((item) => toApiUploadItem(item));
+
+            await uploadCollectionDatasets(
+                apiItems,
+                {
+                    collectionName: batch.name,
+                    collectionType: batch.type,
+                },
+                {
+                    progress: (percentage) => {
+                        ids.forEach((id) => uploadState.updateProgress(id, percentage));
+                    },
+                    success: () => {
+                        ids.forEach((id) => uploadState.updateProgress(id, 100));
+                        uploadState.updateBatchStatus(batchId, "completed");
+                    },
+                    error: (err) => {
+                        const errorMsg = errorMessageAsString(err);
+                        ids.forEach((id) => uploadState.setError(id, errorMsg));
+                        uploadState.setBatchError(batchId, errorMsg);
+                    },
+                },
+            );
+        } catch (err) {
+            const errorMsg = errorMessageAsString(err);
+            ids.forEach((id) => uploadState.setError(id, errorMsg));
+            uploadState.setBatchError(batchId, errorMsg);
         }
     }
 
@@ -166,6 +248,7 @@ export function useUploadBatchOperations(options: UploadBatchOperationsOptions =
         clearAll,
         clearCompleted,
         createCollection,
+        processDirectBatch,
         recoverIncompleteBatches,
         retryCollectionCreation,
     };