From 72f253e39f5a5adf974e31312e977365de987275 Mon Sep 17 00:00:00 2001
From: Koen Vlaswinkel <koesie10@github.com>
Date: Thu, 1 Dec 2022 11:08:32 +0100
Subject: [PATCH 1/7] Add exporting of in-progress/cancelled results

This will allow exporting results for a variant analysis which is
cancelled or in-progress. Repositories for which the results are not yet
available or which have not yet been downloaded will not be exported.

The header of the summary file is incorrect, but this will be fixed in
a follow-up PR.
---
 .../src/remote-queries/export-results.ts      | 23 +++++++--
 .../VariantAnalysis.stories.tsx               |  1 +
 .../VariantAnalysisActions.stories.tsx        | 14 ++++++
 .../view/variant-analysis/VariantAnalysis.tsx |  1 +
 .../VariantAnalysisActions.tsx                | 34 ++++++++-----
 .../VariantAnalysisHeader.tsx                 | 15 ++++++
 .../__tests__/VariantAnalysisActions.spec.tsx | 48 +++++++++++++++----
 7 files changed, 111 insertions(+), 25 deletions(-)

diff --git a/extensions/ql-vscode/src/remote-queries/export-results.ts b/extensions/ql-vscode/src/remote-queries/export-results.ts
index 33c5de803..646ea0740 100644
--- a/extensions/ql-vscode/src/remote-queries/export-results.ts
+++ b/extensions/ql-vscode/src/remote-queries/export-results.ts
@@ -2,12 +2,12 @@ import * as path from "path";
 import * as fs from "fs-extra";
 
 import {
-  window,
   commands,
-  Uri,
   ExtensionContext,
-  workspace,
+  Uri,
   ViewColumn,
+  window,
+  workspace,
 } from "vscode";
 import { Credentials } from "../authentication";
 import { UserCancellationException } from "../commandRunner";
@@ -29,6 +29,7 @@ import { assertNever } from "../pure/helpers-pure";
 import {
   VariantAnalysis,
   VariantAnalysisScannedRepository,
+  VariantAnalysisScannedRepositoryDownloadStatus,
   VariantAnalysisScannedRepositoryResult,
 } from "./shared/variant-analysis";
 import {
@@ -156,6 +157,10 @@ export async function exportVariantAnalysisResults(
     );
   }
 
+  const repoStates = await variantAnalysisManager.getRepoStates(
+    variantAnalysisId,
+  );
+
   void extLogger.log(
     `Exporting variant analysis results for variant analysis with id ${variantAnalysis.id}`,
   );
@@ -181,6 +186,18 @@ export async function exportVariantAnalysisResults(
     }
 
     for (const repo of repositories) {
+      const repoState = repoStates.find(
+        (r) => r.repositoryId === repo.repository.id,
+      );
+
+      // Do not export if it has not yet completed or the download has not yet succeeded.
+      if (
+        repoState?.downloadStatus !==
+        VariantAnalysisScannedRepositoryDownloadStatus.Succeeded
+      ) {
+        continue;
+      }
+
       if (repo.resultCount == 0) {
         yield [
           repo,
diff --git a/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysis.stories.tsx b/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysis.stories.tsx
index 505c9553e..a28b122d7 100644
--- a/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysis.stories.tsx
+++ b/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysis.stories.tsx
@@ -43,6 +43,7 @@ const variantAnalysis: VariantAnalysisDomainModel = {
         private: false,
       },
       analysisStatus: VariantAnalysisRepoStatus.Succeeded,
+      resultCount: 100,
     },
     {
       repository: {
diff --git a/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysisActions.stories.tsx b/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysisActions.stories.tsx
index 2def22117..3b966a304 100644
--- a/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysisActions.stories.tsx
+++ b/extensions/ql-vscode/src/stories/variant-analysis/VariantAnalysisActions.stories.tsx
@@ -47,10 +47,24 @@ InProgress.args = {
   variantAnalysisStatus: VariantAnalysisStatus.InProgress,
 };
 
+export const InProgressWithResults = Template.bind({});
+InProgressWithResults.args = {
+  variantAnalysisStatus: VariantAnalysisStatus.InProgress,
+  showResultActions: true,
+};
+
+export const InProgressWithoutDownloadedRepos = Template.bind({});
+InProgressWithoutDownloadedRepos.args = {
+  variantAnalysisStatus: VariantAnalysisStatus.InProgress,
+  showResultActions: true,
+  exportResultsDisabled: true,
+};
+
 export const Succeeded = Template.bind({});
 Succeeded.args = {
   ...InProgress.args,
   variantAnalysisStatus: VariantAnalysisStatus.Succeeded,
+  showResultActions: true,
 };
 
 export const Failed = Template.bind({});
diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
index 82f74c734..f4d553e5e 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
@@ -144,6 +144,7 @@ export function VariantAnalysis({
     <>
       <VariantAnalysisHeader
         variantAnalysis={variantAnalysis}
+        repositoryStates={repoStates}
         onOpenQueryFileClick={openQueryFile}
         onViewQueryTextClick={openQueryText}
         onStopQueryClick={stopQuery}
diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
index 84120fa8d..01ac03bfa 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
@@ -3,14 +3,16 @@ import styled from "styled-components";
 import { VSCodeButton } from "@vscode/webview-ui-toolkit/react";
 import { VariantAnalysisStatus } from "../../remote-queries/shared/variant-analysis";
 
-type Props = {
+export type VariantAnalysisActionsProps = {
   variantAnalysisStatus: VariantAnalysisStatus;
 
   onStopQueryClick: () => void;
   stopQueryDisabled?: boolean;
 
+  showResultActions?: boolean;
   onCopyRepositoryListClick: () => void;
   onExportResultsClick: () => void;
+  exportResultsDisabled?: boolean;
 };
 
 const Container = styled.div`
@@ -26,12 +28,28 @@ const Button = styled(VSCodeButton)`
 export const VariantAnalysisActions = ({
   variantAnalysisStatus,
   onStopQueryClick,
+  stopQueryDisabled,
+  showResultActions,
   onCopyRepositoryListClick,
   onExportResultsClick,
-  stopQueryDisabled,
-}: Props) => {
+  exportResultsDisabled,
+}: VariantAnalysisActionsProps) => {
   return (
     <Container>
+      {showResultActions && (
+        <>
+          <Button appearance="secondary" onClick={onCopyRepositoryListClick}>
+            Copy repository list
+          </Button>
+          <Button
+            appearance="primary"
+            onClick={onExportResultsClick}
+            disabled={exportResultsDisabled}
+          >
+            Export results
+          </Button>
+        </>
+      )}
       {variantAnalysisStatus === VariantAnalysisStatus.InProgress && (
         <Button
           appearance="secondary"
@@ -41,16 +59,6 @@ export const VariantAnalysisActions = ({
           Stop query
         </Button>
       )}
-      {variantAnalysisStatus === VariantAnalysisStatus.Succeeded && (
-        <>
-          <Button appearance="secondary" onClick={onCopyRepositoryListClick}>
-            Copy repository list
-          </Button>
-          <Button appearance="primary" onClick={onExportResultsClick}>
-            Export results
-          </Button>
-        </>
-      )}
     </Container>
   );
 };
diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
index ed0d5b8d4..afd6744d4 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
@@ -6,6 +6,8 @@ import {
   getTotalResultCount,
   hasRepoScanCompleted,
   VariantAnalysis,
+  VariantAnalysisScannedRepositoryDownloadStatus,
+  VariantAnalysisScannedRepositoryState,
 } from "../../remote-queries/shared/variant-analysis";
 import { QueryDetails } from "./QueryDetails";
 import { VariantAnalysisActions } from "./VariantAnalysisActions";
@@ -15,6 +17,7 @@ import { basename } from "../common/path";
 
 export type VariantAnalysisHeaderProps = {
   variantAnalysis: VariantAnalysis;
+  repositoryStates?: VariantAnalysisScannedRepositoryState[];
 
   onOpenQueryFileClick: () => void;
   onViewQueryTextClick: () => void;
@@ -40,6 +43,7 @@ const Row = styled.div`
 
 export const VariantAnalysisHeader = ({
   variantAnalysis,
+  repositoryStates,
   onOpenQueryFileClick,
   onViewQueryTextClick,
   onStopQueryClick,
@@ -62,6 +66,15 @@ export const VariantAnalysisHeader = ({
   const hasSkippedRepos = useMemo(() => {
     return getSkippedRepoCount(variantAnalysis.skippedRepos) > 0;
   }, [variantAnalysis.skippedRepos]);
+  const hasDownloadedRepos = useMemo(() => {
+    return (
+      repositoryStates?.some(
+        (repo) =>
+          repo.downloadStatus ===
+          VariantAnalysisScannedRepositoryDownloadStatus.Succeeded,
+      ) ?? false
+    );
+  }, [repositoryStates]);
 
   return (
     <Container>
@@ -74,10 +87,12 @@ export const VariantAnalysisHeader = ({
         />
         <VariantAnalysisActions
           variantAnalysisStatus={variantAnalysis.status}
+          showResultActions={(resultCount ?? 0) > 0}
           onStopQueryClick={onStopQueryClick}
           onCopyRepositoryListClick={onCopyRepositoryListClick}
           onExportResultsClick={onExportResultsClick}
           stopQueryDisabled={!variantAnalysis.actionsWorkflowRunId}
+          exportResultsDisabled={!hasDownloadedRepos}
         />
       </Row>
       <VariantAnalysisStats
diff --git a/extensions/ql-vscode/src/view/variant-analysis/__tests__/VariantAnalysisActions.spec.tsx b/extensions/ql-vscode/src/view/variant-analysis/__tests__/VariantAnalysisActions.spec.tsx
index ac7db50a1..20c291128 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/__tests__/VariantAnalysisActions.spec.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/__tests__/VariantAnalysisActions.spec.tsx
@@ -2,7 +2,10 @@ import * as React from "react";
 import { render as reactRender, screen } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { VariantAnalysisStatus } from "../../../remote-queries/shared/variant-analysis";
-import { VariantAnalysisActions } from "../VariantAnalysisActions";
+import {
+  VariantAnalysisActions,
+  VariantAnalysisActionsProps,
+} from "../VariantAnalysisActions";
 
 describe(VariantAnalysisActions.name, () => {
   const onStopQueryClick = jest.fn();
@@ -15,51 +18,78 @@ describe(VariantAnalysisActions.name, () => {
     onExportResultsClick.mockReset();
   });
 
-  const render = (variantAnalysisStatus: VariantAnalysisStatus) =>
+  const render = (
+    props: Pick<VariantAnalysisActionsProps, "variantAnalysisStatus"> &
+      Partial<VariantAnalysisActionsProps>,
+  ) =>
     reactRender(
       <VariantAnalysisActions
-        variantAnalysisStatus={variantAnalysisStatus}
         onStopQueryClick={onStopQueryClick}
         onCopyRepositoryListClick={onCopyRepositoryListClick}
         onExportResultsClick={onExportResultsClick}
+        {...props}
       />,
     );
 
   it("renders 1 button when in progress", async () => {
-    const { container } = render(VariantAnalysisStatus.InProgress);
+    const { container } = render({
+      variantAnalysisStatus: VariantAnalysisStatus.InProgress,
+    });
 
     expect(container.querySelectorAll("vscode-button").length).toEqual(1);
   });
 
   it("renders the stop query button when in progress", async () => {
-    render(VariantAnalysisStatus.InProgress);
+    render({
+      variantAnalysisStatus: VariantAnalysisStatus.InProgress,
+    });
 
     await userEvent.click(screen.getByText("Stop query"));
     expect(onStopQueryClick).toHaveBeenCalledTimes(1);
   });
 
+  it("renders 3 buttons when in progress with results", async () => {
+    const { container } = render({
+      variantAnalysisStatus: VariantAnalysisStatus.InProgress,
+      showResultActions: true,
+    });
+
+    expect(container.querySelectorAll("vscode-button").length).toEqual(3);
+  });
+
   it("renders 2 buttons when succeeded", async () => {
-    const { container } = render(VariantAnalysisStatus.Succeeded);
+    const { container } = render({
+      variantAnalysisStatus: VariantAnalysisStatus.Succeeded,
+      showResultActions: true,
+    });
 
     expect(container.querySelectorAll("vscode-button").length).toEqual(2);
   });
 
   it("renders the copy repository list button when succeeded", async () => {
-    render(VariantAnalysisStatus.Succeeded);
+    render({
+      variantAnalysisStatus: VariantAnalysisStatus.Succeeded,
+      showResultActions: true,
+    });
 
     await userEvent.click(screen.getByText("Copy repository list"));
     expect(onCopyRepositoryListClick).toHaveBeenCalledTimes(1);
   });
 
   it("renders the export results button when succeeded", async () => {
-    render(VariantAnalysisStatus.Succeeded);
+    render({
+      variantAnalysisStatus: VariantAnalysisStatus.Succeeded,
+      showResultActions: true,
+    });
 
     await userEvent.click(screen.getByText("Export results"));
     expect(onExportResultsClick).toHaveBeenCalledTimes(1);
   });
 
   it("does not render any buttons when failed", () => {
-    const { container } = render(VariantAnalysisStatus.Failed);
+    const { container } = render({
+      variantAnalysisStatus: VariantAnalysisStatus.Failed,
+    });
 
     expect(container.querySelectorAll("vscode-button").length).toEqual(0);
   });

From 0f7cf2d935f16c30c29238b6937793dd8d84e4eb Mon Sep 17 00:00:00 2001
From: Koen Vlaswinkel <koesie10@github.com>
Date: Thu, 1 Dec 2022 11:19:43 +0100
Subject: [PATCH 2/7] Take into account filters for action buttons

This will disable the export and copy buttons when no results would be
exported by executing the command. In contrast to the "normal" filtering
in the view, this will also take into account the checkboxes since those
are also used in the extension host.
---
 .../view/variant-analysis/VariantAnalysis.tsx |  2 +
 .../VariantAnalysisActions.tsx                |  8 +++-
 .../VariantAnalysisHeader.tsx                 | 45 ++++++++++++++++---
 3 files changed, 47 insertions(+), 8 deletions(-)

diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
index f4d553e5e..023f2d80a 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysis.tsx
@@ -145,6 +145,8 @@ export function VariantAnalysis({
       <VariantAnalysisHeader
         variantAnalysis={variantAnalysis}
         repositoryStates={repoStates}
+        filterSortState={filterSortState}
+        selectedRepositoryIds={selectedRepositoryIds}
         onOpenQueryFileClick={openQueryFile}
         onViewQueryTextClick={openQueryText}
         onStopQueryClick={stopQuery}
diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
index 01ac03bfa..d6a2588a0 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisActions.tsx
@@ -12,6 +12,7 @@ export type VariantAnalysisActionsProps = {
   showResultActions?: boolean;
   onCopyRepositoryListClick: () => void;
   onExportResultsClick: () => void;
+  copyRepositoryListDisabled?: boolean;
   exportResultsDisabled?: boolean;
 };
 
@@ -32,13 +33,18 @@ export const VariantAnalysisActions = ({
   showResultActions,
   onCopyRepositoryListClick,
   onExportResultsClick,
+  copyRepositoryListDisabled,
   exportResultsDisabled,
 }: VariantAnalysisActionsProps) => {
   return (
     <Container>
       {showResultActions && (
         <>
-          <Button appearance="secondary" onClick={onCopyRepositoryListClick}>
+          <Button
+            appearance="secondary"
+            onClick={onCopyRepositoryListClick}
+            disabled={copyRepositoryListDisabled}
+          >
             Copy repository list
           </Button>
           <Button
diff --git a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
index afd6744d4..ec3fd41b1 100644
--- a/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
+++ b/extensions/ql-vscode/src/view/variant-analysis/VariantAnalysisHeader.tsx
@@ -14,10 +14,17 @@ import { VariantAnalysisActions } from "./VariantAnalysisActions";
 import { VariantAnalysisStats } from "./VariantAnalysisStats";
 import { parseDate } from "../../pure/date";
 import { basename } from "../common/path";
+import {
+  defaultFilterSortState,
+  filterAndSortRepositoriesWithResults,
+  RepositoriesFilterSortState,
+} from "../../pure/variant-analysis-filter-sort";
 
 export type VariantAnalysisHeaderProps = {
   variantAnalysis: VariantAnalysis;
   repositoryStates?: VariantAnalysisScannedRepositoryState[];
+  filterSortState?: RepositoriesFilterSortState;
+  selectedRepositoryIds?: number[];
 
   onOpenQueryFileClick: () => void;
   onViewQueryTextClick: () => void;
@@ -44,6 +51,8 @@ const Row = styled.div`
 export const VariantAnalysisHeader = ({
   variantAnalysis,
   repositoryStates,
+  filterSortState,
+  selectedRepositoryIds,
   onOpenQueryFileClick,
   onViewQueryTextClick,
   onStopQueryClick,
@@ -66,15 +75,36 @@ export const VariantAnalysisHeader = ({
   const hasSkippedRepos = useMemo(() => {
     return getSkippedRepoCount(variantAnalysis.skippedRepos) > 0;
   }, [variantAnalysis.skippedRepos]);
+  const filteredRepositories = useMemo(() => {
+    return filterAndSortRepositoriesWithResults(variantAnalysis.scannedRepos, {
+      ...defaultFilterSortState,
+      ...filterSortState,
+      repositoryIds: selectedRepositoryIds,
+    });
+  }, [filterSortState, selectedRepositoryIds, variantAnalysis.scannedRepos]);
   const hasDownloadedRepos = useMemo(() => {
-    return (
-      repositoryStates?.some(
-        (repo) =>
-          repo.downloadStatus ===
-          VariantAnalysisScannedRepositoryDownloadStatus.Succeeded,
-      ) ?? false
+    const repositoryStatesById = new Map<
+      number,
+      VariantAnalysisScannedRepositoryState
+    >();
+    if (repositoryStates) {
+      for (const repositoryState of repositoryStates) {
+        repositoryStatesById.set(repositoryState.repositoryId, repositoryState);
+      }
+    }
+
+    return filteredRepositories?.some((repo) => {
+      return (
+        repositoryStatesById.get(repo.repository.id)?.downloadStatus ===
+        VariantAnalysisScannedRepositoryDownloadStatus.Succeeded
+      );
+    });
+  }, [repositoryStates, filteredRepositories]);
+  const hasReposWithResults = useMemo(() => {
+    return filteredRepositories?.some(
+      (repo) => repo.resultCount && repo.resultCount > 0,
     );
-  }, [repositoryStates]);
+  }, [filteredRepositories]);
 
   return (
     <Container>
@@ -93,6 +123,7 @@ export const VariantAnalysisHeader = ({
           onExportResultsClick={onExportResultsClick}
           stopQueryDisabled={!variantAnalysis.actionsWorkflowRunId}
           exportResultsDisabled={!hasDownloadedRepos}
+          copyRepositoryListDisabled={!hasReposWithResults}
         />
       </Row>
       <VariantAnalysisStats

From f6bb233a151b3187a2e186818a3331d2eb055e08 Mon Sep 17 00:00:00 2001
From: Koen Vlaswinkel <koesie10@github.com>
Date: Thu, 1 Dec 2022 11:43:37 +0100
Subject: [PATCH 3/7] Close serialized webview when another view already exists

When deserializing a webview, it could happen that a view was already
manually opened by the user before the webview was deserialized. This
would result in duplicate webview tabs, which is not supported by the
manager.

This will close the webview that is being deserialized and focus on the
existing view. This should ensure that we never have duplicate loaded
webview tabs. There could still be duplicate webview tabs if there are
non-deserialized tabs, but once it is opened it should be closed
automatically.
---
 .../src/remote-queries/variant-analysis-view-manager.ts  | 1 +
 .../remote-queries/variant-analysis-view-serializer.ts   | 9 +++++++++
 2 files changed, 10 insertions(+)

diff --git a/extensions/ql-vscode/src/remote-queries/variant-analysis-view-manager.ts b/extensions/ql-vscode/src/remote-queries/variant-analysis-view-manager.ts
index 28a75b8c9..7f307c42d 100644
--- a/extensions/ql-vscode/src/remote-queries/variant-analysis-view-manager.ts
+++ b/extensions/ql-vscode/src/remote-queries/variant-analysis-view-manager.ts
@@ -13,6 +13,7 @@ export interface VariantAnalysisViewManager<
 > {
   registerView(view: T): void;
   unregisterView(view: T): void;
+  getView(variantAnalysisId: number): T | undefined;
 
   getVariantAnalysis(
     variantAnalysisId: number,
diff --git a/extensions/ql-vscode/src/remote-queries/variant-analysis-view-serializer.ts b/extensions/ql-vscode/src/remote-queries/variant-analysis-view-serializer.ts
index fb00587e5..2eeb81793 100644
--- a/extensions/ql-vscode/src/remote-queries/variant-analysis-view-serializer.ts
+++ b/extensions/ql-vscode/src/remote-queries/variant-analysis-view-serializer.ts
@@ -38,6 +38,15 @@ export class VariantAnalysisViewSerializer implements WebviewPanelSerializer {
 
     const manager = await this.waitForExtensionFullyLoaded();
 
+    const existingView = manager.getView(
+      variantAnalysisState.variantAnalysisId,
+    );
+    if (existingView) {
+      await existingView.openView();
+      webviewPanel.dispose();
+      return;
+    }
+
     const view = new VariantAnalysisView(
       this.ctx,
       variantAnalysisState.variantAnalysisId,

From 6a431b0719918e8d991e9476aca727a5729cf8d3 Mon Sep 17 00:00:00 2001
From: Koen Vlaswinkel <koesie10@github.com>
Date: Thu, 1 Dec 2022 12:14:35 +0100
Subject: [PATCH 4/7] Fix Gist title in result export

The Gist title in the result export didn't take into account the actual
number of exported repositories, it only used the scanned, unfiltered,
repositories in the variant analysis. This switches it to use the actual
exported repositories for determining the result and repository counts.

This is somewhat more complicated than we'd expect it to be since the
results are being read in async, so we need to switch the order of
operations and store some additional information for being able to
compute this information. However, this also makes the code somewhat
easier to understand since the summary file is now being created in only
1 location, rather than being split between a method and a for-loop.
---
 .../src/remote-queries/export-results.ts      | 28 +++++-----
 .../remote-queries-markdown-generation.ts     | 53 +++++++++++++++----
 2 files changed, 56 insertions(+), 25 deletions(-)

diff --git a/extensions/ql-vscode/src/remote-queries/export-results.ts b/extensions/ql-vscode/src/remote-queries/export-results.ts
index cc1565a89..ef899d7f7 100644
--- a/extensions/ql-vscode/src/remote-queries/export-results.ts
+++ b/extensions/ql-vscode/src/remote-queries/export-results.ts
@@ -20,6 +20,7 @@ import {
   generateMarkdown,
   generateVariantAnalysisMarkdown,
   MarkdownFile,
+  RepositorySummary,
 } from "./remote-queries-markdown-generation";
 import { RemoteQuery } from "./remote-query";
 import { AnalysisResults, sumAnalysesResults } from "./shared/analysis-result";
@@ -235,11 +236,14 @@ export async function exportVariantAnalysisAnalysisResults(
   >,
   exportFormat: "gist" | "local",
 ) {
-  const description = buildVariantAnalysisGistDescription(variantAnalysis);
-  const markdownFiles = await generateVariantAnalysisMarkdown(
+  const { markdownFiles, summaries } = await generateVariantAnalysisMarkdown(
     variantAnalysis,
     analysesResults,
-    "gist",
+    exportFormat,
+  );
+  const description = buildVariantAnalysisGistDescription(
+    variantAnalysis,
+    summaries,
   );
 
   await exportResults(
@@ -345,20 +349,16 @@ const buildGistDescription = (
  */
 const buildVariantAnalysisGistDescription = (
   variantAnalysis: VariantAnalysis,
+  summaries: RepositorySummary[],
 ) => {
-  const resultCount =
-    variantAnalysis.scannedRepos?.reduce(
-      (acc, item) => acc + (item.resultCount ?? 0),
-      0,
-    ) ?? 0;
+  const resultCount = summaries.reduce(
+    (acc, summary) => acc + (summary.resultCount ?? 0),
+    0,
+  );
   const resultLabel = pluralize(resultCount, "result", "results");
 
-  const repositoryLabel = variantAnalysis.scannedRepos?.length
-    ? `(${pluralize(
-        variantAnalysis.scannedRepos.length,
-        "repository",
-        "repositories",
-      )})`
+  const repositoryLabel = summaries.length
+    ? `(${pluralize(summaries.length, "repository", "repositories")})`
     : "";
   return `${variantAnalysis.query.name} (${variantAnalysis.query.language}) ${resultLabel} ${repositoryLabel}`;
 };
diff --git a/extensions/ql-vscode/src/remote-queries/remote-queries-markdown-generation.ts b/extensions/ql-vscode/src/remote-queries/remote-queries-markdown-generation.ts
index 4cf6f8630..c013bca36 100644
--- a/extensions/ql-vscode/src/remote-queries/remote-queries-markdown-generation.ts
+++ b/extensions/ql-vscode/src/remote-queries/remote-queries-markdown-generation.ts
@@ -18,6 +18,7 @@ import {
   VariantAnalysisScannedRepository,
   VariantAnalysisScannedRepositoryResult,
 } from "./shared/variant-analysis";
+import { RepositoryWithMetadata } from "./shared/repository";
 
 export type MarkdownLinkType = "local" | "gist";
 
@@ -74,6 +75,17 @@ export function generateMarkdown(
   return [summaryFile, ...resultsFiles];
 }
 
+export interface RepositorySummary {
+  fileName: string;
+  repository: RepositoryWithMetadata;
+  resultCount: number;
+}
+
+export interface VariantAnalysisMarkdown {
+  markdownFiles: MarkdownFile[];
+  summaries: RepositorySummary[];
+}
+
 /**
  * Generates markdown files with variant analysis results.
  */
@@ -83,23 +95,22 @@ export async function generateVariantAnalysisMarkdown(
     [VariantAnalysisScannedRepository, VariantAnalysisScannedRepositoryResult]
   >,
   linkType: MarkdownLinkType,
-): Promise<MarkdownFile[]> {
+): Promise<VariantAnalysisMarkdown> {
   const resultsFiles: MarkdownFile[] = [];
-  // Generate summary file with links to individual files
-  const summaryFile: MarkdownFile =
-    generateVariantAnalysisMarkdownSummary(variantAnalysis);
+  const summaries: RepositorySummary[] = [];
   for await (const [scannedRepo, result] of results) {
-    if (scannedRepo.resultCount === 0) {
+    if (!scannedRepo.resultCount || scannedRepo.resultCount === 0) {
       continue;
     }
 
     // Append nwo and results count to the summary table
     const fullName = scannedRepo.repository.fullName;
     const fileName = createFileName(fullName);
-    const link = createRelativeLink(fileName, linkType);
-    summaryFile.content.push(
-      `| ${fullName} | [${scannedRepo.resultCount} result(s)](${link}) |`,
-    );
+    summaries.push({
+      fileName,
+      repository: scannedRepo.repository,
+      resultCount: scannedRepo.resultCount,
+    });
 
     // Generate individual markdown file for each repository
     const resultsFileContent = [`### ${scannedRepo.repository.fullName}`, ""];
@@ -121,7 +132,18 @@ export async function generateVariantAnalysisMarkdown(
       content: resultsFileContent,
     });
   }
-  return [summaryFile, ...resultsFiles];
+
+  // Generate summary file with links to individual files
+  const summaryFile: MarkdownFile = generateVariantAnalysisMarkdownSummary(
+    variantAnalysis,
+    summaries,
+    linkType,
+  );
+
+  return {
+    markdownFiles: [summaryFile, ...resultsFiles],
+    summaries,
+  };
 }
 
 export function generateMarkdownSummary(query: RemoteQuery): MarkdownFile {
@@ -147,6 +169,8 @@ export function generateMarkdownSummary(query: RemoteQuery): MarkdownFile {
 
 export function generateVariantAnalysisMarkdownSummary(
   variantAnalysis: VariantAnalysis,
+  summaries: RepositorySummary[],
+  linkType: MarkdownLinkType,
 ): MarkdownFile {
   const lines: string[] = [];
   // Title
@@ -165,7 +189,14 @@ export function generateVariantAnalysisMarkdownSummary(
 
   // Summary table
   lines.push("### Summary", "", "| Repository | Results |", "| --- | --- |");
-  // nwo and result count will be appended to this table
+
+  for (const summary of summaries) {
+    // Append nwo and results count to the summary table
+    const fullName = summary.repository.fullName;
+    const link = createRelativeLink(summary.fileName, linkType);
+    lines.push(`| ${fullName} | [${summary.resultCount} result(s)](${link}) |`);
+  }
+
   return {
     fileName: "_summary",
     content: lines,

From 3d81e1b31e595be8824d292b1a1c10b08a5b0ac0 Mon Sep 17 00:00:00 2001
From: Koen Vlaswinkel <koesie10@github.com>
Date: Thu, 1 Dec 2022 13:22:53 +0100
Subject: [PATCH 5/7] Handle errors when retrieving variant analyses in the
 monitor

This will add error handling to the retrieval of variant analyses in the
monitor by catching the error. It will show a warning to the user and
log it. Then, it will simply sleep for 5 seconds and try again.

I'm not sure if we want to show all of these errors to the user since
this can result in many warnings popping up if many variant analyses are
being monitored, but this is probably that the user should be made aware
of.
---
 .../variant-analysis-monitor.ts               | 21 ++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/extensions/ql-vscode/src/remote-queries/variant-analysis-monitor.ts b/extensions/ql-vscode/src/remote-queries/variant-analysis-monitor.ts
index a0a0ab947..ba528de15 100644
--- a/extensions/ql-vscode/src/remote-queries/variant-analysis-monitor.ts
+++ b/extensions/ql-vscode/src/remote-queries/variant-analysis-monitor.ts
@@ -13,9 +13,12 @@ import {
   VariantAnalysis,
   VariantAnalysisScannedRepository,
 } from "./shared/variant-analysis";
+import { VariantAnalysis as ApiVariantAnalysis } from "./gh-api/variant-analysis";
 import { processUpdatedVariantAnalysis } from "./variant-analysis-processor";
 import { DisposableObject } from "../pure/disposable-object";
 import { sleep } from "../pure/time";
+import { getErrorMessage } from "../pure/helpers-pure";
+import { showAndLogWarningMessage } from "../helpers";
 
 export class VariantAnalysisMonitor extends DisposableObject {
   // With a sleep of 5 seconds, the maximum number of attempts takes
@@ -60,11 +63,19 @@ export class VariantAnalysisMonitor extends DisposableObject {
         return;
       }
 
-      const variantAnalysisSummary = await getVariantAnalysis(
-        credentials,
-        variantAnalysis.controllerRepo.id,
-        variantAnalysis.id,
-      );
+      let variantAnalysisSummary: ApiVariantAnalysis;
+      try {
+        variantAnalysisSummary = await getVariantAnalysis(
+          credentials,
+          variantAnalysis.controllerRepo.id,
+          variantAnalysis.id,
+        );
+      } catch (e) {
+        void showAndLogWarningMessage(
+          `Error while monitoring variant analysis: ${getErrorMessage(e)}`,
+        );
+        continue;
+      }
 
       variantAnalysis = processUpdatedVariantAnalysis(
         variantAnalysis,

From 6d1b5ab1e1c192d17e830280722fbaea6e5195c7 Mon Sep 17 00:00:00 2001
From: Charis Kyriakou <charisk@users.noreply.github.com>
Date: Thu, 1 Dec 2022 16:27:21 +0000
Subject: [PATCH 6/7] Update the format of selected state and propagate it to
 the treeview (#1817)

---
 .../src/databases/config/db-config.ts         |  91 ++++++++-
 extensions/ql-vscode/src/databases/db-item.ts |  53 +++++
 .../src/databases/db-tree-creator.ts          |  95 +++++++--
 .../src/databases/ui/db-tree-view-item.ts     |  11 ++
 .../databases/db-panel.test.ts                | 148 +++++++++++++-
 .../config/data/workspace-databases.json      |   4 +-
 .../databases/config/db-config-store.test.ts  |   4 +-
 .../databases/db-tree-creator.test.ts         | 185 +++++++++++++++++-
 .../ql-vscode/workspace-databases-schema.json |  93 ++++++++-
 9 files changed, 635 insertions(+), 49 deletions(-)

diff --git a/extensions/ql-vscode/src/databases/config/db-config.ts b/extensions/ql-vscode/src/databases/config/db-config.ts
index 1d286d451..688551cc2 100644
--- a/extensions/ql-vscode/src/databases/config/db-config.ts
+++ b/extensions/ql-vscode/src/databases/config/db-config.ts
@@ -10,14 +10,53 @@ export interface DbConfigDatabases {
   local: LocalDbConfig;
 }
 
-export interface SelectedDbItem {
-  kind: SelectedDbItemKind;
-  value: string;
-}
+export type SelectedDbItem =
+  | SelectedLocalUserDefinedList
+  | SelectedLocalDatabase
+  | SelectedRemoteSystemDefinedList
+  | SelectedRemoteUserDefinedList
+  | SelectedRemoteOwner
+  | SelectedRemoteRepository;
 
 export enum SelectedDbItemKind {
-  ConfigDefined = "configDefined",
+  LocalUserDefinedList = "localUserDefinedList",
+  LocalDatabase = "localDatabase",
   RemoteSystemDefinedList = "remoteSystemDefinedList",
+  RemoteUserDefinedList = "remoteUserDefinedList",
+  RemoteOwner = "remoteOwner",
+  RemoteRepository = "remoteRepository",
+}
+
+export interface SelectedLocalUserDefinedList {
+  kind: SelectedDbItemKind.LocalUserDefinedList;
+  listName: string;
+}
+
+export interface SelectedLocalDatabase {
+  kind: SelectedDbItemKind.LocalDatabase;
+  databaseName: string;
+  listName?: string;
+}
+
+export interface SelectedRemoteSystemDefinedList {
+  kind: SelectedDbItemKind.RemoteSystemDefinedList;
+  listName: string;
+}
+
+export interface SelectedRemoteUserDefinedList {
+  kind: SelectedDbItemKind.RemoteUserDefinedList;
+  listName: string;
+}
+
+export interface SelectedRemoteOwner {
+  kind: SelectedDbItemKind.RemoteOwner;
+  ownerName: string;
+}
+
+export interface SelectedRemoteRepository {
+  kind: SelectedDbItemKind.RemoteRepository;
+  repositoryName: string;
+  listName?: string;
 }
 
 export interface RemoteDbConfig {
@@ -70,10 +109,44 @@ export function cloneDbConfig(config: DbConfig): DbConfig {
       },
     },
     selected: config.selected
-      ? {
-          kind: config.selected.kind,
-          value: config.selected.value,
-        }
+      ? cloneDbConfigSelectedItem(config.selected)
       : undefined,
   };
 }
+
+function cloneDbConfigSelectedItem(selected: SelectedDbItem): SelectedDbItem {
+  switch (selected.kind) {
+    case SelectedDbItemKind.LocalUserDefinedList:
+      return {
+        kind: SelectedDbItemKind.LocalUserDefinedList,
+        listName: selected.listName,
+      };
+    case SelectedDbItemKind.LocalDatabase:
+      return {
+        kind: SelectedDbItemKind.LocalDatabase,
+        databaseName: selected.databaseName,
+        listName: selected.listName,
+      };
+    case SelectedDbItemKind.RemoteSystemDefinedList:
+      return {
+        kind: SelectedDbItemKind.RemoteSystemDefinedList,
+        listName: selected.listName,
+      };
+    case SelectedDbItemKind.RemoteUserDefinedList:
+      return {
+        kind: SelectedDbItemKind.RemoteUserDefinedList,
+        listName: selected.listName,
+      };
+    case SelectedDbItemKind.RemoteOwner:
+      return {
+        kind: SelectedDbItemKind.RemoteOwner,
+        ownerName: selected.ownerName,
+      };
+    case SelectedDbItemKind.RemoteRepository:
+      return {
+        kind: SelectedDbItemKind.RemoteRepository,
+        repositoryName: selected.repositoryName,
+        listName: selected.listName,
+      };
+  }
+}
diff --git a/extensions/ql-vscode/src/databases/db-item.ts b/extensions/ql-vscode/src/databases/db-item.ts
index 99bed2ce2..76bda03c6 100644
--- a/extensions/ql-vscode/src/databases/db-item.ts
+++ b/extensions/ql-vscode/src/databases/db-item.ts
@@ -20,12 +20,14 @@ export type LocalDbItem = LocalListDbItem | LocalDatabaseDbItem;
 
 export interface LocalListDbItem {
   kind: DbItemKind.LocalList;
+  selected: boolean;
   listName: string;
   databases: LocalDatabaseDbItem[];
 }
 
 export interface LocalDatabaseDbItem {
   kind: DbItemKind.LocalDatabase;
+  selected: boolean;
   databaseName: string;
   dateAdded: number;
   language: string;
@@ -51,6 +53,7 @@ export type RemoteDbItem =
 
 export interface RemoteSystemDefinedListDbItem {
   kind: DbItemKind.RemoteSystemDefinedList;
+  selected: boolean;
   listName: string;
   listDisplayName: string;
   listDescription: string;
@@ -58,16 +61,66 @@ export interface RemoteSystemDefinedListDbItem {
 
 export interface RemoteUserDefinedListDbItem {
   kind: DbItemKind.RemoteUserDefinedList;
+  selected: boolean;
   listName: string;
   repos: RemoteRepoDbItem[];
 }
 
 export interface RemoteOwnerDbItem {
   kind: DbItemKind.RemoteOwner;
+  selected: boolean;
   ownerName: string;
 }
 
 export interface RemoteRepoDbItem {
   kind: DbItemKind.RemoteRepo;
+  selected: boolean;
   repoFullName: string;
 }
+
+export function isRemoteSystemDefinedListDbItem(
+  dbItem: DbItem,
+): dbItem is RemoteSystemDefinedListDbItem {
+  return dbItem.kind === DbItemKind.RemoteSystemDefinedList;
+}
+
+export function isRemoteUserDefinedListDbItem(
+  dbItem: DbItem,
+): dbItem is RemoteUserDefinedListDbItem {
+  return dbItem.kind === DbItemKind.RemoteUserDefinedList;
+}
+
+export function isRemoteOwnerDbItem(
+  dbItem: DbItem,
+): dbItem is RemoteOwnerDbItem {
+  return dbItem.kind === DbItemKind.RemoteOwner;
+}
+
+export function isRemoteRepoDbItem(dbItem: DbItem): dbItem is RemoteRepoDbItem {
+  return dbItem.kind === DbItemKind.RemoteRepo;
+}
+
+export function isLocalListDbItem(dbItem: DbItem): dbItem is LocalListDbItem {
+  return dbItem.kind === DbItemKind.LocalList;
+}
+
+export function isLocalDatabaseDbItem(
+  dbItem: DbItem,
+): dbItem is LocalDatabaseDbItem {
+  return dbItem.kind === DbItemKind.LocalDatabase;
+}
+
+export type SelectableDbItem = RemoteDbItem | LocalDbItem;
+
+export function isSelectableDbItem(dbItem: DbItem): dbItem is SelectableDbItem {
+  return SelectableDbItemKinds.includes(dbItem.kind);
+}
+
+const SelectableDbItemKinds = [
+  DbItemKind.LocalList,
+  DbItemKind.LocalDatabase,
+  DbItemKind.RemoteSystemDefinedList,
+  DbItemKind.RemoteUserDefinedList,
+  DbItemKind.RemoteOwner,
+  DbItemKind.RemoteRepo,
+];
diff --git a/extensions/ql-vscode/src/databases/db-tree-creator.ts b/extensions/ql-vscode/src/databases/db-tree-creator.ts
index e6999a9ca..28cabbecf 100644
--- a/extensions/ql-vscode/src/databases/db-tree-creator.ts
+++ b/extensions/ql-vscode/src/databases/db-tree-creator.ts
@@ -3,6 +3,7 @@ import {
   LocalDatabase,
   LocalList,
   RemoteRepositoryList,
+  SelectedDbItemKind,
 } from "./config/db-config";
 import {
   DbItemKind,
@@ -18,16 +19,20 @@ import {
 
 export function createRemoteTree(dbConfig: DbConfig): RootRemoteDbItem {
   const systemDefinedLists = [
-    createSystemDefinedList(10),
-    createSystemDefinedList(100),
-    createSystemDefinedList(1000),
+    createSystemDefinedList(10, dbConfig),
+    createSystemDefinedList(100, dbConfig),
+    createSystemDefinedList(1000, dbConfig),
   ];
 
   const userDefinedRepoLists = dbConfig.databases.remote.repositoryLists.map(
-    createUserDefinedList,
+    (r) => createRemoteUserDefinedList(r, dbConfig),
+  );
+  const owners = dbConfig.databases.remote.owners.map((o) =>
+    createOwnerItem(o, dbConfig),
+  );
+  const repos = dbConfig.databases.remote.repositories.map((r) =>
+    createRepoItem(r, dbConfig),
   );
-  const owners = dbConfig.databases.remote.owners.map(createOwnerItem);
-  const repos = dbConfig.databases.remote.repositories.map(createRepoItem);
 
   return {
     kind: DbItemKind.RootRemote,
@@ -41,8 +46,12 @@ export function createRemoteTree(dbConfig: DbConfig): RootRemoteDbItem {
 }
 
 export function createLocalTree(dbConfig: DbConfig): RootLocalDbItem {
-  const localLists = dbConfig.databases.local.lists.map(createLocalList);
-  const localDbs = dbConfig.databases.local.databases.map(createLocalDb);
+  const localLists = dbConfig.databases.local.lists.map((l) =>
+    createLocalList(l, dbConfig),
+  );
+  const localDbs = dbConfig.databases.local.databases.map((l) =>
+    createLocalDb(l, dbConfig),
+  );
 
   return {
     kind: DbItemKind.RootLocal,
@@ -50,53 +59,105 @@ export function createLocalTree(dbConfig: DbConfig): RootLocalDbItem {
   };
 }
 
-function createSystemDefinedList(n: number): RemoteSystemDefinedListDbItem {
+function createSystemDefinedList(
+  n: number,
+  dbConfig: DbConfig,
+): RemoteSystemDefinedListDbItem {
+  const listName = `top_${n}`;
+
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.RemoteSystemDefinedList &&
+    dbConfig.selected.listName === listName;
+
   return {
     kind: DbItemKind.RemoteSystemDefinedList,
-    listName: `top_${n}`,
+    listName,
     listDisplayName: `Top ${n} repositories`,
     listDescription: `Top ${n} repositories of a language`,
+    selected: !!selected,
   };
 }
 
-function createUserDefinedList(
+function createRemoteUserDefinedList(
   list: RemoteRepositoryList,
+  dbConfig: DbConfig,
 ): RemoteUserDefinedListDbItem {
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.RemoteUserDefinedList &&
+    dbConfig.selected.listName === list.name;
+
   return {
     kind: DbItemKind.RemoteUserDefinedList,
     listName: list.name,
-    repos: list.repositories.map((r) => createRepoItem(r)),
+    repos: list.repositories.map((r) => createRepoItem(r, dbConfig, list.name)),
+    selected: !!selected,
   };
 }
 
-function createOwnerItem(owner: string): RemoteOwnerDbItem {
+function createOwnerItem(owner: string, dbConfig: DbConfig): RemoteOwnerDbItem {
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.RemoteOwner &&
+    dbConfig.selected.ownerName === owner;
+
   return {
     kind: DbItemKind.RemoteOwner,
     ownerName: owner,
+    selected: !!selected,
   };
 }
 
-function createRepoItem(repo: string): RemoteRepoDbItem {
+function createRepoItem(
+  repo: string,
+  dbConfig: DbConfig,
+  listName?: string,
+): RemoteRepoDbItem {
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.RemoteRepository &&
+    dbConfig.selected.repositoryName === repo &&
+    dbConfig.selected.listName === listName;
+
   return {
     kind: DbItemKind.RemoteRepo,
     repoFullName: repo,
+    selected: !!selected,
   };
 }
 
-function createLocalList(list: LocalList): LocalListDbItem {
+function createLocalList(list: LocalList, dbConfig: DbConfig): LocalListDbItem {
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.LocalUserDefinedList &&
+    dbConfig.selected.listName === list.name;
+
   return {
     kind: DbItemKind.LocalList,
     listName: list.name,
-    databases: list.databases.map(createLocalDb),
+    databases: list.databases.map((d) => createLocalDb(d, dbConfig, list.name)),
+    selected: !!selected,
   };
 }
 
-function createLocalDb(db: LocalDatabase): LocalDatabaseDbItem {
+function createLocalDb(
+  db: LocalDatabase,
+  dbConfig: DbConfig,
+  listName?: string,
+): LocalDatabaseDbItem {
+  const selected =
+    dbConfig.selected &&
+    dbConfig.selected.kind === SelectedDbItemKind.LocalDatabase &&
+    dbConfig.selected.databaseName === db.name &&
+    dbConfig.selected.listName === listName;
+
   return {
     kind: DbItemKind.LocalDatabase,
     databaseName: db.name,
     dateAdded: db.dateAdded,
     language: db.language,
     storagePath: db.storagePath,
+    selected: !!selected,
   };
 }
diff --git a/extensions/ql-vscode/src/databases/ui/db-tree-view-item.ts b/extensions/ql-vscode/src/databases/ui/db-tree-view-item.ts
index a63ff851f..67cb8edf3 100644
--- a/extensions/ql-vscode/src/databases/ui/db-tree-view-item.ts
+++ b/extensions/ql-vscode/src/databases/ui/db-tree-view-item.ts
@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import {
   DbItem,
+  isSelectableDbItem,
   LocalDatabaseDbItem,
   LocalListDbItem,
   RemoteOwnerDbItem,
@@ -28,6 +29,16 @@ export class DbTreeViewItem extends vscode.TreeItem {
     public readonly children: DbTreeViewItem[],
   ) {
     super(label, collapsibleState);
+
+    if (dbItem && isSelectableDbItem(dbItem)) {
+      if (dbItem.selected) {
+        // Define the resource id to drive the UI to render this item as selected.
+        this.resourceUri = vscode.Uri.parse("codeql://databases?selected=true");
+      } else {
+        // Define a context value to drive the UI to show an action to select the item.
+        this.contextValue = "selectableDbItem";
+      }
+    }
   }
 }
 
diff --git a/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases/db-panel.test.ts b/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases/db-panel.test.ts
index defa374cf..f869b8b67 100644
--- a/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases/db-panel.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases/db-panel.test.ts
@@ -1,7 +1,10 @@
 import { TreeItemCollapsibleState, ThemeIcon } from "vscode";
 import { join } from "path";
 import { ensureDir, remove, writeJson } from "fs-extra";
-import { DbConfig } from "../../../databases/config/db-config";
+import {
+  DbConfig,
+  SelectedDbItemKind,
+} from "../../../databases/config/db-config";
 import { DbManager } from "../../../databases/db-manager";
 import { DbConfigStore } from "../../../databases/config/db-config-store";
 import { DbTreeDataProvider } from "../../../databases/ui/db-tree-data-provider";
@@ -307,6 +310,7 @@ describe("db panel", () => {
         dateAdded: 1668428293677,
         language: "cpp",
         storagePath: "/path/to/db1/",
+        selected: false,
       },
       {
         kind: DbItemKind.LocalDatabase,
@@ -314,6 +318,7 @@ describe("db panel", () => {
         dateAdded: 1668428472731,
         language: "cpp",
         storagePath: "/path/to/db2/",
+        selected: false,
       },
     ]);
     checkLocalListItem(localListItems[1], "my-list-2", [
@@ -323,6 +328,7 @@ describe("db panel", () => {
         dateAdded: 1668428472731,
         language: "ruby",
         storagePath: "/path/to/db3/",
+        selected: false,
       },
     ]);
   });
@@ -381,6 +387,7 @@ describe("db panel", () => {
       dateAdded: 1668428293677,
       language: "csharp",
       storagePath: "/path/to/db1/",
+      selected: false,
     });
     checkLocalDatabaseItem(localDatabaseItems[1], {
       kind: DbItemKind.LocalDatabase,
@@ -388,9 +395,134 @@ describe("db panel", () => {
       dateAdded: 1668428472731,
       language: "go",
       storagePath: "/path/to/db2/",
+      selected: false,
     });
   });
 
+  it("should mark selected remote db list as selected", async () => {
+    const dbConfig: DbConfig = {
+      databases: {
+        remote: {
+          repositoryLists: [
+            {
+              name: "my-list-1",
+              repositories: ["owner1/repo1", "owner1/repo2"],
+            },
+            {
+              name: "my-list-2",
+              repositories: ["owner2/repo1", "owner2/repo2"],
+            },
+          ],
+          owners: [],
+          repositories: [],
+        },
+        local: {
+          lists: [],
+          databases: [],
+        },
+      },
+      selected: {
+        kind: SelectedDbItemKind.RemoteUserDefinedList,
+        listName: "my-list-2",
+      },
+    };
+
+    await saveDbConfig(dbConfig);
+
+    const dbTreeItems = await dbTreeDataProvider.getChildren();
+
+    expect(dbTreeItems).toBeTruthy();
+    const items = dbTreeItems!;
+
+    const remoteRootNode = items[0];
+    expect(remoteRootNode.dbItem).toBeTruthy();
+    expect(remoteRootNode.dbItem?.kind).toEqual(DbItemKind.RootRemote);
+
+    const list1 = remoteRootNode.children.find(
+      (c) =>
+        c.dbItem?.kind === DbItemKind.RemoteUserDefinedList &&
+        c.dbItem?.listName === "my-list-1",
+    );
+    const list2 = remoteRootNode.children.find(
+      (c) =>
+        c.dbItem?.kind === DbItemKind.RemoteUserDefinedList &&
+        c.dbItem?.listName === "my-list-2",
+    );
+
+    expect(list1).toBeTruthy();
+    expect(list2).toBeTruthy();
+    expect(isTreeViewItemSelectable(list1!)).toBeTruthy();
+    expect(isTreeViewItemSelected(list2!)).toBeTruthy();
+  });
+
+  it("should mark selected remote db inside list as selected", async () => {
+    const dbConfig: DbConfig = {
+      databases: {
+        remote: {
+          repositoryLists: [
+            {
+              name: "my-list-1",
+              repositories: ["owner1/repo1", "owner1/repo2"],
+            },
+            {
+              name: "my-list-2",
+              repositories: ["owner1/repo1", "owner2/repo2"],
+            },
+          ],
+          owners: [],
+          repositories: ["owner1/repo1"],
+        },
+        local: {
+          lists: [],
+          databases: [],
+        },
+      },
+      selected: {
+        kind: SelectedDbItemKind.RemoteRepository,
+        repositoryName: "owner1/repo1",
+        listName: "my-list-2",
+      },
+    };
+
+    await saveDbConfig(dbConfig);
+
+    const dbTreeItems = await dbTreeDataProvider.getChildren();
+
+    expect(dbTreeItems).toBeTruthy();
+    const items = dbTreeItems!;
+
+    const remoteRootNode = items[0];
+    expect(remoteRootNode.dbItem).toBeTruthy();
+    expect(remoteRootNode.dbItem?.kind).toEqual(DbItemKind.RootRemote);
+
+    const list2 = remoteRootNode.children.find(
+      (c) =>
+        c.dbItem?.kind === DbItemKind.RemoteUserDefinedList &&
+        c.dbItem?.listName === "my-list-2",
+    );
+    expect(list2).toBeTruthy();
+
+    const repo1Node = list2?.children.find(
+      (c) =>
+        c.dbItem?.kind === DbItemKind.RemoteRepo &&
+        c.dbItem?.repoFullName === "owner1/repo1",
+    );
+    expect(repo1Node).toBeTruthy();
+    expect(isTreeViewItemSelected(repo1Node!)).toBeTruthy();
+
+    const repo2Node = list2?.children.find(
+      (c) =>
+        c.dbItem?.kind === DbItemKind.RemoteRepo &&
+        c.dbItem?.repoFullName === "owner2/repo2",
+    );
+    expect(repo2Node).toBeTruthy();
+    expect(isTreeViewItemSelectable(repo2Node!)).toBeTruthy();
+
+    for (const item of remoteRootNode.children) {
+      expect(isTreeViewItemSelectable(item)).toBeTruthy();
+    }
+  });
+
   async function saveDbConfig(dbConfig: DbConfig): Promise<void> {
     await writeJson(dbConfigFilePath, dbConfig);
 
@@ -471,4 +603,18 @@ describe("db panel", () => {
     expect(item.iconPath).toEqual(new ThemeIcon("database"));
     expect(item.collapsibleState).toBe(TreeItemCollapsibleState.None);
   }
+
+  function isTreeViewItemSelectable(treeViewItem: DbTreeViewItem) {
+    return (
+      treeViewItem.resourceUri === undefined &&
+      treeViewItem.contextValue === "selectableDbItem"
+    );
+  }
+
+  function isTreeViewItemSelected(treeViewItem: DbTreeViewItem) {
+    return (
+      treeViewItem.resourceUri?.query === "selected=true" &&
+      treeViewItem.contextValue === undefined
+    );
+  }
 });
diff --git a/extensions/ql-vscode/test/pure-tests/databases/config/data/workspace-databases.json b/extensions/ql-vscode/test/pure-tests/databases/config/data/workspace-databases.json
index 0d1a7b1ea..5264d3805 100644
--- a/extensions/ql-vscode/test/pure-tests/databases/config/data/workspace-databases.json
+++ b/extensions/ql-vscode/test/pure-tests/databases/config/data/workspace-databases.json
@@ -46,7 +46,7 @@
     }
   },
   "selected": {
-    "kind": "configDefined",
-    "value": "path.to.database"
+    "kind": "remoteUserDefinedList",
+    "listName": "repoList1"
   }
 }
diff --git a/extensions/ql-vscode/test/pure-tests/databases/config/db-config-store.test.ts b/extensions/ql-vscode/test/pure-tests/databases/config/db-config-store.test.ts
index adacaa791..8f3c3c8b5 100644
--- a/extensions/ql-vscode/test/pure-tests/databases/config/db-config-store.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/databases/config/db-config-store.test.ts
@@ -84,8 +84,8 @@ describe("db config store", () => {
       storagePath: "/path/to/database/",
     });
     expect(config.selected).toEqual({
-      kind: "configDefined",
-      value: "path.to.database",
+      kind: "remoteUserDefinedList",
+      listName: "repoList1",
     });
 
     configStore.dispose();
diff --git a/extensions/ql-vscode/test/pure-tests/databases/db-tree-creator.test.ts b/extensions/ql-vscode/test/pure-tests/databases/db-tree-creator.test.ts
index 4ee36e8c2..142012709 100644
--- a/extensions/ql-vscode/test/pure-tests/databases/db-tree-creator.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/databases/db-tree-creator.test.ts
@@ -1,5 +1,13 @@
-import { DbConfig } from "../../../src/databases/config/db-config";
-import { DbItemKind } from "../../../src/databases/db-item";
+import {
+  DbConfig,
+  SelectedDbItemKind,
+} from "../../../src/databases/config/db-config";
+import {
+  DbItemKind,
+  isRemoteOwnerDbItem,
+  isRemoteRepoDbItem,
+  isRemoteUserDefinedListDbItem,
+} from "../../../src/databases/db-item";
 import {
   createLocalTree,
   createRemoteTree,
@@ -29,18 +37,21 @@ describe("db tree creator", () => {
       expect(dbTreeRoot.children.length).toBe(3);
       expect(dbTreeRoot.children[0]).toEqual({
         kind: DbItemKind.RemoteSystemDefinedList,
+        selected: false,
         listName: "top_10",
         listDisplayName: "Top 10 repositories",
         listDescription: "Top 10 repositories of a language",
       });
       expect(dbTreeRoot.children[1]).toEqual({
         kind: DbItemKind.RemoteSystemDefinedList,
+        selected: false,
         listName: "top_100",
         listDisplayName: "Top 100 repositories",
         listDescription: "Top 100 repositories of a language",
       });
       expect(dbTreeRoot.children[2]).toEqual({
         kind: DbItemKind.RemoteSystemDefinedList,
+        selected: false,
         listName: "top_1000",
         listDisplayName: "Top 1000 repositories",
         listDescription: "Top 1000 repositories of a language",
@@ -76,26 +87,30 @@ describe("db tree creator", () => {
       expect(dbTreeRoot).toBeTruthy();
       expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
       const repositoryListNodes = dbTreeRoot.children.filter(
-        (child) => child.kind === DbItemKind.RemoteUserDefinedList,
+        isRemoteUserDefinedListDbItem,
       );
 
       expect(repositoryListNodes.length).toBe(2);
       expect(repositoryListNodes[0]).toEqual({
         kind: DbItemKind.RemoteUserDefinedList,
+        selected: false,
         listName: dbConfig.databases.remote.repositoryLists[0].name,
         repos: dbConfig.databases.remote.repositoryLists[0].repositories.map(
           (repo) => ({
             kind: DbItemKind.RemoteRepo,
+            selected: false,
             repoFullName: repo,
           }),
         ),
       });
       expect(repositoryListNodes[1]).toEqual({
         kind: DbItemKind.RemoteUserDefinedList,
+        selected: false,
         listName: dbConfig.databases.remote.repositoryLists[1].name,
         repos: dbConfig.databases.remote.repositoryLists[1].repositories.map(
           (repo) => ({
             kind: DbItemKind.RemoteRepo,
+            selected: false,
             repoFullName: repo,
           }),
         ),
@@ -121,17 +136,17 @@ describe("db tree creator", () => {
 
       expect(dbTreeRoot).toBeTruthy();
       expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
-      const ownerNodes = dbTreeRoot.children.filter(
-        (child) => child.kind === DbItemKind.RemoteOwner,
-      );
+      const ownerNodes = dbTreeRoot.children.filter(isRemoteOwnerDbItem);
 
       expect(ownerNodes.length).toBe(2);
       expect(ownerNodes[0]).toEqual({
         kind: DbItemKind.RemoteOwner,
+        selected: false,
         ownerName: dbConfig.databases.remote.owners[0],
       });
       expect(ownerNodes[1]).toEqual({
         kind: DbItemKind.RemoteOwner,
+        selected: false,
         ownerName: dbConfig.databases.remote.owners[1],
       });
     });
@@ -155,25 +170,171 @@ describe("db tree creator", () => {
 
       expect(dbTreeRoot).toBeTruthy();
       expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
-      const repoNodes = dbTreeRoot.children.filter(
-        (child) => child.kind === DbItemKind.RemoteRepo,
-      );
+      const repoNodes = dbTreeRoot.children.filter(isRemoteRepoDbItem);
 
       expect(repoNodes.length).toBe(3);
       expect(repoNodes[0]).toEqual({
         kind: DbItemKind.RemoteRepo,
+        selected: false,
         repoFullName: dbConfig.databases.remote.repositories[0],
       });
       expect(repoNodes[1]).toEqual({
         kind: DbItemKind.RemoteRepo,
+        selected: false,
         repoFullName: dbConfig.databases.remote.repositories[1],
       });
       expect(repoNodes[2]).toEqual({
         kind: DbItemKind.RemoteRepo,
+        selected: false,
         repoFullName: dbConfig.databases.remote.repositories[2],
       });
     });
+
+    describe("selected db item", () => {
+      it("should allow selecting a remote user defined list node", () => {
+        const dbConfig: DbConfig = {
+          databases: {
+            remote: {
+              repositoryLists: [
+                {
+                  name: "my-list-1",
+                  repositories: [
+                    "owner1/repo1",
+                    "owner1/repo2",
+                    "owner2/repo1",
+                  ],
+                },
+              ],
+              owners: [],
+              repositories: [],
+            },
+            local: {
+              lists: [],
+              databases: [],
+            },
+          },
+          selected: {
+            kind: SelectedDbItemKind.RemoteUserDefinedList,
+            listName: "my-list-1",
+          },
+        };
+
+        const dbTreeRoot = createRemoteTree(dbConfig);
+
+        expect(dbTreeRoot).toBeTruthy();
+        expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
+        const repositoryListNodes = dbTreeRoot.children.filter(
+          (child) => child.kind === DbItemKind.RemoteUserDefinedList,
+        );
+
+        expect(repositoryListNodes.length).toBe(1);
+        expect(repositoryListNodes[0].selected).toEqual(true);
+      });
+
+      it("should allow selecting a remote owner node", () => {
+        const dbConfig: DbConfig = {
+          databases: {
+            remote: {
+              repositoryLists: [],
+              owners: ["owner1", "owner2"],
+              repositories: [],
+            },
+            local: {
+              lists: [],
+              databases: [],
+            },
+          },
+          selected: {
+            kind: SelectedDbItemKind.RemoteOwner,
+            ownerName: "owner1",
+          },
+        };
+
+        const dbTreeRoot = createRemoteTree(dbConfig);
+
+        expect(dbTreeRoot).toBeTruthy();
+        expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
+        const ownerNodes = dbTreeRoot.children.filter(
+          (child) => child.kind === DbItemKind.RemoteOwner,
+        );
+
+        expect(ownerNodes.length).toBe(2);
+        expect(ownerNodes[0].selected).toEqual(true);
+        expect(ownerNodes[1].selected).toEqual(false);
+      });
+
+      it("should allow selecting a remote repo node", () => {
+        const dbConfig: DbConfig = {
+          databases: {
+            remote: {
+              repositoryLists: [],
+              owners: [],
+              repositories: ["owner1/repo1", "owner1/repo2"],
+            },
+            local: {
+              lists: [],
+              databases: [],
+            },
+          },
+          selected: {
+            kind: SelectedDbItemKind.RemoteRepository,
+            repositoryName: "owner1/repo2",
+          },
+        };
+
+        const dbTreeRoot = createRemoteTree(dbConfig);
+
+        expect(dbTreeRoot).toBeTruthy();
+        expect(dbTreeRoot.kind).toBe(DbItemKind.RootRemote);
+        const repoNodes = dbTreeRoot.children.filter(isRemoteRepoDbItem);
+
+        expect(repoNodes.length).toBe(2);
+        expect(repoNodes[0].selected).toEqual(false);
+        expect(repoNodes[1].selected).toEqual(true);
+      });
+
+      it("should allow selecting a remote repo in a list", () => {
+        const dbConfig: DbConfig = {
+          databases: {
+            remote: {
+              repositoryLists: [
+                {
+                  name: "my-list-1",
+                  repositories: ["owner1/repo1"],
+                },
+              ],
+              owners: [],
+              repositories: ["owner1/repo2"],
+            },
+            local: {
+              lists: [],
+              databases: [],
+            },
+          },
+          selected: {
+            kind: SelectedDbItemKind.RemoteRepository,
+            listName: "my-list-1",
+            repositoryName: "owner1/repo1",
+          },
+        };
+
+        const dbTreeRoot = createRemoteTree(dbConfig);
+
+        expect(dbTreeRoot).toBeTruthy();
+
+        const listNodes = dbTreeRoot.children.filter(
+          isRemoteUserDefinedListDbItem,
+        );
+
+        expect(listNodes.length).toBe(1);
+        expect(listNodes[0].selected).toEqual(false);
+        expect(listNodes[0].repos.length).toBe(1);
+        expect(listNodes[0].repos[0].repoFullName).toBe("owner1/repo1");
+        expect(listNodes[0].repos[0].selected).toBe(true);
+      });
+    });
   });
+
   describe("createLocalTree", () => {
     it("should build root node", () => {
       const dbConfig: DbConfig = {
@@ -252,9 +413,11 @@ describe("db tree creator", () => {
       expect(localListNodes.length).toBe(2);
       expect(localListNodes[0]).toEqual({
         kind: DbItemKind.LocalList,
+        selected: false,
         listName: dbConfig.databases.local.lists[0].name,
         databases: dbConfig.databases.local.lists[0].databases.map((db) => ({
           kind: DbItemKind.LocalDatabase,
+          selected: false,
           databaseName: db.name,
           dateAdded: db.dateAdded,
           language: db.language,
@@ -263,9 +426,11 @@ describe("db tree creator", () => {
       });
       expect(localListNodes[1]).toEqual({
         kind: DbItemKind.LocalList,
+        selected: false,
         listName: dbConfig.databases.local.lists[1].name,
         databases: dbConfig.databases.local.lists[1].databases.map((db) => ({
           kind: DbItemKind.LocalDatabase,
+          selected: false,
           databaseName: db.name,
           dateAdded: db.dateAdded,
           language: db.language,
@@ -313,6 +478,7 @@ describe("db tree creator", () => {
       expect(localDatabaseNodes.length).toBe(2);
       expect(localDatabaseNodes[0]).toEqual({
         kind: DbItemKind.LocalDatabase,
+        selected: false,
         databaseName: dbConfig.databases.local.databases[0].name,
         dateAdded: dbConfig.databases.local.databases[0].dateAdded,
         language: dbConfig.databases.local.databases[0].language,
@@ -320,6 +486,7 @@ describe("db tree creator", () => {
       });
       expect(localDatabaseNodes[1]).toEqual({
         kind: DbItemKind.LocalDatabase,
+        selected: false,
         databaseName: dbConfig.databases.local.databases[1].name,
         dateAdded: dbConfig.databases.local.databases[1].dateAdded,
         language: dbConfig.databases.local.databases[1].language,
diff --git a/extensions/ql-vscode/workspace-databases-schema.json b/extensions/ql-vscode/workspace-databases-schema.json
index 027b23183..a7281b454 100644
--- a/extensions/ql-vscode/workspace-databases-schema.json
+++ b/extensions/ql-vscode/workspace-databases-schema.json
@@ -123,17 +123,92 @@
     },
     "selected": {
       "type": "object",
-      "properties": {
-        "kind": {
-          "type": "string",
-          "enum": ["configDefined", "remoteSystemDefinedList"]
+      "oneOf": [
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["localUserDefinedList"]
+            },
+            "listName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "listName"],
+          "additionalProperties": false
         },
-        "value": {
-          "type": "string"
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["localDatabase"]
+            },
+            "databaseName": {
+              "type": "string"
+            },
+            "listName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "databaseName"],
+          "additionalProperties": false
+        },
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["remoteSystemDefinedList"]
+            },
+            "listName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "listName"],
+          "additionalProperties": false
+        },
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["remoteUserDefinedList"]
+            },
+            "listName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "listName"],
+          "additionalProperties": false
+        },
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["remoteOwner"]
+            },
+            "ownerName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "ownerName"],
+          "additionalProperties": false
+        },
+        {
+          "properties": {
+            "kind": {
+              "type": "string",
+              "enum": ["remoteRepository"]
+            },
+            "repositoryName": {
+              "type": "string"
+            },
+            "listName": {
+              "type": "string"
+            }
+          },
+          "required": ["kind", "repositoryName"],
+          "additionalProperties": false
         }
-      },
-      "required": ["kind", "value"],
-      "additionalProperties": false
+      ]
     }
   },
   "required": ["databases"],

From 8b354357c186926c7066a079af6880b8e6bb019d Mon Sep 17 00:00:00 2001
From: Shati Patel <42641846+shati-patel@users.noreply.github.com>
Date: Fri, 2 Dec 2022 12:44:51 +0000
Subject: [PATCH 7/7] Show selected item in new DB panel (#1824)

---
 .../ql-vscode/src/databases/db-module.ts      |  6 +++++
 .../ui/db-selection-decoration-provider.ts    | 22 +++++++++++++++++++
 2 files changed, 28 insertions(+)
 create mode 100644 extensions/ql-vscode/src/databases/ui/db-selection-decoration-provider.ts

diff --git a/extensions/ql-vscode/src/databases/db-module.ts b/extensions/ql-vscode/src/databases/db-module.ts
index 95348525a..ed7bef0d2 100644
--- a/extensions/ql-vscode/src/databases/db-module.ts
+++ b/extensions/ql-vscode/src/databases/db-module.ts
@@ -1,3 +1,4 @@
+import { window } from "vscode";
 import { App, AppMode } from "../common/app";
 import { isCanary, isNewQueryRunExperienceEnabled } from "../config";
 import { extLogger } from "../common";
@@ -5,6 +6,7 @@ import { DisposableObject } from "../pure/disposable-object";
 import { DbConfigStore } from "./config/db-config-store";
 import { DbManager } from "./db-manager";
 import { DbPanel } from "./ui/db-panel";
+import { DbSelectionDecorationProvider } from "./ui/db-selection-decoration-provider";
 
 export class DbModule extends DisposableObject {
   public async initialize(app: App): Promise<void> {
@@ -30,6 +32,10 @@ export class DbModule extends DisposableObject {
 
     this.push(dbPanel);
     this.push(dbConfigStore);
+
+    const dbSelectionDecorationProvider = new DbSelectionDecorationProvider();
+
+    window.registerFileDecorationProvider(dbSelectionDecorationProvider);
   }
 }
 
diff --git a/extensions/ql-vscode/src/databases/ui/db-selection-decoration-provider.ts b/extensions/ql-vscode/src/databases/ui/db-selection-decoration-provider.ts
new file mode 100644
index 000000000..1a8d45d75
--- /dev/null
+++ b/extensions/ql-vscode/src/databases/ui/db-selection-decoration-provider.ts
@@ -0,0 +1,22 @@
+import {
+  CancellationToken,
+  FileDecoration,
+  FileDecorationProvider,
+  ProviderResult,
+  Uri,
+} from "vscode";
+
+export class DbSelectionDecorationProvider implements FileDecorationProvider {
+  provideFileDecoration(
+    uri: Uri,
+    _token: CancellationToken,
+  ): ProviderResult<FileDecoration> {
+    if (uri?.query === "selected=true") {
+      return {
+        badge: "✔",
+      };
+    }
+
+    return undefined;
+  }
+}