@finos/legend-application-query 5.1.0 → 5.2.3

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

@@ -0,0 +1,173 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { action, makeAutoObservable } from 'mobx';
+import type { QueryBuilderState } from '../QueryBuilderState.js';
+import { QueryBuilderGraphFetchTreeState } from './graph-fetch/QueryBuilderGraphFetchTreeState.js';
+import { QueryBuilderProjectionState } from './projection/QueryBuilderProjectionState.js';
+import {
+  buildPropertyExpressionFromExplorerTreeNodeData,
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+} from '../explorer/QueryBuilderExplorerState.js';
+import { Class } from '@finos/legend-graph';
+import { filterByType } from '@finos/legend-shared';
+import { addQueryBuilderPropertyNode } from './graph-fetch/QueryBuilderGraphFetchTreeUtil.js';
+import { QueryBuilderSimpleProjectionColumnState } from './projection/QueryBuilderProjectionColumnState.js';
+
+export enum FETCH_STRUCTURE_MODE {
+  PROJECTION = 'PROJECTION',
+  GRAPH_FETCH = 'GRAPH_FETCH',
+}
+
+export class QueryBuilderFetchStructureState {
+  queryBuilderState: QueryBuilderState;
+  /**
+   * TODO: refactor this so we could reduce this to
+   * `implementationState: QueryBuilderFetchStructureImplementationState`
+   * so we don't have graph fetch and projection at the same time
+   *
+   * TODO?: perhaps it would eventually make sense to default to
+   * graph-fetch since `getAll()` naturally works for graph-fetch case
+   * and graph-fetch allows somewhat an empty tree
+   */
+  fetchStructureMode = FETCH_STRUCTURE_MODE.PROJECTION;
+  projectionState: QueryBuilderProjectionState;
+  graphFetchTreeState: QueryBuilderGraphFetchTreeState;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeAutoObservable(this, {
+      queryBuilderState: false,
+      setFetchStructureMode: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+    // TODO: we probably should modularize this a bit better
+    // See https://github.com/finos/legend-studio/issues/731
+    this.projectionState = new QueryBuilderProjectionState(
+      queryBuilderState,
+      this,
+    );
+    this.graphFetchTreeState = new QueryBuilderGraphFetchTreeState(
+      queryBuilderState,
+      this,
+    );
+  }
+
+  setFetchStructureMode(val: FETCH_STRUCTURE_MODE): void {
+    this.fetchStructureMode = val;
+  }
+
+  fetchProperty(node: QueryBuilderExplorerTreeNodeData): void {
+    if (
+      node instanceof QueryBuilderExplorerTreePropertyNodeData &&
+      !(node.type instanceof Class)
+    ) {
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          this.graphFetchTreeState.addProperty(node);
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          this.projectionState.addColumn(
+            new QueryBuilderSimpleProjectionColumnState(
+              this.projectionState,
+              buildPropertyExpressionFromExplorerTreeNodeData(
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                node,
+                this.queryBuilderState.graphManagerState.graph,
+                this.queryBuilderState.explorerState.propertySearchPanelState
+                  .allMappedPropertyNodes,
+              ),
+              this.queryBuilderState.explorerState.humanizePropertyName,
+            ),
+          );
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  fetchNodeChildrenProperties(node: QueryBuilderExplorerTreeNodeData): void {
+    if (node.type instanceof Class) {
+      // NOTE: here we require the node to already been expanded so the child nodes are generated
+      // we don't allow adding unopened node. Maybe if it helps, we can show a warning.
+      const nodesToAdd = node.childrenIds
+        .map((childId) =>
+          this.queryBuilderState.explorerState.nonNullableTreeData.nodes.get(
+            childId,
+          ),
+        )
+        .filter(filterByType(QueryBuilderExplorerTreePropertyNodeData))
+        .filter(
+          (childNode) =>
+            !(childNode.type instanceof Class) && childNode.mappingData.mapped,
+        );
+
+      switch (this.fetchStructureMode) {
+        case FETCH_STRUCTURE_MODE.GRAPH_FETCH: {
+          const graphFetchTreeData = this.graphFetchTreeState.treeData;
+          if (graphFetchTreeData) {
+            nodesToAdd.forEach((nodeToAdd) =>
+              addQueryBuilderPropertyNode(
+                graphFetchTreeData,
+                this.queryBuilderState.explorerState.nonNullableTreeData,
+                nodeToAdd,
+                this.queryBuilderState,
+              ),
+            );
+            this.graphFetchTreeState.setGraphFetchTree({
+              ...graphFetchTreeData,
+            });
+          }
+          return;
+        }
+        case FETCH_STRUCTURE_MODE.PROJECTION: {
+          nodesToAdd.forEach((nodeToAdd) => {
+            this.projectionState.addColumn(
+              new QueryBuilderSimpleProjectionColumnState(
+                this.projectionState,
+                buildPropertyExpressionFromExplorerTreeNodeData(
+                  this.queryBuilderState.explorerState.nonNullableTreeData,
+                  nodeToAdd,
+                  this.queryBuilderState.graphManagerState.graph,
+                  this.queryBuilderState.explorerState.propertySearchPanelState
+                    .allMappedPropertyNodes,
+                ),
+                this.queryBuilderState.explorerState.humanizePropertyName,
+              ),
+            );
+          });
+          return;
+        }
+        default:
+          return;
+      }
+    }
+  }
+
+  get validationIssues(): string[] | undefined {
+    switch (this.fetchStructureMode) {
+      case FETCH_STRUCTURE_MODE.PROJECTION:
+        return this.projectionState.validationIssues;
+      case FETCH_STRUCTURE_MODE.GRAPH_FETCH:
+      default:
+        return undefined;
+    }
+  }
+}

package/src/stores/{QueryBuilderGraphFetchTreeState.ts → fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts}

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import type { QueryBuilderState } from './QueryBuilderState.js';
-import { makeAutoObservable, action } from 'mobx';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import { action, makeObservable, observable } from 'mobx';
 import {
   PackageableElementExplicitReference,
   RootGraphFetchTree,
@@ -25,10 +25,12 @@ import {
   addQueryBuilderPropertyNode,
   buildGraphFetchTreeData,
 } from './QueryBuilderGraphFetchTreeUtil.js';
-import type { QueryBuilderExplorerTreePropertyNodeData } from './QueryBuilderExplorerState.js';
+import type { QueryBuilderExplorerTreePropertyNodeData } from '../../explorer/QueryBuilderExplorerState.js';
+import { assertNonNullable } from '@finos/legend-shared';
+import { QueryBuilderFetchStructureImplementationState } from '../QueryBuilderFetchStructureImplementationState.js';
+import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
 
-export class QueryBuilderGraphFetchTreeState {
-  queryBuilderState: QueryBuilderState;
+export class QueryBuilderGraphFetchTreeState extends QueryBuilderFetchStructureImplementationState {
   treeData?: QueryBuilderGraphFetchTreeData | undefined;
   /**
    * If set to `true` we will use `graphFetchChecked` function instead of `graphFetch`.
@@ -37,14 +39,18 @@ export class QueryBuilderGraphFetchTreeState {
    */
   isChecked = false;
 
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
+  constructor(
+    queryBuilderState: QueryBuilderState,
+    fetchStructureState: QueryBuilderFetchStructureState,
+  ) {
+    super(queryBuilderState, fetchStructureState);
+
+    makeObservable(this, {
+      treeData: observable,
+      isChecked: observable,
       setGraphFetchTree: action,
       setChecked: action,
     });
-
-    this.queryBuilderState = queryBuilderState;
   }
 
   setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
@@ -55,36 +61,40 @@ export class QueryBuilderGraphFetchTreeState {
     this.isChecked = val;
   }
 
+  // TODO-BEFORE-PR: consider removing this
   initialize(tree?: RootGraphFetchTree): void {
-    if (this.queryBuilderState.fetchStructureState.isGraphFetchMode()) {
-      if (tree) {
-        this.setGraphFetchTree(buildGraphFetchTreeData(tree));
-      } else {
-        const _class = this.queryBuilderState.querySetupState._class;
-        if (_class) {
-          this.setGraphFetchTree(
-            buildGraphFetchTreeData(
-              new RootGraphFetchTree(
-                PackageableElementExplicitReference.create(_class),
-              ),
+    if (tree) {
+      this.setGraphFetchTree(buildGraphFetchTreeData(tree));
+    } else {
+      const _class = this.queryBuilderState.querySetupState._class;
+      if (_class) {
+        this.setGraphFetchTree(
+          buildGraphFetchTreeData(
+            new RootGraphFetchTree(
+              PackageableElementExplicitReference.create(_class),
             ),
-          );
-        } else {
-          this.setGraphFetchTree(undefined);
-        }
+          ),
+        );
+      } else {
+        this.setGraphFetchTree(undefined);
       }
     }
   }
 
   addProperty(node: QueryBuilderExplorerTreePropertyNodeData): void {
-    if (this.treeData) {
-      addQueryBuilderPropertyNode(
-        this.treeData,
-        this.queryBuilderState.explorerState.nonNullableTreeData,
-        node,
-        this.queryBuilderState,
-      );
-      this.setGraphFetchTree({ ...this.treeData });
+    if (!this.treeData) {
+      this.initialize();
     }
+    assertNonNullable(
+      this.treeData,
+      `Graph-fetch tree has not been properly initialized`,
+    );
+    addQueryBuilderPropertyNode(
+      this.treeData,
+      this.queryBuilderState.explorerState.nonNullableTreeData,
+      node,
+      this.queryBuilderState,
+    );
+    this.setGraphFetchTree({ ...this.treeData });
   }
 }

package/src/stores/{QueryBuilderGraphFetchTreeUtil.ts → fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeUtil.ts}

@@ -30,8 +30,8 @@ import {
   type QueryBuilderExplorerTreeNodeData,
   QueryBuilderExplorerTreePropertyNodeData,
   QueryBuilderExplorerTreeSubTypeNodeData,
-} from './QueryBuilderExplorerState.js';
-import type { QueryBuilderState } from './QueryBuilderState.js';
+} from '../../explorer/QueryBuilderExplorerState.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
 import {
   graphFetchTree_addSubTree,
   graphFetchTree_removeSubTree,

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

@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  extractElementNameFromPath,
+  GenericType,
+  GenericTypeExplicitReference,
+  matchFunctionName,
+  PrimitiveInstanceValue,
+  PRIMITIVE_TYPE,
+  SimpleFunctionExpression,
+  TYPICAL_MULTIPLICITY_TYPE,
+  type ValueSpecification,
+  type LambdaFunction,
+} from '@finos/legend-graph';
+import { guaranteeType } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../QueryBuilder_Const.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+
+export const appendTakeLimit = (
+  queryBuilderState: QueryBuilderState,
+  lambda: LambdaFunction,
+  previewLimit?: number | undefined,
+): LambdaFunction => {
+  if (!previewLimit) {
+    return lambda;
+  }
+  const multiplicityOne =
+    queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+      TYPICAL_MULTIPLICITY_TYPE.ONE,
+    );
+  if (lambda.expressionSequence.length === 1) {
+    const func = lambda.expressionSequence[0];
+    if (func instanceof SimpleFunctionExpression) {
+      if (
+        matchFunctionName(
+          func.functionName,
+          QUERY_BUILDER_SUPPORTED_FUNCTIONS.SERIALIZE,
+        )
+      ) {
+        const limit = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(
+            new GenericType(
+              queryBuilderState.graphManagerState.graph.getPrimitiveType(
+                PRIMITIVE_TYPE.INTEGER,
+              ),
+            ),
+          ),
+          multiplicityOne,
+        );
+        limit.values = [previewLimit];
+        const takeFunction = new SimpleFunctionExpression(
+          extractElementNameFromPath(QUERY_BUILDER_SUPPORTED_FUNCTIONS.TAKE),
+          multiplicityOne,
+        );
+
+        // NOTE: `take()` does not work on `graphFetch()` or `serialize()` so we will put it
+        // right next to `all()`
+        const serializeFunction = func;
+        const graphFetchFunc = guaranteeType(
+          serializeFunction.parametersValues[0],
+          SimpleFunctionExpression,
+        );
+        const getAllFunc = graphFetchFunc
+          .parametersValues[0] as ValueSpecification;
+        takeFunction.parametersValues[0] = getAllFunc;
+        takeFunction.parametersValues[1] = limit;
+        graphFetchFunc.parametersValues = [
+          takeFunction,
+          graphFetchFunc.parametersValues[1] as ValueSpecification,
+        ];
+        return lambda;
+      }
+    }
+  }
+  return lambda;
+};