@finos/legend-query-builder 4.2.4 → 4.3.1

package/src/components/workflows/ClassQueryBuilder.tsx

@@ -71,11 +71,15 @@ const ClassQueryBuilderSetupPanelContent = observer(
           )
         : []
     ).map(buildElementOption);
-    const selectedMappingOption = queryBuilderState.mapping
-      ? buildElementOption(queryBuilderState.mapping)
+    const selectedMappingOption = queryBuilderState.executionContextState
+      .mapping
+      ? buildElementOption(queryBuilderState.executionContextState.mapping)
       : null;
     const changeMapping = (val: PackageableElementOption<Mapping>): void => {
-      if (!queryBuilderState.class || val.value === queryBuilderState.mapping) {
+      if (
+        !queryBuilderState.class ||
+        val.value === queryBuilderState.executionContextState.mapping
+      ) {
         return;
       }
       queryBuilderState.changeMapping(val.value);
@@ -90,9 +94,9 @@ const ClassQueryBuilderSetupPanelContent = observer(
 
     // runtime
     const runtimeOptions = (
-      queryBuilderState.mapping
+      queryBuilderState.executionContextState.mapping
         ? getMappingCompatibleRuntimes(
-            queryBuilderState.mapping,
+            queryBuilderState.executionContextState.mapping,
             queryBuilderState.graphManagerState.usableRuntimes,
           )
         : []
@@ -102,11 +106,14 @@ const ClassQueryBuilderSetupPanelContent = observer(
           new RuntimePointer(PackageableElementExplicitReference.create(rt)),
       )
       .map(buildRuntimeValueOption);
-    const selectedRuntimeOption = queryBuilderState.runtimeValue
-      ? buildRuntimeValueOption(queryBuilderState.runtimeValue)
+    const selectedRuntimeOption = queryBuilderState.executionContextState
+      .runtimeValue
+      ? buildRuntimeValueOption(
+          queryBuilderState.executionContextState.runtimeValue,
+        )
       : null;
     const changeRuntime = (val: { value: Runtime }): void => {
-      if (val.value === queryBuilderState.runtimeValue) {
+      if (val.value === queryBuilderState.executionContextState.runtimeValue) {
         return;
       }
       queryBuilderState.changeRuntime(val.value);
@@ -177,7 +184,8 @@ const ClassQueryBuilderSetupPanelContent = observer(
                 placeholder="Choose a runtime..."
                 noMatchMessage="No compatible runtime found for specified mapping"
                 disabled={
-                  !queryBuilderState.class || !queryBuilderState.mapping
+                  !queryBuilderState.class ||
+                  !queryBuilderState.executionContextState.mapping
                 }
                 options={runtimeOptions}
                 onChange={changeRuntime}

package/src/components/workflows/MappingQueryBuilder.tsx

@@ -62,11 +62,12 @@ const MappingQueryBuilderSetupPanelContent = observer(
       queryBuilderState.graphManagerState.usableMappings.map(
         buildElementOption,
       );
-    const selectedMappingOption = queryBuilderState.mapping
-      ? buildElementOption(queryBuilderState.mapping)
+    const selectedMappingOption = queryBuilderState.executionContextState
+      .mapping
+      ? buildElementOption(queryBuilderState.executionContextState.mapping)
       : null;
     const changeMapping = (val: PackageableElementOption<Mapping>): void => {
-      if (val.value === queryBuilderState.mapping) {
+      if (val.value === queryBuilderState.executionContextState.mapping) {
         return;
       }
       queryBuilderState.changeMapping(val.value);
@@ -82,9 +83,9 @@ const MappingQueryBuilderSetupPanelContent = observer(
 
     // runtime
     const runtimeOptions = (
-      queryBuilderState.mapping
+      queryBuilderState.executionContextState.mapping
         ? getMappingCompatibleRuntimes(
-            queryBuilderState.mapping,
+            queryBuilderState.executionContextState.mapping,
             queryBuilderState.graphManagerState.usableRuntimes,
           )
         : []
@@ -94,11 +95,14 @@ const MappingQueryBuilderSetupPanelContent = observer(
           new RuntimePointer(PackageableElementExplicitReference.create(rt)),
       )
       .map(buildRuntimeValueOption);
-    const selectedRuntimeOption = queryBuilderState.runtimeValue
-      ? buildRuntimeValueOption(queryBuilderState.runtimeValue)
+    const selectedRuntimeOption = queryBuilderState.executionContextState
+      .runtimeValue
+      ? buildRuntimeValueOption(
+          queryBuilderState.executionContextState.runtimeValue,
+        )
       : null;
     const changeRuntime = (val: { value: Runtime }): void => {
-      if (val.value === queryBuilderState.runtimeValue) {
+      if (val.value === queryBuilderState.executionContextState.runtimeValue) {
         return;
       }
       queryBuilderState.changeRuntime(val.value);
@@ -113,9 +117,9 @@ const MappingQueryBuilderSetupPanelContent = observer(
     });
 
     // class
-    const classes = queryBuilderState.mapping
+    const classes = queryBuilderState.executionContextState.mapping
       ? getMappingCompatibleClasses(
-          queryBuilderState.mapping,
+          queryBuilderState.executionContextState.mapping,
           queryBuilderState.graphManagerState.usableClasses,
         )
       : [];
@@ -170,7 +174,7 @@ const MappingQueryBuilderSetupPanelContent = observer(
                 className="panel__content__form__section__dropdown query-builder__setup__config-group__item__selector"
                 placeholder="Choose a runtime..."
                 noMatchMessage="No compatible runtime found for specified mapping"
-                disabled={!queryBuilderState.mapping}
+                disabled={!queryBuilderState.executionContextState.mapping}
                 options={runtimeOptions}
                 onChange={changeRuntime}
                 value={selectedRuntimeOption}

package/src/components/workflows/ServiceQueryBuilder.tsx

@@ -47,6 +47,7 @@ const buildExecutionContextOption = (
  *
  * See details on propagation/cascading in {@link ServiceQueryBuilderState}
  */
+// TODO: add mapping/runtime for `from` queries
 const ServiceQueryBuilderSetupPanelContent = observer(
   (props: { queryBuilderState: ServiceQueryBuilderState }) => {
     const { queryBuilderState } = props;
@@ -87,9 +88,9 @@ const ServiceQueryBuilderSetupPanelContent = observer(
     };
 
     // class
-    const classes = queryBuilderState.mapping
+    const classes = queryBuilderState.executionContextState.mapping
       ? getMappingCompatibleClasses(
-          queryBuilderState.mapping,
+          queryBuilderState.executionContextState.mapping,
           queryBuilderState.graphManagerState.usableClasses,
         )
       : [];

package/src/index.ts

@@ -37,6 +37,7 @@ export {
   getRuntimeOptionFormatter,
 } from './components/QueryBuilderSideBar.js';
 export { ClassQueryBuilderState } from './stores/workflows/ClassQueryBuilderState.js';
+export { FunctionQueryBuilderState } from './stores/workflows/FunctionQueryBuilderState.js';
 export { MappingQueryBuilderState } from './stores/workflows/MappingQueryBuilderState.js';
 export {
   type ServiceExecutionContext,

package/src/stores/QueryBuilderExecutionContextState.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 { Mapping, Runtime } from '@finos/legend-graph';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import { action, makeObservable, observable } from 'mobx';
+
+export abstract class QueryBuilderExecutionContextState {
+  readonly queryBuilderState: QueryBuilderState;
+  mapping: Mapping | undefined;
+  runtimeValue: Runtime | undefined;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  setMapping(val: Mapping | undefined): void {
+    this.mapping = val;
+  }
+
+  setRuntimeValue(val: Runtime | undefined): void {
+    this.runtimeValue = val;
+  }
+
+  get specifiedInQuery(): boolean {
+    return true;
+  }
+}
+
+export class QueryBuilderEmbeddedFromExecutionContextState extends QueryBuilderExecutionContextState {
+  constructor(queryBuilderState: QueryBuilderState) {
+    super(queryBuilderState);
+    makeObservable(this, {
+      mapping: observable,
+      runtimeValue: observable,
+      setMapping: action,
+      setRuntimeValue: action,
+    });
+  }
+}
+
+export class QueryBuilderExternalExecutionContextState extends QueryBuilderExecutionContextState {
+  constructor(queryBuilderState: QueryBuilderState) {
+    super(queryBuilderState);
+    makeObservable(this, {
+      mapping: observable,
+      runtimeValue: observable,
+      setMapping: action,
+      setRuntimeValue: action,
+    });
+  }
+
+  override get specifiedInQuery(): boolean {
+    return false;
+  }
+}

package/src/stores/QueryBuilderInternalizeState.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { Binding, VariableExpression } from '@finos/legend-graph';
+
+export class QueryBuilderInternalizeState {
+  readonly queryBuilderState: QueryBuilderState;
+  binding: Binding;
+  inputData: VariableExpression;
+
+  constructor(
+    binding: Binding,
+    inputData: VariableExpression,
+    queryBuilderState: QueryBuilderState,
+  ) {
+    this.queryBuilderState = queryBuilderState;
+    this.binding = binding;
+    this.inputData = inputData;
+  }
+}

package/src/stores/QueryBuilderResultState.ts

@@ -217,8 +217,8 @@ export class QueryBuilderResultState {
       const result =
         (yield this.queryBuilderState.graphManagerState.graphManager.runQuery(
           query,
-          this.queryBuilderState.mapping,
-          this.queryBuilderState.runtimeValue,
+          this.queryBuilderState.executionContextState.mapping,
+          this.queryBuilderState.executionContextState.runtimeValue,
           this.queryBuilderState.graphManagerState.graph,
           {
             serializationFormat,
@@ -260,11 +260,11 @@ export class QueryBuilderResultState {
       this.setIsRunningQuery(true);
       const currentHashCode = this.queryBuilderState.hashCode;
       const mapping = guaranteeNonNullable(
-        this.queryBuilderState.mapping,
+        this.queryBuilderState.executionContextState.mapping,
         'Mapping is required to execute query',
       );
       const runtime = guaranteeNonNullable(
-        this.queryBuilderState.runtimeValue,
+        this.queryBuilderState.executionContextState.runtimeValue,
         `Runtime is required to execute query`,
       );
       const query = this.buildExecutionRawLambda();
@@ -350,11 +350,11 @@ export class QueryBuilderResultState {
     try {
       this.isGeneratingPlan = true;
       const mapping = guaranteeNonNullable(
-        this.queryBuilderState.mapping,
+        this.queryBuilderState.executionContextState.mapping,
         'Mapping is required to execute query',
       );
       const runtime = guaranteeNonNullable(
-        this.queryBuilderState.runtimeValue,
+        this.queryBuilderState.executionContextState.runtimeValue,
         `Runtime is required to execute query`,
       );
       const query = this.queryBuilderState.buildQuery();

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,
       );
     }