@finos/legend-application-query 6.0.0 → 7.0.1

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

@@ -1,65 +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 {
-  Class,
-  CompilationError,
-  LambdaFunction,
-} from '@finos/legend-graph';
-import { computed, makeObservable } from 'mobx';
-import type { QueryBuilderExplorerTreePropertyNodeData } from '../explorer/QueryBuilderExplorerState.js';
-import type { QueryBuilderState } from '../QueryBuilderState.js';
-import type { LambdaFunctionBuilderOption } from '../QueryBuilderValueSpecificationBuilderHelper.js';
-import type { QueryBuilderFetchStructureState } from './QueryBuilderFetchStructureState.js';
-
-export enum FETCH_STRUCTURE_IMPLEMENTATION {
-  PROJECTION = 'PROJECTION',
-  GRAPH_FETCH = 'GRAPH_FETCH',
-}
-
-export abstract class QueryBuilderFetchStructureImplementationState {
-  queryBuilderState: QueryBuilderState;
-  fetchStructureState: QueryBuilderFetchStructureState;
-
-  constructor(
-    queryBuilderState: QueryBuilderState,
-    fetchStructureState: QueryBuilderFetchStructureState,
-  ) {
-    makeObservable(this, {
-      usedExplorerTreePropertyNodeIDs: computed,
-      validationIssues: computed,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-    this.fetchStructureState = fetchStructureState;
-  }
-
-  abstract get type(): string;
-  abstract get usedExplorerTreePropertyNodeIDs(): string[];
-  abstract get validationIssues(): string[] | undefined;
-  abstract onClassChange(_class: Class | undefined): void;
-  abstract revealCompilationError(compilationError: CompilationError): boolean;
-  abstract clearCompilationError(): void;
-  abstract fetchProperty(node: QueryBuilderExplorerTreePropertyNodeData): void;
-  abstract fetchProperties(
-    nodes: QueryBuilderExplorerTreePropertyNodeData[],
-  ): void;
-  abstract checkBeforeChangingImplementation(onChange: () => void): void;
-  abstract appendFetchStructure(
-    lambdaFunction: LambdaFunction,
-    options?: LambdaFunctionBuilderOption,
-  ): void;
-}

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

@@ -1,107 +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 {
-  type QueryBuilderExplorerTreeNodeData,
-  QueryBuilderExplorerTreePropertyNodeData,
-} from '../explorer/QueryBuilderExplorerState.js';
-import { Class } from '@finos/legend-graph';
-import { filterByType, UnsupportedOperationError } from '@finos/legend-shared';
-import {
-  FETCH_STRUCTURE_IMPLEMENTATION,
-  type QueryBuilderFetchStructureImplementationState,
-} from './QueryBuilderFetchStructureImplementationState.js';
-
-export class QueryBuilderFetchStructureState {
-  queryBuilderState: QueryBuilderState;
-  implementation: QueryBuilderFetchStructureImplementationState;
-
-  constructor(queryBuilderState: QueryBuilderState) {
-    makeAutoObservable(this, {
-      queryBuilderState: false,
-      changeImplementation: action,
-    });
-
-    this.queryBuilderState = queryBuilderState;
-    /**
-     * TODO?: if needed, we could make this configurable as part of QueryBuilderState
-     * Also, perhaps, some day it would even make sense to default to
-     * graph-fetch since `getAll()` naturally works for graph-fetch case
-     * and graph-fetch allows somewhat an empty tree
-     */
-    this.implementation = new QueryBuilderProjectionState(
-      this.queryBuilderState,
-      this,
-    );
-  }
-
-  changeImplementation(type: string): void {
-    switch (type) {
-      case FETCH_STRUCTURE_IMPLEMENTATION.PROJECTION: {
-        this.implementation = new QueryBuilderProjectionState(
-          this.queryBuilderState,
-          this,
-        );
-        return;
-      }
-      case FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH: {
-        this.implementation = new QueryBuilderGraphFetchTreeState(
-          this.queryBuilderState,
-          this,
-        );
-        return;
-      }
-      default:
-        throw new UnsupportedOperationError(
-          `Can't change fetch-structure implementation to unsupported type: '${type}'`,
-        );
-    }
-  }
-
-  fetchProperty(node: QueryBuilderExplorerTreeNodeData): void {
-    if (
-      node instanceof QueryBuilderExplorerTreePropertyNodeData &&
-      !(node.type instanceof Class)
-    ) {
-      this.implementation.fetchProperty(node);
-    }
-  }
-
-  fetchNodeChildrenProperties(node: QueryBuilderExplorerTreeNodeData): void {
-    if (node.type instanceof Class) {
-      this.implementation.fetchProperties(
-        // 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.
-        node.childrenIds
-          .map((childId) =>
-            this.queryBuilderState.explorerState.nonNullableTreeData.nodes.get(
-              childId,
-            ),
-          )
-          .filter(filterByType(QueryBuilderExplorerTreePropertyNodeData))
-          .filter(
-            (childNode) =>
-              !(childNode.type instanceof Class) &&
-              childNode.mappingData.mapped,
-          ),
-      );
-    }
-  }
-}

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

@@ -1,240 +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 {
-  type CompilationError,
-  PackageableElementExplicitReference,
-  RootGraphFetchTree,
-  type Class,
-  type LambdaFunction,
-  getAllSuperclasses,
-} from '@finos/legend-graph';
-import {
-  type QueryBuilderGraphFetchTreeData,
-  addQueryBuilderPropertyNode,
-  buildGraphFetchTreeData,
-} from './QueryBuilderGraphFetchTreeUtil.js';
-import {
-  generateExplorerTreePropertyNodeID,
-  generateExplorerTreeSubtypeNodeID,
-  type QueryBuilderExplorerTreePropertyNodeData,
-} from '../../explorer/QueryBuilderExplorerState.js';
-import {
-  FETCH_STRUCTURE_IMPLEMENTATION,
-  QueryBuilderFetchStructureImplementationState,
-} from '../QueryBuilderFetchStructureImplementationState.js';
-import type { QueryBuilderFetchStructureState } from '../QueryBuilderFetchStructureState.js';
-import {
-  ActionAlertActionType,
-  ActionAlertType,
-} from '@finos/legend-application';
-import type { LambdaFunctionBuilderOption } from '../../QueryBuilderValueSpecificationBuilderHelper.js';
-import { appendGraphFetch } from './QueryBuilderGraphFetchValueSpecificationBuilder.js';
-import { guaranteeNonNullable } from '@finos/legend-shared';
-
-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.ref,
-      isChecked: observable,
-      setGraphFetchTree: action,
-      setChecked: action,
-    });
-
-    // try to initialize the graph-fetch tree data using the setup class
-    this.updateTreeData(this.queryBuilderState.class);
-  }
-
-  get type(): string {
-    return FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH;
-  }
-
-  get usedExplorerTreePropertyNodeIDs(): string[] {
-    if (!this.treeData) {
-      return [];
-    }
-    const explorerTreeNodeIDIndex = new Map<string, string>();
-    const ids: string[] = [];
-
-    // traverse in breadth-first fashion
-    const nodesToProcess: string[] = this.treeData.rootIds.slice();
-    while (nodesToProcess.length) {
-      const currentNodeID = guaranteeNonNullable(nodesToProcess[0]);
-      const node = this.treeData.nodes.get(currentNodeID);
-      if (!node) {
-        continue;
-      }
-      let nodeID: string;
-      const parentNodeID = node.parentId
-        ? // since we traverse the nodes in order, parent node ID should already been computed
-          guaranteeNonNullable(explorerTreeNodeIDIndex.get(node.parentId))
-        : '';
-      const propertyNodeID = generateExplorerTreePropertyNodeID(
-        parentNodeID,
-        node.tree.property.value.name,
-      );
-      ids.push(propertyNodeID);
-      if (node.tree.subType) {
-        nodeID = generateExplorerTreeSubtypeNodeID(
-          propertyNodeID,
-          node.tree.subType.value.path,
-        );
-        getAllSuperclasses(node.tree.subType.value)
-          .concat(node.tree.subType.value)
-          .forEach((_class) =>
-            ids.push(
-              generateExplorerTreeSubtypeNodeID(propertyNodeID, _class.path),
-            ),
-          );
-      } else {
-        nodeID = propertyNodeID;
-      }
-      explorerTreeNodeIDIndex.set(node.id, nodeID);
-
-      // update list of nodes to process
-      nodesToProcess.shift();
-      node.childrenIds.forEach((childId) => nodesToProcess.push(childId));
-    }
-
-    // de-duplicate
-    return Array.from(new Set(ids).values());
-  }
-
-  get validationIssues(): string[] | undefined {
-    return undefined;
-  }
-
-  setGraphFetchTree(val: QueryBuilderGraphFetchTreeData | undefined): void {
-    this.treeData = val;
-  }
-
-  setChecked(val: boolean): void {
-    this.isChecked = val;
-  }
-
-  private updateTreeData(_class: Class | undefined): void {
-    this.setGraphFetchTree(
-      _class
-        ? buildGraphFetchTreeData(
-            new RootGraphFetchTree(
-              PackageableElementExplicitReference.create(_class),
-            ),
-          )
-        : undefined,
-    );
-  }
-
-  onClassChange(_class: Class | undefined): void {
-    this.updateTreeData(_class);
-  }
-
-  appendFetchStructure(
-    lambdaFunction: LambdaFunction,
-    options?: LambdaFunctionBuilderOption,
-  ): void {
-    appendGraphFetch(this, lambdaFunction, options);
-  }
-
-  addProperty(
-    node: QueryBuilderExplorerTreePropertyNodeData,
-    options?: {
-      refreshTreeData?: boolean;
-    },
-  ): void {
-    if (!this.treeData) {
-      this.queryBuilderState.applicationStore.notifyWarning(
-        `Can't add property: graph-fetch tree has not been properly initialized`,
-      );
-      return;
-    }
-    addQueryBuilderPropertyNode(
-      this.treeData,
-      this.queryBuilderState.explorerState.nonNullableTreeData,
-      node,
-      this.queryBuilderState,
-    );
-    if (options?.refreshTreeData) {
-      this.setGraphFetchTree({ ...this.treeData });
-    }
-  }
-
-  revealCompilationError(compilationError: CompilationError): boolean {
-    return false;
-  }
-
-  clearCompilationError(): void {
-    return;
-  }
-
-  fetchProperty(node: QueryBuilderExplorerTreePropertyNodeData): void {
-    this.addProperty(node, { refreshTreeData: true });
-  }
-
-  fetchProperties(nodes: QueryBuilderExplorerTreePropertyNodeData[]): void {
-    if (!this.treeData) {
-      this.queryBuilderState.applicationStore.notifyWarning(
-        `Can't add property: graph-fetch tree has not been properly initialized`,
-      );
-      return;
-    }
-    nodes.forEach((nodeToAdd) => this.addProperty(nodeToAdd));
-    this.setGraphFetchTree({
-      ...this.treeData,
-    });
-  }
-
-  checkBeforeChangingImplementation(onChange: () => void): void {
-    if (this.treeData?.rootIds.length) {
-      this.queryBuilderState.applicationStore.setActionAlertInfo({
-        message:
-          'Current graph-fetch will be lost when switching to projection mode. Do you still want to proceed?',
-        type: ActionAlertType.CAUTION,
-        actions: [
-          {
-            label: 'Proceed',
-            type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-            handler:
-              this.queryBuilderState.applicationStore.guardUnhandledError(
-                async () => onChange(),
-              ),
-          },
-          {
-            label: 'Cancel',
-            type: ActionAlertActionType.PROCEED,
-            default: true,
-          },
-        ],
-      });
-    } else {
-      onChange();
-    }
-  }
-}

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

@@ -1,131 +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 {
-  GraphFetchTreeInstanceValue,
-  matchFunctionName,
-  RootGraphFetchTree,
-  SimpleFunctionExpression,
-} from '@finos/legend-graph';
-import { assertTrue, guaranteeType } from '@finos/legend-shared';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../../graphManager/QueryBuilderSupportedFunctions.js';
-import type { QueryBuilderState } from '../../QueryBuilderState.js';
-import { QueryBuilderValueSpecificationProcessor } from '../../QueryBuilderStateBuilder.js';
-import { FETCH_STRUCTURE_IMPLEMENTATION } from '../QueryBuilderFetchStructureImplementationState.js';
-import { QueryBuilderGraphFetchTreeState } from './QueryBuilderGraphFetchTreeState.js';
-import { buildGraphFetchTreeData } from './QueryBuilderGraphFetchTreeUtil.js';
-
-export const processGraphFetchExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  const functionName = expression.functionName;
-
-  // check parameters
-  assertTrue(
-    expression.parametersValues.length === 2,
-    `Can't process ${functionName}() expression: ${functionName}() expects 1 argument`,
-  );
-
-  // check preceding expression
-  const precedingExpression = guaranteeType(
-    expression.parametersValues[0],
-    SimpleFunctionExpression,
-    `Can't process ${functionName}() expression: only support ${functionName}() immediately following an expression`,
-  );
-  assertTrue(
-    matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL,
-    ]),
-    `Can't process ${functionName}(): only support ${functionName}() immediately following either getAll() or filter()`,
-  );
-  QueryBuilderValueSpecificationProcessor.process(
-    precedingExpression,
-    queryBuilderState,
-  );
-
-  // build state
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderGraphFetchTreeState
-  ) {
-    const graphFetchTreeState =
-      queryBuilderState.fetchStructureState.implementation;
-    graphFetchTreeState.setChecked(
-      matchFunctionName(
-        expression.functionName,
-        QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
-      ),
-    );
-  }
-};
-
-export const processGraphFetchSerializeExpression = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-): void => {
-  // update fetch-structure
-  queryBuilderState.fetchStructureState.changeImplementation(
-    FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH,
-  );
-
-  // check parameters
-  assertTrue(
-    expression.parametersValues.length === 2,
-    `Can't process serialize() expression: serialize() expects 1 argument`,
-  );
-
-  // check preceding expression
-  const precedingExpression = guaranteeType(
-    expression.parametersValues[0],
-    SimpleFunctionExpression,
-    `Can't process serialize() expression: only support serialize() immediately following an expression`,
-  );
-  assertTrue(
-    matchFunctionName(precedingExpression.functionName, [
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
-      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
-    ]),
-    `Can't process serialize() expression: only support serialize() in graph-fetch expression`,
-  );
-  QueryBuilderValueSpecificationProcessor.process(
-    precedingExpression,
-    queryBuilderState,
-  );
-
-  // build state
-  if (
-    queryBuilderState.fetchStructureState.implementation instanceof
-    QueryBuilderGraphFetchTreeState
-  ) {
-    const graphFetchTreeState =
-      queryBuilderState.fetchStructureState.implementation;
-    const graphFetchTree = guaranteeType(
-      expression.parametersValues[1],
-      GraphFetchTreeInstanceValue,
-      `Can't process serialize() expression: serialize() graph-fetch is missing`,
-    );
-    const graphFetchTreeRoot = guaranteeType(
-      graphFetchTree.values[0],
-      RootGraphFetchTree,
-      `Can't process serialize() expression: serialize() graph-fetch tree root is missing`,
-    );
-    graphFetchTreeState.setGraphFetchTree(
-      buildGraphFetchTreeData(graphFetchTreeRoot),
-    );
-  }
-};