Merge branch 'release_26.0' into dev

Author: nsoranzo

client/src/components/Tool/ToolCard.vue

@@ -117,8 +117,16 @@ const { isOnlyPreference } = useStorageLocationConfiguration();
 const { currentUser, isAnonymous } = storeToRefs(useUserStore());
 const { isLoaded: isConfigLoaded, config } = storeToRefs(useConfigStore());
 const hasUser = computed(() => !isAnonymous.value);
-const versions = computed(() => props.options.versions);
-const showVersions = computed(() => props.options.versions?.length > 1);
+const versions = computed(() => props.options.versions ?? []);
+const hiddenVersions = computed(() => props.options.hidden_versions ?? []);
+const visibleVersions = computed(() => {
+    const filtered = versions.value.filter((v) => !hiddenVersions.value.includes(v));
+    if (props.version && !filtered.includes(props.version) && versions.value.includes(props.version)) {
+        filtered.push(props.version);
+    }
+    return filtered;
+});
+const showVersions = computed(() => visibleVersions.value.length > 1);
 
 const storageLocationModalTitle = computed(() => {
     if (isOnlyPreference.value) {
@@ -165,7 +173,7 @@ onBeforeMount(() => {
                 <ToolVersionsButton
                     v-if="showVersions"
                     :version="props.version"
-                    :versions="versions"
+                    :versions="visibleVersions"
                     @onChangeVersion="onChangeVersion" />
                 <ToolOptionsButton
                     :id="props.id"

client/src/components/Upload/model.ts

@@ -41,6 +41,7 @@ export interface UploadRowModel {
     targetHistoryId?: string;
     toPosixLines: boolean;
     id?: string;
+    autoDecompress: boolean;
 }
 
 export const defaultModel: UploadRowModel = {
@@ -62,4 +63,5 @@ export const defaultModel: UploadRowModel = {
     spaceToTab: false,
     status: "init",
     toPosixLines: true,
+    autoDecompress: true,
 };

client/src/composables/zipExplorer.ts

@@ -193,6 +193,7 @@ export function useZipExplorer() {
                 ext: defaultModel.extension,
                 space_to_tab: defaultModel.spaceToTab,
                 to_posix_lines: defaultModel.toPosixLines,
+                auto_decompress: defaultModel.autoDecompress,
                 deferred: defaultModel.deferred ?? false,
             };
             uploadItems.push(uploadItem);

client/src/utils/upload-queue.test.js

@@ -221,11 +221,11 @@ describe("UploadQueue", () => {
             history_id: "historyId",
             targets: [
                 {
-                    auto_decompress: false,
+                    auto_decompress: true,
                     destination: { type: "hdas" },
                     elements: [
                         {
-                            auto_decompress: false,
+                            auto_decompress: true,
                             dbkey: "?",
                             deferred: true,
                             ext: "auto",
@@ -236,7 +236,7 @@ describe("UploadQueue", () => {
                             url: "http://test.me.0",
                         },
                         {
-                            auto_decompress: false,
+                            auto_decompress: true,
                             dbkey: "?",
                             deferred: true,
                             ext: "auto",
@@ -247,7 +247,7 @@ describe("UploadQueue", () => {
                             url: "http://test.me.1",
                         },
                         {
-                            auto_decompress: false,
+                            auto_decompress: true,
                             dbkey: "?",
                             deferred: true,
                             ext: "auto",

client/src/utils/upload.test.ts

@@ -427,6 +427,13 @@ describe("createUrlUploadItem", () => {
         expect(item.deferred).toBe(true);
         expect(item.dbkey).toBe("hg38");
     });
+
+    test("trims surrounding whitespace from URL", () => {
+        const item = createUrlUploadItem("  http://example.com/data.bed\n", "historyId");
+
+        expect(item.url).toBe("http://example.com/data.bed");
+        expect(item.name).toBe("data.bed");
+    });
 });
 
 describe("parseContentToUploadItems", () => {
@@ -462,6 +469,22 @@ describe("parseContentToUploadItems", () => {
         );
     });
 
+    test("throws on network URL with empty DNS labels", () => {
+        expect(() => parseContentToUploadItems("https://.../SRR1957099.fastq.gz", "historyId")).toThrow(
+            "Invalid URL: https://.../SRR1957099.fastq.gz",
+        );
+    });
+
+    test("accepts Galaxy file-source URIs", () => {
+        const content = "gxfiles://myftp/file.txt\ndrs://example.org/abc\nzenodo://record/123";
+        const items = parseContentToUploadItems(content, "historyId");
+
+        expect(items).toHaveLength(3);
+        expect((items[0] as { url: string }).url).toBe("gxfiles://myftp/file.txt");
+        expect((items[1] as { url: string }).url).toBe("drs://example.org/abc");
+        expect((items[2] as { url: string }).url).toBe("zenodo://record/123");
+    });
+
     test("handles whitespace around URLs", () => {
         const items = parseContentToUploadItems("  http://example.com/file.txt  \n  ", "historyId");
 
@@ -537,6 +560,12 @@ describe("buildUploadPayload", () => {
 
         expect(() => buildUploadPayload(items)).toThrow("Invalid URL: not-a-valid-url");
     });
+
+    test("rejects network URL with empty DNS labels", () => {
+        const items: ApiUploadItem[] = [createUrlUploadItem("https://.../SRR1957099.fastq.gz", "historyId")];
+
+        expect(() => buildUploadPayload(items)).toThrow("Invalid URL: https://.../SRR1957099.fastq.gz");
+    });
 });
 
 // ============================================================================

client/src/utils/upload.ts

@@ -58,7 +58,7 @@ import type { SupportedCollectionType, UploadCollectionConfig } from "@/composab
 import type { NewUploadItem } from "@/composables/upload/uploadItemTypes";
 import { getAppRoot } from "@/onload/loadConfig";
 import { errorMessageAsString } from "@/utils/simple-error";
-import { isUrl } from "@/utils/url";
+import { isUrl, isValidUrl } from "@/utils/url";
 
 import { createTusUpload, type FileStream, type NamedBlob, type UploadableFile } from "./tusUpload";
 
@@ -127,6 +127,8 @@ interface UploadItemCommon {
     deferred: boolean;
     /** Optional hash values for verification */
     hashes?: FetchDatasetHash[];
+    /** Whether to auto-decompress the upload */
+    auto_decompress: boolean;
 }
 
 /** Upload item from a local file */
@@ -349,6 +351,7 @@ export function createFileUploadItem(
         to_posix_lines: options.to_posix_lines ?? uploadItemDefaults.to_posix_lines,
         deferred: options.deferred ?? uploadItemDefaults.deferred,
         hashes: options.hashes,
+        auto_decompress: true,
     };
 }
 
@@ -385,6 +388,7 @@ export function createPastedUploadItem(
         to_posix_lines: options.to_posix_lines ?? uploadItemDefaults.to_posix_lines,
         deferred: options.deferred ?? uploadItemDefaults.deferred,
         hashes: options.hashes,
+        auto_decompress: true,
     };
 }
 
@@ -410,12 +414,13 @@ export function createUrlUploadItem(
     historyId: string,
     options: Partial<Omit<UrlUploadItem, "src" | "url" | "historyId">> = {},
 ): UrlUploadItem {
+    const trimmedUrl = url.trim();
     // Extract filename from URL if not provided
-    const defaultName = url.split("/").pop()?.split("?")[0] || DEFAULT_FILE_NAME;
+    const defaultName = trimmedUrl.split("/").pop()?.split("?")[0] || DEFAULT_FILE_NAME;
 
     return {
         src: "url",
-        url,
+        url: trimmedUrl,
         historyId,
         name: options.name ?? defaultName,
         size: options.size ?? 0,
@@ -425,6 +430,7 @@ export function createUrlUploadItem(
         to_posix_lines: options.to_posix_lines ?? uploadItemDefaults.to_posix_lines,
         deferred: options.deferred ?? uploadItemDefaults.deferred,
         hashes: options.hashes,
+        auto_decompress: true,
     };
 }
 
@@ -449,6 +455,7 @@ export function toApiUploadItem(item: NewUploadItem): ApiUploadItem {
         to_posix_lines: item.toPosixLines,
         deferred: item.deferred,
         hashes: item.hashes,
+        auto_decompress: true,
     };
 
     switch (item.uploadMode) {
@@ -510,7 +517,7 @@ export function parseContentToUploadItems(
     // If first line is a URL, treat all lines as URLs
     if (isUrl(firstLine)) {
         return lines.filter(Boolean).map((urlLine) => {
-            if (!isUrl(urlLine)) {
+            if (!isValidUrl(urlLine)) {
                 throw new Error(`Invalid URL: ${urlLine}`);
             }
             return createUrlUploadItem(urlLine, historyId, options);
@@ -536,7 +543,7 @@ function buildDataElement(item: ApiUploadItem): ApiDataElement {
         name: normalizeFileName(item.name),
         space_to_tab: item.space_to_tab,
         to_posix_lines: item.to_posix_lines,
-        auto_decompress: false,
+        auto_decompress: true,
         deferred: item.deferred,
     };
 
@@ -598,7 +605,7 @@ function validateItemContent(item: ApiUploadItem): void {
             if (!item.url || item.url.trim().length === 0) {
                 throw new Error(`No URL for upload item: ${item.name}`);
             }
-            if (!isUrl(item.url)) {
+            if (!isValidUrl(item.url)) {
                 throw new Error(`Invalid URL: ${item.url}`);
             }
             break;
@@ -674,7 +681,7 @@ export function buildUploadPayload(items: ApiUploadItem[], options: BuildPayload
         history_id: historyId,
         targets: [
             {
-                auto_decompress: false,
+                auto_decompress: true,
                 destination: { type: "hdas" },
                 elements,
             },

client/src/utils/upload/itemMappers.ts

@@ -71,7 +71,7 @@ export function mapToPasteUrlUpload(item: PasteUrlItem, targetHistoryId: string)
         spaceToTab: item.spaceToTab,
         toPosixLines: item.toPosixLines,
         deferred: item.deferred,
-        url: item.url,
+        url: item.url.trim(),
     };
 }
 

client/src/utils/url.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it, test } from "vitest";
 
-import { addSearchParams, isUrl } from "./url";
+import { addSearchParams, isUrl, isValidNetworkUrl, isValidUrl } from "./url";
 
 describe("test url utilities", () => {
     it("adding parameters to url", async () => {
@@ -14,4 +14,59 @@ describe("test url utilities", () => {
         expect(isUrl("ftp://")).toBeTruthy();
         expect(isUrl("http://")).toBeTruthy();
     });
+
+    test("network url validation accepts well-formed hosts", () => {
+        expect(isValidNetworkUrl("https://example.com/x")).toBe(true);
+        expect(isValidNetworkUrl("http://sub.example.org/path?q=1")).toBe(true);
+        expect(isValidNetworkUrl("ftp://ftp.example.org/a")).toBe(true);
+    });
+
+    test("network url validation rejects empty DNS labels", () => {
+        expect(isValidNetworkUrl("https://.../foo")).toBe(false);
+        expect(isValidNetworkUrl("https://./foo")).toBe(false);
+        expect(isValidNetworkUrl("https://..example.com/x")).toBe(false);
+        expect(isValidNetworkUrl("https:///foo")).toBe(false);
+    });
+
+    test("network url validation rejects non-network schemes", () => {
+        expect(isValidNetworkUrl("gxfiles://foo")).toBe(false);
+        expect(isValidNetworkUrl("drs://example.org/123")).toBe(false);
+        expect(isValidNetworkUrl("not-a-url")).toBe(false);
+    });
+
+    test("isValidUrl accepts custom Galaxy file-source schemes", () => {
+        expect(isValidUrl("gxfiles://myftp/file.txt")).toBe(true);
+        expect(isValidUrl("gxuserfiles://mysource/x")).toBe(true);
+        expect(isValidUrl("drs://example.org/abc")).toBe(true);
+        expect(isValidUrl("zenodo://record/123")).toBe(true);
+        expect(isValidUrl("invenio://record/123")).toBe(true);
+        expect(isValidUrl("dataverse://doi/x")).toBe(true);
+        expect(isValidUrl("base64://aGVsbG8=")).toBe(true);
+    });
+
+    test("isValidUrl accepts well-formed network urls", () => {
+        expect(isValidUrl("https://example.com/")).toBe(true);
+        expect(isValidUrl("https://example.com/file.txt")).toBe(true);
+        expect(isValidUrl("ftp://ftp.example.org/a")).toBe(true);
+    });
+
+    test("isValidUrl rejects network urls with empty DNS labels", () => {
+        expect(isValidUrl("https://.../foo")).toBe(false);
+        expect(isValidUrl("https://./foo")).toBe(false);
+        expect(isValidUrl("https:///foo")).toBe(false);
+    });
+
+    test("isValidUrl rejects unknown schemes and non-urls", () => {
+        expect(isValidUrl("")).toBe(false);
+        expect(isValidUrl("not-a-url")).toBe(false);
+        expect(isValidUrl("xyz://foo")).toBe(false);
+    });
+
+    test("isValidUrl tolerates surrounding whitespace", () => {
+        expect(isValidUrl("  https://example.com/x  ")).toBe(true);
+        expect(isValidUrl("\thttps://example.com/x\n")).toBe(true);
+        expect(isValidUrl("   gxfiles://myftp/file.txt   ")).toBe(true);
+        expect(isValidUrl("   ")).toBe(false);
+        expect(isValidUrl("  https://.../x  ")).toBe(false);
+    });
 });