feat: add Move button to change a managed query's folder (fixes #141)

Copilot · MathiasVDA · web-flow · commit a0dfead92cd1 · 2026-02-28T14:13:28.000+01:00
* Initial plan

* feat: add Move button to change a managed query's folder

- Add moveQuery?(queryId, newFolderId): Promise&lt;string&gt; to WorkspaceBackend interface
- Implement moveQuery in GitWorkspaceBackend (read+write to new path+delete old)
- Implement moveQuery in SparqlWorkspaceBackend (update dcterms:isPartOf triple, ensure folder exists)
- Implement moveQuery in InMemoryWorkspaceBackend (for tests)
- Add showFolderPickerOnly() to SaveManagedQueryModal for folder-only selection
- Add Move button in QueryBrowser that opens folder picker and calls moveQuery
- Update open git tabs when a query is moved to preserve path metadata
- Add 3 unit tests for moveQuery behaviour

Co-authored-by: MathiasVDA &lt;15101339+MathiasVDA@users.noreply.github.com&gt;

---------

Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
Co-authored-by: MathiasVDA &lt;15101339+MathiasVDA@users.noreply.github.com&gt;
diff --git a/packages/yasgui/src/queryManagement/QueryBrowser.ts b/packages/yasgui/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";
diff --git a/packages/yasgui/src/queryManagement/SaveManagedQueryModal.ts b/packages/yasgui/src/queryManagement/SaveManagedQueryModal.ts
@@ -41,6 +41,8 @@ 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;
@@ -49,6 +51,8 @@ export default class SaveManagedQueryModal {
 
   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;
@@ -65,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";
@@ -203,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);
@@ -343,9 +349,24 @@ export default class SaveManagedQueryModal {
     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) {
@@ -371,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();
@@ -570,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;
+    });
+  }
 }
diff --git a/packages/yasgui/src/queryManagement/backends/GitWorkspaceBackend.ts b/packages/yasgui/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();
 
diff --git a/packages/yasgui/src/queryManagement/backends/InMemoryWorkspaceBackend.ts b/packages/yasgui/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");
diff --git a/packages/yasgui/src/queryManagement/backends/SparqlWorkspaceBackend.ts b/packages/yasgui/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 = `
diff --git a/packages/yasgui/src/queryManagement/backends/WorkspaceBackend.ts b/packages/yasgui/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).
diff --git a/test/unit/query-management-backend-test.ts b/test/unit/query-management-backend-test.ts
