@finos/legend-query-builder 0.0.1

package/src/graphManager/protocol/pure/v1/V1_QueryBuilder_PureGraphManagerExtension.ts

@@ -0,0 +1,296 @@
+/**
+ * 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 {
+  EngineRuntime,
+  GraphBuilderError,
+  MappingInclude,
+  V1_getIncludedMappingPath,
+  V1_GraphBuilderContextBuilder,
+  V1_Mapping,
+  V1_MAPPING_ELEMENT_PROTOCOL_TYPE,
+  V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
+  V1_PureMultiExecution,
+  V1_Service,
+  V1_PackageableRuntime,
+  type V1_PackageableElement,
+  type PureModel,
+  V1_PureGraphManager,
+  PureClientVersion,
+  type AbstractPureGraphManager,
+  type V1_EngineRuntime,
+  CORE_PURE_PATH,
+  getAllIncludedMappings,
+} from '@finos/legend-graph';
+import type { Entity } from '@finos/legend-storage';
+import {
+  assertErrorThrown,
+  filterByType,
+  guaranteeNonEmptyString,
+  guaranteeType,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { MappingRuntimeCompatibilityAnalysisResult } from '../../../action/analytics/MappingRuntimeCompatibilityAnalysis.js';
+import { ServiceExecutionAnalysisResult } from '../../../action/analytics/ServiceExecutionAnalysis.js';
+import { QueryBuilder_PureGraphManagerExtension } from '../QueryBuilder_PureGraphManagerExtension.js';
+
+export class V1_QueryBuilder_PureGraphManagerExtension extends QueryBuilder_PureGraphManagerExtension {
+  declare graphManager: V1_PureGraphManager;
+
+  constructor(graphManager: AbstractPureGraphManager) {
+    super(graphManager);
+    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
+  }
+
+  getSupportedProtocolVersion(): string {
+    return PureClientVersion.V1_0_0;
+  }
+
+  // We could optimize this further by omitting parts of the entities we don't need
+  async buildGraphForCreateQuerySetup(
+    graph: PureModel,
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<void> {
+    try {
+      const graphBuilderInput = await this.graphManager.indexLightGraph(
+        graph,
+        entities,
+        dependencyEntities,
+        (entity: Entity): boolean =>
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_MAPPING_ELEMENT_PROTOCOL_TYPE ||
+          ((entity.content as PlainObject<V1_PackageableElement>)
+            ._type as string) === V1_PACKAGEABLE_RUNTIME_ELEMENT_PROTOCOL_TYPE,
+      );
+      // handle mapping includes
+      const mappings = [
+        ...graph.ownMappings,
+        ...graph.dependencyManager.mappings,
+      ];
+      const v1Mappings = graphBuilderInput
+        .map((e) => e.data.elements.filter(filterByType(V1_Mapping)))
+        .flat();
+      const context = new V1_GraphBuilderContextBuilder(
+        graph,
+        graph,
+        this.graphManager.graphBuilderExtensions,
+        this.graphManager.log,
+      ).build();
+      // build include index for compatible runtime analysis
+      v1Mappings.forEach((element) => {
+        const mapping = mappings.find((e) => e.path === element.path);
+        if (mapping) {
+          mapping.includes = element.includedMappings.map(
+            (i) =>
+              new MappingInclude(
+                mapping,
+                context.resolveMapping(
+                  guaranteeNonEmptyString(
+                    V1_getIncludedMappingPath(i),
+                    `Mapping include path is missing or empty`,
+                  ),
+                ),
+              ),
+          );
+        }
+      });
+      // handle runtimes
+      const runtimes = [
+        ...graph.ownRuntimes,
+        ...graph.dependencyManager.runtimes,
+      ];
+      const v1Runtimes = graphBuilderInput
+        .map((e) => e.data.elements.filter(filterByType(V1_PackageableRuntime)))
+        .flat();
+      v1Runtimes.forEach((element) => {
+        const runtime = runtimes.find((e) => e.path === element.path);
+        if (runtime) {
+          const runtimeValue = new EngineRuntime();
+          runtime.runtimeValue = runtimeValue;
+          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
+            context.resolveMapping(mapping.path),
+          );
+        }
+      });
+    } catch (error) {
+      assertErrorThrown(error);
+      /**
+       * Wrap all error with `GraphBuilderError`, as we throw a lot of assertion error in the graph builder
+       * But we might want to rethink this decision in the future and throw appropriate type of error
+       */
+      throw error instanceof GraphBuilderError
+        ? error
+        : new GraphBuilderError(error);
+    }
+  }
+
+  async surveyMappingRuntimeCompatibility(
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<MappingRuntimeCompatibilityAnalysisResult[]> {
+    const result: MappingRuntimeCompatibilityAnalysisResult[] = [];
+    const graph = await this.graphManager.createEmptyGraph({
+      initializeSystem: false,
+    });
+
+    const graphBuilderInput = await this.graphManager.indexLightGraph(
+      graph,
+      entities,
+      dependencyEntities,
+      (entity: Entity): boolean =>
+        ([CORE_PURE_PATH.MAPPING, CORE_PURE_PATH.RUNTIME] as string[]).includes(
+          entity.classifierPath,
+        ),
+      // NOTE: small optimization since we only need to survey runtimes and mappings
+      (entity: Entity): Entity => {
+        if (entity.classifierPath === CORE_PURE_PATH.MAPPING) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            includes: entity.content.includes,
+          };
+        } else if (entity.classifierPath === CORE_PURE_PATH.RUNTIME) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            runtimeValue: {
+              mappings: (
+                entity.content.runtimeValue as
+                  | PlainObject<V1_EngineRuntime>
+                  | undefined
+              )?.mappings,
+            },
+          };
+        }
+        return entity;
+      },
+    );
+
+    const context = new V1_GraphBuilderContextBuilder(
+      graph,
+      graph,
+      this.graphManager.graphBuilderExtensions,
+      this.graphManager.log,
+    ).build();
+
+    graphBuilderInput
+      .map((element) => element.data.elements.filter(filterByType(V1_Mapping)))
+      .flat()
+      .forEach((element) => {
+        const mapping = graph.getNullableMapping(element.path);
+        if (mapping) {
+          mapping.includes = element.includedMappings.map(
+            (include) =>
+              new MappingInclude(
+                mapping,
+                context.resolveMapping(
+                  guaranteeNonEmptyString(
+                    V1_getIncludedMappingPath(include),
+                    `Mapping include path is missing or empty`,
+                  ),
+                ),
+              ),
+          );
+        }
+      });
+
+    graphBuilderInput
+      .map((element) =>
+        element.data.elements.filter(filterByType(V1_PackageableRuntime)),
+      )
+      .flat()
+      .forEach((element) => {
+        const runtime = graph.getNullableRuntime(element.path);
+        if (runtime) {
+          const runtimeValue = new EngineRuntime();
+          runtime.runtimeValue = runtimeValue;
+          runtimeValue.mappings = element.runtimeValue.mappings.map((mapping) =>
+            context.resolveMapping(mapping.path),
+          );
+        }
+      });
+
+    graph.mappings.forEach((mapping) => {
+      const mappingRuntimeCompatibilityAnalysisResult =
+        new MappingRuntimeCompatibilityAnalysisResult();
+      mappingRuntimeCompatibilityAnalysisResult.mapping = mapping;
+      mappingRuntimeCompatibilityAnalysisResult.runtimes =
+        // If the runtime claims to cover some mappings which include the specified mapping,
+        // then we deem the runtime to be compatible with the such mapping
+        graph.runtimes.filter((runtime) =>
+          runtime.runtimeValue.mappings
+            .map((mappingReference) => [
+              mappingReference.value,
+              ...getAllIncludedMappings(mappingReference.value),
+            ])
+            .flat()
+            .includes(mapping),
+        );
+      result.push(mappingRuntimeCompatibilityAnalysisResult);
+    });
+
+    return result;
+  }
+
+  async surveyServiceExecution(
+    entities: Entity[],
+    dependencyEntities: Map<string, Entity[]>,
+  ): Promise<ServiceExecutionAnalysisResult[]> {
+    const result: ServiceExecutionAnalysisResult[] = [];
+    const graph = await this.graphManager.createEmptyGraph({
+      initializeSystem: false,
+    });
+
+    const graphBuilderInput = await this.graphManager.indexLightGraph(
+      graph,
+      entities,
+      dependencyEntities,
+      (entity: Entity): boolean =>
+        entity.classifierPath === CORE_PURE_PATH.SERVICE,
+      // NOTE: small optimization since we only need to inspect services' execution context
+      (entity: Entity): Entity => {
+        if (entity.classifierPath === CORE_PURE_PATH.SERVICE) {
+          entity.content = {
+            _type: entity.content._type,
+            name: entity.content.name,
+            package: entity.content.package,
+            execution: entity.content.execution,
+          };
+        }
+        return entity;
+      },
+    );
+    graphBuilderInput
+      .map((element) => element.data.elements.filter(filterByType(V1_Service)))
+      .flat()
+      .forEach((protocol) => {
+        const service = graph.getNullableService(protocol.path);
+        if (service) {
+          const serviceAnalysisResult = new ServiceExecutionAnalysisResult();
+          serviceAnalysisResult.service = service;
+          if (protocol.execution instanceof V1_PureMultiExecution) {
+            serviceAnalysisResult.executionKeys =
+              protocol.execution.executionParameters.map((param) => param.key);
+          }
+          result.push(serviceAnalysisResult);
+        }
+      });
+    return result;
+  }
+}

package/src/index.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.
+ */
+
+export * from './stores/QueryBuilderBootstraper.js';
+export { QueryBuilder_GraphManagerPreset } from './graphManager/QueryBuilder_GraphManagerPreset.js';
+
+export { QUERY_BUILDER_TEST_ID } from './components//QueryBuilder_TestID.js';
+export { QueryBuilder } from './components//QueryBuilder.js';
+export { QueryBuilderState } from './stores//QueryBuilderState.js';
+
+export {
+  QueryBuilderClassSelector,
+  buildRuntimeValueOption,
+  getRuntimeOptionFormatter,
+} from './components/QueryBuilderSideBar.js';
+export { ClassQueryBuilderState } from './stores/workflows/ClassQueryBuilderState.js';
+export { MappingQueryBuilderState } from './stores/workflows/MappingQueryBuilderState.js';
+export {
+  type ServiceExecutionContext,
+  ServiceQueryBuilderState,
+} from './stores//workflows/ServiceQueryBuilderState.js';
+
+export { getQueryBuilderGraphManagerExtension } from './graphManager/protocol/pure/QueryBuilder_PureGraphManagerExtension.js';
+export type { ServiceExecutionAnalysisResult } from './graphManager/action/analytics/ServiceExecutionAnalysis.js';
+export type { MappingRuntimeCompatibilityAnalysisResult } from './graphManager/action/analytics/MappingRuntimeCompatibilityAnalysis.js';

package/src/stores/QueryBuilderBootstraper.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 { ModuleRegistry as agGrid_ModuleRegistry } from '@ag-grid-community/core';
+import { ClientSideRowModelModule } from '@ag-grid-community/client-side-row-model';
+
+export const setupQueryBuilderUILibrary = async (): Promise<void> => {
+  // Register module extensions for `ag-grid`
+  agGrid_ModuleRegistry.registerModules([ClientSideRowModelModule]);
+};

package/src/stores/QueryBuilderChangeDetectionState.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 { RawLambda } from '@finos/legend-graph';
+import { hashObject } from '@finos/legend-shared';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+export class QueryBuilderChangeDetectionState {
+  querybuildState: QueryBuilderState;
+  queryHashCode = hashObject(new RawLambda(undefined, undefined));
+  isEnabled = false;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    this.querybuildState = queryBuilderState;
+  }
+
+  setQueryHashCode(val: string): void {
+    this.queryHashCode = val;
+  }
+
+  setIsEnabled(val: boolean): void {
+    this.isEnabled = val;
+  }
+}

package/src/stores/QueryBuilderConfig.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.
+ */
+
+export enum QUERY_BUILDER_SOURCE_ID_LABEL {
+  QUERY_BUILDER = 'query-builder',
+  PROJECTION = 'projection',
+}
+
+export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
+export const DEFAULT_VARIABLE_NAME = 'var';
+export const DEFAULT_POST_FILTER_LAMBDA_VARIABLE_NAME = 'row';
+
+export const QUERY_BUILDER_PROPERTY_SEARCH_MAX_DEPTH = 5;
+export const QUERY_BUILDER_PROPERTY_SEARCH_RESULTS_LIMIT = 100;
+export enum QUERY_BUILDER_PROPERTY_SEARCH_TYPE {
+  CLASS = 'CLASS',
+  STRING = 'STRING',
+  BOOLEAN = 'BOOLEAN',
+  NUMBER = 'NUMBER',
+  DATE = 'DATE',
+}

package/src/stores/QueryBuilderGroupOperationHelper.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 { matchFunctionName } from '@finos/legend-graph';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
+
+export enum QUERY_BUILDER_GROUP_OPERATION {
+  AND = 'and',
+  OR = 'or',
+}
+
+export const fromGroupOperation = (
+  operation: QUERY_BUILDER_GROUP_OPERATION,
+): string => {
+  switch (operation) {
+    case QUERY_BUILDER_GROUP_OPERATION.AND:
+      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND;
+    case QUERY_BUILDER_GROUP_OPERATION.OR:
+      return QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR;
+    default:
+      throw new UnsupportedOperationError(
+        `Can't derive function name from group operation '${operation}'`,
+      );
+  }
+};
+
+export const toGroupOperation = (
+  functionName: string,
+): QUERY_BUILDER_GROUP_OPERATION => {
+  if (matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.AND)) {
+    return QUERY_BUILDER_GROUP_OPERATION.AND;
+  } else if (
+    matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.OR)
+  ) {
+    return QUERY_BUILDER_GROUP_OPERATION.OR;
+  }
+  throw new UnsupportedOperationError(
+    `Can't derive group operation from function name '${functionName}'`,
+  );
+};

package/src/stores/QueryBuilderMilestoningState.ts

@@ -0,0 +1,164 @@
+/**
+ * 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 { LambdaParameterState } from '@finos/legend-application';
+import {
+  DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+  DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+  GenericType,
+  GenericTypeExplicitReference,
+  getMilestoneTemporalStereotype,
+  MILESTONING_STEREOTYPE,
+  observe_ValueSpecification,
+  PRIMITIVE_TYPE,
+  TYPICAL_MULTIPLICITY_TYPE,
+  VariableExpression,
+  type ValueSpecification,
+} from '@finos/legend-graph';
+import { action, computed, makeObservable, observable } from 'mobx';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+
+export class QueryBuilderMilestoningState {
+  queryBuilderState: QueryBuilderState;
+
+  showMilestoningEditor = false;
+  // TODO: Change this when we modify how we deal with milestoning.
+  // See https://github.com/finos/legend-studio/issues/1149
+  businessDate?: ValueSpecification | undefined;
+  processingDate?: ValueSpecification | undefined;
+
+  constructor(queryBuilderState: QueryBuilderState) {
+    makeObservable(this, {
+      processingDate: observable,
+      businessDate: observable,
+      showMilestoningEditor: observable,
+      isMilestonedQuery: computed,
+      setProcessingDate: action,
+      setBusinessDate: action,
+      setShowMilestoningEditor: action,
+    });
+
+    this.queryBuilderState = queryBuilderState;
+  }
+
+  get isMilestonedQuery(): boolean {
+    return Boolean(this.businessDate ?? this.processingDate);
+  }
+
+  setShowMilestoningEditor(val: boolean): void {
+    this.showMilestoningEditor = val;
+  }
+
+  private initializeQueryMilestoningParameters(stereotype: string): void {
+    switch (stereotype) {
+      case MILESTONING_STEREOTYPE.BUSINESS_TEMPORAL: {
+        this.setBusinessDate(
+          this.buildMilestoningParameter(
+            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      case MILESTONING_STEREOTYPE.PROCESSING_TEMPORAL: {
+        this.setProcessingDate(
+          this.buildMilestoningParameter(
+            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      case MILESTONING_STEREOTYPE.BITEMPORAL: {
+        this.setProcessingDate(
+          this.buildMilestoningParameter(
+            DEFAULT_PROCESSING_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        this.setBusinessDate(
+          this.buildMilestoningParameter(
+            DEFAULT_BUSINESS_DATE_MILESTONING_PARAMETER_NAME,
+          ),
+        );
+        break;
+      }
+      default:
+    }
+  }
+
+  setProcessingDate(val: ValueSpecification | undefined): void {
+    this.processingDate = val
+      ? observe_ValueSpecification(
+          val,
+          this.queryBuilderState.observableContext,
+        )
+      : val;
+  }
+
+  setBusinessDate(val: ValueSpecification | undefined): void {
+    this.businessDate = val
+      ? observe_ValueSpecification(
+          val,
+          this.queryBuilderState.observableContext,
+        )
+      : val;
+  }
+
+  updateMilestoningConfiguration(): void {
+    const currentclass = this.queryBuilderState.class;
+    if (currentclass !== undefined) {
+      const stereotype = getMilestoneTemporalStereotype(
+        currentclass,
+        this.queryBuilderState.graphManagerState.graph,
+      );
+      this.setBusinessDate(undefined);
+      this.setProcessingDate(undefined);
+      if (stereotype) {
+        this.initializeQueryMilestoningParameters(stereotype);
+        // Show the parameter panel because we populate paramaters state with milestoning parameters
+        this.queryBuilderState.setShowParametersPanel(true);
+      }
+    }
+  }
+
+  buildMilestoningParameter(parameterName: string): ValueSpecification {
+    const milestoningParameter = new VariableExpression(
+      parameterName,
+      this.queryBuilderState.graphManagerState.graph.getTypicalMultiplicity(
+        TYPICAL_MULTIPLICITY_TYPE.ONE,
+      ),
+      GenericTypeExplicitReference.create(
+        new GenericType(
+          this.queryBuilderState.parametersState.queryBuilderState.graphManagerState.graph.getPrimitiveType(
+            PRIMITIVE_TYPE.DATE,
+          ),
+        ),
+      ),
+    );
+    if (
+      !this.queryBuilderState.parametersState.parameterStates.find(
+        (p) => p.variableName === parameterName,
+      )
+    ) {
+      const variableState = new LambdaParameterState(
+        milestoningParameter,
+        this.queryBuilderState.observableContext,
+        this.queryBuilderState.graphManagerState.graph,
+      );
+      variableState.mockParameterValue();
+      this.queryBuilderState.parametersState.addParameter(variableState);
+    }
+    return milestoningParameter;
+  }
+}