Merge pull request #2242 from github/nora/query-history-refactoring

Query History: create and map data model to domain model

Author: norascheuch

extensions/ql-vscode/src/legacy-query-server/run-queries.ts

@@ -172,10 +172,6 @@ async function runQuery(
  */
 export class QueryInProgress {
   public queryEvalInfo: QueryEvaluationInfo;
-  /**
-   * Note that in the {@link readQueryHistoryFromFile} method, we create a QueryEvaluationInfo instance
-   * by explicitly setting the prototype in order to avoid calling this constructor.
-   */
   constructor(
     readonly querySaveDir: string,
     readonly dbItemPath: string,

extensions/ql-vscode/src/query-history/store/data-mapper.ts

@@ -0,0 +1,105 @@
+import {
+  LocalQueryInfo,
+  CompletedQueryInfo,
+  InitialQueryInfo,
+} from "../../query-results";
+import { QueryEvaluationInfo } from "../../run-queries-shared";
+import { QueryHistoryInfo } from "../query-history-info";
+import { VariantAnalysisHistoryItem } from "../variant-analysis-history-item";
+import {
+  CompletedQueryInfoData,
+  QueryEvaluationInfoData,
+  InitialQueryInfoData,
+  LocalQueryDataItem,
+} from "./local-query-data-item";
+import { QueryHistoryDataItem } from "./query-history-data";
+
+// Maps Query History Data Models to Domain Models
+
+export function mapQueryHistoryToDomainModels(
+  queries: QueryHistoryDataItem[],
+): QueryHistoryInfo[] {
+  return queries.map((d) => {
+    if (d.t === "variant-analysis") {
+      const query: VariantAnalysisHistoryItem = d;
+      return query;
+    } else if (d.t === "local") {
+      return mapLocalQueryDataItemToDomainModel(d);
+    }
+
+    throw Error(
+      `Unexpected or corrupted query history file. Unknown query history item: ${JSON.stringify(
+        d,
+      )}`,
+    );
+  });
+}
+
+function mapLocalQueryDataItemToDomainModel(
+  localQuery: LocalQueryDataItem,
+): LocalQueryInfo {
+  return new LocalQueryInfo(
+    mapInitialQueryInfoDataToDomainModel(localQuery.initialInfo),
+    undefined,
+    localQuery.failureReason,
+    localQuery.completedQuery &&
+      mapCompletedQueryInfoDataToDomainModel(localQuery.completedQuery),
+    localQuery.evalLogLocation,
+    localQuery.evalLogSummaryLocation,
+    localQuery.jsonEvalLogSummaryLocation,
+    localQuery.evalLogSummarySymbolsLocation,
+  );
+}
+
+function mapCompletedQueryInfoDataToDomainModel(
+  completedQuery: CompletedQueryInfoData,
+): CompletedQueryInfo {
+  return new CompletedQueryInfo(
+    mapQueryEvaluationInfoDataToDomainModel(completedQuery.query),
+    {
+      runId: completedQuery.result.runId,
+      queryId: completedQuery.result.queryId,
+      resultType: completedQuery.result.resultType,
+      evaluationTime: completedQuery.result.evaluationTime,
+      message: completedQuery.result.message,
+      logFileLocation: completedQuery.result.logFileLocation,
+    },
+    completedQuery.logFileLocation,
+    completedQuery.successful ?? completedQuery.sucessful,
+    completedQuery.message,
+    completedQuery.interpretedResultsSortState,
+    completedQuery.resultCount,
+    completedQuery.sortedResultsInfo,
+  );
+}
+
+function mapInitialQueryInfoDataToDomainModel(
+  initialInfo: InitialQueryInfoData,
+): InitialQueryInfo {
+  return {
+    userSpecifiedLabel: initialInfo.userSpecifiedLabel,
+    queryText: initialInfo.queryText,
+    isQuickQuery: initialInfo.isQuickQuery,
+    isQuickEval: initialInfo.isQuickEval,
+    quickEvalPosition: initialInfo.quickEvalPosition,
+    queryPath: initialInfo.queryPath,
+    databaseInfo: {
+      databaseUri: initialInfo.databaseInfo.databaseUri,
+      name: initialInfo.databaseInfo.name,
+    },
+    start: new Date(initialInfo.start),
+    id: initialInfo.id,
+  };
+}
+
+function mapQueryEvaluationInfoDataToDomainModel(
+  evaluationInfo: QueryEvaluationInfoData,
+): QueryEvaluationInfo {
+  return new QueryEvaluationInfo(
+    evaluationInfo.querySaveDir,
+    evaluationInfo.dbItemPath,
+    evaluationInfo.databaseHasMetadataFile,
+    evaluationInfo.quickEvalPosition,
+    evaluationInfo.metadata,
+  );
+}

extensions/ql-vscode/src/query-history/store/domain-mapper.ts

@@ -0,0 +1,90 @@
+import { assertNever } from "../../pure/helpers-pure";
+import { LocalQueryInfo, InitialQueryInfo } from "../../query-results";
+import { QueryEvaluationInfo } from "../../run-queries-shared";
+import { QueryHistoryInfo } from "../query-history-info";
+import {
+  LocalQueryDataItem,
+  InitialQueryInfoData,
+  QueryEvaluationInfoData,
+} from "./local-query-data-item";
+import { QueryHistoryDataItem } from "./query-history-data";
+import { VariantAnalysisDataItem } from "./variant-analysis-data-item";
+
+// Maps Query History Domain Models to Data Models
+
+export function mapQueryHistoryToDataModels(
+  queries: QueryHistoryInfo[],
+): QueryHistoryDataItem[] {
+  return queries.map((q) => {
+    if (q.t === "variant-analysis") {
+      const query: VariantAnalysisDataItem = q;
+      return query;
+    } else if (q.t === "local") {
+      return mapLocalQueryInfoToDataModel(q);
+    } else {
+      assertNever(q);
+    }
+  });
+}
+
+function mapLocalQueryInfoToDataModel(
+  query: LocalQueryInfo,
+): LocalQueryDataItem {
+  return {
+    initialInfo: mapInitialQueryInfoToDataModel(query.initialInfo),
+    t: "local",
+    evalLogLocation: query.evalLogLocation,
+    evalLogSummaryLocation: query.evalLogSummaryLocation,
+    jsonEvalLogSummaryLocation: query.jsonEvalLogSummaryLocation,
+    evalLogSummarySymbolsLocation: query.evalLogSummarySymbolsLocation,
+    failureReason: query.failureReason,
+    completedQuery: query.completedQuery && {
+      query: mapQueryEvaluationInfoToDataModel(query.completedQuery.query),
+      result: {
+        runId: query.completedQuery.result.runId,
+        queryId: query.completedQuery.result.queryId,
+        resultType: query.completedQuery.result.resultType,
+        evaluationTime: query.completedQuery.result.evaluationTime,
+        message: query.completedQuery.result.message,
+        logFileLocation: query.completedQuery.result.logFileLocation,
+      },
+      logFileLocation: query.completedQuery.logFileLocation,
+      successful: query.completedQuery.successful,
+      message: query.completedQuery.message,
+      resultCount: query.completedQuery.resultCount,
+      sortedResultsInfo: query.completedQuery.sortedResultsInfo,
+    },
+  };
+}
+
+function mapInitialQueryInfoToDataModel(
+  localQueryInitialInfo: InitialQueryInfo,
+): InitialQueryInfoData {
+  return {
+    userSpecifiedLabel: localQueryInitialInfo.userSpecifiedLabel,
+    queryText: localQueryInitialInfo.queryText,
+    isQuickQuery: localQueryInitialInfo.isQuickQuery,
+    isQuickEval: localQueryInitialInfo.isQuickEval,
+    quickEvalPosition: localQueryInitialInfo.quickEvalPosition,
+    queryPath: localQueryInitialInfo.queryPath,
+    databaseInfo: {
+      databaseUri: localQueryInitialInfo.databaseInfo.databaseUri,
+      name: localQueryInitialInfo.databaseInfo.name,
+    },
+    start: localQueryInitialInfo.start,
+    id: localQueryInitialInfo.id,
+  };
+}
+
+function mapQueryEvaluationInfoToDataModel(
+  queryEvaluationInfo: QueryEvaluationInfo,
+): QueryEvaluationInfoData {
+  return {
+    querySaveDir: queryEvaluationInfo.querySaveDir,
+    dbItemPath: queryEvaluationInfo.dbItemPath,
+    databaseHasMetadataFile: queryEvaluationInfo.databaseHasMetadataFile,
+    quickEvalPosition: queryEvaluationInfo.quickEvalPosition,
+    metadata: queryEvaluationInfo.metadata,
+    resultsPaths: queryEvaluationInfo.resultsPaths,
+  };
+}

extensions/ql-vscode/src/query-history/store/local-query-data-item.ts

@@ -0,0 +1,100 @@
+export interface LocalQueryDataItem {
+  initialInfo: InitialQueryInfoData;
+  t: "local";
+  evalLogLocation?: string;
+  evalLogSummaryLocation?: string;
+  jsonEvalLogSummaryLocation?: string;
+  evalLogSummarySymbolsLocation?: string;
+  completedQuery?: CompletedQueryInfoData;
+  failureReason?: string;
+}
+
+export interface InitialQueryInfoData {
+  userSpecifiedLabel?: string;
+  queryText: string;
+  isQuickQuery: boolean;
+  isQuickEval: boolean;
+  quickEvalPosition?: PositionData;
+  queryPath: string;
+  databaseInfo: DatabaseInfoData;
+  start: Date;
+  id: string;
+}
+
+interface DatabaseInfoData {
+  name: string;
+  databaseUri: string;
+}
+
+interface PositionData {
+  line: number;
+  column: number;
+  endLine: number;
+  endColumn: number;
+  fileName: string;
+}
+
+export interface CompletedQueryInfoData {
+  query: QueryEvaluationInfoData;
+  message?: string;
+  successful?: boolean;
+
+  // There once was a typo in the data model, which is why we need to support both
+  sucessful?: boolean;
+  result: EvaluationResultData;
+  logFileLocation?: string;
+  resultCount: number;
+  sortedResultsInfo: Record<string, SortedResultSetInfo>;
+  interpretedResultsSortState?: InterpretedResultsSortState;
+}
+
+interface InterpretedResultsSortState {
+  sortBy: InterpretedResultsSortColumn;
+  sortDirection: SortDirection;
+}
+
+type InterpretedResultsSortColumn = "alert-message";
+
+interface SortedResultSetInfo {
+  resultsPath: string;
+  sortState: RawResultsSortState;
+}
+
+interface RawResultsSortState {
+  columnIndex: number;
+  sortDirection: SortDirection;
+}
+
+enum SortDirection {
+  asc,
+  desc,
+}
+
+interface EvaluationResultData {
+  runId: number;
+  queryId: number;
+  resultType: number;
+  evaluationTime: number;
+  message?: string;
+  logFileLocation?: string;
+}
+
+export interface QueryEvaluationInfoData {
+  querySaveDir: string;
+  dbItemPath: string;
+  databaseHasMetadataFile: boolean;
+  quickEvalPosition?: PositionData;
+  metadata?: QueryMetadataData;
+  resultsPaths: {
+    resultsPath: string;
+    interpretedResultsPath: string;
+  };
+}
+
+interface QueryMetadataData {
+  name?: string;
+  description?: string;
+  id?: string;
+  kind?: string;
+  scored?: string;
+}

extensions/ql-vscode/src/query-history/store/query-history-data.ts

@@ -0,0 +1,14 @@
+// Contains models and consts for the data we want to store in the query history store.
+// Changes to these models should be done carefully and account for backwards compatibility of data.
+
+import { LocalQueryDataItem } from "./local-query-data-item";
+import { VariantAnalysisDataItem } from "./variant-analysis-data-item";
+
+export const ALLOWED_QUERY_HISTORY_VERSIONS = [1, 2];
+
+export interface QueryHistoryData {
+  version: number;
+  queries: QueryHistoryDataItem[];
+}
+
+export type QueryHistoryDataItem = LocalQueryDataItem | VariantAnalysisDataItem;