Merge pull request #2287 from github/robertbrignull/selection

Introduce helpers for commands that operate on selections

Author: robertbrignull

extensions/ql-vscode/src/common/selection-commands.ts

@@ -0,0 +1,51 @@
+import { showAndLogErrorMessage } from "../helpers";
+import {
+  ExplorerSelectionCommandFunction,
+  TreeViewContextMultiSelectionCommandFunction,
+  TreeViewContextSingleSelectionCommandFunction,
+} from "./commands";
+
+// A hack to match types that are not an array, which is useful to help avoid
+// misusing createSingleSelectionCommand, e.g. where T accidentally gets instantiated
+// as DatabaseItem[] instead of DatabaseItem.
+type NotArray = object & { length?: never };
+
+// A way to get the type system to help assert that one type is a supertype of another.
+type CreateSupertypeOf<Super, Sub extends Super> = Sub;
+
+// This asserts that SelectionCommand is assignable to all of the different types of
+// SelectionCommand defined in commands.ts. The intention is the output from the helpers
+// in this file can be used with any of the select command types and can handle any of
+// the inputs.
+type SelectionCommand<T extends NotArray> = CreateSupertypeOf<
+  TreeViewContextMultiSelectionCommandFunction<T> &
+    TreeViewContextSingleSelectionCommandFunction<T> &
+    ExplorerSelectionCommandFunction<T>,
+  (singleItem: T, multiSelect?: T[] | undefined) => Promise<void>
+>;
+
+export function createSingleSelectionCommand<T extends NotArray>(
+  f: (argument: T) => Promise<void>,
+  itemName: string,
+): SelectionCommand<T> {
+  return async (singleItem, multiSelect) => {
+    if (multiSelect === undefined || multiSelect.length === 1) {
+      return f(singleItem);
+    } else {
+      void showAndLogErrorMessage(`Please select a single ${itemName}.`);
+      return;
+    }
+  };
+}
+
+export function createMultiSelectionCommand<T extends NotArray>(
+  f: (argument: T[]) => Promise<void>,
+): SelectionCommand<T> {
+  return async (singleItem, multiSelect) => {
+    if (multiSelect !== undefined && multiSelect.length > 0) {
+      return f(multiSelect);
+    } else {
+      return f([singleItem]);
+    }
+  };
+}

extensions/ql-vscode/src/databases/local-databases-ui.ts

@@ -46,6 +46,10 @@ import { isCanary } from "../config";
 import { App } from "../common/app";
 import { redactableError } from "../pure/errors";
 import { LocalDatabasesCommands } from "../common/commands";
+import {
+  createMultiSelectionCommand,
+  createSingleSelectionCommand,
+} from "../common/selection-commands";
 
 enum SortOrder {
   NameAsc = "NameAsc",
@@ -240,11 +244,22 @@ export class DatabaseUI extends DisposableObject {
         this.handleMakeCurrentDatabase.bind(this),
       "codeQLDatabases.sortByName": this.handleSortByName.bind(this),
       "codeQLDatabases.sortByDateAdded": this.handleSortByDateAdded.bind(this),
-      "codeQLDatabases.removeDatabase": this.handleRemoveDatabase.bind(this),
-      "codeQLDatabases.upgradeDatabase": this.handleUpgradeDatabase.bind(this),
-      "codeQLDatabases.renameDatabase": this.handleRenameDatabase.bind(this),
-      "codeQLDatabases.openDatabaseFolder": this.handleOpenFolder.bind(this),
-      "codeQLDatabases.addDatabaseSource": this.handleAddSource.bind(this),
+      "codeQLDatabases.removeDatabase": createMultiSelectionCommand(
+        this.handleRemoveDatabase.bind(this),
+      ),
+      "codeQLDatabases.upgradeDatabase": createMultiSelectionCommand(
+        this.handleUpgradeDatabase.bind(this),
+      ),
+      "codeQLDatabases.renameDatabase": createSingleSelectionCommand(
+        this.handleRenameDatabase.bind(this),
+        "database",
+      ),
+      "codeQLDatabases.openDatabaseFolder": createMultiSelectionCommand(
+        this.handleOpenFolder.bind(this),
+      ),
+      "codeQLDatabases.addDatabaseSource": createMultiSelectionCommand(
+        this.handleAddSource.bind(this),
+      ),
       "codeQLDatabases.removeOrphanedDatabases":
         this.handleRemoveOrphanedDatabases.bind(this),
     };
@@ -515,12 +530,11 @@ export class DatabaseUI extends DisposableObject {
   private async handleUpgradeCurrentDatabase(): Promise<void> {
     return withProgress(
       async (progress, token) => {
-        await this.handleUpgradeDatabaseInternal(
-          progress,
-          token,
-          this.databaseManager.currentDatabaseItem,
-          [],
-        );
+        if (this.databaseManager.currentDatabaseItem !== undefined) {
+          await this.handleUpgradeDatabasesInternal(progress, token, [
+            this.databaseManager.currentDatabaseItem,
+          ]);
+        }
       },
       {
         title: "Upgrading current database",
@@ -530,16 +544,14 @@ export class DatabaseUI extends DisposableObject {
   }
 
   private async handleUpgradeDatabase(
-    databaseItem: DatabaseItem | undefined,
-    multiSelect: DatabaseItem[] | undefined,
+    databaseItems: DatabaseItem[],
   ): Promise<void> {
     return withProgress(
       async (progress, token) => {
-        return await this.handleUpgradeDatabaseInternal(
+        return await this.handleUpgradeDatabasesInternal(
           progress,
           token,
-          databaseItem,
-          multiSelect,
+          databaseItems,
         );
       },
       {
@@ -549,46 +561,37 @@ export class DatabaseUI extends DisposableObject {
     );
   }
 
-  private async handleUpgradeDatabaseInternal(
+  private async handleUpgradeDatabasesInternal(
     progress: ProgressCallback,
     token: CancellationToken,
-    databaseItem: DatabaseItem | undefined,
-    multiSelect: DatabaseItem[] | undefined,
+    databaseItems: DatabaseItem[],
   ): Promise<void> {
-    if (multiSelect?.length) {
-      await Promise.all(
-        multiSelect.map((dbItem) =>
-          this.handleUpgradeDatabaseInternal(progress, token, dbItem, []),
-        ),
-      );
-    }
-    if (this.queryServer === undefined) {
-      throw new Error(
-        "Received request to upgrade database, but there is no running query server.",
-      );
-    }
-    if (databaseItem === undefined) {
-      throw new Error(
-        "Received request to upgrade database, but no database was provided.",
-      );
-    }
-    if (databaseItem.contents === undefined) {
-      throw new Error(
-        "Received request to upgrade database, but database contents could not be found.",
-      );
-    }
-    if (databaseItem.contents.dbSchemeUri === undefined) {
-      throw new Error(
-        "Received request to upgrade database, but database has no schema.",
-      );
-    }
+    await Promise.all(
+      databaseItems.map(async (databaseItem) => {
+        if (this.queryServer === undefined) {
+          throw new Error(
+            "Received request to upgrade database, but there is no running query server.",
+          );
+        }
+        if (databaseItem.contents === undefined) {
+          throw new Error(
+            "Received request to upgrade database, but database contents could not be found.",
+          );
+        }
+        if (databaseItem.contents.dbSchemeUri === undefined) {
+          throw new Error(
+            "Received request to upgrade database, but database has no schema.",
+          );
+        }
 
-    // Search for upgrade scripts in any workspace folders available
+        // Search for upgrade scripts in any workspace folders available
 
-    await this.queryServer.upgradeDatabaseExplicit(
-      databaseItem,
-      progress,
-      token,
+        await this.queryServer.upgradeDatabaseExplicit(
+          databaseItem,
+          progress,
+          token,
+        );
+      }),
     );
   }
 
@@ -651,24 +654,15 @@ export class DatabaseUI extends DisposableObject {
   }
 
   private async handleRemoveDatabase(
-    databaseItem: DatabaseItem,
-    multiSelect: DatabaseItem[] | undefined,
+    databaseItems: DatabaseItem[],
   ): Promise<void> {
     return withProgress(
       async (progress, token) => {
-        if (multiSelect?.length) {
-          await Promise.all(
-            multiSelect.map((dbItem) =>
-              this.databaseManager.removeDatabaseItem(progress, token, dbItem),
-            ),
-          );
-        } else {
-          await this.databaseManager.removeDatabaseItem(
-            progress,
-            token,
-            databaseItem,
-          );
-        }
+        await Promise.all(
+          databaseItems.map((dbItem) =>
+            this.databaseManager.removeDatabaseItem(progress, token, dbItem),
+          ),
+        );
       },
       {
         title: "Removing database",
@@ -679,10 +673,7 @@ export class DatabaseUI extends DisposableObject {
 
   private async handleRenameDatabase(
     databaseItem: DatabaseItem,
-    multiSelect: DatabaseItem[] | undefined,
   ): Promise<void> {
-    this.assertSingleDatabase(multiSelect);
-
     const newName = await window.showInputBox({
       prompt: "Choose new database name",
       value: databaseItem.name,
@@ -693,34 +684,20 @@ export class DatabaseUI extends DisposableObject {
     }
   }
 
-  private async handleOpenFolder(
-    databaseItem: DatabaseItem,
-    multiSelect: DatabaseItem[] | undefined,
-  ): Promise<void> {
-    if (multiSelect?.length) {
-      await Promise.all(
-        multiSelect.map((dbItem) => env.openExternal(dbItem.databaseUri)),
-      );
-    } else {
-      await env.openExternal(databaseItem.databaseUri);
-    }
+  private async handleOpenFolder(databaseItems: DatabaseItem[]): Promise<void> {
+    await Promise.all(
+      databaseItems.map((dbItem) => env.openExternal(dbItem.databaseUri)),
+    );
   }
 
   /**
    * Adds the source folder of a CodeQL database to the workspace.
    * When a database is first added in the "Databases" view, its source folder is added to the workspace.
    * If the source folder is removed from the workspace for some reason, we want to be able to re-add it if need be.
    */
-  private async handleAddSource(
-    databaseItem: DatabaseItem,
-    multiSelect: DatabaseItem[] | undefined,
-  ): Promise<void> {
-    if (multiSelect?.length) {
-      for (const dbItem of multiSelect) {
-        await this.databaseManager.addDatabaseSourceArchiveFolder(dbItem);
-      }
-    } else {
-      await this.databaseManager.addDatabaseSourceArchiveFolder(databaseItem);
+  private async handleAddSource(databaseItems: DatabaseItem[]): Promise<void> {
+    for (const dbItem of databaseItems) {
+      await this.databaseManager.addDatabaseSourceArchiveFolder(dbItem);
     }
   }
 
@@ -823,13 +800,4 @@ export class DatabaseUI extends DisposableObject {
     }
     return Uri.file(dbPath);
   }
-
-  private assertSingleDatabase(
-    multiSelect: DatabaseItem[] = [],
-    message = "Please select a single database.",
-  ) {
-    if (multiSelect.length > 1) {
-      throw new Error(message);
-    }
-  }
 }

extensions/ql-vscode/src/local-queries/local-queries.ts

@@ -43,6 +43,7 @@ import { App } from "../common/app";
 import { DisposableObject } from "../pure/disposable-object";
 import { SkeletonQueryWizard } from "../skeleton-query-wizard";
 import { LocalQueryRun } from "./local-query-run";
+import { createMultiSelectionCommand } from "../common/selection-commands";
 
 interface DatabaseQuickPickItem extends QuickPickItem {
   databaseItem: DatabaseItem;
@@ -89,7 +90,9 @@ export class LocalQueries extends DisposableObject {
         this.runQueryOnMultipleDatabases.bind(this),
       "codeQL.runQueryOnMultipleDatabasesContextEditor":
         this.runQueryOnMultipleDatabases.bind(this),
-      "codeQL.runQueries": this.runQueries.bind(this),
+      "codeQL.runQueries": createMultiSelectionCommand(
+        this.runQueries.bind(this),
+      ),
       "codeQL.quickEval": this.quickEval.bind(this),
       "codeQL.quickEvalContextEditor": this.quickEval.bind(this),
       "codeQL.codeLensQuickEval": this.codeLensQuickEval.bind(this),
@@ -130,12 +133,12 @@ export class LocalQueries extends DisposableObject {
     );
   }
 
-  private async runQueries(_: unknown, multi: Uri[]): Promise<void> {
+  private async runQueries(fileURIs: Uri[]): Promise<void> {
     await withProgress(
       async (progress, token) => {
         const maxQueryCount = MAX_QUERIES.getValue() as number;
         const [files, dirFound] = await gatherQlFiles(
-          multi.map((uri) => uri.fsPath),
+          fileURIs.map((uri) => uri.fsPath),
         );
         if (files.length > maxQueryCount) {
           throw new Error(