@finos/legend-query-builder 0.6.22 → 0.6.23

package/src/components/shared/QueryBuilderVariableSelector.tsx

@@ -133,7 +133,7 @@ export const VariableViewer = observer(
               <TimesIcon />
             </button>
             <VariableInfoTooltip variable={variable}>
-              <div className="value-spec-editor__variable__info">
+              <div className="query-builder__variables__variable__action value-spec-editor__variable__info">
                 <InfoCircleIcon />
               </div>
             </VariableInfoTooltip>

package/src/graphManager/QueryBuilderSupportedFunctions.ts

@@ -19,6 +19,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   EXISTS = 'meta::pure::functions::collection::exists',
   FILTER = 'meta::pure::functions::collection::filter',
   GET_ALL = 'meta::pure::functions::collection::getAll',
+  GET_ALL_VERSIONS = 'meta::pure::functions::collection::getAllVersions',
   NOT = 'meta::pure::functions::boolean::not',
   OR = 'meta::pure::functions::boolean::or',
   TAKE = 'meta::pure::functions::collection::take',

package/src/stores/QueryBuilderPreviewDataHelper.ts

@@ -141,7 +141,9 @@ export const buildNumericPreviewDataQuery = (
     aggregationState.changeColumnAggregateOperator(valAggOp, colState);
   });
 
-  return builderState.resultState.buildExecutionRawLambda();
+  return builderState.resultState.buildExecutionRawLambda({
+    useAllVersionsForMilestoning: true,
+  });
 };
 
 export const buildNonNumericPreviewDataQuery = (
@@ -198,5 +200,7 @@ export const buildNonNumericPreviewDataQuery = (
     sortValueCount,
     new SortColumnState(valueProjectionColState),
   ];
-  return builderState.resultState.buildExecutionRawLambda();
+  return builderState.resultState.buildExecutionRawLambda({
+    useAllVersionsForMilestoning: true,
+  });
 };

package/src/stores/QueryBuilderResultState.ts

@@ -42,6 +42,7 @@ import {
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
 } from './shared/LambdaParameterState.js';
+import type { LambdaFunctionBuilderOption } from './QueryBuilderValueSpecificationBuilderHelper.js';
 
 const DEFAULT_LIMIT = 1000;
 
@@ -51,6 +52,7 @@ export class QueryBuilderResultState {
   readonly executionPlanState: ExecutionPlanState;
 
   previewLimit = DEFAULT_LIMIT;
+  pressedRunQuery = ActionState.create();
   isRunningQuery = false;
   isGeneratingPlan = false;
   executionResult?: ExecutionResult | undefined;
@@ -113,11 +115,14 @@ export class QueryBuilderResultState {
     return false;
   }
 
-  buildExecutionRawLambda(): RawLambda {
+  buildExecutionRawLambda(
+    executionOptions?: LambdaFunctionBuilderOption,
+  ): RawLambda {
     let query: RawLambda;
     if (this.queryBuilderState.isQuerySupported) {
       const lambdaFunction = buildLambdaFunction(this.queryBuilderState, {
         isBuildingExecutionQuery: true,
+        ...executionOptions,
       });
       query = buildRawLambdaFromLambdaFunction(
         lambdaFunction,
@@ -241,6 +246,7 @@ export class QueryBuilderResultState {
       this.queryBuilderState.applicationStore.notifyError(error);
     } finally {
       this.setIsRunningQuery(false);
+      this.pressedRunQuery.complete();
     }
   }
 

package/src/stores/QueryBuilderValueSpecificationBuilder.ts

@@ -57,6 +57,24 @@ const buildGetAllFunction = (
   return _func;
 };
 
+const buildGetAllVersionsFunction = (
+  _class: Class,
+  multiplicity: Multiplicity,
+): SimpleFunctionExpression => {
+  const _func = new SimpleFunctionExpression(
+    extractElementNameFromPath(
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.GET_ALL_VERSIONS,
+    ),
+  );
+  const classInstance = new InstanceValue(
+    multiplicity,
+    GenericTypeExplicitReference.create(new GenericType(_class)),
+  );
+  classInstance.values[0] = PackageableElementExplicitReference.create(_class);
+  _func.parametersValues.push(classInstance);
+  return _func;
+};
+
 const buildLetExpression = (
   constantExpressionState: QueryBuilderConstantExpressionState,
 ): SimpleFunctionExpression => {
@@ -101,20 +119,32 @@ export const buildLambdaFunction = (
     ),
   );
 
-  // build getAll()
-  const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
-
-  // build milestoning parameter(s) for getAll()
   const milestoningStereotype = getMilestoneTemporalStereotype(
     _class,
     queryBuilderState.graphManagerState.graph,
   );
-  if (milestoningStereotype) {
-    queryBuilderState.milestoningState
-      .getMilestoningImplementation(milestoningStereotype)
-      .buildGetAllParameters(getAllFunction);
+
+  if (milestoningStereotype && options?.useAllVersionsForMilestoning) {
+    // build getAllVersions() when we preview data for milestoned classes
+    // because if we use getAll() we need to pass in data to execute the query
+    // but we don't give user that option in this flow.
+    const getAllVersionsFunction = buildGetAllVersionsFunction(
+      _class,
+      Multiplicity.ONE,
+    );
+
+    lambdaFunction.expressionSequence[0] = getAllVersionsFunction;
+  } else {
+    // build getAll()
+    const getAllFunction = buildGetAllFunction(_class, Multiplicity.ONE);
+    if (milestoningStereotype) {
+      // build milestoning parameter(s) for getAll()
+      queryBuilderState.milestoningState
+        .getMilestoningImplementation(milestoningStereotype)
+        .buildGetAllParameters(getAllFunction);
+    }
+    lambdaFunction.expressionSequence[0] = getAllFunction;
   }
-  lambdaFunction.expressionSequence[0] = getAllFunction;
 
   // build watermark
   buildWatermarkExpression(queryBuilderState.watermarkState, lambdaFunction);

package/src/stores/QueryBuilderValueSpecificationBuilderHelper.ts

@@ -16,9 +16,12 @@
 
 import {
   AbstractPropertyExpression,
+  Class,
   DerivedProperty,
   INTERNAL__PropagatedValue,
   matchFunctionName,
+  MILESTONING_VERSION_PROPERTY_SUFFIX,
+  PropertyExplicitReference,
   SimpleFunctionExpression,
   VariableExpression,
   type ValueSpecification,
@@ -30,7 +33,11 @@ import {
 } from '@finos/legend-shared';
 import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graphManager/QueryBuilderSupportedFunctions.js';
 import type { QueryBuilderState } from './QueryBuilderState.js';
-import { variableExpression_setName } from './shared/ValueSpecificationModifierHelper.js';
+import {
+  functionExpression_setParametersValues,
+  propertyExpression_setFunc,
+  variableExpression_setName,
+} from './shared/ValueSpecificationModifierHelper.js';
 
 /**
  * Gets the value of ValueSpecification given INTERNAL__PropagatedValue is pointing to.
@@ -50,6 +57,7 @@ export const buildPropertyExpressionChain = (
   propertyExpression: AbstractPropertyExpression,
   queryBuilderState: QueryBuilderState,
   lambdaParameterName: string,
+  options?: LambdaFunctionBuilderOption,
   /**
    * 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
@@ -81,45 +89,73 @@ export const buildPropertyExpressionChain = (
       currentExpression instanceof AbstractPropertyExpression &&
       currentExpression.func.value instanceof DerivedProperty
     ) {
-      const currentPropertyExpression = currentExpression;
-      const parameterValues = currentExpression.parametersValues.slice(1);
-      parameterValues.forEach((parameterValue, index) => {
-        if (parameterValue instanceof INTERNAL__PropagatedValue) {
-          // Replace with argumentless derived property expression only when default date propagation is supported
-          if (
-            !TEMPORARY__disableDatePropagation &&
-            parameterValue.isPropagatedValue
-          ) {
-            // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
-            // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
+      // check if we are building the expression chain to view preview data and if the
+      // the property is milestoned. If that is the case we need to replace the
+      // `property` with `propertyAllVersions`
+      if (
+        options?.useAllVersionsForMilestoning &&
+        currentExpression.func.value.genericType.value.rawType instanceof
+          Class &&
+        currentExpression.func.value._OWNER._generatedMilestonedProperties
+          .length !== 0
+      ) {
+        const name = currentExpression.func.value.name;
+        const property =
+          currentExpression.func.value._OWNER._generatedMilestonedProperties.find(
+            (e) => e.name === `${name}${MILESTONING_VERSION_PROPERTY_SUFFIX}`,
+          );
+        if (property) {
+          propertyExpression_setFunc(
+            currentExpression,
+            PropertyExplicitReference.create(property),
+          );
+          functionExpression_setParametersValues(
+            currentExpression,
+            [guaranteeNonNullable(currentExpression.parametersValues[0])],
+            queryBuilderState.observableContext,
+          );
+        }
+      } else {
+        const currentPropertyExpression = currentExpression;
+        const parameterValues = currentExpression.parametersValues.slice(1);
+        parameterValues.forEach((parameterValue, index) => {
+          if (parameterValue instanceof INTERNAL__PropagatedValue) {
+            // Replace with argumentless derived property expression only when default date propagation is supported
             if (
-              (index === 1 &&
-                currentPropertyExpression.parametersValues.length === 3) ||
-              (index === 0 &&
-                currentPropertyExpression.parametersValues.length === 3 &&
-                !(
-                  currentPropertyExpression.parametersValues[2] instanceof
-                    INTERNAL__PropagatedValue &&
-                  currentPropertyExpression.parametersValues[2]
-                    .isPropagatedValue === true
-                ))
+              !TEMPORARY__disableDatePropagation &&
+              parameterValue.isPropagatedValue
             ) {
+              // NOTE: For `bitemporal` property check if the property expression has parameters which are not instance of
+              // `INTERNAL_PropagatedValue` then pass the parameters as user explicitly changed values of either of the parameters.
+              if (
+                (index === 1 &&
+                  currentPropertyExpression.parametersValues.length === 3) ||
+                (index === 0 &&
+                  currentPropertyExpression.parametersValues.length === 3 &&
+                  !(
+                    currentPropertyExpression.parametersValues[2] instanceof
+                      INTERNAL__PropagatedValue &&
+                    currentPropertyExpression.parametersValues[2]
+                      .isPropagatedValue === true
+                  ))
+              ) {
+                currentPropertyExpression.parametersValues[index + 1] =
+                  getValueOfInternalPropagatedValue(parameterValue);
+              } else {
+                currentPropertyExpression.parametersValues = [
+                  guaranteeNonNullable(
+                    guaranteeType(currentExpression, AbstractPropertyExpression)
+                      .parametersValues[0],
+                  ),
+                ];
+              }
+            } else {
               currentPropertyExpression.parametersValues[index + 1] =
                 getValueOfInternalPropagatedValue(parameterValue);
-            } else {
-              currentPropertyExpression.parametersValues = [
-                guaranteeNonNullable(
-                  guaranteeType(currentExpression, AbstractPropertyExpression)
-                    .parametersValues[0],
-                ),
-              ];
             }
-          } else {
-            currentPropertyExpression.parametersValues[index + 1] =
-              getValueOfInternalPropagatedValue(parameterValue);
           }
-        }
-      });
+        });
+      }
     }
     currentExpression = nextExpression;
     // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
@@ -150,5 +186,12 @@ export type LambdaFunctionBuilderOption = {
    * queryBuilderState will make the lambda function building process overrides several query values, such as the row limit.
    */
   isBuildingExecutionQuery?: boolean | undefined;
+
+  /**
+   * Set this to `true` when we construct query for execution within the app to view preview data.
+   * queryBuilderState will make the lambda function building process overrides `.all()` to `.allVersions()` if the Class
+   * is milestoned and `property` to `propertyAllVersions` if a property is milestoned.
+   */
+  useAllVersionsForMilestoning?: boolean | undefined;
   keepSourceInformation?: boolean | undefined;
 };

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

@@ -227,6 +227,7 @@ export const appendProjection = (
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
               projectionColumnState.lambdaParameterName,
+              options,
               true,
             ),
           ],
@@ -328,6 +329,7 @@ export const appendProjection = (
               projectionColumnState.propertyExpressionState.propertyExpression,
               projectionColumnState.propertyExpressionState.queryBuilderState,
               projectionColumnState.lambdaParameterName,
+              options,
             ),
           ],
           queryBuilderState.graphManagerState.graph,

package/src/stores/shared/LambdaParameterState.ts

@@ -58,7 +58,7 @@ import {
 } from './ValueSpecificationModifierHelper.js';
 
 export enum PARAMETER_SUBMIT_ACTION {
-  EXECUTE = 'EXECUTE',
+  RUN = 'RUN',
   EXPORT = 'EXPORT',
 }