@finos/legend-application-query 5.0.0

package/src/stores/QueryBuilderGraphFetchTreeState.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 type { QueryBuilderState } from './QueryBuilderState.js';
+import { makeAutoObservable, action } from 'mobx';
+import {
+  PackageableElementExplicitReference,
+  RootGraphFetchTree,
+} from '@finos/legend-graph';
+import {
+  type QueryBuilderGraphFetchTreeData,
+  addQueryBuilderPropertyNode,
+  buildGraphFetchTreeData,
+} from './QueryBuilderGraphFetchTreeUtil.js';
+import type { QueryBuilderExplorerTreePropertyNodeData } from './QueryBuilderExplorerState.js';
+
+export class QueryBuilderGraphFetchTreeState {
+  queryBuilderState: QueryBuilderState;
+  treeData?: QueryBuilderGraphFetchTreeData | undefined;
+  /**
+   * If set to `true` we will use `graphFetchChecked` function instead of `graphFetch`.
+   * `graphFetchChecked` will do extra checks on constraints and only work on M2M use case for now.
+   * Hence we default this to `false` for graph fetch to work universally.
+   */
+  isChecked = false;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeAutoObservable(this, {
+      queryBuilderState: false,
+      setGraphFetchTree: action,
+      setChecked: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
+    this.treeData = val;
+  }
+
+  setChecked(val: boolean): void {
+    this.isChecked = val;
+  }
+
+  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),
+              ),
+            ),
+          );
+        } 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 });
+    }
+  }
+}

package/src/stores/QueryBuilderGraphFetchTreeUtil.ts

@@ -0,0 +1,281 @@
+/**
+ * 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 { assertType, addUniqueEntry, deleteEntry } from '@finos/legend-shared';
+import type { TreeNodeData, TreeData } from '@finos/legend-art';
+import {
+  type AbstractProperty,
+  type GraphFetchTree,
+  type Type,
+  type RootGraphFetchTree,
+  PropertyExplicitReference,
+  Class,
+  PropertyGraphFetchTree,
+  PackageableElementExplicitReference,
+} from '@finos/legend-graph';
+import {
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+  QueryBuilderExplorerTreeSubTypeNodeData,
+} from './QueryBuilderExplorerState.js';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import {
+  graphFetchTree_addSubTree,
+  graphFetchTree_removeSubTree,
+} from '@finos/legend-application';
+
+export class QueryBuilderGraphFetchTreeNodeData implements TreeNodeData {
+  isSelected?: boolean | undefined;
+  isOpen?: boolean | undefined;
+  id: string;
+  label: string;
+  childrenIds: string[] = [];
+  parentId?: string | undefined;
+  tree: PropertyGraphFetchTree;
+
+  constructor(
+    id: string,
+    label: string,
+    parentId: string | undefined,
+    graphFetchTreeNode: PropertyGraphFetchTree,
+  ) {
+    this.id = id;
+    this.label = label;
+    this.parentId = parentId;
+    this.tree = graphFetchTreeNode;
+    // NOTE: in this tree, every node is open
+    this.isOpen = true;
+  }
+
+  get type(): Type {
+    return this.tree.property.value.genericType.value.rawType;
+  }
+}
+
+export interface QueryBuilderGraphFetchTreeData
+  extends TreeData<QueryBuilderGraphFetchTreeNodeData> {
+  tree: RootGraphFetchTree;
+}
+
+const generateNodeId = (
+  property: AbstractProperty,
+  subType: Type | undefined,
+  parentNodeId: string | undefined,
+): string =>
+  `${parentNodeId ? `${parentNodeId}.` : ''}${property.name}${
+    subType ? subType.path : ''
+  }`;
+
+const buildGraphFetchSubTree = (
+  tree: GraphFetchTree,
+  parentNode: QueryBuilderGraphFetchTreeNodeData | undefined,
+  nodes: Map<string, QueryBuilderGraphFetchTreeNodeData>,
+): QueryBuilderGraphFetchTreeNodeData => {
+  assertType(
+    tree,
+    PropertyGraphFetchTree,
+    'Graph fetch sub-tree must be a property graph fetch tree',
+  );
+  const property = tree.property.value;
+  const subType = tree.subType?.value;
+  const parentNodeId = parentNode?.id;
+  const node = new QueryBuilderGraphFetchTreeNodeData(
+    generateNodeId(property, subType, parentNodeId),
+    property.name,
+    parentNodeId,
+    tree,
+  );
+  tree.subTrees.forEach((subTree) => {
+    const subTreeNode = buildGraphFetchSubTree(subTree, node, nodes);
+    addUniqueEntry(node.childrenIds, subTreeNode.id);
+    nodes.set(subTreeNode.id, subTreeNode);
+  });
+  return node;
+};
+
+/**
+ * Build graph fetch tree data from an existing graph fetch tree root
+ */
+export const buildGraphFetchTreeData = (
+  tree: RootGraphFetchTree,
+): QueryBuilderGraphFetchTreeData => {
+  const rootIds: string[] = [];
+  const nodes = new Map<string, QueryBuilderGraphFetchTreeNodeData>();
+  tree.subTrees.forEach((subTree) => {
+    const subTreeNode = buildGraphFetchSubTree(subTree, undefined, nodes);
+    addUniqueEntry(rootIds, subTreeNode.id);
+    nodes.set(subTreeNode.id, subTreeNode);
+  });
+  return { rootIds, nodes, tree };
+};
+
+export const isGraphFetchTreeDataEmpty = (
+  treeData: QueryBuilderGraphFetchTreeData,
+): boolean => treeData.tree.subTrees.length === 0;
+
+const getPrunableNodes = (
+  treeData: QueryBuilderGraphFetchTreeData,
+): QueryBuilderGraphFetchTreeNodeData[] =>
+  Array.from(treeData.nodes.values()).filter(
+    (node) =>
+      // childless class nodes
+      (node.tree instanceof PropertyGraphFetchTree &&
+        node.type instanceof Class &&
+        node.childrenIds.length === 0) ||
+      // orphan node
+      (node.tree instanceof PropertyGraphFetchTree &&
+        !(node.type instanceof Class) &&
+        node.parentId &&
+        !treeData.nodes.has(node.parentId)),
+  );
+
+const removeNode = (
+  treeData: QueryBuilderGraphFetchTreeData,
+  node: QueryBuilderGraphFetchTreeNodeData,
+): void => {
+  const parentNode = node.parentId
+    ? treeData.nodes.get(node.parentId)
+    : undefined;
+  if (parentNode) {
+    deleteEntry(parentNode.childrenIds, node.id);
+    graphFetchTree_removeSubTree(parentNode.tree, node.tree);
+  } else {
+    deleteEntry(treeData.rootIds, node.id);
+    graphFetchTree_removeSubTree(treeData.tree, node.tree);
+  }
+  treeData.nodes.delete(node.id);
+};
+
+const pruneTreeData = (treeData: QueryBuilderGraphFetchTreeData): void => {
+  let prunableNodes = getPrunableNodes(treeData);
+  while (prunableNodes.length) {
+    prunableNodes.forEach((node) => {
+      removeNode(treeData, node);
+    });
+    prunableNodes = getPrunableNodes(treeData);
+  }
+};
+
+export const removeNodeRecursively = (
+  treeData: QueryBuilderGraphFetchTreeData,
+  node: QueryBuilderGraphFetchTreeNodeData,
+): void => {
+  removeNode(treeData, node);
+  pruneTreeData(treeData);
+};
+
+export const addQueryBuilderPropertyNode = (
+  treeData: QueryBuilderGraphFetchTreeData,
+  explorerTreeData: TreeData<QueryBuilderExplorerTreeNodeData>,
+  node: QueryBuilderExplorerTreePropertyNodeData,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  // traverse the property node all the way to the root and resolve the
+  // chain of property that leads to this property node
+  const propertyGraphFetchTrees: PropertyGraphFetchTree[] = [
+    new PropertyGraphFetchTree(
+      PropertyExplicitReference.create(node.property),
+      undefined,
+    ),
+  ];
+  let parentExplorerTreeNode = explorerTreeData.nodes.get(node.parentId);
+  while (
+    parentExplorerTreeNode instanceof
+      QueryBuilderExplorerTreePropertyNodeData ||
+    parentExplorerTreeNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
+  ) {
+    let subType = undefined;
+    let subtypeAssigned = false;
+    while (
+      parentExplorerTreeNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
+    ) {
+      if (!subtypeAssigned) {
+        subType = PackageableElementExplicitReference.create(
+          parentExplorerTreeNode.subclass,
+        );
+        subtypeAssigned = true;
+      }
+      parentExplorerTreeNode = explorerTreeData.nodes.get(
+        parentExplorerTreeNode.parentId,
+      );
+    }
+    if (
+      parentExplorerTreeNode instanceof QueryBuilderExplorerTreePropertyNodeData
+    ) {
+      const propertyGraphFetchTree = new PropertyGraphFetchTree(
+        PropertyExplicitReference.create(parentExplorerTreeNode.property),
+        subType,
+      );
+      propertyGraphFetchTree.subTrees.push(
+        propertyGraphFetchTrees[0] as PropertyGraphFetchTree,
+      );
+      propertyGraphFetchTrees.unshift(propertyGraphFetchTree);
+      parentExplorerTreeNode = explorerTreeData.nodes.get(
+        parentExplorerTreeNode.parentId,
+      );
+    } else {
+      queryBuilderState.applicationStore.notifyError(
+        `Can't cast the root class of graph fetch structure to its subtype`,
+      );
+      return;
+    }
+  }
+
+  // traverse the chain of property from the root class to find a node in the
+  // current graph fetch tree that matches any of this property, consider
+  // this the starting point
+  //
+  // If we found a match, use that as the starting point, otherwise, use the root
+  // of the graph fetch tree as the starting point
+  //
+  // NOTE: here we assume that we don't allow specifying duplicated nodes.
+  // perhaps we need to allow that behavior in the future so people can customize the
+  // shape of the object (e.g. same field but under different aliases)
+  let currentNodeId: string | undefined = undefined;
+  let parentNode: QueryBuilderGraphFetchTreeNodeData | undefined = undefined;
+  let newSubTree: PropertyGraphFetchTree | undefined;
+  for (const propertyGraphFetchTree of propertyGraphFetchTrees) {
+    currentNodeId = generateNodeId(
+      propertyGraphFetchTree.property.value,
+      propertyGraphFetchTree.subType?.value,
+      currentNodeId,
+    );
+    const existingGraphFetchNode = treeData.nodes.get(currentNodeId);
+    if (existingGraphFetchNode) {
+      parentNode = existingGraphFetchNode;
+    } else {
+      newSubTree = propertyGraphFetchTree;
+      break;
+    }
+  }
+
+  // construct the query builder graph fetch subtree from the starting point
+  if (newSubTree) {
+    const childNode = buildGraphFetchSubTree(
+      newSubTree,
+      parentNode,
+      treeData.nodes,
+    );
+    treeData.nodes.set(childNode.id, childNode);
+    if (parentNode) {
+      addUniqueEntry(parentNode.childrenIds, childNode.id);
+      graphFetchTree_addSubTree(parentNode.tree, childNode.tree);
+    } else {
+      addUniqueEntry(treeData.rootIds, childNode.id);
+      graphFetchTree_addSubTree(treeData.tree, childNode.tree);
+    }
+  }
+};