@finos/legend-query-builder 4.2.3 → 4.3.0

package/src/stores/QueryBuilderState.ts

@@ -51,6 +51,8 @@ import {
   type Mapping,
   type Runtime,
   type GraphManagerState,
+  type ValueSpecification,
+  type Type,
   GRAPH_MANAGER_EVENT,
   CompilationError,
   extractSourceInformationCoordinates,
@@ -62,9 +64,7 @@ import {
   isStubbed_RawLambda,
   buildLambdaVariableExpressions,
   buildRawLambdaFromLambdaFunction,
-  type ValueSpecification,
   PrimitiveType,
-  type Type,
   SimpleFunctionExpression,
   extractElementNameFromPath,
   SUPPORTED_FUNCTIONS,
@@ -94,6 +94,11 @@ import { QueryBuilderConstantsState } from './QueryBuilderConstantsState.js';
 import { QueryBuilderCheckEntitlementsState } from './entitlements/QueryBuilderCheckEntitlementsState.js';
 import { QueryBuilderTDSState } from './fetch-structure/tds/QueryBuilderTDSState.js';
 import { QUERY_BUILDER_PURE_PATH } from '../graph/QueryBuilderMetaModelConst.js';
+import type { QueryBuilderInternalizeState } from './QueryBuilderInternalizeState.js';
+import {
+  QueryBuilderExternalExecutionContextState,
+  type QueryBuilderExecutionContextState,
+} from './QueryBuilderExecutionContextState.js';
 
 export abstract class QueryBuilderState implements CommandRegistrar {
   readonly applicationStore: GenericLegendApplicationStore;
@@ -125,8 +130,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   isQueryChatOpened = false;
 
   class?: Class | undefined;
-  mapping?: Mapping | undefined;
-  runtimeValue?: Runtime | undefined;
+  executionContextState: QueryBuilderExecutionContextState;
+  internalizeState?: QueryBuilderInternalizeState | undefined;
 
   // NOTE: this makes it so that we need to import components in stores code,
   // we probably want to refactor to an extension mechanism
@@ -154,9 +159,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       isCheckingEntitlments: observable,
       isCalendarEnabled: observable,
       changeDetectionState: observable,
+      executionContextState: observable,
       class: observable,
-      mapping: observable,
-      runtimeValue: observable,
       isQueryChatOpened: observable,
 
       sideBarClassName: computed,
@@ -169,14 +173,13 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setIsCalendarEnabled: action,
       setIsCheckingEntitlments: action,
       setClass: action,
-      setMapping: action,
-      setRuntimeValue: action,
       setIsQueryChatOpened: action,
 
       resetQueryResult: action,
       resetQueryContent: action,
       changeClass: action,
       changeMapping: action,
+      setExecutionContextState: action,
 
       rebuildWithQuery: action,
       compileQuery: flow,
@@ -185,7 +188,9 @@ export abstract class QueryBuilderState implements CommandRegistrar {
 
     this.applicationStore = applicationStore;
     this.graphManagerState = graphManagerState;
-
+    this.executionContextState = new QueryBuilderExternalExecutionContextState(
+      this,
+    );
     this.milestoningState = new QueryBuilderMilestoningState(this);
     this.explorerState = new QueryBuilderExplorerState(this);
     this.parametersState = new QueryBuilderParametersState(this);
@@ -250,6 +255,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.isQueryChatOpened = val;
   }
 
+  setInternalize(val: QueryBuilderInternalizeState | undefined): void {
+    this.internalizeState = val;
+  }
+
   setShowFunctionsExplorerPanel(val: boolean): void {
     this.showFunctionsExplorerPanel = val;
   }
@@ -274,12 +283,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.class = val;
   }
 
-  setMapping(val: Mapping | undefined): void {
-    this.mapping = val;
-  }
-
-  setRuntimeValue(val: Runtime | undefined): void {
-    this.runtimeValue = val;
+  setExecutionContextState(val: QueryBuilderExecutionContextState): void {
+    this.executionContextState = val;
   }
 
   get isQuerySupported(): boolean {
@@ -373,12 +378,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.resetQueryContent();
       this.milestoningState.updateMilestoningConfiguration();
     }
-    this.setMapping(val);
+    this.executionContextState.setMapping(val);
   }
 
   changeRuntime(val: Runtime): void {
     this.resetQueryResult();
-    this.setRuntimeValue(val);
+    this.executionContextState.setRuntimeValue(val);
   }
 
   getCurrentParameterValues(): Map<string, ValueSpecification> | undefined {
@@ -421,11 +426,11 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       'Query must be supported to build from function',
     );
     const mapping = guaranteeNonNullable(
-      this.mapping,
+      this.executionContextState.mapping,
       'Mapping required to build from() function',
     );
     const runtime = guaranteeNonNullable(
-      this.runtimeValue,
+      this.executionContextState.runtimeValue,
       'Runtime required to build from query',
     );
     const runtimePointer = guaranteeType(
@@ -666,8 +671,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.graphManagerState,
     );
     basicState.class = this.class;
-    basicState.mapping = this.mapping;
-    basicState.runtimeValue = this.runtimeValue;
+    basicState.executionContextState.mapping =
+      this.executionContextState.mapping;
+    basicState.executionContextState.runtimeValue =
+      this.executionContextState.runtimeValue;
     return basicState;
   }
 

package/src/stores/QueryBuilderStateBuilder.ts

@@ -30,7 +30,7 @@ import {
   type FunctionExpression,
   type GraphFetchTreeInstanceValue,
   type ValueSpecificationVisitor,
-  type InstanceValue,
+  InstanceValue,
   type INTERNAL__UnknownValueSpecification,
   type LambdaFunction,
   type KeyExpressionInstanceValue,
@@ -47,6 +47,11 @@ import {
   type ValueSpecification,
   SUPPORTED_FUNCTIONS,
   isSuperType,
+  PackageableElementReference,
+  Mapping,
+  PackageableRuntime,
+  RuntimePointer,
+  PackageableElementExplicitReference,
 } from '@finos/legend-graph';
 import { processTDSPostFilterExpression } from './fetch-structure/tds/post-filter/QueryBuilderPostFilterStateBuilder.js';
 import { processFilterExpression } from './filter/QueryBuilderFilterStateBuilder.js';
@@ -58,6 +63,7 @@ import {
   processGraphFetchExpression,
   processGraphFetchExternalizeExpression,
   processGraphFetchSerializeExpression,
+  processInternalizeExpression,
 } from './fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.js';
 import {
   processTDSDistinctExpression,
@@ -78,6 +84,7 @@ import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkSta
 import { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
 import { checkIfEquivalent } from './milestoning/QueryBuilderMilestoningHelper.js';
 import type { QueryBuilderParameterValue } from './QueryBuilderParametersState.js';
+import { QueryBuilderEmbeddedFromExecutionContextState } from './QueryBuilderExecutionContextState.js';
 
 const processGetAllExpression = (
   expression: SimpleFunctionExpression,
@@ -146,6 +153,51 @@ const processLetExpression = (
   queryBuilderState.constantState.addConstant(constantExpression);
 };
 
+const processFromFunction = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+): void => {
+  // mapping
+  const mappingInstanceExpression = guaranteeType(
+    expression.parametersValues[1],
+    InstanceValue,
+    `Can't process from() expression: only support from() with 1st parameter as instance value`,
+  );
+  const mapping = guaranteeType(
+    guaranteeType(
+      mappingInstanceExpression.values[0],
+      PackageableElementReference,
+      `Can't process from() expression: only support from() with 1st parameter as packagableElement value`,
+    ).value,
+    Mapping,
+    `Can't process from() expression: only support from() with 1st parameter as mapping value`,
+  );
+  // runtime
+  const runtimeInstanceExpression = guaranteeType(
+    expression.parametersValues[2],
+    InstanceValue,
+    `Can't process from() expression: only support from() with 2nd parameter as instance value`,
+  );
+  const runtimeVal = guaranteeType(
+    guaranteeType(
+      runtimeInstanceExpression.values[0],
+      PackageableElementReference,
+      `Can't process from() expression: only support from() with 2nd parameter as packagableElement value`,
+    ).value,
+    PackageableRuntime,
+    `Can't process from() expression: only support from() with 2nd parameter as runtime value`,
+  );
+  const fromContext = new QueryBuilderEmbeddedFromExecutionContextState(
+    queryBuilderState,
+  );
+  fromContext.setMapping(mapping);
+  fromContext.setRuntimeValue(
+    new RuntimePointer(PackageableElementExplicitReference.create(runtimeVal)),
+  );
+  queryBuilderState.setExecutionContextState(fromContext);
+  return;
+};
+
 /**
  * This is the value specification processor (a.k.a state builder) for query builder.
  *
@@ -321,6 +373,18 @@ export class QueryBuilderValueSpecificationProcessor
     ) {
       processGetAllExpression(valueSpecification, this.queryBuilderState);
       return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.INTERNALIZE,
+      )
+    ) {
+      processInternalizeExpression(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
+      return;
     } else if (
       matchFunctionName(functionName, [
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.FILTER,
@@ -545,6 +609,20 @@ export class QueryBuilderValueSpecificationProcessor
         this.parentLambda,
       );
       return;
+    } else if (matchFunctionName(functionName, [SUPPORTED_FUNCTIONS.FROM])) {
+      const parameters = valueSpecification.parametersValues;
+      assertTrue(
+        parameters.length === 3,
+        'From function expects 2 parameters (mapping and runtime)',
+      );
+      processFromFunction(valueSpecification, this.queryBuilderState);
+      QueryBuilderValueSpecificationProcessor.processChild(
+        guaranteeNonNullable(parameters[0]),
+        valueSpecification,
+        this.parentLambda,
+        this.queryBuilderState,
+      );
+      return;
     } else if (
       matchFunctionName(
         functionName,

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import { guaranteeNonNullable, guaranteeType } from '@finos/legend-shared';
 import {
   type Class,
   Multiplicity,
@@ -31,6 +31,7 @@ import {
   PrimitiveInstanceValue,
   PrimitiveType,
   SUPPORTED_FUNCTIONS,
+  RuntimePointer,
 } from '@finos/legend-graph';
 import type { QueryBuilderState } from './QueryBuilderState.js';
 import { buildFilterExpression } from './filter/QueryBuilderFilterValueSpecificationBuilder.js';
@@ -40,6 +41,10 @@ import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaMode
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
 import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
 import type { QueryBuilderConstantExpressionState } from './QueryBuilderConstantsState.js';
+import {
+  QueryBuilderEmbeddedFromExecutionContextState,
+  type QueryBuilderExecutionContextState,
+} from './QueryBuilderExecutionContextState.js';
 
 export const buildGetAllFunction = (
   _class: Class,
@@ -91,6 +96,45 @@ const buildLetExpression = (
   return letFunc;
 };
 
+const buildExecutionContextState = (
+  executionState: QueryBuilderExecutionContextState,
+  lambdaFunction: LambdaFunction,
+): LambdaFunction => {
+  if (executionState instanceof QueryBuilderEmbeddedFromExecutionContextState) {
+    const precedingExpression = guaranteeNonNullable(
+      lambdaFunction.expressionSequence[0],
+      `Can't build from() expression: preceding expression is not defined`,
+    );
+    const fromFunc = new SimpleFunctionExpression(
+      extractElementNameFromPath(SUPPORTED_FUNCTIONS.FROM),
+    );
+    // 1st param
+    const mapping = guaranteeNonNullable(
+      executionState.mapping,
+      'Mapping required for building from() expression',
+    );
+    const mappingInstance = new InstanceValue(Multiplicity.ONE, undefined);
+    mappingInstance.values = [
+      PackageableElementExplicitReference.create(mapping),
+    ];
+    // 2nd parameter
+    const runtime = guaranteeType(
+      executionState.runtimeValue,
+      RuntimePointer,
+      'Runtime Pointer required for building from() expression',
+    );
+    const runtimeInstance = new InstanceValue(Multiplicity.ONE, undefined);
+    runtimeInstance.values = [runtime.packageableRuntime];
+    fromFunc.parametersValues = [
+      precedingExpression,
+      mappingInstance,
+      runtimeInstance,
+    ];
+    lambdaFunction.expressionSequence[0] = fromFunc;
+  }
+  return lambdaFunction;
+};
+
 const buildFetchStructure = (
   fetchStructureState: QueryBuilderFetchStructureState,
   lambdaFunction: LambdaFunction,
@@ -157,6 +201,11 @@ export const buildLambdaFunction = (
     lambdaFunction,
     options,
   );
+  // build execution-state
+  buildExecutionContextState(
+    queryBuilderState.executionContextState,
+    lambdaFunction,
+  );
 
   // build variable expressions
   if (queryBuilderState.constantState.constants.length) {

package/src/stores/__test-utils__/QueryBuilderStateTestUtils.ts

@@ -138,9 +138,11 @@ export const TEST__setUpQueryBuilderState = async (
   if (executionContext) {
     const graph = queryBuilderState.graphManagerState.graph;
     queryBuilderState.class = graph.getClass(executionContext._class);
-    queryBuilderState.mapping = graph.getMapping(executionContext.mapping);
+    queryBuilderState.executionContextState.mapping = graph.getMapping(
+      executionContext.mapping,
+    );
     if (executionContext.runtime) {
-      queryBuilderState.runtimeValue = graph.getRuntime(
+      queryBuilderState.executionContextState.runtimeValue = graph.getRuntime(
         executionContext.runtime,
       );
     }

package/src/stores/entitlements/QueryBuilderCheckEntitlementsState.ts

@@ -53,16 +53,18 @@ export class QueryBuilderCheckEntitlementsState implements Hashable {
 
     this.dataAccessState = undefined;
     if (
-      this.queryBuilderState.mapping &&
-      this.queryBuilderState.runtimeValue instanceof RuntimePointer
+      this.queryBuilderState.executionContextState.mapping &&
+      this.queryBuilderState.executionContextState.runtimeValue instanceof
+        RuntimePointer
     ) {
       this.dataAccessState = new DataAccessState(
         this.queryBuilderState.applicationStore,
         this.queryBuilderState.graphManagerState,
         {
-          mapping: this.queryBuilderState.mapping.path,
+          mapping: this.queryBuilderState.executionContextState.mapping.path,
           runtime:
-            this.queryBuilderState.runtimeValue.packageableRuntime.value.path,
+            this.queryBuilderState.executionContextState.runtimeValue
+              .packageableRuntime.value.path,
           getQuery: async () =>
             this.createExecutableQuery(
               this.queryBuilderState.buildQuery(),

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -660,7 +660,7 @@ export class QueryBuilderExplorerState {
 
   refreshTreeData(): void {
     const _class = this.queryBuilderState.class;
-    const _mapping = this.queryBuilderState.mapping;
+    const _mapping = this.queryBuilderState.executionContextState.mapping;
     this.setTreeData(
       _class && _mapping && this.mappingModelCoverageAnalysisResult
         ? getQueryBuilderTreeData(
@@ -675,9 +675,9 @@ export class QueryBuilderExplorerState {
     // We will only refetch if the analysis result's mapping has changed.
     // This makes the assumption that the mapping has not been edited, which is a valid assumption since query is not for editing mappings
     if (
-      this.queryBuilderState.mapping &&
-      this.queryBuilderState.mapping.path !==
-        this.mappingModelCoverageAnalysisResult?.mapping.path
+      this.queryBuilderState.executionContextState.mapping &&
+      this.queryBuilderState.executionContextState.mapping !==
+        this.mappingModelCoverageAnalysisResult?.mapping
     ) {
       this.mappingModelCoverageAnalysisState.inProgress();
       QueryBuilderTelemetryHelper.logEvent_QueryMappingModelCoverageAnalysisLaunched(
@@ -692,7 +692,7 @@ export class QueryBuilderExplorerState {
       try {
         this.mappingModelCoverageAnalysisResult = (yield flowResult(
           this.queryBuilderState.graphManagerState.graphManager.analyzeMappingModelCoverage(
-            this.queryBuilderState.mapping,
+            this.queryBuilderState.executionContextState.mapping,
             this.queryBuilderState.graphManagerState.graph,
           ),
         )) as MappingModelCoverageAnalysisResult;
@@ -720,7 +720,7 @@ export class QueryBuilderExplorerState {
   *previewData(
     node: QueryBuilderExplorerTreePropertyNodeData,
   ): GeneratorFn<void> {
-    const runtime = this.queryBuilderState.runtimeValue;
+    const runtime = this.queryBuilderState.executionContextState.runtimeValue;
     if (!runtime) {
       this.queryBuilderState.applicationStore.notificationService.notifyWarning(
         `Can't preview data for property '${node.property.name}': runtime is not specified`,
@@ -730,7 +730,7 @@ export class QueryBuilderExplorerState {
     if (
       !node.mappingData.mapped ||
       !this.queryBuilderState.class ||
-      !this.queryBuilderState.mapping
+      !this.queryBuilderState.executionContextState.mapping
     ) {
       return;
     }
@@ -759,7 +759,7 @@ export class QueryBuilderExplorerState {
                 this.queryBuilderState,
                 propertyExpression,
               ),
-              this.queryBuilderState.mapping,
+              this.queryBuilderState.executionContextState.mapping,
               runtime,
               this.queryBuilderState.graphManagerState.graph,
             )) as ExecutionResult;
@@ -796,7 +796,7 @@ export class QueryBuilderExplorerState {
                 this.queryBuilderState,
                 propertyExpression,
               ),
-              this.queryBuilderState.mapping,
+              this.queryBuilderState.executionContextState.mapping,
               runtime,
               this.queryBuilderState.graphManagerState.graph,
             )) as ExecutionResult;

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

@@ -32,11 +32,13 @@ import {
   CollectionInstanceValue,
   getClassProperty,
   PrimitiveType,
+  VariableExpression,
 } from '@finos/legend-graph';
 import {
   assertIsBoolean,
   assertIsString,
   assertTrue,
+  assertType,
   guaranteeIsString,
   guaranteeNonNullable,
   guaranteeType,
@@ -45,7 +47,7 @@ import {
   QUERY_BUILDER_PURE_PATH,
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
 } from '../../../graph/QueryBuilderMetaModelConst.js';
-import type { QueryBuilderState } from '../../QueryBuilderState.js';
+import { type QueryBuilderState } from '../../QueryBuilderState.js';
 import { QueryBuilderValueSpecificationProcessor } from '../../QueryBuilderStateBuilder.js';
 import { FETCH_STRUCTURE_IMPLEMENTATION } from '../QueryBuilderFetchStructureImplementationState.js';
 import {
@@ -56,6 +58,7 @@ import {
 } from './QueryBuilderGraphFetchTreeState.js';
 import { buildGraphFetchTreeData } from './QueryBuilderGraphFetchTreeUtil.js';
 import {} from 'mobx';
+import { QueryBuilderInternalizeState } from '../../QueryBuilderInternalizeState.js';
 
 export const processGraphFetchExpression = (
   expression: SimpleFunctionExpression,
@@ -105,6 +108,65 @@ export const processGraphFetchExpression = (
   }
 };
 
+export const processInternalizeExpression = (
+  expression: SimpleFunctionExpression,
+  queryBuilderState: QueryBuilderState,
+  parentLambda: LambdaFunction,
+): void => {
+  // update fetch-structure
+  queryBuilderState.fetchStructureState.changeImplementation(
+    FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH,
+  );
+  const functionName = expression.functionName;
+  // check parameters
+  assertTrue(
+    expression.parametersValues.length === 3,
+    `Can't process ${functionName}() expression: ${functionName}() expects 2 argument`,
+  );
+
+  // first param classs
+  const classVal = expression.parametersValues[0];
+  const _class = classVal?.genericType?.value.rawType;
+  assertType(
+    _class,
+    Class,
+    `Can't process internalize() expression: internalize() return type is missing`,
+  );
+
+  queryBuilderState.setClass(_class);
+  queryBuilderState.milestoningState.clearMilestoningDates();
+  queryBuilderState.explorerState.refreshTreeData();
+
+  // binding
+  const instanceExpression = guaranteeType(
+    expression.parametersValues[1],
+    InstanceValue,
+    `Can't process internalize() expression: only support internalize() with 1st parameter as instance value`,
+  );
+  const binding = guaranteeType(
+    guaranteeType(
+      instanceExpression.values[0],
+      PackageableElementReference,
+      `Can't process internalize() expression: only support internalize() with 1st parameter as packagableElement value`,
+    ).value,
+    Binding,
+    `Can't process internalize() expression: only support internalize() with 1st parameter as binding value`,
+  );
+
+  const variableExpression = guaranteeType(
+    expression.parametersValues[2],
+    VariableExpression,
+  );
+
+  const inernalize = new QueryBuilderInternalizeState(
+    binding,
+    variableExpression,
+    queryBuilderState,
+  );
+
+  queryBuilderState.setInternalize(inernalize);
+};
+
 type PropertyValue = object | string | number | boolean;
 
 // Dynamically sets key values of config
@@ -327,6 +389,7 @@ export const processGraphFetchExternalizeExpression = (
     matchFunctionName(precedingExpression.functionName, [
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH,
       QUERY_BUILDER_SUPPORTED_FUNCTIONS.GRAPH_FETCH_CHECKED,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.INTERNALIZE,
     ]),
     `Can't process externalize() expression: only support externalize() in graph-fetch expression`,
   );
@@ -373,7 +436,6 @@ export const processGraphFetchExternalizeExpression = (
       Binding,
       `Can't process externalize() expression: only support externalize() with 1st parameter as binding value`,
     );
-
     const externalizeState = new GraphFetchExternalFormatSerializationState(
       graphFetchTreeState,
       binding,

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -452,7 +452,7 @@ export class QueryBuilderTDSState
       new QueryBuilderDerivationProjectionColumnState(
         this,
         guaranteeType(
-          this.queryBuilderState.graphManagerState.graphManager.buildRawValueSpecification(
+          this.queryBuilderState.graphManagerState.graphManager.transformValueSpecToRawValueSpec(
             columnColumnLambda,
             this.queryBuilderState.graphManagerState.graph,
           ),

package/src/stores/fetch-structure/tds/post-filter/QueryBuilderPostFilterState.ts

@@ -380,10 +380,12 @@ export class PostFilterConditionState implements Hashable {
               this.value,
             ),
             guaranteeNonNullable(
-              this.postFilterState.tdsState.queryBuilderState.mapping,
+              this.postFilterState.tdsState.queryBuilderState
+                .executionContextState.mapping,
             ),
             guaranteeNonNullable(
-              this.postFilterState.tdsState.queryBuilderState.runtimeValue,
+              this.postFilterState.tdsState.queryBuilderState
+                .executionContextState.runtimeValue,
             ),
             this.postFilterState.tdsState.queryBuilderState.graphManagerState
               .graph,

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -134,9 +134,12 @@ export class FilterConditionState implements Hashable {
               this.propertyExpressionState.propertyExpression,
               this.value,
             ),
-            guaranteeNonNullable(this.filterState.queryBuilderState.mapping),
             guaranteeNonNullable(
-              this.filterState.queryBuilderState.runtimeValue,
+              this.filterState.queryBuilderState.executionContextState.mapping,
+            ),
+            guaranteeNonNullable(
+              this.filterState.queryBuilderState.executionContextState
+                .runtimeValue,
             ),
             this.filterState.queryBuilderState.graphManagerState.graph,
           )) as ExecutionResult;

package/src/stores/workflows/ClassQueryBuilderState.ts

@@ -44,7 +44,8 @@ export class ClassQueryBuilderState extends QueryBuilderState {
     );
     // cascading
     const isCurrentMappingCompatible =
-      this.mapping && compatibleMappings.includes(this.mapping);
+      this.executionContextState.mapping &&
+      compatibleMappings.includes(this.executionContextState.mapping);
     if (this.isMappingReadOnly || isCurrentMappingCompatible) {
       return;
     }

package/src/stores/workflows/FunctionQueryBuilderState.ts

@@ -0,0 +1,38 @@
+/**
+ * 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 { GenericLegendApplicationStore } from '@finos/legend-application';
+import type {
+  ConcreteFunctionDefinition,
+  GraphManagerState,
+} from '@finos/legend-graph';
+import { ClassQueryBuilderState } from './ClassQueryBuilderState.js';
+
+// Note: We may want to move it to extend QueryBuilderState directly
+// but for now we will use the same setup as class as class, mapping, runtime are editable
+export class FunctionQueryBuilderState extends ClassQueryBuilderState {
+  readonly functionElement: ConcreteFunctionDefinition;
+
+  constructor(
+    applicationStore: GenericLegendApplicationStore,
+    graphManagerState: GraphManagerState,
+    functionElemenet: ConcreteFunctionDefinition,
+  ) {
+    super(applicationStore, graphManagerState);
+    this.functionElement = functionElemenet;
+    this.showParametersPanel = true;
+  }
+}