Rename mapping functions to follow same patterns and conventions

Author: charisk

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

@@ -26,15 +26,15 @@ import {
 
 // Maps Query History Data Models to Domain Models
 
-export function mapQueryHistoryToDomainModels(
+export function mapQueryHistoryToDomainModel(
   queries: QueryHistoryItemDto[],
 ): QueryHistoryInfo[] {
   return queries.map((d) => {
     if (d.t === "variant-analysis") {
       const query: VariantAnalysisHistoryItem = d;
       return query;
     } else if (d.t === "local") {
-      return mapLocalQueryDataItemToDomainModel(d);
+      return mapLocalQueryItemToDomainModel(d);
     }
 
     throw Error(
@@ -45,23 +45,23 @@ export function mapQueryHistoryToDomainModels(
   });
 }
 
-function mapLocalQueryDataItemToDomainModel(
+function mapLocalQueryItemToDomainModel(
   localQuery: QueryHistoryLocalQueryDto,
 ): LocalQueryInfo {
   return new LocalQueryInfo(
-    mapInitialQueryInfoDataToDomainModel(localQuery.initialInfo),
+    mapInitialQueryInfoToDomainModel(localQuery.initialInfo),
     undefined,
     localQuery.failureReason,
     localQuery.completedQuery &&
-      mapCompletedQueryInfoDataToDomainModel(localQuery.completedQuery),
+      mapCompletedQueryInfoToDomainModel(localQuery.completedQuery),
     localQuery.evalLogLocation,
     localQuery.evalLogSummaryLocation,
     localQuery.jsonEvalLogSummaryLocation,
     localQuery.evalLogSummarySymbolsLocation,
   );
 }
 
-function mapCompletedQueryInfoDataToDomainModel(
+function mapCompletedQueryInfoToDomainModel(
   completedQuery: CompletedQueryInfoDto,
 ): CompletedQueryInfo {
   const sortState =
@@ -70,12 +70,12 @@ function mapCompletedQueryInfoDataToDomainModel(
 
   const sortedResults = Object.fromEntries(
     Object.entries(completedQuery.sortedResultsInfo).map(([key, value]) => {
-      return [key, mapSortedResultSetInfoDtoToDomainModel(value)];
+      return [key, mapSortedResultSetInfoToDomainModel(value)];
     }),
   );
 
   return new CompletedQueryInfo(
-    mapQueryEvaluationInfoDataToDomainModel(completedQuery.query),
+    mapQueryEvaluationInfoToDomainModel(completedQuery.query),
     {
       runId: completedQuery.result.runId,
       queryId: completedQuery.result.queryId,
@@ -93,7 +93,7 @@ function mapCompletedQueryInfoDataToDomainModel(
   );
 }
 
-function mapInitialQueryInfoDataToDomainModel(
+function mapInitialQueryInfoToDomainModel(
   initialInfo: InitialQueryInfoDto,
 ): InitialQueryInfo {
   return {
@@ -112,7 +112,7 @@ function mapInitialQueryInfoDataToDomainModel(
   };
 }
 
-function mapQueryEvaluationInfoDataToDomainModel(
+function mapQueryEvaluationInfoToDomainModel(
   evaluationInfo: QueryEvaluationInfoDto,
 ): QueryEvaluationInfo {
   return new QueryEvaluationInfo(
@@ -144,7 +144,7 @@ function mapSortStateToDomainModel(
   };
 }
 
-function mapSortedResultSetInfoDtoToDomainModel(
+function mapSortedResultSetInfoToDomainModel(
   sortedResultSetInfo: SortedResultSetInfoDto,
 ): SortedResultSetInfo {
   return {

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

@@ -24,49 +24,48 @@ import {
 
 // Maps Query History Domain Models to Data Models
 
-export function mapQueryHistoryToDataModels(
+export function mapQueryHistoryToDto(
   queries: QueryHistoryInfo[],
 ): QueryHistoryItemDto[] {
   return queries.map((q) => {
     if (q.t === "variant-analysis") {
       const query: QueryHistoryVariantAnalysisDto = q;
       return query;
     } else if (q.t === "local") {
-      return mapLocalQueryInfoToDataModel(q);
+      return mapLocalQueryInfoToDto(q);
     } else {
       assertNever(q);
     }
   });
 }
 
-function mapLocalQueryInfoToDataModel(
+function mapLocalQueryInfoToDto(
   query: LocalQueryInfo,
 ): QueryHistoryLocalQueryDto {
   return {
-    initialInfo: mapInitialQueryInfoToDataModel(query.initialInfo),
+    initialInfo: mapInitialQueryInfoToDto(query.initialInfo),
     t: "local",
     evalLogLocation: query.evalLogLocation,
     evalLogSummaryLocation: query.evalLogSummaryLocation,
     jsonEvalLogSummaryLocation: query.jsonEvalLogSummaryLocation,
     evalLogSummarySymbolsLocation: query.evalLogSummarySymbolsLocation,
     failureReason: query.failureReason,
     completedQuery:
-      query.completedQuery &&
-      mapCompletedQueryToDataModel(query.completedQuery),
+      query.completedQuery && mapCompletedQueryToDto(query.completedQuery),
   };
 }
 
-function mapCompletedQueryToDataModel(
+function mapCompletedQueryToDto(
   query: CompletedQueryInfo,
 ): CompletedQueryInfoDto {
   const sortedResults = Object.fromEntries(
     Object.entries(query.sortedResultsInfo).map(([key, value]) => {
-      return [key, mapSortedResultSetInfoToDataModel(value)];
+      return [key, mapSortedResultSetInfoToDto(value)];
     }),
   );
 
   return {
-    query: mapQueryEvaluationInfoToDataModel(query.query),
+    query: mapQueryEvaluationInfoToDto(query.query),
     result: {
       runId: query.result.runId,
       queryId: query.result.queryId,
@@ -83,9 +82,7 @@ function mapCompletedQueryToDataModel(
   };
 }
 
-function mapSortDirectionToDomainModel(
-  sortDirection: SortDirection,
-): SortDirectionDto {
+function mapSortDirectionToDto(sortDirection: SortDirection): SortDirectionDto {
   switch (sortDirection) {
     case SortDirection.asc:
       return SortDirectionDto.asc;
@@ -94,25 +91,25 @@ function mapSortDirectionToDomainModel(
   }
 }
 
-function mapRawResultsSortStateToDataModel(
+function mapRawResultsSortStateToDto(
   sortState: RawResultsSortState,
 ): SortedResultSetInfoDto["sortState"] {
   return {
     columnIndex: sortState.columnIndex,
-    sortDirection: mapSortDirectionToDomainModel(sortState.sortDirection),
+    sortDirection: mapSortDirectionToDto(sortState.sortDirection),
   };
 }
 
-function mapSortedResultSetInfoToDataModel(
+function mapSortedResultSetInfoToDto(
   resultSet: SortedResultSetInfo,
 ): SortedResultSetInfoDto {
   return {
     resultsPath: resultSet.resultsPath,
-    sortState: mapRawResultsSortStateToDataModel(resultSet.sortState),
+    sortState: mapRawResultsSortStateToDto(resultSet.sortState),
   };
 }
 
-function mapInitialQueryInfoToDataModel(
+function mapInitialQueryInfoToDto(
   localQueryInitialInfo: InitialQueryInfo,
 ): InitialQueryInfoDto {
   return {
@@ -131,7 +128,7 @@ function mapInitialQueryInfoToDataModel(
   };
 }
 
-function mapQueryEvaluationInfoToDataModel(
+function mapQueryEvaluationInfoToDto(
   queryEvaluationInfo: QueryEvaluationInfo,
 ): QueryEvaluationInfoDto {
   return {

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

@@ -15,8 +15,8 @@ import {
   QueryHistoryDto,
   QueryHistoryItemDto,
 } from "./query-history-dto";
-import { mapQueryHistoryToDomainModels } from "./data-mapper";
-import { mapQueryHistoryToDataModels } from "./domain-mapper";
+import { mapQueryHistoryToDomainModel } from "./data-mapper";
+import { mapQueryHistoryToDto } from "./domain-mapper";
 
 export async function readQueryHistoryFromFile(
   fsPath: string,
@@ -45,7 +45,7 @@ export async function readQueryHistoryFromFile(
 
     // Map the data models to the domain models.
     const domainModels: QueryHistoryInfo[] =
-      mapQueryHistoryToDomainModels(parsedQueries);
+      mapQueryHistoryToDomainModel(parsedQueries);
 
     // filter out queries that have been deleted on disk
     // most likely another workspace has deleted them because the
@@ -101,7 +101,7 @@ export async function writeQueryHistoryToFile(
     );
 
     // map domain model queries to data model
-    const queryHistoryData = mapQueryHistoryToDataModels(filteredQueries);
+    const queryHistoryData = mapQueryHistoryToDto(filteredQueries);
 
     const data = JSON.stringify(
       {