@finos/legend-query-builder 0.0.1

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

@@ -0,0 +1,282 @@
+/**
+ * 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,
+  TYPE_CAST_TOKEN,
+} from '@finos/legend-graph';
+import {
+  type QueryBuilderExplorerTreeNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+  QueryBuilderExplorerTreeSubTypeNodeData,
+} from '../../explorer/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;
+}
+
+export const generateGraphFetchTreeNodeID = (
+  property: AbstractProperty,
+  parentNodeId: string | undefined,
+  subType: Type | undefined,
+): string =>
+  `${parentNodeId ? `${parentNodeId}.` : ''}${property.name}${
+    subType ? `${TYPE_CAST_TOKEN}${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(
+    generateGraphFetchTreeNodeID(property, parentNodeId, subType),
+    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 = generateGraphFetchTreeNodeID(
+      propertyGraphFetchTree.property.value,
+      currentNodeId,
+      propertyGraphFetchTree.subType?.value,
+    );
+    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);
+    }
+  }
+};

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

@@ -0,0 +1,154 @@
+/**
+ * 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,
+  RootGraphFetchTreeInstanceValue,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graphManager/QueryBuilderSupportedFunctions.js';
+import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import type { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
+import { isGraphFetchTreeDataEmpty } from './QueryBuilderGraphFetchTreeUtil.js';
+
+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 need to
+        // put it 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;
+};
+
+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,
+    );
+  }
+};