@finos/legend-application-query 5.2.4 → 5.2.7

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

@@ -25,12 +25,15 @@ import {
   TYPICAL_MULTIPLICITY_TYPE,
   type ValueSpecification,
   type LambdaFunction,
+  RootGraphFetchTreeInstanceValue,
 } from '@finos/legend-graph';
-import { guaranteeType } from '@finos/legend-shared';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilder_Const.js';
 import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import type { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
+import { isGraphFetchTreeDataEmpty } from './QueryBuilderGraphFetchTreeUtil.js';
 
-export const appendTakeLimit = (
+const appendTakeLimit = (
   queryBuilderState: QueryBuilderState,
   lambda: LambdaFunction,
   previewLimit?: number | undefined,
@@ -67,8 +70,8 @@ export const appendTakeLimit = (
           multiplicityOne,
         );
 
-        // NOTE: `take()` does not work on `graphFetch()` or `serialize()` so we will put it
-        // right next to `all()`
+        // NOTE: `take()` does not work on `graphFetch()` or `serialize()` so we need to
+        // put it next to `all()`
         const serializeFunction = func;
         const graphFetchFunc = guaranteeType(
           serializeFunction.parametersValues[0],
@@ -88,3 +91,64 @@ export const appendTakeLimit = (
   }
   return lambda;
 };
+
+export const appendGraphFetch = (
+  graphFetchTreeState: QueryBuilderGraphFetchTreeState,
+  lambdaFunction: LambdaFunction,
+  options?: {
+    /**
+     * Set queryBuilderState to `true` when we construct query for execution within the app.
+     * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
+     */
+    isBuildingExecutionQuery?: boolean | undefined;
+    keepSourceInformation?: boolean | undefined;
+  },
+): void => {
+  const queryBuilderState = graphFetchTreeState.queryBuilderState;
+  const precedingExpression = guaranteeNonNullable(
+    lambdaFunction.expressionSequence[0],
+    `Can't build graph-fetch tree expression: preceding expression is not defined`,
+  );
+  const multiplicityOne =
+    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+
+  // build graph-fetch tree
+  if (
+    graphFetchTreeState.treeData &&
+    !isGraphFetchTreeDataEmpty(graphFetchTreeState.treeData)
+  ) {
+    const graphFetchInstance = new RootGraphFetchTreeInstanceValue(
+      multiplicityOne,
+    );
+    graphFetchInstance.values = [graphFetchTreeState.treeData.tree];
+    const serializeFunction = new SimpleFunctionExpression(
+      extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE),
+      multiplicityOne,
+    );
+    const graphFetchFunc = new SimpleFunctionExpression(
+      graphFetchTreeState.isChecked
+        ? extractElementNameFromPath(
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
+          )
+        : extractElementNameFromPath(
+            QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
+          ),
+      multiplicityOne,
+    );
+
+    graphFetchFunc.parametersValues = [precedingExpression, graphFetchInstance];
+    serializeFunction.parametersValues = [graphFetchFunc, graphFetchInstance];
+    lambdaFunction.expressionSequence[0] = serializeFunction;
+  }
+
+  // build result set modifier: i.e. preview limit
+  if (options?.isBuildingExecutionQuery) {
+    appendTakeLimit(
+      queryBuilderState,
+      lambdaFunction,
+      queryBuilderState.resultState.previewLimit,
+    );
+  }
+};

package/src/stores/fetch-structure/projection/QueryBuilderProjectionColumnState.ts

@@ -131,8 +131,8 @@ export class QueryBuilderSimpleProjectionColumnState extends QueryBuilderProject
           .nonNullableTreeData,
         node,
         this.projectionState.queryBuilderState.graphManagerState.graph,
-        this.projectionState.queryBuilderState.explorerState
-          .propertySearchPanelState.allMappedPropertyNodes,
+        this.projectionState.queryBuilderState.explorerState.propertySearchState
+          .allMappedPropertyNodes,
       ),
     );
     this.columnName = getPropertyChainName(

package/src/stores/fetch-structure/projection/QueryBuilderProjectionState.ts

@@ -42,14 +42,25 @@ import {
   LAMBDA_PIPE,
   RawLambda,
   isStubbed_RawLambda,
+  Class,
+  type LambdaFunction,
+  type ValueSpecification,
+  AbstractPropertyExpression,
+  matchFunctionName,
+  SimpleFunctionExpression,
+  getAllSuperclasses,
 } from '@finos/legend-graph';
 import {
   DEFAULT_LAMBDA_VARIABLE_NAME,
   QUERY_BUILDER_SOURCE_ID_LABEL,
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
 } from '../../../QueryBuilder_Const.js';
 import { QueryBuilderAggregationState } from './aggregation/QueryBuilderAggregationState.js';
 import { buildGenericLambdaFunctionInstanceValue } from '../../QueryBuilderValueSpecificationHelper.js';
-import { QueryBuilderFetchStructureImplementationState } from '../QueryBuilderFetchStructureImplementationState.js';
+import {
+  FETCH_STRUCTURE_IMPLEMENTATION,
+  QueryBuilderFetchStructureImplementationState,
+} from '../QueryBuilderFetchStructureImplementationState.js';
 import { QueryResultSetModifierState } from './QueryResultSetModifierState.js';
 import { QueryBuilderPostFilterState } from './post-filter/QueryBuilderPostFilterState.js';
 import type { QueryBuilderPostFilterOperator } from './post-filter/QueryBuilderPostFilterOperator.js';
@@ -58,10 +69,22 @@ import type { QueryBuilderAggregateOperator } from './aggregation/QueryBuilderAg
 import { getQueryBuilderCoreAggregrationOperators } from './aggregation/QueryBuilderAggregateOperatorLoader.js';
 import {
   QueryBuilderDerivationProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
   type QueryBuilderProjectionColumnState,
-  type QueryBuilderSimpleProjectionColumnState,
 } from './QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
+import {
+  buildPropertyExpressionFromExplorerTreeNodeData,
+  generateExplorerTreePropertyNodeID,
+  generateExplorerTreeSubtypeNodeID,
+  type QueryBuilderExplorerTreePropertyNodeData,
+} from '../../explorer/QueryBuilderExplorerState.js';
+import {
+  ActionAlertActionType,
+  ActionAlertType,
+} from '@finos/legend-application';
+import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecificationBuilderHelper.js';
+import { appendProjection } from './QueryBuilderProjectionValueSpecificationBuilder.js';
 
 export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImplementationState {
   columns: QueryBuilderProjectionColumnState[] = [];
@@ -91,7 +114,6 @@ export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImple
       showPostFilterPanel: observable,
       derivations: computed,
       hasParserError: computed,
-      validationIssues: computed,
       addColumn: action,
       moveColumn: action,
       replaceColumn: action,
@@ -110,6 +132,10 @@ export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImple
     );
   }
 
+  get type(): string {
+    return FETCH_STRUCTURE_IMPLEMENTATION.PROJECTION;
+  }
+
   get derivations(): QueryBuilderDerivationProjectionColumnState[] {
     return this.columns.filter(
       filterByType(QueryBuilderDerivationProjectionColumnState),
@@ -122,6 +148,80 @@ export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImple
     );
   }
 
+  get usedExplorerTreePropertyNodeIDs(): string[] {
+    let nodeIDs: string[] = [];
+    this.columns.forEach((column) => {
+      if (column instanceof QueryBuilderSimpleProjectionColumnState) {
+        let chunks: (string | Class)[] = [];
+        let currentExpression: ValueSpecification =
+          column.propertyExpressionState.propertyExpression;
+        while (currentExpression instanceof AbstractPropertyExpression) {
+          chunks.push(currentExpression.func.name);
+          currentExpression = guaranteeNonNullable(
+            currentExpression.parametersValues[0],
+          );
+          while (currentExpression instanceof SimpleFunctionExpression) {
+            if (
+              matchFunctionName(
+                currentExpression.functionName,
+                QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+              ) &&
+              currentExpression.parametersValues.length >= 1 &&
+              currentExpression.parametersValues[1]?.genericType?.value
+                .rawType instanceof Class
+            ) {
+              // flatten subtype casting chain: stop pushing more classes
+              if (!(chunks[chunks.length - 1] instanceof Class)) {
+                chunks.push(
+                  currentExpression.parametersValues[1]?.genericType?.value
+                    .rawType,
+                );
+              }
+              currentExpression = guaranteeNonNullable(
+                currentExpression.parametersValues[0],
+              );
+            } else {
+              // unknown property expression
+              return;
+            }
+          }
+        }
+        chunks = chunks.reverse();
+        const chunkIDs: string[] = [];
+        const ids: string[] = [];
+
+        for (let i = 0; i < chunks.length; i++) {
+          const currentChunk = guaranteeNonNullable(chunks[i]);
+          const previousID = i > 0 ? guaranteeNonNullable(chunkIDs[i - 1]) : '';
+          if (currentChunk instanceof Class) {
+            getAllSuperclasses(currentChunk)
+              .concat(currentChunk)
+              .forEach((_class) =>
+                ids.push(
+                  generateExplorerTreeSubtypeNodeID(previousID, _class.path),
+                ),
+              );
+            chunkIDs.push(
+              generateExplorerTreeSubtypeNodeID(previousID, currentChunk.path),
+            );
+          } else {
+            const id = generateExplorerTreePropertyNodeID(
+              previousID,
+              currentChunk,
+            );
+            chunkIDs.push(id);
+            ids.push(id);
+          }
+        }
+
+        nodeIDs = nodeIDs.concat(ids);
+      }
+    });
+
+    // deduplicate
+    return Array.from(new Set(nodeIDs).values());
+  }
+
   get validationIssues(): string[] | undefined {
     const hasDuplicatedProjectionColumns = this.columns.some(
       (column) =>
@@ -138,6 +238,17 @@ export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImple
     return undefined;
   }
 
+  onClassChange(_class: Class | undefined): void {
+    return;
+  }
+
+  appendFetchStructure(
+    lambdaFunction: LambdaFunction,
+    options?: LambdaFunctionBuilderOption,
+  ): void {
+    appendProjection(this, lambdaFunction, options);
+  }
+
   setShowPostFilterPanel(val: boolean): void {
     this.showPostFilterPanel = val;
   }
@@ -387,4 +498,72 @@ export class QueryBuilderProjectionState extends QueryBuilderFetchStructureImple
       ),
     );
   }
+
+  fetchProperty(node: QueryBuilderExplorerTreePropertyNodeData): void {
+    this.addColumn(
+      new QueryBuilderSimpleProjectionColumnState(
+        this,
+        buildPropertyExpressionFromExplorerTreeNodeData(
+          this.queryBuilderState.explorerState.nonNullableTreeData,
+          node,
+          this.queryBuilderState.graphManagerState.graph,
+          this.queryBuilderState.explorerState.propertySearchState
+            .allMappedPropertyNodes,
+        ),
+        this.queryBuilderState.explorerState.humanizePropertyName,
+      ),
+    );
+  }
+
+  fetchProperties(nodes: QueryBuilderExplorerTreePropertyNodeData[]): void {
+    nodes.forEach((nodeToAdd) => {
+      this.addColumn(
+        new QueryBuilderSimpleProjectionColumnState(
+          this,
+          buildPropertyExpressionFromExplorerTreeNodeData(
+            this.queryBuilderState.explorerState.nonNullableTreeData,
+            nodeToAdd,
+            this.queryBuilderState.graphManagerState.graph,
+            this.queryBuilderState.explorerState.propertySearchState
+              .allMappedPropertyNodes,
+          ),
+          this.queryBuilderState.explorerState.humanizePropertyName,
+        ),
+      );
+    });
+  }
+
+  checkBeforeChangingImplementation(onChange: () => void): void {
+    if (
+      this.columns.length > 0
+      // NOTE: here we could potentially check for the presence of post-filter as well
+      // but we make the assumption that if there is no projection column, there should
+      // not be any post-filter at all
+    ) {
+      this.queryBuilderState.applicationStore.setActionAlertInfo({
+        message:
+          this.showPostFilterPanel && this.postFilterState.nodes.size > 0
+            ? 'With graph-fetch mode, post filter is not supported. Current projection columns and post filters will be lost when switching to the graph-fetch mode. Do you still want to proceed?'
+            : 'Current projection columns will be lost when switching to the graph-fetch mode. Do you still want to proceed?',
+        type: ActionAlertType.CAUTION,
+        actions: [
+          {
+            label: 'Proceed',
+            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+            handler:
+              this.queryBuilderState.applicationStore.guardUnhandledError(
+                async () => onChange(),
+              ),
+          },
+          {
+            label: 'Cancel',
+            type: ActionAlertActionType.PROCEED,
+            default: true,
+          },
+        ],
+      });
+    } else {
+      onChange();
+    }
+  }
 }