@finos/legend-query-builder 0.4.2 → 0.4.4

package/src/components/QueryBuilderParametersPanel.tsx

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { useState } from 'react';
 import { observer } from 'mobx-react-lite';
 import type { QueryBuilderState } from '../stores/QueryBuilderState.js';
 import {
@@ -40,11 +39,12 @@ import {
 } from '../stores/QueryBuilderParametersState.js';
 import {
   type Type,
-  MULTIPLICITY_INFINITE,
   VariableExpression,
   GenericTypeExplicitReference,
   GenericType,
   PrimitiveType,
+  Multiplicity,
+  getMultiplicityPrettyDescription,
 } from '@finos/legend-graph';
 import {
   type PackageableElementOption,
@@ -59,6 +59,15 @@ import { variableExpression_setName } from '../stores/shared/ValueSpecificationM
 import { LambdaParameterState } from '../stores/shared/LambdaParameterState.js';
 import { LambdaParameterValuesEditor } from './shared/LambdaParameterValuesEditor.js';
 
+type MultiplicityOption = { label: string; value: Multiplicity };
+
+const buildMultiplicityOption = (
+  multiplicity: Multiplicity,
+): MultiplicityOption => ({
+  label: getMultiplicityPrettyDescription(multiplicity),
+  value: multiplicity,
+});
+
 const VariableExpressionEditor = observer(
   (props: {
     queryBuilderState: QueryBuilderState;
@@ -89,6 +98,7 @@ const VariableExpressionEditor = observer(
     const variableType =
       lambdaParameterState.variableType ?? PrimitiveType.STRING;
     const selectedType = buildElementOption(variableType);
+    const selectedMultiplicity = buildMultiplicityOption(multiplity);
     const typeOptions: PackageableElementOption<Type>[] =
       queryBuilderState.graphManagerState.graph.primitiveTypes
         .map(buildElementOption)
@@ -104,38 +114,15 @@ const VariableExpressionEditor = observer(
     };
 
     // multiplicity
-    const changeLowerBound: React.ChangeEventHandler<HTMLInputElement> = (
-      event,
-    ) => {
-      lambdaParameterState.changeMultiplicity(
-        varState,
-        parseInt(event.target.value),
-        multiplity.upperBound,
-      );
-    };
-    const [upperBound, setUppBound] = useState<string>(
-      multiplity.upperBound === undefined
-        ? MULTIPLICITY_INFINITE
-        : multiplity.upperBound.toString(),
-    );
-    const changeUpperBound: React.ChangeEventHandler<HTMLInputElement> = (
-      event,
-    ) => {
-      const value = event.target.value;
-      if (
-        value === MULTIPLICITY_INFINITE ||
-        value === '' ||
-        !isNaN(parseInt(value, 10))
-      ) {
-        lambdaParameterState.changeMultiplicity(
-          varState,
-          multiplity.lowerBound,
-          value === MULTIPLICITY_INFINITE || value === ''
-            ? undefined
-            : parseInt(value, 10),
-        );
-        setUppBound(value);
-      }
+    const validParamMultiplicityList = [
+      Multiplicity.ONE,
+      Multiplicity.ZERO_ONE,
+      Multiplicity.ZERO_MANY,
+    ];
+    const multilicityOptions: MultiplicityOption[] =
+      validParamMultiplicityList.map(buildMultiplicityOption);
+    const changeMultiplicity = (val: MultiplicityOption): void => {
+      lambdaParameterState.changeMultiplicity(varState, val.value);
     };
 
     const close = (): void => {
@@ -202,19 +189,17 @@ const VariableExpressionEditor = observer(
                 The multiplity determines how many values a parameter can have.
                 Default is set to mandatory single vlue.
               </div>
-              <input
-                className="panel__content__form__section__input panel__content__form__section__number-input"
-                type="number"
-                spellCheck={false}
-                value={multiplity.lowerBound}
-                onChange={changeLowerBound}
-              />
-              ..
-              <input
-                className="panel__content__form__section__input panel__content__form__section__number-input"
-                spellCheck={false}
-                value={upperBound}
-                onChange={changeUpperBound}
+              <CustomSelectorInput
+                placeholder="Choose a multiplicity..."
+                options={multilicityOptions}
+                onChange={changeMultiplicity}
+                value={selectedMultiplicity}
+                hasError={
+                  !validParamMultiplicityList.includes(
+                    selectedMultiplicity.value,
+                  )
+                }
+                darkMode={!applicationStore.TEMPORARY__isLightThemeEnabled}
               />
             </div>
           </ModalBody>

package/src/stores/QueryBuilderResultState.ts

@@ -35,10 +35,13 @@ import {
   EXECUTION_SERIALIZATION_FORMAT,
   RawExecutionResult,
   buildRawLambdaFromLambdaFunction,
-  ParameterValue,
 } from '@finos/legend-graph';
 import { buildLambdaFunction } from './QueryBuilderValueSpecificationBuilder.js';
 import { ExecutionPlanState } from '@finos/legend-application';
+import {
+  buildExecutionParameterValues,
+  getExecutionQueryFromRawLambda,
+} from './shared/LambdaParameterState.js';
 
 const DEFAULT_LIMIT = 1000;
 
@@ -125,24 +128,17 @@ export class QueryBuilderResultState {
         this.queryBuilderState.unsupportedQueryState.rawLambda,
         'Lambda is required to execute query',
       );
+      if (!this.queryBuilderState.isParameterSupportDisabled) {
+        return getExecutionQueryFromRawLambda(
+          query,
+          this.queryBuilderState.parametersState.parameterStates,
+          this.queryBuilderState.graphManagerState,
+        );
+      }
     }
     return query;
   }
 
-  buildExecutionParameterValues(): ParameterValue[] {
-    return this.queryBuilderState.parametersState.parameterStates.map(
-      (queryParamState) => {
-        const paramValue = new ParameterValue();
-        paramValue.name = queryParamState.parameter.name;
-        paramValue.value =
-          this.queryBuilderState.graphManagerState.graphManager.serializeValueSpecification(
-            guaranteeNonNullable(queryParamState.value),
-          );
-        return paramValue;
-      },
-    );
-  }
-
   *exportData(
     serializationFormat: EXECUTION_SERIALIZATION_FORMAT,
   ): GeneratorFn<void> {
@@ -165,6 +161,10 @@ export class QueryBuilderResultState {
           this.queryBuilderState.graphManagerState.graph,
           {
             serializationFormat,
+            parameterValues: buildExecutionParameterValues(
+              this.queryBuilderState.parametersState.parameterStates,
+              this.queryBuilderState.graphManagerState,
+            ),
           },
         )) as ExecutionResult;
       let contentType: ContentType;
@@ -210,7 +210,6 @@ export class QueryBuilderResultState {
         `Runtime is required to execute query`,
       );
       const query = this.buildExecutionRawLambda();
-      const parameterValues = this.buildExecutionParameterValues();
       const startTime = Date.now();
       const promise =
         this.queryBuilderState.graphManagerState.graphManager.executeMapping(
@@ -219,7 +218,10 @@ export class QueryBuilderResultState {
           runtime,
           this.queryBuilderState.graphManagerState.graph,
           {
-            parameterValues: parameterValues,
+            parameterValues: buildExecutionParameterValues(
+              this.queryBuilderState.parametersState.parameterStates,
+              this.queryBuilderState.graphManagerState,
+            ),
           },
         );
       this.setQueryRunPromise(promise);

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -36,6 +36,7 @@ import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificati
 import type { QueryBuilderFetchStructureState } from './fetch-structure/QueryBuilderFetchStructureState.js';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import { buildWatermarkExpression } from './watermark/QueryBuilderWatermarkValueSpecificationBuilder.js';
+import { buildExecutionQueryFromLambdaFunction } from './shared/LambdaParameterState.js';
 
 const buildGetAllFunction = (
   _class: Class,
@@ -155,13 +156,19 @@ export const buildLambdaFunction = (
   );
 
   // build parameters
-  if (
-    !queryBuilderState.isParameterSupportDisabled &&
-    queryBuilderState.parametersState.parameterStates.length
-  ) {
-    lambdaFunction.functionType.parameters =
-      queryBuilderState.parametersState.parameterStates.map((e) => e.parameter);
+  if (queryBuilderState.parametersState.parameterStates.length) {
+    if (options?.isBuildingExecutionQuery) {
+      buildExecutionQueryFromLambdaFunction(
+        lambdaFunction,
+        queryBuilderState.parametersState.parameterStates,
+        queryBuilderState.graphManagerState,
+      );
+    } else {
+      lambdaFunction.functionType.parameters =
+        queryBuilderState.parametersState.parameterStates.map(
+          (e) => e.parameter,
+        );
+    }
   }
-
   return lambdaFunction;
 };

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -23,6 +23,7 @@ import {
   matchFunctionName,
   MILESTONING_STEREOTYPE,
   SimpleFunctionExpression,
+  VariableExpression,
   type ValueSpecification,
 } from '@finos/legend-graph';
 import {
@@ -133,6 +134,7 @@ const isDefaultDatePropagationSupported = (
 export const buildPropertyExpressionChain = (
   propertyExpression: AbstractPropertyExpression,
   queryBuilderState: QueryBuilderState,
+  lambdaParameterName: string,
   /**
    * As of now, we don't support date propagation for aggregation-class functions
    * so we have this temporary flag to disable date propagation, there could be other
@@ -223,6 +225,11 @@ export const buildPropertyExpressionChain = (
       );
     }
   }
+
+  // Update the root lambda name based on the parent's lambda parameter name.
+  if (currentExpression instanceof VariableExpression) {
+    currentExpression.name = lambdaParameterName;
+  }
   return newPropertyExpression;
 };
 

package/src/stores/fetch-structure/tds/projection/QueryBuilderProjectionValueSpecificationBuilder.ts

@@ -225,6 +225,7 @@ export const appendProjection = (
             buildPropertyExpressionChain(
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
+              projectionColumnState.lambdaParameterName,
               true,
             ),
           ],
@@ -325,6 +326,7 @@ export const appendProjection = (
             buildPropertyExpressionChain(
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
+              projectionColumnState.lambdaParameterName,
             ),
           ],
           queryBuilderState.graphManagerState.graph,

package/src/stores/filter/operators/QueryBuilderFilterOperatorValueSpecificationBuilder.ts

@@ -78,6 +78,7 @@ const buildFilterConditionExpressionWithExists = (
     buildPropertyExpressionChain(
       filterConditionState.propertyExpressionState.propertyExpression,
       filterConditionState.propertyExpressionState.queryBuilderState,
+      filterConditionState.filterState.lambdaParameterName,
     );
   while (
     currentPropertyExpression instanceof AbstractPropertyExpression ||
@@ -225,6 +226,7 @@ export const buildFilterConditionExpression = (
   const propertyExpression = buildPropertyExpressionChain(
     filterConditionState.propertyExpressionState.propertyExpression,
     filterConditionState.propertyExpressionState.queryBuilderState,
+    filterConditionState.filterState.lambdaParameterName,
   );
   expression.parametersValues.push(guaranteeNonNullable(propertyExpression));
   // NOTE: there are simple operators which do not require any params (e.g. isEmpty)

package/src/stores/shared/LambdaParameterState.ts

@@ -19,11 +19,26 @@ import {
   type Type,
   type ValueSpecification,
   type PureModel,
+  type GraphManagerState,
+  type RawLambda,
   GenericType,
   GenericTypeExplicitReference,
   observe_ValueSpecification,
   observe_VariableExpression,
   VariableExpression,
+  SimpleFunctionExpression,
+  PackageableElementExplicitReference,
+  LambdaFunction,
+  FunctionType,
+  CORE_PURE_PATH,
+  extractElementNameFromPath,
+  Multiplicity,
+  PrimitiveInstanceValue,
+  PrimitiveType,
+  SUPPORTED_FUNCTIONS,
+  areMultiplicitiesEqual,
+  ParameterValue,
+  buildRawLambdaFromLambdaFunction,
 } from '@finos/legend-graph';
 import {
   addUniqueEntry,
@@ -32,6 +47,8 @@ import {
   hashArray,
   IllegalStateError,
   uuid,
+  isNonNullable,
+  guaranteeNonNullable,
 } from '@finos/legend-shared';
 import { makeObservable, observable, action, computed } from 'mobx';
 import { generateVariableExpressionMockValue } from './ValueSpecificationEditorHelper.js';
@@ -49,6 +66,137 @@ enum LAMABA_PARAMETER_HASH_STRUCTURE {
   LAMBDA_PARAMETER_STATE = 'LAMBDA_PARAMETER_STATE',
   LAMBDA_PARAMETERS_STATE = 'LAMBDA_PARAMETERS_STATE',
 }
+
+export const buildParametersLetLambdaFunc = (
+  graph: PureModel,
+  lambdaParametersStates: LambdaParameterState[],
+): LambdaFunction => {
+  const letlambdaFunction = new LambdaFunction(
+    new FunctionType(
+      PackageableElementExplicitReference.create(
+        graph.getType(CORE_PURE_PATH.ANY),
+      ),
+      Multiplicity.ONE,
+    ),
+  );
+  letlambdaFunction.expressionSequence = lambdaParametersStates
+    .map((queryParamState) => {
+      if (queryParamState.value) {
+        const letFunc = new SimpleFunctionExpression(
+          extractElementNameFromPath(SUPPORTED_FUNCTIONS.LET),
+        );
+        const letVar = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(
+            new GenericType(PrimitiveType.STRING),
+          ),
+        );
+        letVar.values = [queryParamState.variableName];
+        letFunc.parametersValues.push(letVar);
+        letFunc.parametersValues.push(queryParamState.value);
+        return letFunc;
+      }
+      return undefined;
+    })
+    .filter(isNonNullable);
+  return letlambdaFunction;
+};
+
+/**
+ * For most query executions we will use the stragtical method of sending in `paramValues` as part of the execution input payload.
+ * However when the user wants to use a function value as the parameter value, engine does not understand this i.e for date param the functions `now()`, `today()`.
+ * Engine Does not support this because those functions require a building of execution nodes inside the execution plan.
+ * To continue supporting this execution flow , we will add let statements for parameter values with function values so that they can be evaluated to constants in the execution plan.
+ */
+export const doesLambdaParameterStateContainFunctionValues = (
+  parameterState: LambdaParameterState,
+): boolean =>
+  parameterState.value instanceof SimpleFunctionExpression &&
+  [Multiplicity.ONE, Multiplicity.ZERO_ONE].some((p) =>
+    areMultiplicitiesEqual(p, parameterState.parameter.multiplicity),
+  );
+
+export const getParameterStatesWithFunctionValues = (
+  parameterStates: LambdaParameterState[],
+): LambdaParameterState[] =>
+  parameterStates.filter(doesLambdaParameterStateContainFunctionValues);
+
+export const buildExecutionParameterValues = (
+  paramStates: LambdaParameterState[],
+  graphState: GraphManagerState,
+): ParameterValue[] =>
+  paramStates
+    .filter((ps) => !doesLambdaParameterStateContainFunctionValues(ps))
+    .map((queryParamState) => {
+      const paramValue = new ParameterValue();
+      paramValue.name = queryParamState.parameter.name;
+      paramValue.value = graphState.graphManager.serializeValueSpecification(
+        guaranteeNonNullable(queryParamState.value),
+      );
+      return paramValue;
+    });
+
+export const getExecutionQueryFromRawLambda = (
+  rawLambda: RawLambda,
+  parameterStates: LambdaParameterState[],
+  graphManagerState: GraphManagerState,
+): RawLambda => {
+  const paramsWithLetStatements =
+    getParameterStatesWithFunctionValues(parameterStates);
+  if (paramsWithLetStatements.length > 0) {
+    const execuLambdaFunction = buildParametersLetLambdaFunc(
+      graphManagerState.graph,
+      paramsWithLetStatements,
+    );
+    // remove parameters added as let statements from lambda parameters
+    execuLambdaFunction.functionType.parameters = parameterStates
+      .filter((ps) => !paramsWithLetStatements.includes(ps))
+      .map((e) => e.parameter);
+    const execQuery = buildRawLambdaFromLambdaFunction(
+      execuLambdaFunction,
+      graphManagerState,
+    );
+    // reset paramaters
+    if (Array.isArray(rawLambda.body) && Array.isArray(execQuery.body)) {
+      execQuery.body = [
+        ...(execQuery.body as object[]),
+        ...(rawLambda.body as object[]),
+      ];
+      return execQuery;
+    }
+  }
+  return rawLambda;
+};
+
+export const buildExecutionQueryFromLambdaFunction = (
+  lambdaFunction: LambdaFunction,
+  parameterStates: LambdaParameterState[],
+  graphManagerState: GraphManagerState,
+): LambdaFunction => {
+  const funcParameterStates =
+    getParameterStatesWithFunctionValues(parameterStates);
+  if (funcParameterStates.length) {
+    // To handle parameter value with function calls we
+    // 1. remove those parameters from parameter list
+    // 2. add let statements with parameter values
+    lambdaFunction.functionType.parameters = parameterStates
+      .filter((ps) => !funcParameterStates.includes(ps))
+      .map((e) => e.parameter);
+    const letsFuncs = buildParametersLetLambdaFunc(
+      graphManagerState.graph,
+      funcParameterStates,
+    );
+    lambdaFunction.expressionSequence = [
+      ...letsFuncs.expressionSequence,
+      ...lambdaFunction.expressionSequence,
+    ];
+  } else {
+    lambdaFunction.functionType.parameters = parameterStates.map(
+      (e) => e.parameter,
+    );
+  }
+  return lambdaFunction;
+};
+
 export class LambdaParameterState implements Hashable {
   readonly uuid = uuid();
   readonly parameter: VariableExpression;
@@ -109,18 +257,11 @@ export class LambdaParameterState implements Hashable {
 
   changeMultiplicity(
     variableExpression: VariableExpression,
-    lowerBound: number,
-    uppderBound: number | undefined,
+    mul: Multiplicity,
   ): void {
     const current = this.parameter.multiplicity;
-    if (
-      current.lowerBound !== lowerBound ||
-      current.upperBound !== uppderBound
-    ) {
-      valueSpecification_setMultiplicity(
-        variableExpression,
-        this.graph.getMultiplicity(lowerBound, uppderBound),
-      );
+    if (!areMultiplicitiesEqual(current, mul)) {
+      valueSpecification_setMultiplicity(variableExpression, mul);
       this.mockParameterValue();
     }
   }