@finos/legend-application-query 6.0.0 → 7.0.0

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

@@ -1,282 +0,0 @@
-/**
- * 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/query-builder/fetch-structure/graph-fetch/QueryBuilderGraphFetchValueSpecificationBuilder.ts

@@ -1,154 +0,0 @@
-/**
- * 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,
-    );
-  }
-};