@finos/legend-query-builder 4.14.40 → 4.14.41

package/src/components/shared/QueryBuilderVariableSelector.tsx

@@ -149,6 +149,18 @@ export const VariableViewer = observer(
     const variableTypeName =
       variable.genericType?.value.rawType.name ??
       (isConstant ? CALCULATED : undefined);
+    const isMilestoningParameter =
+      queryBuilderState.milestoningState.isMilestoningParameter(variable);
+    const milestoningParameterValue =
+      queryBuilderState.milestoningState.getMilestoningParameterValue(variable);
+    const milestoningParameterValueString = isMilestoningParameter
+      ? milestoningParameterValue
+        ? getNameOfValueSpecification(
+            milestoningParameterValue,
+            queryBuilderState,
+          )
+        : undefined
+      : undefined;
     const deleteDisabled = isReadOnly || isVariableUsed;
     const deleteTitle = isVariableUsed ? 'Used in query' : 'Remove';
     const editVariable = (): void => {
@@ -227,6 +239,16 @@ export const VariableViewer = observer(
                   <div className="query-builder__variables__variable__type__label">
                     {variableTypeName ?? 'unknown'}
                   </div>
+                  {isMilestoningParameter && (
+                    <>
+                      <div className="query-builder__variables__variable__type__label query-builder__variables__variable__type__label--milestoning">
+                        milestoning
+                      </div>
+                      <div className="query-builder__constants__value">
+                        {milestoningParameterValueString}
+                      </div>
+                    </>
+                  )}
                 </div>
               )}
             </div>

package/src/stores/QueryBuilderPropertyEditorState.ts

@@ -161,7 +161,8 @@ export const generateValueSpecificationForParameter = (
   return createNullishValue(graph);
 };
 
-const fillDerivedPropertyParameterValues = (
+//here
+export const fillDerivedPropertyParameterValues = (
   derivedPropertyExpressionState: QueryBuilderDerivedPropertyExpressionState,
 ): void => {
   const parameterValues: ValueSpecification[] =

package/src/stores/QueryBuilderState.ts

@@ -110,6 +110,8 @@ import type { QueryBuilderConfig } from '../graph-manager/QueryBuilderConfig.js'
 import { QUERY_BUILDER_EVENT } from '../__lib__/QueryBuilderEvent.js';
 import { QueryBuilderChangeHistoryState } from './QueryBuilderChangeHistoryState.js';
 import { type QueryBuilderWorkflowState } from './query-workflow/QueryBuilderWorkFlowState.js';
+import { initializeMilestoningStateFromDerivedProperty } from './milestoning/QueryBuilderMilestoningHelper.js';
+import { QueryBuilderSimpleProjectionColumnState } from './fetch-structure/tds/projection/QueryBuilderProjectionColumnState.js';
 
 export interface QuerySDLC {}
 
@@ -697,6 +699,18 @@ export abstract class QueryBuilderState implements CommandRegistrar {
         );
       }
       if (this.parametersState.parameterStates.length > 0) {
+        const fetchStructureStateImp = this.fetchStructureState.implementation;
+        if (fetchStructureStateImp instanceof QueryBuilderTDSState) {
+          fetchStructureStateImp.projectionColumns.forEach((colState) => {
+            if (colState instanceof QueryBuilderSimpleProjectionColumnState) {
+              colState.propertyExpressionState.derivedPropertyExpressionStates.forEach(
+                (state) => {
+                  initializeMilestoningStateFromDerivedProperty(state);
+                },
+              );
+            }
+          });
+        }
         this.setShowParametersPanel(true);
       }
       this.fetchStructureState.initializeWithQuery();

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

@@ -53,7 +53,7 @@ export class QueryBuilderPostFilterOperator_In
   implements Hashable
 {
   getLabel(): string {
-    return 'is in';
+    return 'is in list of';
   }
 
   isCompatibleWithType(type: Type): boolean {
@@ -168,7 +168,7 @@ export class QueryBuilderPostFilterOperator_In
 
 export class QueryBuilderPostFilterOperator_NotIn extends QueryBuilderPostFilterOperator_In {
   override getLabel(): string {
-    return `is not in`;
+    return `is not in list of`;
   }
 
   override buildPostFilterConditionExpression(

package/src/stores/filter/QueryBuilderFilterState.ts

@@ -128,17 +128,20 @@ export class FilterConditionState implements Hashable {
     );
   }
 
-  *handleTypeaheadSearch(): GeneratorFn<void> {
+  *handleTypeaheadSearch(
+    searchValue?: ValueSpecification | undefined,
+  ): GeneratorFn<void> {
+    const value = searchValue ?? this.value;
     try {
       this.typeaheadSearchState.inProgress();
       this.typeaheadSearchResults = undefined;
-      if (performTypeahead(this.value)) {
+      if (performTypeahead(value)) {
         const result =
           (yield this.filterState.queryBuilderState.graphManagerState.graphManager.runQuery(
             buildPropertyTypeaheadQuery(
               this.filterState.queryBuilderState,
               this.propertyExpressionState.propertyExpression,
-              this.value,
+              value,
             ),
             guaranteeNonNullable(
               this.filterState.queryBuilderState.executionContextState.mapping,

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

@@ -48,7 +48,7 @@ export class QueryBuilderFilterOperator_In
   implements Hashable
 {
   getLabel(filterConditionState: FilterConditionState): string {
-    return 'is in';
+    return 'is in list of';
   }
 
   isCompatibleWithFilterConditionProperty(
@@ -172,7 +172,7 @@ export class QueryBuilderFilterOperator_In
 
 export class QueryBuilderFilterOperator_NotIn extends QueryBuilderFilterOperator_In {
   override getLabel(filterConditionState: FilterConditionState): string {
-    return `is not in`;
+    return `is not in list of`;
   }
 
   override buildFilterConditionExpression(

package/src/stores/milestoning/QueryBuilderMilestoningHelper.ts

@@ -290,6 +290,30 @@ export const generateMilestonedPropertyParameterValue = (
     );
 };
 
+export const initializeMilestoningStateFromDerivedProperty = (
+  derivedPropertyExpressionState: QueryBuilderDerivedPropertyExpressionState,
+): void => {
+  const milestoningState =
+    derivedPropertyExpressionState.queryBuilderState.milestoningState;
+  const temporalTarget =
+    derivedPropertyExpressionState.propertyExpression.func.value.genericType
+      .value.rawType instanceof Class &&
+    derivedPropertyExpressionState.propertyExpression.func.value._OWNER
+      ._generatedMilestonedProperties.length !== 0
+      ? getMilestoneTemporalStereotype(
+          derivedPropertyExpressionState.propertyExpression.func.value
+            .genericType.value.rawType,
+          derivedPropertyExpressionState.queryBuilderState.graphManagerState
+            .graph,
+        )
+      : undefined;
+  if (temporalTarget) {
+    milestoningState
+      .getMilestoningImplementation(temporalTarget)
+      .initializeMilestoningParameters();
+  }
+};
+
 export const validateMilestoningPropertyExpressionChain = (
   sourceStereotype: MILESTONING_STEREOTYPE | undefined,
   targetStereotype: MILESTONING_STEREOTYPE,

package/src/stores/milestoning/QueryBuilderMilestoningState.ts

@@ -451,6 +451,33 @@ export class QueryBuilderMilestoningState implements Hashable {
     return milestoningParameter;
   }
 
+  updateMilestoningParameterValue(
+    parameter: VariableExpression,
+    value: ValueSpecification | undefined,
+  ): void {
+    const variableState =
+      this.queryBuilderState.parametersState.parameterStates.find(
+        (param) => param.parameter.name === parameter.name,
+      );
+    if (variableState) {
+      variableState.setValue(value);
+    }
+  }
+
+  getMilestoningParameterValue(
+    milestoningParameter: ValueSpecification,
+  ): ValueSpecification | undefined {
+    let value: ValueSpecification | undefined = milestoningParameter;
+    if (milestoningParameter instanceof VariableExpression) {
+      const paramState =
+        this.queryBuilderState.parametersState.parameterStates.find(
+          (param) => param.parameter.name === milestoningParameter.name,
+        );
+      value = paramState?.value;
+    }
+    return value;
+  }
+
   isVariableUsed(variable: VariableExpression): boolean {
     const usedInBusiness = this.businessDate
       ? isValueExpressionReferencedInValue(variable, this.businessDate)
@@ -461,6 +488,33 @@ export class QueryBuilderMilestoningState implements Hashable {
     return usedInBusiness || usedInProcessingDate;
   }
 
+  isMilestoningParameter(parameter: VariableExpression): boolean {
+    let isMilestoningParameter = false;
+    if (this.businessDate instanceof VariableExpression) {
+      isMilestoningParameter =
+        parameter.name ===
+        guaranteeType(this.businessDate, VariableExpression).name;
+    }
+    if (this.processingDate instanceof VariableExpression) {
+      isMilestoningParameter =
+        isMilestoningParameter ||
+        parameter.name ===
+          guaranteeType(this.processingDate, VariableExpression).name;
+    }
+    if (this.startDate instanceof VariableExpression) {
+      isMilestoningParameter =
+        isMilestoningParameter ||
+        parameter.name ===
+          guaranteeType(this.startDate, VariableExpression).name;
+    }
+    if (this.endDate instanceof VariableExpression) {
+      isMilestoningParameter =
+        isMilestoningParameter ||
+        parameter.name === guaranteeType(this.endDate, VariableExpression).name;
+    }
+    return isMilestoningParameter;
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.MILESTONING_STATE,

package/src/stores/shared/ValueSpecificationEditorHelper.ts

@@ -321,3 +321,66 @@ export const valueSpecReturnTDS = (
     retunType && tdsType && (retunType === tdsType || retunType === tdsRowType),
   );
 };
+
+export const convertTextToPrimitiveInstanceValue = (
+  expectedType: Type,
+  value: string,
+  obseverContext: ObserverContext,
+): PrimitiveInstanceValue | null => {
+  let result = null;
+  if (expectedType instanceof PrimitiveType) {
+    switch (expectedType.path) {
+      case PRIMITIVE_TYPE.STRING: {
+        result = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+        );
+        instanceValue_setValues(result, [value.toString()], obseverContext);
+        break;
+      }
+      case PRIMITIVE_TYPE.NUMBER:
+      case PRIMITIVE_TYPE.FLOAT:
+      case PRIMITIVE_TYPE.DECIMAL:
+      case PRIMITIVE_TYPE.INTEGER: {
+        if (isNaN(Number(value))) {
+          return null;
+        }
+        result = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+        );
+        instanceValue_setValues(result, [Number(value)], obseverContext);
+        break;
+      }
+      case PRIMITIVE_TYPE.DATE:
+      case PRIMITIVE_TYPE.STRICTDATE: {
+        if (isNaN(Date.parse(value))) {
+          return null;
+        }
+        result = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+        );
+        instanceValue_setValues(result, [value], obseverContext);
+        break;
+      }
+      case PRIMITIVE_TYPE.DATETIME: {
+        if (
+          isNaN(Date.parse(value)) ||
+          !new Date(value).getTime() ||
+          (value.includes('%') &&
+            (isNaN(Date.parse(value.slice(1))) ||
+              !new Date(value.slice(1)).getTime()))
+        ) {
+          return null;
+        }
+        result = new PrimitiveInstanceValue(
+          GenericTypeExplicitReference.create(new GenericType(expectedType)),
+        );
+        instanceValue_setValues(result, [value], obseverContext);
+        break;
+      }
+      default:
+        // unsupported expected type, just escape
+        return null;
+    }
+  }
+  return result;
+};