@galaxyproject/galaxy-api-client 25.0.0-dev.0

package/src/dist/example.js

@@ -0,0 +1,258 @@
+"use strict";
+var __awaiter =
+    (this && this.__awaiter) ||
+    function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+            return value instanceof P
+                ? value
+                : new P(function (resolve) {
+                      resolve(value);
+                  });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) {
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function rejected(value) {
+                try {
+                    step(generator["throw"](value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function step(result) {
+                result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+            }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+var __generator =
+    (this && this.__generator) ||
+    function (thisArg, body) {
+        var _ = {
+                label: 0,
+                sent: function () {
+                    if (t[0] & 1) throw t[1];
+                    return t[1];
+                },
+                trys: [],
+                ops: [],
+            },
+            f,
+            y,
+            t,
+            g;
+        return (
+            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
+            typeof Symbol === "function" &&
+                (g[Symbol.iterator] = function () {
+                    return this;
+                }),
+            g
+        );
+        function verb(n) {
+            return function (v) {
+                return step([n, v]);
+            };
+        }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_)
+                try {
+                    if (
+                        ((f = 1),
+                        y &&
+                            (t =
+                                op[0] & 2
+                                    ? y["return"]
+                                    : op[0]
+                                      ? y["throw"] || ((t = y["return"]) && t.call(y), 0)
+                                      : y.next) &&
+                            !(t = t.call(y, op[1])).done)
+                    )
+                        return t;
+                    if (((y = 0), t)) op = [op[0] & 2, t.value];
+                    switch (op[0]) {
+                        case 0:
+                        case 1:
+                            t = op;
+                            break;
+                        case 4:
+                            _.label++;
+                            return { value: op[1], done: false };
+                        case 5:
+                            _.label++;
+                            y = op[1];
+                            op = [0];
+                            continue;
+                        case 7:
+                            op = _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                        default:
+                            if (
+                                !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
+                                (op[0] === 6 || op[0] === 2)
+                            ) {
+                                _ = 0;
+                                continue;
+                            }
+                            if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                                _.label = op[1];
+                                break;
+                            }
+                            if (op[0] === 6 && _.label < t[1]) {
+                                _.label = t[1];
+                                t = op;
+                                break;
+                            }
+                            if (t && _.label < t[2]) {
+                                _.label = t[2];
+                                _.ops.push(op);
+                                break;
+                            }
+                            if (t[2]) _.ops.pop();
+                            _.trys.pop();
+                            continue;
+                    }
+                    op = body.call(thisArg, _);
+                } catch (e) {
+                    op = [6, e];
+                    y = 0;
+                } finally {
+                    f = t = 0;
+                }
+            if (op[0] & 5) throw op[1];
+            return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    };
+exports.__esModule = true;
+exports.createDataset = exports.getToolById = exports.getTools = void 0;
+// Example usage of the Galaxy API client
+var index_1 = require("./index");
+//
+// Basic usage - just provide a base URL
+//
+var basicApi = index_1.createGalaxyApi("https://usegalaxy.org");
+//
+// Advanced usage - with API key authentication and custom headers
+//
+var authenticatedApi = index_1.createGalaxyApi({
+    baseUrl: "https://usegalaxy.org",
+    apiKey: "your-api-key-here",
+    headers: {
+        Accept: "application/json",
+        "User-Agent": "GalaxyClientApp/1.0",
+    },
+});
+//
+// Example with request options (timeouts, credentials, etc.)
+//
+var apiWithOptions = index_1.createGalaxyApi({
+    baseUrl: "https://usegalaxy.org",
+    fetchOptions: {
+        credentials: "include",
+        cache: "no-cache",
+        timeout: 30000,
+    },
+});
+// Example function to get a list of tools
+function getTools() {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, data, error, sections, _i, data_1, tool, section;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    return [4 /*yield*/, basicApi.GET("/api/tools")];
+                case 1:
+                    (_a = _b.sent()), (data = _a.data), (error = _a.error);
+                    if (error) {
+                        console.error("Error fetching tools:", error);
+                        return [2 /*return*/, []];
+                    }
+                    // Log tool count
+                    console.log("Found " + data.length + " tools");
+                    sections = {};
+                    for (_i = 0, data_1 = data; _i < data_1.length; _i++) {
+                        tool = data_1[_i];
+                        section = tool.panel_section_name || "Ungrouped";
+                        if (!sections[section]) sections[section] = [];
+                        sections[section].push(tool);
+                    }
+                    // Print summary
+                    Object.keys(sections).forEach(function (section) {
+                        console.log(section + ": " + sections[section].length + " tools");
+                    });
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+exports.getTools = getTools;
+// Example function to get a specific tool by ID
+function getToolById(id) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, data, error;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    return [
+                        4 /*yield*/,
+                        authenticatedApi.GET("/api/tools/{tool_id}", {
+                            params: {
+                                path: {
+                                    tool_id: id,
+                                },
+                            },
+                        }),
+                    ];
+                case 1:
+                    (_a = _b.sent()), (data = _a.data), (error = _a.error);
+                    if (error || !data) {
+                        console.error("Error fetching tool:", error);
+                        return [2 /*return*/, null];
+                    }
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+exports.getToolById = getToolById;
+// Example function to create a dataset in a history
+function createDataset(historyId, name, content) {
+    return __awaiter(this, void 0, void 0, function () {
+        var _a, data, error;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    return [
+                        4 /*yield*/,
+                        apiWithOptions.POST("/api/histories/{history_id}/contents", {
+                            params: {
+                                path: {
+                                    history_id: historyId,
+                                },
+                            },
+                            body: {
+                                name: name,
+                                content: content,
+                                type: "file",
+                            },
+                        }),
+                    ];
+                case 1:
+                    (_a = _b.sent()), (data = _a.data), (error = _a.error);
+                    if (error) {
+                        console.error("Error creating dataset:", error);
+                        return [2 /*return*/, null];
+                    }
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+}
+exports.createDataset = createDataset;

package/src/example.ts

@@ -0,0 +1,105 @@
+// Example usage of the Galaxy API client
+import { createGalaxyApi } from "./index";
+
+//
+// Basic usage - just provide a base URL
+//
+const basicApi = createGalaxyApi("https://usegalaxy.org");
+
+//
+// Advanced usage - with API key authentication and custom headers
+//
+const authenticatedApi = createGalaxyApi({
+    baseUrl: "https://usegalaxy.org",
+    apiKey: "your-api-key-here",
+    headers: {
+        Accept: "application/json",
+        "User-Agent": "GalaxyClientApp/1.0",
+    },
+});
+
+//
+// Example with request options (timeouts, credentials, etc.)
+//
+const apiWithOptions = createGalaxyApi({
+    baseUrl: "https://usegalaxy.org",
+    fetchOptions: {
+        credentials: "include", // Include cookies for CORS requests
+        cache: "no-cache", // Don't cache responses
+        timeout: 30000, // 30 second timeout
+    },
+});
+
+// Example function to get a list of tools
+async function getTools() {
+    // Using the basic API
+    const { data, error } = await basicApi.GET("/api/tools");
+
+    if (error) {
+        console.error("Error fetching tools:", error);
+        return [];
+    }
+
+    // Log tool count
+    console.log(`Found ${data.length} tools`);
+
+    // Group tools by section
+    const sections: Record<string, any[]> = {};
+    for (const tool of data) {
+        const section = tool.panel_section_name || "Ungrouped";
+        if (!sections[section]) sections[section] = [];
+        sections[section].push(tool);
+    }
+
+    // Print summary
+    Object.keys(sections).forEach((section) => {
+        console.log(`${section}: ${sections[section].length} tools`);
+    });
+
+    return data;
+}
+
+// Example function to get a specific tool by ID
+async function getToolById(id: string) {
+    // Using the authenticated API
+    const { data, error } = await authenticatedApi.GET("/api/tools/{tool_id}", {
+        params: {
+            path: {
+                tool_id: id,
+            },
+        },
+    });
+
+    if (error || !data) {
+        console.error("Error fetching tool:", error);
+        return null;
+    }
+
+    return data;
+}
+
+// Example function to create a dataset in a history
+async function createDataset(historyId: string, name: string, content: string) {
+    // Using the API with custom options
+    const { data, error } = await apiWithOptions.POST("/api/histories/{history_id}/contents", {
+        params: {
+            path: {
+                history_id: historyId,
+            },
+        },
+        body: {
+            name,
+            content,
+            type: "file",
+        },
+    });
+
+    if (error) {
+        console.error("Error creating dataset:", error);
+        return null;
+    }
+
+    return data;
+}
+
+export { getTools, getToolById, createDataset };

package/src/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Galaxy Client API
+ * A client library for the Galaxy API
+ */
+
+import { createGalaxyApi, type GalaxyApiClient } from "./client";
+import { errorMessageAsString } from "./utils/error";
+
+// Re-export all the types from our type compatibility layer
+export * from "./api-types";
+
+// SimpleError class for error handling
+export class SimpleError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "GalaxyApiError";
+    }
+}
+
+// Re-export the client functions
+export { createGalaxyApi, type GalaxyApiClient };
+
+// For backward compatibility - creates a client with default settings
+export function GalaxyApi() {
+    return createGalaxyApi();
+}
+
+// Utility function to format error messages
+export function formatErrorMessage(error: any): string {
+    return errorMessageAsString(error);
+}

package/src/integration.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { type HistorySummary } from "./api-types";
+
+// Set up mock responses
+const mockHistories: HistorySummary[] = [
+    {
+        id: "1",
+        name: "Test History 1",
+        deleted: false,
+        purged: false,
+        archived: false,
+        tags: [],
+        model_class: "History",
+        url: "/api/histories/1",
+    },
+    {
+        id: "2",
+        name: "Test History 2",
+        deleted: false,
+        purged: false,
+        archived: false,
+        tags: ["test"],
+        model_class: "History",
+        url: "/api/histories/2",
+    },
+];
+
+// Create a mock API client with typed responses
+const mockApiClient = {
+    GET: vi.fn().mockImplementation((path, options) => {
+        if (path === "/api/histories") {
+            return Promise.resolve({
+                data: mockHistories,
+                error: null,
+                response: new Response(),
+            });
+        }
+        if (path === "/api/histories/{history_id}" && options?.params?.path?.history_id === "1") {
+            return Promise.resolve({
+                data: mockHistories[0],
+                error: null,
+                response: new Response(),
+            });
+        }
+        return Promise.resolve({
+            data: null,
+            error: { status: 404, message: "Not found" },
+            response: new Response(),
+        });
+    }),
+    POST: vi.fn(),
+    PUT: vi.fn(),
+    DELETE: vi.fn(),
+    PATCH: vi.fn(),
+};
+
+// Setup mocks before importing the modules that use them
+vi.mock("openapi-fetch", () => {
+    return {
+        default: vi.fn().mockImplementation(() => mockApiClient),
+    };
+});
+
+// Import the modules after setting up mocks
+import { createGalaxyApi, GalaxyApi } from "./index";
+
+describe("Galaxy API Integration", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("exports the createGalaxyApi function", () => {
+        expect(typeof createGalaxyApi).toBe("function");
+    });
+
+    it("exports the backward-compatible GalaxyApi function", () => {
+        expect(typeof GalaxyApi).toBe("function");
+        expect(GalaxyApi()).toEqual(mockApiClient);
+    });
+
+    it("retrieves histories with proper typing", async () => {
+        const api = createGalaxyApi();
+        const { data, error } = await api.GET("/api/histories");
+
+        expect(error).toBeNull();
+        expect(data).toEqual(mockHistories);
+
+        if (data) {
+            // This is a type check - if TypeScript can compile this,
+            // it means the types are working correctly
+            const firstHistory = data[0];
+            expect(firstHistory.id).toBe("1");
+            expect(firstHistory.name).toBe("Test History 1");
+        }
+    });
+
+    it("retrieves a single history by ID", async () => {
+        const api = createGalaxyApi();
+        const { data, error } = await api.GET("/api/histories/{history_id}", {
+            params: {
+                path: {
+                    history_id: "1",
+                },
+            },
+        });
+
+        expect(error).toBeNull();
+        expect(data).toEqual(mockHistories[0]);
+    });
+
+    it("handles errors properly", async () => {
+        const api = createGalaxyApi();
+        const { data, error } = await api.GET("/api/nonexistent");
+
+        expect(data).toBeNull();
+        expect(error).toEqual({ status: 404, message: "Not found" });
+    });
+});

package/src/utils/error.ts

@@ -0,0 +1,38 @@
+/**
+ * Simple error handling utilities for Galaxy Client API
+ */
+
+/**
+ * Convert various error formats to a readable string message
+ */
+export function errorMessageAsString(error: any): string {
+    if (typeof error === "string") {
+        return error;
+    }
+
+    if (error instanceof Error) {
+        return error.message;
+    }
+
+    if (error && typeof error === "object") {
+        // Handle API response errors
+        if (error.status && error.error) {
+            return `API Error (${error.status}): ${error.error}`;
+        }
+
+        // Handle response objects with error message
+        if (error.message) {
+            return error.message;
+        }
+
+        // Try to stringify the error object
+        try {
+            return JSON.stringify(error);
+        } catch (e) {
+            // Fall back to object inspection
+            return String(error);
+        }
+    }
+
+    return "Unknown error";
+}