@finos/legend-query-builder 2.0.0 → 2.1.0

package/src/stores/QueryBuilderResultState.ts

@@ -20,26 +20,26 @@ import {
   assertErrorThrown,
   LogEvent,
   guaranteeNonNullable,
-  ContentType,
-  guaranteeType,
+  type ContentType,
   downloadFileUsingDataURI,
-  UnsupportedOperationError,
   ActionState,
   StopWatch,
+  getContentTypeFileExtension,
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import {
   type RawExecutionPlan,
   type ExecutionResult,
   type RawLambda,
+  type EXECUTION_SERIALIZATION_FORMAT,
   GRAPH_MANAGER_EVENT,
-  EXECUTION_SERIALIZATION_FORMAT,
   RawExecutionResult,
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
+  extractExecutionResultValues,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
-import { ExecutionPlanState } from '@finos/legend-application';
+import { ExecutionPlanState, TAB_SIZE } from '@finos/legend-application';
 import {
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
@@ -50,6 +50,11 @@ import { QUERY_BUILDER_EVENT } from '../application/QueryBuilderEvent.js';
 
 const DEFAULT_LIMIT = 1000;
 
+export interface ExportDataInfo {
+  contentType: ContentType;
+  serializationFormat?: EXECUTION_SERIALIZATION_FORMAT | undefined;
+}
+
 export class QueryBuilderResultState {
   readonly queryBuilderState: QueryBuilderState;
   readonly exportDataState = ActionState.create();
@@ -148,25 +153,21 @@ export class QueryBuilderResultState {
     return query;
   }
 
-  *exportData(
-    serializationFormat: EXECUTION_SERIALIZATION_FORMAT,
-  ): GeneratorFn<void> {
+  *exportData(format: string): GeneratorFn<void> {
     try {
+      const exportData =
+        this.queryBuilderState.fetchStructureState.implementation.getExportDataInfo(
+          format,
+        );
+      const contentType = exportData.contentType;
+      const serializationFormat = exportData.serializationFormat;
       this.exportDataState.inProgress();
-      const mapping = guaranteeNonNullable(
-        this.queryBuilderState.mapping,
-        'Mapping is required to execute query',
-      );
-      const runtime = guaranteeNonNullable(
-        this.queryBuilderState.runtimeValue,
-        `Runtime is required to execute query`,
-      );
       const query = this.buildExecutionRawLambda();
       const result =
         (yield this.queryBuilderState.graphManagerState.graphManager.runQuery(
           query,
-          mapping,
-          runtime,
+          this.queryBuilderState.mapping,
+          this.queryBuilderState.runtimeValue,
           this.queryBuilderState.graphManagerState.graph,
           {
             serializationFormat,
@@ -176,23 +177,17 @@ export class QueryBuilderResultState {
             ),
           },
         )) as ExecutionResult;
-      let contentType: ContentType;
-      let fileName = 'result';
       let content: string;
-      switch (serializationFormat) {
-        case EXECUTION_SERIALIZATION_FORMAT.CSV:
-          {
-            const rawResult = guaranteeType(result, RawExecutionResult);
-            contentType = ContentType.TEXT_CSV;
-            fileName = `${fileName}.csv`;
-            content = rawResult.value;
-          }
-          break;
-        default:
-          throw new UnsupportedOperationError(
-            `Can't download file for serialization type: '${serializationFormat}'`,
-          );
+      if (result instanceof RawExecutionResult) {
+        content = result.value;
+      } else {
+        content = JSON.stringify(
+          extractExecutionResultValues(result),
+          null,
+          TAB_SIZE,
+        );
       }
+      const fileName = `result.${getContentTypeFileExtension(contentType)}`;
       downloadFileUsingDataURI(fileName, content, contentType);
       this.exportDataState.pass();
     } catch (error) {

package/src/stores/fetch-structure/QueryBuilderFetchStructureImplementationState.ts

@@ -26,6 +26,7 @@ import type { QueryBuilderExplorerTreePropertyNodeData } from '../explorer/Query
 import type { QueryBuilderState } from '../QueryBuilderState.js';
 import type { LambdaFunctionBuilderOption } from '../QueryBuilderValueSpecificationBuilderHelper.js';
 import type { QueryBuilderFetchStructureState } from './QueryBuilderFetchStructureState.js';
+import type { ExportDataInfo } from '../QueryBuilderResultState.js';
 
 export enum FETCH_STRUCTURE_IMPLEMENTATION {
   TABULAR_DATA_STRUCTURE = 'TABULAR_DATA_STRUCTURE',
@@ -75,4 +76,8 @@ export abstract class QueryBuilderFetchStructureImplementationState
   get TEMPORARY__showPostFetchStructurePanel(): boolean {
     return this.queryBuilderState.filterState.showPanel;
   }
+
+  // export options
+  abstract get exportDataFormatOptions(): string[];
+  abstract getExportDataInfo(format: string): ExportDataInfo;
 }

package/src/stores/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -51,15 +51,22 @@ import {
   guaranteeNonNullable,
   hashArray,
   type Hashable,
+  UnsupportedOperationError,
+  ContentType,
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../graphManager/QueryBuilderHashUtils.js';
 import { isValueExpressionReferencedInValue } from '../../QueryBuilderValueSpecificationHelper.js';
+import type { ExportDataInfo } from '../../QueryBuilderResultState.js';
 
 export enum SERIALIZATION_TYPE {
   PURE = 'PURE',
   EXTERNAL_FORMAT = 'EXTERNAL_FORMAT',
 }
 
+export enum GRAPH_FETCH_EXPORT_DATA_FORMAT {
+  RESULT = 'RESULT',
+}
+
 const DEFAULT_PURE_CONFIG_TYPE_NAME = '@type';
 
 export class PureSerializationConfig {
@@ -135,6 +142,8 @@ export abstract class GraphFetchSerializationState {
   }
 
   abstract getLabel(): string;
+
+  abstract get serializationContentType(): ContentType;
 }
 
 export class GraphFetchPureSerializationState extends GraphFetchSerializationState {
@@ -161,6 +170,10 @@ export class GraphFetchPureSerializationState extends GraphFetchSerializationSta
   override getLabel(): string {
     return SERIALIZATION_TYPE.PURE;
   }
+
+  override get serializationContentType(): ContentType {
+    return ContentType.APPLICATION_JSON;
+  }
 }
 
 export class GraphFetchExternalFormatSerializationState extends GraphFetchSerializationState {
@@ -176,6 +189,7 @@ export class GraphFetchExternalFormatSerializationState extends GraphFetchSerial
     makeObservable(this, {
       targetBinding: observable,
       treeData: observable.ref,
+      serializationContentType: computed,
     });
     this.targetBinding = targetBinding;
     this.treeData = treeData;
@@ -192,6 +206,20 @@ export class GraphFetchExternalFormatSerializationState extends GraphFetchSerial
   override getLabel(): string {
     return SERIALIZATION_TYPE.EXTERNAL_FORMAT;
   }
+
+  override get serializationContentType(): ContentType {
+    const contentType = this.targetBinding.contentType;
+    if (Object.values(ContentType).includes(contentType as ContentType)) {
+      return contentType as ContentType;
+    } else {
+      // TEMP: need to investigate if flatdata should be returned as content type
+      // for now we will assume all flatdata is csv
+      if (contentType === 'application/x.flatdata') {
+        return ContentType.TEXT_CSV;
+      }
+      return ContentType.TEXT_PLAIN;
+    }
+  }
 }
 
 export class QueryBuilderGraphFetchTreeState
@@ -321,6 +349,22 @@ export class QueryBuilderGraphFetchTreeState
     );
   }
 
+  override get exportDataFormatOptions(): string[] {
+    return [GRAPH_FETCH_EXPORT_DATA_FORMAT.RESULT];
+  }
+
+  override getExportDataInfo(format: string): ExportDataInfo {
+    if (format === GRAPH_FETCH_EXPORT_DATA_FORMAT.RESULT) {
+      return {
+        contentType: this.serializationState.serializationContentType,
+      };
+    } else {
+      throw new UnsupportedOperationError(
+        `Unsupported Graph Fetch export type ${format}`,
+      );
+    }
+  }
+
   onClassChange(_class: Class | undefined): void {
     this.updateTreeData(_class);
   }

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -35,6 +35,8 @@ import {
   filterByType,
   type Hashable,
   hashArray,
+  UnsupportedOperationError,
+  ContentType,
 } from '@finos/legend-shared';
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import {
@@ -52,6 +54,7 @@ import {
   matchFunctionName,
   SimpleFunctionExpression,
   getAllSuperclasses,
+  EXECUTION_SERIALIZATION_FORMAT,
 } from '@finos/legend-graph';
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
@@ -97,6 +100,12 @@ import type { QueryBuilderTDS_WindowOperator } from './window/operators/QueryBui
 import { getQueryBuilderCoreWindowOperators } from './window/QueryBuilderWindowGroupByOperatorLoader.js';
 import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState.js';
 import { QUERY_BUILDER_SETTING_KEY } from '../../../application/QueryBuilderSetting.js';
+import type { ExportDataInfo } from '../../QueryBuilderResultState.js';
+
+// TODO: should we support raw once externalize() is supported on TDS ?
+export enum TDS_EXECUTION_SERIALIZATION_FORMAT {
+  CSV = 'CSV',
+}
 
 export class QueryBuilderTDSState
   extends QueryBuilderFetchStructureImplementationState
@@ -289,6 +298,25 @@ export class QueryBuilderTDSState
     ];
   }
 
+  override get exportDataFormatOptions(): string[] {
+    return [TDS_EXECUTION_SERIALIZATION_FORMAT.CSV];
+  }
+
+  override getExportDataInfo(format: string): ExportDataInfo {
+    switch (format) {
+      case TDS_EXECUTION_SERIALIZATION_FORMAT.CSV:
+        return {
+          contentType: ContentType.TEXT_CSV,
+          serializationFormat: EXECUTION_SERIALIZATION_FORMAT.CSV,
+        };
+
+      default:
+        throw new UnsupportedOperationError(
+          `Unsupported TDS export type ${format}`,
+        );
+    }
+  }
+
   isDuplicateColumn(col: QueryBuilderTDSColumnState): boolean {
     return (
       this.tdsColumns.filter((c) => c.columnName === col.columnName).length > 1

package/src/stores/fetch-structure/tds/window/QueryBuilderWindowState.ts

@@ -23,7 +23,7 @@ import {
   uniq,
   type Hashable,
 } from '@finos/legend-shared';
-import { action, makeObservable, observable } from 'mobx';
+import { action, computed, makeObservable, observable } from 'mobx';
 import { QUERY_BUILDER_HASH_STRUCTURE } from '../../../../graphManager/QueryBuilderHashUtils.js';
 import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../../QueryBuilderConfig.js';
 import type { QueryBuilderProjectionColumnDragSource } from '../projection/QueryBuilderProjectionColumnState.js';
@@ -333,6 +333,7 @@ export class QueryBuilderWindowState implements Hashable {
     makeObservable(this, {
       windowColumns: observable,
       editColumn: observable,
+      validationIssues: computed,
       addWindowColumn: action,
       removeColumn: action,
       moveColumn: action,
@@ -346,6 +347,18 @@ export class QueryBuilderWindowState implements Hashable {
     return !this.windowColumns.length;
   }
 
+  get validationIssues(): string[] | undefined {
+    const hasDuplicatedWindowColumns = this.windowColumns.some(
+      (column) =>
+        this.windowColumns.filter((c) => c.columnName === column.columnName)
+          .length > 1,
+    );
+    if (hasDuplicatedWindowColumns) {
+      return ['Query has duplicated window columns'];
+    }
+    return undefined;
+  }
+
   get referencedTDSColumns(): QueryBuilderTDSColumnState[] {
     return uniq(this.windowColumns.map((c) => c.referencedTDSColumns).flat());
   }