Convert local query commands to typed commands

The local query commands are using a separate logger, and this is not
supported by the command manager because it is quite specific to this
extension. Therefore, we create a separate command manager which uses
a different logger to separate the commands.

Author: koesie10

extensions/ql-vscode/src/commandRunner.ts

@@ -89,7 +89,7 @@ export type ProgressTaskWithArgs<R> = (
  * @param args arguments passed to this task passed on from
  * `commands.registerCommand`.
  */
-type NoProgressTask = (...args: any[]) => Promise<any>;
+export type NoProgressTask = (...args: any[]) => Promise<any>;
 
 /**
  * This mediates between the kind of progress callbacks we want to

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

@@ -1,5 +1,5 @@
 import type { CommandManager } from "../packages/commands";
-import type { Uri } from "vscode";
+import type { Uri, Range } from "vscode";
 import type { DbTreeViewItem } from "../databases/ui/db-tree-view-item";
 import type { DatabaseItem } from "../local-databases";
 import type { QueryHistoryInfo } from "../query-history/query-history-info";
@@ -29,6 +29,21 @@ export type BaseCommands = {
   "codeQL.openDocumentation": () => Promise<void>;
 };
 
+// Commands used for running local queries
+export type LocalQueryCommands = {
+  "codeQL.runQuery": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryContextEditor": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryOnMultipleDatabases": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryOnMultipleDatabasesContextEditor": (
+    uri?: Uri,
+  ) => Promise<void>;
+  "codeQL.runQueries": SelectionCommandFunction<Uri>;
+  "codeQL.quickEval": (uri: Uri) => Promise<void>;
+  "codeQL.quickEvalContextEditor": (uri: Uri) => Promise<void>;
+  "codeQL.codeLensQuickEval": (uri: Uri, range: Range) => Promise<void>;
+  "codeQL.quickQuery": () => Promise<void>;
+};
+
 // Commands used for the query history panel
 export type QueryHistoryCommands = {
   // Commands in the "navigation" group
@@ -115,3 +130,7 @@ export type AllCommands = BaseCommands &
   DatabasePanelCommands;
 
 export type AppCommandManager = CommandManager<AllCommands>;
+
+// Separate command manager because it uses a different logger
+export type QueryServerCommands = LocalQueryCommands;
+export type QueryServerCommandManager = CommandManager<QueryServerCommands>;

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

@@ -1,15 +1,18 @@
 import { commands } from "vscode";
-import { commandRunner } from "../../commandRunner";
+import { commandRunner, NoProgressTask } from "../../commandRunner";
 import { CommandFunction, CommandManager } from "../../packages/commands";
+import { OutputChannelLogger } from "../logging";
 
 /**
  * Create a command manager for VSCode, wrapping the commandRunner
  * and vscode.executeCommand.
  */
 export function createVSCodeCommandManager<
   Commands extends Record<string, CommandFunction>,
->(): CommandManager<Commands> {
-  return new CommandManager(commandRunner, wrapExecuteCommand);
+>(outputLogger?: OutputChannelLogger): CommandManager<Commands> {
+  return new CommandManager((commandId, task: NoProgressTask) => {
+    return commandRunner(commandId, task, outputLogger);
+  }, wrapExecuteCommand);
 }
 
 /**

extensions/ql-vscode/src/common/vscode/vscode-app.ts

@@ -3,21 +3,23 @@ import { VSCodeCredentials } from "../../authentication";
 import { Disposable } from "../../pure/disposable-object";
 import { App, AppMode } from "../app";
 import { AppEventEmitter } from "../events";
-import { extLogger, Logger } from "../logging";
+import { extLogger, Logger, queryServerLogger } from "../logging";
 import { Memento } from "../memento";
 import { VSCodeAppEventEmitter } from "./events";
-import { AppCommandManager } from "../commands";
+import { AppCommandManager, QueryServerCommandManager } from "../commands";
 import { createVSCodeCommandManager } from "./commands";
 
 export class ExtensionApp implements App {
   public readonly credentials: VSCodeCredentials;
   public readonly commands: AppCommandManager;
+  public readonly queryServerCommands: QueryServerCommandManager;
 
   public constructor(
     public readonly extensionContext: vscode.ExtensionContext,
   ) {
     this.credentials = new VSCodeCredentials();
     this.commands = createVSCodeCommandManager();
+    this.queryServerCommands = createVSCodeCommandManager(queryServerLogger);
     extensionContext.subscriptions.push(this.commands);
   }
 

extensions/ql-vscode/src/extension.ts

@@ -124,10 +124,14 @@ import { DbModule } from "./databases/db-module";
 import { redactableError } from "./pure/errors";
 import { QueryHistoryDirs } from "./query-history/query-history-dirs";
 import { DirResult } from "tmp";
-import { AllCommands, BaseCommands } from "./common/commands";
+import {
+  AllCommands,
+  BaseCommands,
+  QueryServerCommands,
+} from "./common/commands";
 import {
   compileAndRunQuery,
-  registerLocalQueryCommands,
+  getLocalQueryCommands,
   showResultsForCompletedQuery,
 } from "./local-queries";
 
@@ -785,16 +789,6 @@ async function activateWithInstalledDistribution(
 
   void extLogger.log("Registering top-level command palette commands.");
 
-  registerLocalQueryCommands(ctx, {
-    queryRunner: qs,
-    queryHistoryManager: qhm,
-    databaseManager: dbm,
-    cliServer,
-    databaseUI,
-    localQueryResultsView,
-    queryStorageDir,
-  });
-
   const allCommands: AllCommands = {
     ...getCommands(),
     ...qhm.getCommands(),
@@ -807,6 +801,26 @@ async function activateWithInstalledDistribution(
     app.commands.register(commandName as keyof AllCommands, command);
   }
 
+  const queryServerCommands: QueryServerCommands = {
+    ...getLocalQueryCommands({
+      app,
+      queryRunner: qs,
+      queryHistoryManager: qhm,
+      databaseManager: dbm,
+      cliServer,
+      databaseUI,
+      localQueryResultsView,
+      queryStorageDir,
+    }),
+  };
+
+  for (const [commandName, command] of Object.entries(queryServerCommands)) {
+    app.queryServerCommands.register(
+      commandName as keyof QueryServerCommands,
+      command,
+    );
+  }
+
   ctx.subscriptions.push(
     commandRunner(
       "codeQL.copyVariantAnalysisRepoList",