@finos/legend-query-builder 4.14.69 → 4.14.71

package/src/components/shared/QueryBuilderPropertyInfoTooltip.tsx

@@ -117,7 +117,7 @@ export const QueryBuilderTaggedValueInfoTooltip: React.FC<{
   );
 };
 
-const QueryBuilderBaseInfoTooltip: React.FC<{
+export const QueryBuilderBaseInfoTooltip: React.FC<{
   title: string;
   data: {
     label: string;
@@ -133,7 +133,10 @@ const QueryBuilderBaseInfoTooltip: React.FC<{
   const [open, setIsOpen] = useState(false);
 
   return (
-    <ClickAwayListener onClickAway={() => setIsOpen(false)}>
+    <ClickAwayListener
+      onClickAway={() => setIsOpen(false)}
+      mouseEvent="onMouseDown"
+    >
       <div>
         <Tooltip
           arrow={true}
@@ -172,7 +175,14 @@ const QueryBuilderBaseInfoTooltip: React.FC<{
             </div>
           }
         >
-          <div onClick={() => setIsOpen(true)}>{children}</div>
+          <div
+            onClick={(event: React.MouseEvent) => {
+              setIsOpen(!open);
+              event.stopPropagation();
+            }}
+          >
+            {children}
+          </div>
         </Tooltip>
       </div>
     </ClickAwayListener>

package/src/graph-manager/QueryBuilderConfig.ts

@@ -33,11 +33,17 @@ export class QueryBuilderConfig {
    */
   legendAIServiceURL = '';
 
+  /**
+   * This is the URL of the zipkin trace
+   */
+  zipkinTraceBaseURL = '';
+
   static readonly serialization = new SerializationFactory(
     createModelSchema(QueryBuilderConfig, {
       TEMPORARY__disableQueryBuilderChat: optional(primitive()),
       TEMPORARY__enableGridEnterpriseMode: optional(primitive()),
       legendAIServiceURL: optional(primitive()),
+      zipkinTraceBaseURL: optional(primitive()),
     }),
   );
 }

package/src/stores/QueryBuilderConstantsState.ts

@@ -288,6 +288,7 @@ export class QueryBuilderCalculatedConstantExpressionState
       variable: observable,
       lambdaState: observable,
       value: observable,
+      setLambdaState: action,
       setValue: action,
     });
     this.value = value;
@@ -298,6 +299,10 @@ export class QueryBuilderCalculatedConstantExpressionState
     );
   }
 
+  setLambdaState(val: QueryBuilderConstantLambdaEditorState): void {
+    this.lambdaState = val;
+  }
+
   setValue(val: PlainObject): void {
     this.value = val;
   }
@@ -393,8 +398,18 @@ export class QueryBuilderConstantsState implements Hashable {
 export const cloneQueryBuilderConstantLambdaEditorState = (
   state: QueryBuilderConstantLambdaEditorState,
 ): QueryBuilderConstantLambdaEditorState => {
+  const clonedCalculatedState =
+    new QueryBuilderCalculatedConstantExpressionState(
+      state.calculatedState.queryBuilderState,
+      new VariableExpression(
+        state.calculatedState.variable.name,
+        state.calculatedState.variable.multiplicity,
+        state.calculatedState.variable.genericType,
+      ),
+      deepClone(state.calculatedState.value),
+    );
   const clonedState = new QueryBuilderConstantLambdaEditorState(
-    deepClone(state.calculatedState),
+    clonedCalculatedState,
   );
   clonedState.lambdaString = state.lambdaString;
   clonedState.parserError = deepClone(state.parserError);

package/src/stores/QueryBuilderResultState.ts

@@ -17,10 +17,10 @@
 import { action, flow, makeObservable, observable } from 'mobx';
 import {
   type GeneratorFn,
+  type ContentType,
   assertErrorThrown,
   LogEvent,
   guaranteeNonNullable,
-  type ContentType,
   ActionState,
   StopWatch,
   getContentTypeFileExtension,
@@ -32,11 +32,13 @@ import {
   type RawLambda,
   type EXECUTION_SERIALIZATION_FORMAT,
   type QueryGridConfig,
+  type ExecutionResultWithMetadata,
   GRAPH_MANAGER_EVENT,
   buildRawLambdaFromLambdaFunction,
   reportGraphAnalytics,
+  TDSExecutionResult,
+  V1_ZIPKIN_TRACE_HEADER,
 } from '@finos/legend-graph';
-
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import {
   buildExecutionParameterValues,
@@ -49,6 +51,7 @@ import { ExecutionPlanState } from './execution-plan/ExecutionPlanState.js';
 import type { DataGridColumnState } from '@finos/legend-lego/data-grid';
 import { downloadStream } from '@finos/legend-application';
 import { QueryBuilderDataGridCustomAggregationFunction } from '../components/result/tds/QueryBuilderTDSGridResult.js';
+import { QueryBuilderTDSState } from './fetch-structure/tds/QueryBuilderTDSState.js';
 
 export const DEFAULT_LIMIT = 1000;
 
@@ -125,10 +128,13 @@ export class QueryBuilderResultState {
   isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
+  isExecutionResultOverflowing = false;
   executionDuration?: number | undefined;
+  executionTraceId?: string;
   latestRunHashCode?: string | undefined;
-  queryRunPromise: Promise<ExecutionResult> | undefined = undefined;
+  queryRunPromise: Promise<ExecutionResultWithMetadata> | undefined = undefined;
   isQueryUsageViewerOpened = false;
+  executionError: Error | string | undefined;
 
   selectedCells: QueryBuilderTDSResultCellData[];
   mousedOverCell: QueryBuilderTDSResultCellData | null = null;
@@ -140,6 +146,7 @@ export class QueryBuilderResultState {
   constructor(queryBuilderState: QueryBuilderState) {
     makeObservable(this, {
       executionResult: observable,
+      executionTraceId: observable,
       previewLimit: observable,
       executionDuration: observable,
       latestRunHashCode: observable,
@@ -150,13 +157,16 @@ export class QueryBuilderResultState {
       isRunningQuery: observable,
       isSelectingCells: observable,
       isQueryUsageViewerOpened: observable,
+      isExecutionResultOverflowing: observable,
       gridConfig: observable,
       wavgAggregationState: observable,
+      executionError: observable,
       setGridConfig: action,
       setWavgAggregationState: action,
       setIsSelectingCells: action,
       setIsRunningQuery: action,
       setExecutionResult: action,
+      setExecutionTraceId: action,
       setExecutionDuration: action,
       setPreviewLimit: action,
       addSelectedCell: action,
@@ -164,8 +174,10 @@ export class QueryBuilderResultState {
       setMouseOverCell: action,
       setQueryRunPromise: action,
       setIsQueryUsageViewerOpened: action,
+      setIsExecutionResultOverflowing: action,
       handlePreConfiguredGridConfig: action,
       updatePreviewLimitInConfig: action,
+      setExecutionError: action,
       exportData: flow,
       runQuery: flow,
       cancelQuery: flow,
@@ -204,6 +216,10 @@ export class QueryBuilderResultState {
     this.executionResult = val;
   }
 
+  setExecutionTraceId(val: string): void {
+    this.executionTraceId = val;
+  }
+
   setExecutionDuration(val: number | undefined): void {
     this.executionDuration = val;
   }
@@ -224,7 +240,9 @@ export class QueryBuilderResultState {
     this.mousedOverCell = val;
   }
 
-  setQueryRunPromise(promise: Promise<ExecutionResult> | undefined): void {
+  setQueryRunPromise(
+    promise: Promise<ExecutionResultWithMetadata> | undefined,
+  ): void {
     this.queryRunPromise = promise;
   }
 
@@ -232,12 +250,44 @@ export class QueryBuilderResultState {
     this.isQueryUsageViewerOpened = val;
   }
 
+  setExecutionError(val: Error | string | undefined): void {
+    this.executionError = val;
+  }
+
+  setIsExecutionResultOverflowing(val: boolean): void {
+    this.isExecutionResultOverflowing = val;
+  }
+
   updatePreviewLimitInConfig(): void {
     if (this.gridConfig) {
       this.gridConfig.previewLimit = this.previewLimit;
     }
   }
 
+  getExecutionResultLimit = (): number =>
+    Math.min(
+      this.queryBuilderState.fetchStructureState.implementation instanceof
+        QueryBuilderTDSState &&
+        this.queryBuilderState.fetchStructureState.implementation
+          .resultSetModifierState.limit
+        ? this.queryBuilderState.fetchStructureState.implementation
+            .resultSetModifierState.limit
+        : Number.MAX_SAFE_INTEGER,
+      this.previewLimit,
+    );
+
+  processExecutionResult = (result: ExecutionResult): void => {
+    this.setIsExecutionResultOverflowing(false);
+    if (result instanceof TDSExecutionResult) {
+      const resultLimit = this.getExecutionResultLimit();
+      if (result.result.rows.length > resultLimit) {
+        this.setIsExecutionResultOverflowing(true);
+        result.result.rows = result.result.rows.slice(0, resultLimit);
+      }
+    }
+    this.setExecutionResult(result);
+  };
+
   processWeightedColumnPairsMap(
     config: QueryGridConfig,
   ): Map<string, string> | undefined {
@@ -421,7 +471,9 @@ export class QueryBuilderResultState {
         this.queryBuilderState.executionContextState.runtimeValue,
         `Runtime is required to execute query`,
       );
-      const query = this.buildExecutionRawLambda();
+      const query = this.buildExecutionRawLambda({
+        withDataOverflowCheck: true,
+      });
       const parameterValues = buildExecutionParameterValues(
         this.queryBuilderState.parametersState.parameterStates,
         this.queryBuilderState.graphManagerState,
@@ -444,13 +496,17 @@ export class QueryBuilderResultState {
         {
           parameterValues,
           convertUnsafeNumbersToString: true,
+          preservedResponseHeadersList: [V1_ZIPKIN_TRACE_HEADER],
         },
       );
 
       this.setQueryRunPromise(promise);
-      const result = (yield promise) as ExecutionResult;
+      const result = (yield promise) as ExecutionResultWithMetadata;
       if (this.queryRunPromise === promise) {
-        this.setExecutionResult(result);
+        this.processExecutionResult(result.executionResult);
+        if (result.executionTraceId) {
+          this.setExecutionTraceId(result.executionTraceId);
+        }
         this.latestRunHashCode = currentHashCode;
         this.setExecutionDuration(stopWatch.elapsed);
 
@@ -479,9 +535,7 @@ export class QueryBuilderResultState {
           LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
           error,
         );
-        this.queryBuilderState.applicationStore.notificationService.notifyError(
-          error,
-        );
+        this.setExecutionError(error);
       }
     } finally {
       this.setIsRunningQuery(false);

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -210,4 +210,9 @@ export type LambdaFunctionBuilderOption = {
    * typed in engine. This is still an experimental feature, hence we should only enable this flag when user wants to enable this directly.
    */
   useTypedRelationFunctions?: boolean | undefined;
+
+  /**
+   * Set this flag to `true` when you want to execute a query that exceeds the limit to check for additional data in the database.
+   */
+  withDataOverflowCheck?: boolean | undefined;
 };

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -118,8 +118,10 @@ export abstract class QueryBuilderExplorerTreeNodeData implements TreeNodeData {
   ) {
     makeObservable(this, {
       isHighlighting: observable,
+      isOpen: observable,
       isSelected: observable,
       setIsHighlighting: action,
+      setIsOpen: action,
       setIsSelected: action,
     });
 
@@ -136,6 +138,10 @@ export abstract class QueryBuilderExplorerTreeNodeData implements TreeNodeData {
     this.isSelected = val;
   }
 
+  setIsOpen(val: boolean | undefined): void {
+    this.isOpen = val;
+  }
+
   setIsHighlighting(val: boolean | undefined): void {
     this.isHighlighting = val;
   }
@@ -761,21 +767,99 @@ export class QueryBuilderExplorerState {
     );
   }
 
-  highlightTreeNode(key: string): void {
-    const nodeToHighlight = this.treeData?.nodes.get(key);
-    if (nodeToHighlight instanceof QueryBuilderExplorerTreePropertyNodeData) {
+  generateOpenNodeChildren(node: QueryBuilderExplorerTreeNodeData): void {
+    if (
+      node.isOpen &&
+      (node instanceof QueryBuilderExplorerTreePropertyNodeData ||
+        node instanceof QueryBuilderExplorerTreeSubTypeNodeData) &&
+      node.type instanceof Class
+    ) {
+      (node instanceof QueryBuilderExplorerTreeSubTypeNodeData
+        ? getAllOwnClassProperties(node.type)
+        : getAllClassProperties(node.type).concat(
+            getAllClassDerivedProperties(node.type),
+          )
+      ).forEach((property) => {
+        const propertyTreeNodeData = getQueryBuilderPropertyNodeData(
+          property,
+          node,
+          guaranteeNonNullable(this.mappingModelCoverageAnalysisResult),
+        );
+        if (propertyTreeNodeData) {
+          this.nonNullableTreeData.nodes.set(
+            propertyTreeNodeData.id,
+            propertyTreeNodeData,
+          );
+        }
+      });
+      node.type._subclasses.forEach((subclass) => {
+        const subTypeTreeNodeData = getQueryBuilderSubTypeNodeData(
+          subclass,
+          node,
+          guaranteeNonNullable(this.mappingModelCoverageAnalysisResult),
+        );
+        this.nonNullableTreeData.nodes.set(
+          subTypeTreeNodeData.id,
+          subTypeTreeNodeData,
+        );
+      });
+      this.refreshTree();
+    }
+  }
+
+  highlightTreeNode(nodeId: string): void {
+    // If the node doesn't yet exist in the explorer tree,
+    // we need to open all the parent nodes of the node and
+    // generate their children.
+    if (this.nonNullableTreeData.nodes.get(nodeId) === undefined) {
+      const parentNodeIdElements: string[][] = nodeId
+        .split('@')
+        .map((subpath) => subpath.split('.'));
+      // remove last element of final subpath, as it is the node id and not a parent
+      if (
+        parentNodeIdElements.length > 0 &&
+        parentNodeIdElements[parentNodeIdElements.length - 1] !== undefined
+      ) {
+        parentNodeIdElements[parentNodeIdElements.length - 1]!.pop();
+      }
+
+      let currentNodeId = '';
+
+      parentNodeIdElements.forEach((subpath) => {
+        subpath.forEach((element, index) => {
+          currentNodeId += `${index > 0 ? '.' : ''}${element}`;
+          const currentNode = this.nonNullableTreeData.nodes.get(currentNodeId);
+          if (currentNode) {
+            currentNode.setIsOpen(true);
+            this.generateOpenNodeChildren(currentNode);
+          }
+        });
+        currentNodeId += '@';
+      });
+    }
+
+    // All parent nodes should be created now, so we can get the node to highlight.
+    const nodeToHighlight = this.nonNullableTreeData.nodes.get(nodeId);
+
+    // If we didn't need to open and create the parent nodes above, we will
+    // open the parent nodes here in case they are closed. Then, we will highlight
+    // and scroll to the node.
+    if (
+      nodeToHighlight instanceof QueryBuilderExplorerTreePropertyNodeData ||
+      nodeToHighlight instanceof QueryBuilderExplorerTreeSubTypeNodeData
+    ) {
       let nodeToOpen: QueryBuilderExplorerTreeNodeData | null =
-        this.treeData?.nodes.get(nodeToHighlight.parentId) ?? null;
+        this.nonNullableTreeData.nodes.get(nodeToHighlight.parentId) ?? null;
       while (nodeToOpen !== null) {
         if (!nodeToOpen.isOpen) {
-          nodeToOpen.isOpen = true;
+          nodeToOpen.setIsOpen(true);
         }
         nodeToOpen =
-          nodeToOpen instanceof QueryBuilderExplorerTreePropertyNodeData
-            ? (this.treeData?.nodes.get(nodeToOpen.parentId) ?? null)
+          nodeToOpen instanceof QueryBuilderExplorerTreePropertyNodeData ||
+          nodeToOpen instanceof QueryBuilderExplorerTreeSubTypeNodeData
+            ? (this.nonNullableTreeData.nodes.get(nodeToOpen.parentId) ?? null)
             : null;
       }
-      this.refreshTree();
       nodeToHighlight.setIsHighlighting(true);
       // scrollIntoView must be called in a setTimeout because it must happen after
       // the tree nodes are recursively opened and the tree is refreshed.

package/src/stores/explorer/QueryBuilderFuzzySearchAdvancedConfigState.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { FuzzySearchAdvancedConfigState } from '@finos/legend-shared';
+import { action, makeObservable, observable } from 'mobx';
+
+export class QueryBuilderFuzzySearchAdvancedConfigState extends FuzzySearchAdvancedConfigState {
+  includeSubTypes = false;
+  includeDocumentation = false;
+
+  constructor(
+    onSearchModeChange: () => Promise<void>,
+    onSearchModeChangeError: (error: Error) => void,
+  ) {
+    super(() => {
+      onSearchModeChange().catch(onSearchModeChangeError);
+    });
+    makeObservable(this, {
+      includeSubTypes: observable,
+      includeDocumentation: observable,
+      setIncludeSubTypes: action,
+      setIncludeDocumentation: action,
+    });
+  }
+
+  setIncludeSubTypes(val: boolean): void {
+    this.includeSubTypes = val;
+  }
+
+  setIncludeDocumentation(val: boolean): void {
+    this.includeDocumentation = val;
+  }
+}