@finos/legend-application-query 5.2.6 → 6.0.0

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

@@ -1,34 +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 type { QueryBuilderState } from '../QueryBuilderState.js';
-import type { QueryBuilderFetchStructureState } from './QueryBuilderFetchStructureState.js';
-
-export abstract class QueryBuilderFetchStructureImplementationState {
-  queryBuilderState: QueryBuilderState;
-  fetchStructureState: QueryBuilderFetchStructureState;
-
-  constructor(
-    queryBuilderState: QueryBuilderState,
-    fetchStructureState: QueryBuilderFetchStructureState,
-  ) {
-    this.queryBuilderState = queryBuilderState;
-    this.fetchStructureState = fetchStructureState;
-  }
-
-  // abstract addProperty(node: QueryBuilderExplorerTreePropertyNodeData): void;
-  // abstract addChildrenProperties(node: QueryBuilderExplorerTreePropertyNodeData): void;
-}

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

@@ -1,173 +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 { 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/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeState.ts

@@ -1,100 +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 type { QueryBuilderState } from '../../QueryBuilderState.js';
-import { action, makeObservable, observable } from 'mobx';
-import {
-  PackageableElementExplicitReference,
-  RootGraphFetchTree,
-} from '@finos/legend-graph';
-import {
-  type QueryBuilderGraphFetchTreeData,
-  addQueryBuilderPropertyNode,
-  buildGraphFetchTreeData,
-} from './QueryBuilderGraphFetchTreeUtil.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 extends QueryBuilderFetchStructureImplementationState {
-  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,
-    fetchStructureState: QueryBuilderFetchStructureState,
-  ) {
-    super(queryBuilderState, fetchStructureState);
-
-    makeObservable(this, {
-      treeData: observable,
-      isChecked: observable,
-      setGraphFetchTree: action,
-      setChecked: action,
-    });
-  }
-
-  setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
-    this.treeData = val;
-  }
-
-  setChecked(val: boolean): void {
-    this.isChecked = val;
-  }
-
-  // TODO-BEFORE-PR: consider removing this
-  initialize(tree?: RootGraphFetchTree): void {
-    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) {
-      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/fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeUtil.ts

@@ -1,291 +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;
-}
-
-const generateNodeId = (
-  property: AbstractProperty,
-  parentNodeId: string | undefined,
-): string => `${parentNodeId ? `${parentNodeId}.` : ''}${property.name}`;
-
-const generateNodeIdForSubType = (
-  property: AbstractProperty,
-  subType: Type,
-  parentNodeId: string | undefined,
-): string =>
-  `${parentNodeId ? `${parentNodeId}.` : ''}${property.name}${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(
-    subType
-      ? generateNodeIdForSubType(property, subType, parentNodeId)
-      : generateNodeId(property, 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 = propertyGraphFetchTree.subType?.value
-      ? generateNodeIdForSubType(
-          propertyGraphFetchTree.property.value,
-          propertyGraphFetchTree.subType.value,
-          currentNodeId,
-        )
-      : generateNodeId(propertyGraphFetchTree.property.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);
-    }
-  }
-};

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

@@ -1,90 +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,
-} 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;
-};