@matdata/yasgui 5.14.0 → 5.16.0

package/src/queryManagement/QueryBrowser.ts

@@ -8,6 +8,7 @@ import { getEndpointToAutoSwitch } from "./openManagedQuery";
 import { hashQueryText } from "./textHash";
 import type { BackendType, VersionRef, ManagedTabMetadata } from "./types";
 import { normalizeQueryFilename } from "./normalizeQueryFilename";
+import SaveManagedQueryModal from "./SaveManagedQueryModal";
 
 import "./QueryBrowser.scss";
 
@@ -47,6 +48,7 @@ export default class QueryBrowser {
   private lastRenderedSignature: string | undefined;
 
   private lastPointerPos: { x: number; y: number } | undefined;
+  private folderPickerModal?: SaveManagedQueryModal;
 
   private entrySignature(entry: FolderEntry): string {
     const parent = entry.parentId || "";
@@ -712,6 +714,76 @@ export default class QueryBrowser {
       actions.appendChild(renameBtn);
     }
 
+    if (backend.moveQuery) {
+      const moveBtn = document.createElement("button");
+      moveBtn.type = "button";
+      addClass(moveBtn, "yasgui-query-browser__action");
+      moveBtn.textContent = "Move";
+      moveBtn.setAttribute("aria-label", `Move ${entry.label} to a different folder`);
+      moveBtn.addEventListener("click", async (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+
+        const currentFolderPath = entry.parentId || "";
+        if (!this.folderPickerModal) this.folderPickerModal = new SaveManagedQueryModal(this.yasgui);
+        const newFolderPath = await this.folderPickerModal.showFolderPickerOnly(
+          this.selectedWorkspaceId!,
+          currentFolderPath,
+        );
+        if (newFolderPath === undefined) return;
+        if (newFolderPath === currentFolderPath) return;
+
+        // Show loading state
+        const originalText = moveBtn.textContent;
+        moveBtn.disabled = true;
+        moveBtn.textContent = "Moving…";
+        addClass(moveBtn, "loading");
+
+        try {
+          const newQueryId = await backend.moveQuery!(entry.id, newFolderPath);
+
+          // For git workspaces: update any already-open managed tabs referencing the old path.
+          if (backend.type === "git" && newQueryId !== entry.id) {
+            for (const tab of Object.values(this.yasgui._tabs)) {
+              const meta = (tab as any).getManagedQueryMetadata?.() as ManagedTabMetadata | undefined;
+              if (!meta) continue;
+              if (meta.backendType !== "git") continue;
+              if (meta.workspaceId !== this.selectedWorkspaceId) continue;
+              const currentPath = (meta.queryRef as any)?.path as string | undefined;
+              if (currentPath !== entry.id) continue;
+
+              try {
+                const read = await backend.readQuery(newQueryId);
+                const lastSavedTextHash = hashQueryText(read.queryText);
+                const lastSavedVersionRef = this.versionRefFromVersionTag("git", read.versionTag);
+
+                (tab as any).setManagedQueryMetadata?.({
+                  ...meta,
+                  queryRef: { ...(meta.queryRef as any), path: newQueryId },
+                  lastSavedTextHash,
+                  lastSavedVersionRef,
+                });
+              } catch {
+                // Best-effort: if refreshing metadata fails, the Query Browser still reflects the move.
+              }
+            }
+          }
+
+          this.queryPreviewById.delete(entry.id);
+          this.folderEntriesById.clear();
+          this.invalidateRenderCache();
+          await this.refresh();
+        } catch (err) {
+          // Restore button state on error
+          moveBtn.disabled = false;
+          moveBtn.textContent = originalText || "Move";
+          removeClass(moveBtn, "loading");
+          window.alert(asWorkspaceBackendError(err).message);
+        }
+      });
+      actions.appendChild(moveBtn);
+    }
+
     if (backend.deleteQuery) {
       const deleteBtn = document.createElement("button");
       deleteBtn.type = "button";

package/src/queryManagement/SaveManagedQueryModal.ts

@@ -41,13 +41,18 @@ export default class SaveManagedQueryModal {
   private saveBtn!: HTMLButtonElement;
   private cancelBtn!: HTMLButtonElement;
   private saveBtnOriginalText = "Save";
+  private titleEl!: HTMLHeadingElement;
+  private workspaceRowEl!: HTMLDivElement;
 
   private filenameTouched = false;
   private folderPickerOpen = false;
   private folderBrowsePath = "";
+  private mouseDownOnOverlay = false;
 
   private resolve?: (value: SaveManagedQueryModalResult) => void;
   private reject?: (reason?: unknown) => void;
+  private moveResolve?: (value: string | undefined) => void;
+  private isMoveMode = false;
 
   constructor(yasgui: Yasgui) {
     this.yasgui = yasgui;
@@ -64,6 +69,7 @@ export default class SaveManagedQueryModal {
 
     const titleEl = document.createElement("h2");
     titleEl.textContent = "Save as managed query";
+    this.titleEl = titleEl;
 
     const closeBtn = document.createElement("button");
     closeBtn.type = "button";
@@ -202,6 +208,7 @@ export default class SaveManagedQueryModal {
     this.messageEl.setAttribute("aria-label", "Save message");
 
     const workspaceRow = this.row("Workspace", this.workspaceSelectEl);
+    this.workspaceRowEl = workspaceRow;
     const folderRow = this.folderRow();
     this.nameRowEl = this.row("Name", this.nameEl);
     this.filenameRowEl = this.row("Filename", this.filenameEl);
@@ -247,7 +254,22 @@ export default class SaveManagedQueryModal {
 
     this.overlayEl.appendChild(this.modalEl);
 
-    this.overlayEl.addEventListener("click", () => this.cancel());
+    // Track mousedown on overlay to distinguish from text selection that moves outside
+    this.overlayEl.addEventListener("mousedown", (e) => {
+      // Only mark as overlay mousedown if the target is the overlay itself (not modal content)
+      if (e.target === this.overlayEl) {
+        this.mouseDownOnOverlay = true;
+      }
+    });
+
+    // Only close if mousedown also happened on overlay (not during text selection)
+    this.overlayEl.addEventListener("mouseup", (e) => {
+      if (e.target === this.overlayEl && this.mouseDownOnOverlay) {
+        this.cancel();
+      }
+      this.mouseDownOnOverlay = false;
+    });
+
     document.addEventListener("keydown", (e) => {
       if (!this.isOpen()) return;
       if (e.key === "Escape") {
@@ -324,11 +346,27 @@ export default class SaveManagedQueryModal {
   }
 
   private cancel() {
+    this.mouseDownOnOverlay = false;
     this.close();
     this.overlayEl.remove();
-    this.reject?.(new Error("cancelled"));
-    this.resolve = undefined;
-    this.reject = undefined;
+    if (this.isMoveMode) {
+      this.resetMoveMode();
+      const resolve = this.moveResolve;
+      this.moveResolve = undefined;
+      resolve?.(undefined);
+    } else {
+      this.reject?.(new Error("cancelled"));
+      this.resolve = undefined;
+      this.reject = undefined;
+    }
+  }
+
+  private resetMoveMode() {
+    this.isMoveMode = false;
+    this.titleEl.textContent = "Save as managed query";
+    this.saveBtn.textContent = "Save";
+    this.saveBtnOriginalText = "Save";
+    this.workspaceRowEl.style.display = "";
   }
 
   private setLoading(isLoading: boolean) {
@@ -354,6 +392,18 @@ export default class SaveManagedQueryModal {
   }
 
   private submit() {
+    if (this.isMoveMode) {
+      const folderPath = this.folderPathEl.value.trim();
+      this.mouseDownOnOverlay = false;
+      this.close();
+      this.overlayEl.remove();
+      this.resetMoveMode();
+      const resolve = this.moveResolve;
+      this.moveResolve = undefined;
+      resolve?.(folderPath);
+      return;
+    }
+
     const workspaceId = this.workspaceSelectEl.value;
     const name = this.nameEl.value.trim();
     const filename = this.filenameEl.value.trim();
@@ -399,6 +449,7 @@ export default class SaveManagedQueryModal {
       }
     }
 
+    this.mouseDownOnOverlay = false;
     this.close();
     this.overlayEl.remove();
 
@@ -454,6 +505,7 @@ export default class SaveManagedQueryModal {
     this.folderBrowsePath = this.folderPathEl.value.trim();
     this.folderPickerErrorEl.textContent = "";
     this.folderPickerListEl.innerHTML = "";
+    this.mouseDownOnOverlay = false;
 
     document.body.appendChild(this.overlayEl);
     this.open();
@@ -551,4 +603,50 @@ export default class SaveManagedQueryModal {
     this.newFolderNameEl.value = "";
     void this.refreshFolderPicker();
   }
+
+  /**
+   * Show a simplified modal containing only the folder picker, for moving an existing query.
+   * Resolves with the selected folder path (empty string = root), or `undefined` if cancelled.
+   */
+  public async showFolderPickerOnly(workspaceId: string, currentFolderPath: string): Promise<string | undefined> {
+    const workspaces = this.yasgui.persistentConfig.getWorkspaces();
+
+    this.workspaceSelectEl.innerHTML = "";
+    for (const w of workspaces) {
+      const opt = document.createElement("option");
+      opt.value = w.id;
+      opt.textContent = w.label;
+      this.workspaceSelectEl.appendChild(opt);
+    }
+    this.workspaceSelectEl.value = workspaceId;
+
+    // Hide rows not needed for a move operation.
+    this.workspaceRowEl.style.display = "none";
+    this.nameRowEl.style.display = "none";
+    this.filenameRowEl.style.display = "none";
+    this.messageRowEl.style.display = "none";
+
+    this.folderPathEl.value = currentFolderPath;
+    this.filenameTouched = false;
+    this.folderPickerOpen = false;
+    removeClass(this.folderPickerEl, "open");
+    this.folderBrowsePath = currentFolderPath;
+    this.folderPickerErrorEl.textContent = "";
+    this.folderPickerListEl.innerHTML = "";
+    this.mouseDownOnOverlay = false;
+
+    this.titleEl.textContent = "Move to folder";
+    this.saveBtn.textContent = "Move";
+    this.saveBtnOriginalText = "Move";
+
+    this.isMoveMode = true;
+
+    document.body.appendChild(this.overlayEl);
+    this.open();
+    this.folderPickerToggleEl.focus();
+
+    return new Promise<string | undefined>((resolve) => {
+      this.moveResolve = resolve;
+    });
+  }
 }

package/src/queryManagement/WorkspaceSettingsForm.ts

@@ -27,6 +27,67 @@ export class WorkspaceSettingsForm {
     this.options = options;
   }
 
+  private async fetchExistingWorkspaces(endpoint: string): Promise<string[]> {
+    try {
+      const query = `
+PREFIX yasgui: <https://matdata.eu/ns/yasgui#>
+
+SELECT DISTINCT ?workspace WHERE {
+  ?workspace a yasgui:Workspace .
+}
+ORDER BY ?workspace`;
+
+      // Get authentication for this endpoint
+      const endpointConfig = this.options.persistentConfig.getEndpointConfig(endpoint);
+      const headers: Record<string, string> = {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/sparql-results+json",
+      };
+
+      // Add authentication headers if configured
+      if (endpointConfig?.authentication) {
+        const auth = endpointConfig.authentication;
+        if (auth.type === "basic") {
+          const credentials = btoa(`${auth.username}:${auth.password}`);
+          headers["Authorization"] = `Basic ${credentials}`;
+        } else if (auth.type === "bearer") {
+          headers["Authorization"] = `Bearer ${auth.token}`;
+        } else if (auth.type === "apiKey") {
+          headers[auth.headerName] = auth.apiKey;
+        } else if (auth.type === "oauth2" && auth.accessToken) {
+          headers["Authorization"] = `Bearer ${auth.accessToken}`;
+        }
+      }
+
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: new URLSearchParams({ query }),
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const data = await response.json();
+      const workspaces: string[] = [];
+
+      if (data.results?.bindings) {
+        for (const binding of data.results.bindings) {
+          const workspace = binding.workspace?.value;
+          if (workspace) {
+            workspaces.push(workspace);
+          }
+        }
+      }
+
+      return workspaces;
+    } catch (error) {
+      console.error("Failed to fetch existing workspaces:", error);
+      return [];
+    }
+  }
+
   public render() {
     this.container.innerHTML = "";
 
@@ -234,6 +295,9 @@ export class WorkspaceSettingsForm {
   }
 
   private openWorkspaceConfigModal(input: { mode: "add" } | { mode: "edit"; workspace: WorkspaceConfig }) {
+    // Track mousedown for proper modal close behavior
+    let mouseDownOnOverlay = false;
+
     const overlay = document.createElement("div");
     addClass(overlay, "tabSettingsModalOverlay", "workspaceConfigModalOverlay", "open");
 
@@ -242,6 +306,7 @@ export class WorkspaceSettingsForm {
     modal.onclick = (e) => e.stopPropagation();
 
     const close = () => {
+      mouseDownOnOverlay = false;
       overlay.remove();
       document.removeEventListener("keydown", onKeyDown);
     };
@@ -253,7 +318,20 @@ export class WorkspaceSettingsForm {
     };
     document.addEventListener("keydown", onKeyDown);
 
-    overlay.onclick = () => close();
+    // Track mousedown on overlay to distinguish from text selection that moves outside
+    overlay.addEventListener("mousedown", (e) => {
+      if (e.target === overlay) {
+        mouseDownOnOverlay = true;
+      }
+    });
+
+    // Only close if mousedown also happened on overlay (not during text selection)
+    overlay.addEventListener("mouseup", (e) => {
+      if (e.target === overlay && mouseDownOnOverlay) {
+        close();
+      }
+      mouseDownOnOverlay = false;
+    });
 
     const header = document.createElement("div");
     addClass(header, "modalHeader");
@@ -440,11 +518,133 @@ export class WorkspaceSettingsForm {
       sparqlHelp.textContent =
         "Tip: you can reuse an existing Workspace IRI to point to an already-populated workspace, or choose a new IRI to start a fresh workspace.";
 
-      const workspaceIriInput = document.createElement("input");
-      workspaceIriInput.type = "url";
-      workspaceIriInput.placeholder = "Workspace IRI";
-      workspaceIriInput.value = existing && existing.type === "sparql" ? existing.workspaceIri : "";
-      addClass(workspaceIriInput, "settingsInput");
+      // Workspace IRI selection (dropdown + custom input)
+      const workspaceIriSelect = document.createElement("select");
+      workspaceIriSelect.setAttribute("aria-label", "Workspace IRI");
+      addClass(workspaceIriSelect, "settingsSelect");
+
+      const loadingOption = document.createElement("option");
+      loadingOption.value = "";
+      loadingOption.textContent = "Select endpoint first";
+      workspaceIriSelect.appendChild(loadingOption);
+
+      const workspaceIriCustomInput = document.createElement("input");
+      workspaceIriCustomInput.type = "url";
+      workspaceIriCustomInput.placeholder =
+        "Enter new workspace IRI (e.g., https://example.org/workspace/my-workspace)";
+      workspaceIriCustomInput.style.display = "none";
+      workspaceIriCustomInput.style.marginTop = "5px";
+      addClass(workspaceIriCustomInput, "settingsInput");
+
+      if (existing && existing.type === "sparql") {
+        workspaceIriCustomInput.value = existing.workspaceIri;
+      }
+
+      // Function to populate workspace options
+      const populateWorkspaceOptions = async (endpoint: string) => {
+        // Clear existing options
+        workspaceIriSelect.innerHTML = "";
+
+        // Add loading option
+        const loading = document.createElement("option");
+        loading.value = "";
+        loading.textContent = "Loading workspaces...";
+        workspaceIriSelect.appendChild(loading);
+        workspaceIriSelect.disabled = true;
+
+        try {
+          const workspaces = await this.fetchExistingWorkspaces(endpoint);
+
+          workspaceIriSelect.innerHTML = "";
+          workspaceIriSelect.disabled = false;
+
+          if (workspaces.length > 0) {
+            const selectPlaceholder = document.createElement("option");
+            selectPlaceholder.value = "";
+            selectPlaceholder.textContent = "Select existing workspace";
+            workspaceIriSelect.appendChild(selectPlaceholder);
+
+            for (const workspace of workspaces) {
+              const option = document.createElement("option");
+              option.value = workspace;
+              option.textContent = workspace;
+              workspaceIriSelect.appendChild(option);
+            }
+          } else {
+            const noWorkspaces = document.createElement("option");
+            noWorkspaces.value = "";
+            noWorkspaces.textContent = "No existing workspaces found";
+            workspaceIriSelect.appendChild(noWorkspaces);
+          }
+
+          // Add custom option
+          const customOption = document.createElement("option");
+          customOption.value = "__custom__";
+          customOption.textContent = "➕ Enter new workspace IRI";
+          workspaceIriSelect.appendChild(customOption);
+
+          // Set current value if editing existing
+          if (existing && existing.type === "sparql") {
+            const existingIri = existing.workspaceIri;
+            const matchingOption = workspaces.find((w) => w === existingIri);
+            if (matchingOption) {
+              workspaceIriSelect.value = existingIri;
+            } else {
+              workspaceIriSelect.value = "__custom__";
+              workspaceIriCustomInput.style.display = "";
+              workspaceIriCustomInput.value = existingIri;
+            }
+          }
+        } catch (error) {
+          workspaceIriSelect.innerHTML = "";
+          workspaceIriSelect.disabled = false;
+
+          const errorOption = document.createElement("option");
+          errorOption.value = "";
+          errorOption.textContent = "Failed to load workspaces";
+          workspaceIriSelect.appendChild(errorOption);
+
+          const customOption = document.createElement("option");
+          customOption.value = "__custom__";
+          customOption.textContent = "➕ Enter new workspace IRI";
+          workspaceIriSelect.appendChild(customOption);
+        }
+      };
+
+      // Handle workspace selection change
+      workspaceIriSelect.onchange = () => {
+        if (workspaceIriSelect.value === "__custom__") {
+          workspaceIriCustomInput.style.display = "";
+          workspaceIriCustomInput.focus();
+        } else {
+          workspaceIriCustomInput.style.display = "none";
+        }
+      };
+
+      // Handle endpoint change
+      endpointSelect.onchange = () => {
+        const selectedEndpoint = endpointSelect.value.trim();
+        if (selectedEndpoint) {
+          void populateWorkspaceOptions(selectedEndpoint);
+        } else {
+          workspaceIriSelect.innerHTML = "";
+          const placeholder = document.createElement("option");
+          placeholder.value = "";
+          placeholder.textContent = "Select endpoint first";
+          workspaceIriSelect.appendChild(placeholder);
+        }
+      };
+
+      // Initial load if endpoint is already selected
+      const initialEndpoint = endpointSelect.value.trim();
+      if (initialEndpoint) {
+        void populateWorkspaceOptions(initialEndpoint);
+      }
+
+      // Wrapper for workspace IRI selection
+      const workspaceIriWrapper = document.createElement("div");
+      workspaceIriWrapper.appendChild(workspaceIriSelect);
+      workspaceIriWrapper.appendChild(workspaceIriCustomInput);
 
       const defaultGraphInput = document.createElement("input");
       defaultGraphInput.type = "url";
@@ -454,17 +654,24 @@ export class WorkspaceSettingsForm {
 
       dynamic.appendChild(this.wrapField("SPARQL endpoint", endpointSelect));
       dynamic.appendChild(sparqlHelp);
-      dynamic.appendChild(this.wrapField("Workspace IRI", workspaceIriInput));
+      dynamic.appendChild(this.wrapField("Workspace IRI", workspaceIriWrapper));
       dynamic.appendChild(this.wrapField("Default graph", defaultGraphInput));
 
       (dynamic as any).__getConfig = (): WorkspaceConfig => {
+        let workspaceIri = "";
+        if (workspaceIriSelect.value === "__custom__") {
+          workspaceIri = workspaceIriCustomInput.value.trim();
+        } else {
+          workspaceIri = workspaceIriSelect.value.trim();
+        }
+
         return {
           id: existing?.id || newWorkspaceId(),
           type: "sparql",
           label: labelInput.value.trim(),
           description: descriptionInput.value.trim() || undefined,
           endpoint: endpointSelect.value.trim(),
-          workspaceIri: workspaceIriInput.value.trim(),
+          workspaceIri,
           defaultGraph: defaultGraphInput.value.trim() || undefined,
         };
       };

package/src/queryManagement/backends/GitWorkspaceBackend.ts

@@ -69,6 +69,25 @@ export default class GitWorkspaceBackend implements WorkspaceBackend {
     return this.client.deleteQuery(this.config, _queryId);
   }
 
+  async moveQuery(queryId: string, newFolderId: string): Promise<string> {
+    if (!this.client) throw this.missingClientError();
+
+    const parts = queryId.split("/").filter(Boolean);
+    const filename = parts[parts.length - 1] || queryId;
+    const folder = newFolderId.replace(/^\/+|\/+$/g, "");
+
+    const newPath = folder ? `${folder}/${filename}` : filename;
+    if (newPath === queryId) return queryId;
+
+    const read = await this.client.readQuery(this.config, queryId);
+    await this.client.writeQuery(this.config, newPath, read.queryText, {
+      message: `Move ${filename} to ${folder || "(root)"}`,
+    });
+    await this.client.deleteQuery(this.config, queryId);
+
+    return newPath;
+  }
+
   async renameQuery(queryId: string, newLabel: string): Promise<void> {
     if (!this.client) throw this.missingClientError();
 

package/src/queryManagement/backends/InMemoryWorkspaceBackend.ts

@@ -152,6 +152,23 @@ export default class InMemoryWorkspaceBackend implements WorkspaceBackend {
     return { queryText: found.queryText, versionTag: found.id };
   }
 
+  async moveQuery(queryId: string, newFolderId: string): Promise<string> {
+    const versions = this.versionsByQueryId.get(queryId);
+    if (!versions || versions.length === 0) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+
+    const filename = basename(queryId);
+    const folder = normalizeFolderId(newFolderId);
+    const newId = folder ? `${folder}/${filename}` : filename;
+    if (newId === queryId) return queryId;
+
+    if (this.versionsByQueryId.has(newId))
+      throw new WorkspaceBackendError("CONFLICT", "A query already exists at this path");
+
+    this.versionsByQueryId.delete(queryId);
+    this.versionsByQueryId.set(newId, versions);
+    return newId;
+  }
+
   async renameQuery(queryId: string, newLabel: string): Promise<void> {
     const trimmed = newLabel.trim();
     if (!trimmed) throw new WorkspaceBackendError("UNKNOWN", "New name is required");

package/src/queryManagement/backends/SparqlWorkspaceBackend.ts

@@ -422,6 +422,75 @@ WHERE  { OPTIONAL { ${iri(mqIri)} rdfs:label ?oldLabel . } }
     await this.sparqlUpdate(update);
   }
 
+  async moveQuery(queryId: string, newFolderId: string): Promise<string> {
+    const mqIriValue = this.resolveManagedQueryIri(queryId);
+    const workspaceIri = this.config.workspaceIri;
+    const folder = (newFolderId || "").replace(/^\/+|\/+$/g, "");
+
+    const newContainerIriValue = folder ? mintFolderIri(workspaceIri, folder) : workspaceIri;
+
+    // Fetch the current container to detect no-ops.
+    const currentContainerIriValue = await (async () => {
+      const q = `
+PREFIX yasgui:  <https://matdata.eu/ns/yasgui#>
+PREFIX dcterms: <http://purl.org/dc/terms/>
+
+SELECT ?container WHERE {
+  ${iri(mqIriValue)} a yasgui:ManagedQuery ;
+    dcterms:isPartOf ?container .
+}
+LIMIT 1`;
+      const res = await this.sparqlQuery<SparqlJsonResults>(q);
+      const row = this.getBindings(res)[0];
+      const container = row?.container?.value;
+      if (!container) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+      return container;
+    })();
+
+    if (currentContainerIriValue === newContainerIriValue) return queryId;
+
+    // Ensure each ancestor folder exists in the store.
+    if (folder) {
+      const parts = splitPath(folder);
+      const folderTriples: string[] = [];
+      for (let i = 0; i < parts.length; i++) {
+        const subPath = parts.slice(0, i + 1).join("/");
+        const folderIriValue = mintFolderIri(workspaceIri, subPath);
+        const folderLabel = parts[i];
+        folderTriples.push(`${iri(folderIriValue)} a <https://matdata.eu/ns/yasgui#WorkspaceFolder> ;`);
+        folderTriples.push(`  <http://www.w3.org/2004/02/skos/core#inScheme> ${iri(workspaceIri)} ;`);
+        folderTriples.push(`  <http://www.w3.org/2000/01/rdf-schema#label> ${sparqlStringLiteral(folderLabel)} .`);
+
+        if (i > 0) {
+          const parentPath = parts.slice(0, i).join("/");
+          const parentIri = mintFolderIri(workspaceIri, parentPath);
+          folderTriples.push(
+            `${iri(folderIriValue)} <http://www.w3.org/2004/02/skos/core#broader> ${iri(parentIri)} .`,
+          );
+        }
+      }
+      await this.sparqlUpdate(`
+PREFIX yasgui: <https://matdata.eu/ns/yasgui#>
+
+INSERT DATA {
+  ${iri(workspaceIri)} a yasgui:Workspace .
+  ${folderTriples.join("\n  ")}
+}
+`);
+    }
+
+    // Update dcterms:isPartOf to point to the new container.
+    await this.sparqlUpdate(`
+PREFIX dcterms: <http://purl.org/dc/terms/>
+
+DELETE { ${iri(mqIriValue)} dcterms:isPartOf ${iri(currentContainerIriValue)} . }
+INSERT { ${iri(mqIriValue)} dcterms:isPartOf ${iri(newContainerIriValue)} . }
+WHERE  { ${iri(mqIriValue)} dcterms:isPartOf ${iri(currentContainerIriValue)} . }
+`);
+
+    return queryId;
+  }
+
   async deleteQuery(queryId: string): Promise<void> {
     const mqIri = this.resolveManagedQueryIri(queryId);
     const update = `

package/src/queryManagement/backends/WorkspaceBackend.ts

@@ -23,6 +23,12 @@ export interface WorkspaceBackend {
    */
   renameQuery?(queryId: string, newLabel: string): Promise<void>;
 
+  /**
+   * Optional: Move a query to a different folder.
+   * Returns the new query ID (may differ from the original for Git backends where the ID encodes the path).
+   */
+  moveQuery?(queryId: string, newFolderId: string): Promise<string>;
+
   /**
    * Optional: Delete a query and its version history.
    * Implementations may not support this (e.g., some Git provider clients).

package/src/tab.scss

@@ -169,5 +169,6 @@
     flex-shrink: 0;
     max-height: 35px;
     gap: 2px;
+    position: relative; // For hamburger dropdown positioning
   }
 }