Prompt non-codespace users for storage path

Offer non-codespace users the option to configure their storage folder for skeleton packs.

Suggested here:
#2310 (comment)

At the moment we're choosing to create our skeleton packs in the first
folder in the workspace.

This is fine for the codespace template because we can control the
folder structure in that repo.

For users outside of this we'd like to offer them the option to choose
where to save their skeleton packs.

Author: elenatanasoiu

extensions/ql-vscode/src/config.ts

@@ -608,3 +608,19 @@ export const CODESPACES_TEMPLATE = new Setting(
 export function isCodespacesTemplate() {
   return !!CODESPACES_TEMPLATE.getValue<boolean>();
 }
+
+/**
+ * The name of the folder where we want to create skeleton wizard QL packs.
+ **/
+const SKELETON_WIZARD_FOLDER = new Setting(
+  "folder",
+  new Setting("skeletonWizard", ROOT_SETTING),
+);
+
+export function getSkeletonWizardFolder(): string | undefined {
+  return SKELETON_WIZARD_FOLDER.getValue<string>() || undefined;
+}
+
+export async function setSkeletonWizardFolder(folder: string | undefined) {
+  await SKELETON_WIZARD_FOLDER.updateValue(folder, ConfigurationTarget.Global);
+}

extensions/ql-vscode/src/skeleton-query-wizard.ts

@@ -1,4 +1,4 @@
-import { join } from "path";
+import { dirname, join } from "path";
 import { CancellationToken, Uri, workspace, window as Window } from "vscode";
 import { CodeQLCliServer } from "./cli";
 import { OutputChannelLogger } from "./common";
@@ -14,7 +14,12 @@ import { QlPackGenerator } from "./qlpack-generator";
 import { DatabaseItem, DatabaseManager } from "./local-databases";
 import { ProgressCallback, UserCancellationException } from "./progress";
 import { askForGitHubRepo, downloadGitHubDatabase } from "./databaseFetcher";
-import { existsSync } from "fs";
+import {
+  getSkeletonWizardFolder,
+  isCodespacesTemplate,
+  setSkeletonWizardFolder,
+} from "./config";
+import { existsSync } from "fs-extra";
 
 type QueryLanguagesToDatabaseMap = Record<string, string>;
 
@@ -55,7 +60,7 @@ export class SkeletonQueryWizard {
       return;
     }
 
-    this.qlPackStoragePath = getFirstWorkspaceFolder();
+    this.qlPackStoragePath = await this.determineStoragePath();
 
     const skeletonPackAlreadyExists =
       existsSync(join(this.qlPackStoragePath, this.folderName)) ||
@@ -98,6 +103,59 @@ export class SkeletonQueryWizard {
     });
   }
 
+  public async determineStoragePath() {
+    const firstStorageFolder = getFirstWorkspaceFolder();
+
+    if (isCodespacesTemplate()) {
+      return firstStorageFolder;
+    }
+
+    let storageFolder = getSkeletonWizardFolder();
+
+    if (storageFolder === undefined || !existsSync(storageFolder)) {
+      storageFolder = await Window.showInputBox({
+        title:
+          "Please choose a folder in which to create your new query pack. You can change this in the extension settings.",
+        value: firstStorageFolder,
+        ignoreFocusOut: true,
+      });
+    }
+
+    if (storageFolder === undefined) {
+      throw new UserCancellationException("No storage folder entered.");
+    }
+
+    if (!existsSync(storageFolder)) {
+      throw new UserCancellationException(
+        "Invalid folder. Must be a folder that already exists.",
+      );
+    }
+
+    await setSkeletonWizardFolder(storageFolder);
+    return storageFolder;
+  }
+
+  public getFirstStoragePath() {
+    const workspaceFolders = workspace.workspaceFolders;
+
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      throw new Error("No workspace folders found");
+    }
+
+    const firstFolder = workspaceFolders[0];
+    const firstFolderFsPath = firstFolder.uri.fsPath;
+
+    // For the vscode-codeql-starter repo, the first folder will be a ql pack
+    // so we need to get the parent folder
+    if (firstFolderFsPath.includes("codeql-custom-queries")) {
+      // return the parent folder
+      return dirname(firstFolderFsPath);
+    } else {
+      // if the first folder is not a ql pack, then we are in a normal workspace
+      return firstFolderFsPath;
+    }
+  }
+
   private async chooseLanguage() {
     this.progress({
       message: "Choose language",

extensions/ql-vscode/test/vscode-tests/cli-integration/skeleton-query-wizard.test.ts

@@ -21,6 +21,7 @@ import {
 import * as databaseFetcher from "../../../src/databaseFetcher";
 import { createMockDB } from "../../factories/databases/databases";
 import { asError } from "../../../src/pure/helpers-pure";
+import { Setting } from "../../../src/config";
 
 describe("SkeletonQueryWizard", () => {
   let mockCli: CodeQLCliServer;
@@ -29,6 +30,7 @@ describe("SkeletonQueryWizard", () => {
   let dir: tmp.DirResult;
   let storagePath: string;
   let quickPickSpy: jest.SpiedFunction<typeof window.showQuickPick>;
+  let showInputBoxSpy: jest.SpiedFunction<typeof window.showInputBox>;
   let generateSpy: jest.SpiedFunction<
     typeof QlPackGenerator.prototype.generate
   >;
@@ -93,6 +95,9 @@ describe("SkeletonQueryWizard", () => {
     quickPickSpy = jest
       .spyOn(window, "showQuickPick")
       .mockResolvedValueOnce(mockedQuickPickItem(chosenLanguage));
+    showInputBoxSpy = jest
+      .spyOn(window, "showInputBox")
+      .mockResolvedValue(storagePath);
     generateSpy = jest
       .spyOn(QlPackGenerator.prototype, "generate")
       .mockResolvedValue(undefined);
@@ -433,4 +438,116 @@ describe("SkeletonQueryWizard", () => {
       });
     });
   });
+
+  describe("determineStoragePath", () => {
+    it("should prompt the user to provide a storage path", async () => {
+      const chosenPath = await wizard.determineStoragePath();
+
+      expect(showInputBoxSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ value: storagePath }),
+      );
+      expect(chosenPath).toEqual(storagePath);
+    });
+
+    it("should write the chosen folder to settings", async () => {
+      const updateValueSpy = jest.spyOn(Setting.prototype, "updateValue");
+
+      await wizard.determineStoragePath();
+
+      expect(updateValueSpy).toHaveBeenCalledWith(storagePath, 1);
+    });
+
+    describe("when the user is using the codespace template", () => {
+      let originalValue: any;
+      let storedPath: string;
+
+      beforeEach(async () => {
+        storedPath = join(dir.name, "pickles-folder");
+        ensureDirSync(storedPath);
+
+        originalValue = workspace
+          .getConfiguration("codeQL.skeletonWizard")
+          .get("folder");
+
+        // Set isCodespacesTemplate to true to indicate we are in the codespace template
+        await workspace
+          .getConfiguration("codeQL")
+          .update("codespacesTemplate", true);
+      });
+
+      afterEach(async () => {
+        await workspace
+          .getConfiguration("codeQL")
+          .update("codespacesTemplate", originalValue);
+      });
+
+      it("should not prompt the user", async () => {
+        const chosenPath = await wizard.determineStoragePath();
+
+        expect(showInputBoxSpy).not.toHaveBeenCalled();
+        expect(chosenPath).toEqual(storagePath);
+      });
+    });
+
+    describe("when there is already a saved storage path in settings", () => {
+      describe("when the saved storage path exists", () => {
+        let originalValue: any;
+        let storedPath: string;
+
+        beforeEach(async () => {
+          storedPath = join(dir.name, "pickles-folder");
+          ensureDirSync(storedPath);
+
+          originalValue = workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .get("folder");
+          await workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .update("folder", storedPath);
+        });
+
+        afterEach(async () => {
+          await workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .update("folder", originalValue);
+        });
+
+        it("should return it and not prompt the user", async () => {
+          const chosenPath = await wizard.determineStoragePath();
+
+          expect(showInputBoxSpy).not.toHaveBeenCalled();
+          expect(chosenPath).toEqual(storedPath);
+        });
+      });
+
+      describe("when the saved storage path does not exist", () => {
+        let originalValue: any;
+        let storedPath: string;
+
+        beforeEach(async () => {
+          storedPath = join(dir.name, "this-folder-does-not-exist");
+
+          originalValue = workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .get("folder");
+          await workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .update("folder", storedPath);
+        });
+
+        afterEach(async () => {
+          await workspace
+            .getConfiguration("codeQL.skeletonWizard")
+            .update("folder", originalValue);
+        });
+
+        it("should prompt the user for to provide a new folder name", async () => {
+          const chosenPath = await wizard.determineStoragePath();
+
+          expect(showInputBoxSpy).toHaveBeenCalled();
+          expect(chosenPath).toEqual(storagePath);
+        });
+      });
+    });
+  });
 });