@finos/legend-query-builder 4.14.51 → 4.14.52

package/src/components/shared/CustomDatePicker.tsx

@@ -1244,7 +1244,9 @@ export const CustomDatePicker: React.FC<{
      */
     match?: boolean;
   };
+  displayAsEditableValue?: boolean | undefined;
   setValueSpecification: (val: ValueSpecification) => void;
+  handleBlur?: (() => void) | undefined;
 }> = (props) => {
   const {
     valueSpecification,
@@ -1253,6 +1255,8 @@ export const CustomDatePicker: React.FC<{
     observerContext,
     hasError,
     typeCheckOption,
+    displayAsEditableValue,
+    handleBlur,
   } = props;
   const applicationStore = useApplicationStore();
   // For some cases where types need to be matched strictly.
@@ -1283,6 +1287,7 @@ export const CustomDatePicker: React.FC<{
       buildDatePickerOption(valueSpecification, applicationStore),
     );
     setAnchorEl(null);
+    handleBlur?.();
   };
   const handleDatePickerOptionChange = (
     event: React.ChangeEvent<HTMLInputElement>,
@@ -1408,15 +1413,35 @@ export const CustomDatePicker: React.FC<{
 
   return (
     <>
-      <button
-        className={clsx('value-spec-editor__date-picker__trigger', {
-          'value-spec-editor__date-picker__trigger--error': hasError,
-        })}
-        title="Click to edit and pick from more date options"
-        onClick={openCustomDatePickerPopover}
-      >
-        {datePickerOption.label || 'Select value'}
-      </button>
+      {displayAsEditableValue ? (
+        <span
+          className={clsx(
+            'value-spec-editor__date-picker__editable__display--content editable-value',
+            {
+              'value-spec-editor__date-picker__editable__display--content--error':
+                hasError,
+            },
+          )}
+          title="Click to edit and pick from more date options"
+          onClick={openCustomDatePickerPopover}
+        >
+          {datePickerOption.label ? (
+            `"${datePickerOption.label}"`
+          ) : (
+            <>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</>
+          )}
+        </span>
+      ) : (
+        <button
+          className={clsx('value-spec-editor__date-picker__trigger', {
+            'value-spec-editor__date-picker__trigger--error': hasError,
+          })}
+          title="Click to edit and pick from more date options"
+          onClick={openCustomDatePickerPopover}
+        >
+          {datePickerOption.label || 'Select value'}
+        </button>
+      )}
       <BasePopover
         open={Boolean(anchorEl)}
         TransitionProps={{
@@ -1425,8 +1450,8 @@ export const CustomDatePicker: React.FC<{
         anchorEl={anchorEl}
         onClose={closeCustomDatePickerPopover}
         anchorOrigin={{
-          vertical: 'bottom',
-          horizontal: 'center',
+          vertical: displayAsEditableValue ? 20 : 'bottom',
+          horizontal: displayAsEditableValue ? 50 : 'center',
         }}
         transformOrigin={{
           vertical: 'top',

package/src/components/shared/LambdaParameterValuesEditor.tsx

@@ -103,7 +103,7 @@ export const LambdaParameterValuesEditor = observer(
                         paramState.setValue(val);
                       }}
                       graph={graph}
-                      obseverContext={observerContext}
+                      observerContext={observerContext}
                       typeCheckOption={{
                         expectedType: variableType,
                         match: variableType === PrimitiveType.DATETIME,

package/src/components/shared/QueryBuilderVariableSelector.tsx

@@ -61,7 +61,10 @@ export const getNameOfValueSpecification = (
       return possibleDateLabel;
     }
   }
-  return getValueSpecificationStringValue(value);
+  return getValueSpecificationStringValue(
+    value,
+    queryBuilderState.applicationStore,
+  );
 };
 
 const QueryBuilderVariableContextMenu = observer(

package/src/graph/QueryBuilderMetaModelConst.ts

@@ -116,6 +116,7 @@ export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   TDS_TAKE = 'meta::pure::tds::take',
   TDS_RESTRICT = 'meta::pure::tds::restrict',
   TDS_FUNC = 'meta::pure::tds::func',
+  TDS_COL = 'meta::pure::tds::col',
 
   // Relation
   RELATION_PROJECT = 'meta::pure::functions::relation::project',

package/src/graph-manager/protocol/pure/QueryBuilder_PureGraphManagerExtension.ts

@@ -44,4 +44,4 @@ export const getQueryBuilderGraphManagerExtension = (
         extension instanceof QueryBuilder_PureGraphManagerExtension,
     ),
     `Can't find query builder Pure graph manager extension`,
-  ) as QueryBuilder_PureGraphManagerExtension;
+  );

package/src/graph-manager/protocol/pure/v1/V1_QueryValueSpecificationBuilderHelper.ts

@@ -27,10 +27,10 @@ import {
 import {
   type V1_GraphBuilderContext,
   type V1_ProcessingContext,
-  V1_ValueSpecification,
   type ValueSpecification,
-  type SimpleFunctionExpression,
   type Type,
+  type SimpleFunctionExpression,
+  V1_ValueSpecification,
   V1_buildBaseSimpleFunctionExpression,
   V1_buildGenericFunctionExpression,
   extractElementNameFromPath,
@@ -580,7 +580,7 @@ export const V1_buildFilterFunctionExpression = (
   return expression;
 };
 
-export const V1_buildTypedProjectFunctionExpression = (
+const V1_buildTypedProjectFunctionExpression = (
   functionName: string,
   parameters: V1_ValueSpecification[],
   openVariables: string[],
@@ -684,23 +684,184 @@ export const V1_buildTypedProjectFunctionExpression = (
   return expression;
 };
 
-export const V1_buildProjectFunctionExpression = (
+const V1_buildColFunctionExpression = (
+  valueSpecification: V1_ValueSpecification,
+  precedingExperession: ValueSpecification,
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  const appliedFunc = guaranteeType(
+    valueSpecification,
+    V1_AppliedFunction,
+    `Can't build tds col func: only support applied function`,
+  );
+  assertTrue(
+    matchFunctionName(
+      appliedFunc.function,
+      QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_COL,
+    ),
+    `Can't build tds col func: unsupported func name ${appliedFunc.function}`,
+  );
+  assertTrue(
+    appliedFunc.parameters.length === 2,
+    `Can't build tds col func: only support col function with 2 parameters`,
+  );
+  const colLambda = guaranteeType(
+    appliedFunc.parameters[0],
+    V1_Lambda,
+    `Can't build tds col func: only support first parameter of col function as Lambda`,
+  );
+  let lambda: ValueSpecification;
+  try {
+    colLambda.parameters.forEach((variable): void => {
+      if (variable.name && !variable.class) {
+        const variableExpression = new VariableExpression(
+          variable.name,
+          Multiplicity.ONE,
+        );
+        variableExpression.genericType = precedingExperession.genericType;
+        processingContext.addInferredVariables(
+          variable.name,
+          variableExpression,
+        );
+      }
+    });
+    lambda = buildProjectionColumnLambda(
+      colLambda,
+      openVariables,
+      compileContext,
+      processingContext,
+    );
+  } catch {
+    lambda = new INTERNAL__UnknownValueSpecification(
+      V1_serializeValueSpecification(
+        colLambda,
+        compileContext.extensions.plugins,
+      ),
+    );
+  }
+  guaranteeType(
+    appliedFunc.parameters[1],
+    V1_CString,
+    `Can't build tds col func: only support second parameter of col function as String`,
+  );
+  const colNameValueSpec = guaranteeNonNullable(
+    appliedFunc.parameters[1],
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  const colFunctionExpression = V1_buildBaseSimpleFunctionExpression(
+    [lambda, colNameValueSpec],
+    appliedFunc.function,
+    compileContext,
+  );
+  return colFunctionExpression;
+};
+
+const V1_buildTDSProjectWithColFunctionExpression = (
   functionName: string,
   parameters: V1_ValueSpecification[],
   openVariables: string[],
   compileContext: V1_GraphBuilderContext,
   processingContext: V1_ProcessingContext,
 ): SimpleFunctionExpression => {
-  if (parameters.length === 2) {
-    return V1_buildTypedProjectFunctionExpression(
-      functionName,
-      parameters,
+  assertTrue(
+    parameters.length === 2,
+    `Can't build tds project() expression: project() expects 2 arguments`,
+  );
+  const precedingExperession = (
+    parameters[0] as V1_ValueSpecification
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  assertNonNullable(
+    precedingExperession.genericType,
+    `Can't build tds project() expression: preceding expression return type is missing`,
+  );
+  const colFuncExpress = guaranteeNonNullable(
+    parameters[1],
+    `Can't build tds project() expression: second parameter is missing`,
+  );
+  let secondProcessedParameter: ValueSpecification;
+  if (colFuncExpress instanceof V1_Collection) {
+    const processedColExpressions = new CollectionInstanceValue(
+      compileContext.graph.getMultiplicity(
+        colFuncExpress.multiplicity.lowerBound,
+        colFuncExpress.multiplicity.upperBound,
+      ),
+    );
+    processedColExpressions.values = colFuncExpress.values.map((value) =>
+      V1_buildColFunctionExpression(
+        value,
+        precedingExperession,
+        openVariables,
+        compileContext,
+        processingContext,
+      ),
+    );
+    secondProcessedParameter = processedColExpressions;
+  } else {
+    assertType(
+      colFuncExpress,
+      V1_AppliedFunction,
+      `Can't build project() expression: project() expects argument #2 to be a function`,
+    );
+    secondProcessedParameter = V1_buildColFunctionExpression(
+      colFuncExpress,
+      precedingExperession,
       openVariables,
       compileContext,
       processingContext,
     );
   }
+  const expression = V1_buildBaseSimpleFunctionExpression(
+    [precedingExperession, secondProcessedParameter],
+    functionName,
+    compileContext,
+  );
+  expression.genericType = GenericTypeExplicitReference.create(
+    new GenericType(
+      compileContext.resolveType(QUERY_BUILDER_PURE_PATH.TDS_ROW).value,
+    ),
+  );
+  return expression;
+};
 
+export const V1_buildProjectFunctionExpression = (
+  functionName: string,
+  parameters: V1_ValueSpecification[],
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): SimpleFunctionExpression => {
+  if (parameters.length === 2) {
+    try {
+      return V1_buildTDSProjectWithColFunctionExpression(
+        functionName,
+        parameters,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    } catch {
+      return V1_buildTypedProjectFunctionExpression(
+        functionName,
+        parameters,
+        openVariables,
+        compileContext,
+        processingContext,
+      );
+    }
+  }
   const length = parameters.length;
   assertTrue(
     length === 3 || length === 2,
@@ -723,15 +884,19 @@ export const V1_buildProjectFunctionExpression = (
   );
 
   const columnExpressions = parameters[1];
-  assertType(
-    columnExpressions,
-    V1_Collection,
-    `Can't build project() expression: project() expects argument #1 to be a collection`,
-  );
-  topLevelLambdaParameters = columnExpressions.values
-    .filter(filterByType(V1_Lambda))
-    .map((lambda) => lambda.parameters)
-    .flat();
+  if (columnExpressions instanceof V1_Lambda) {
+    topLevelLambdaParameters = columnExpressions.parameters;
+  } else {
+    assertType(
+      columnExpressions,
+      V1_Collection,
+      `Can't build project() expression: project() expects argument #1 to be a collection`,
+    );
+    topLevelLambdaParameters = columnExpressions.values
+      .filter(filterByType(V1_Lambda))
+      .map((lambda) => lambda.parameters)
+      .flat();
+  }
 
   const variables = new Set<string>();
   // Make sure top-level lambdas have their lambda parameter types set properly
@@ -753,7 +918,13 @@ export const V1_buildProjectFunctionExpression = (
       columnExpressions.multiplicity.upperBound,
     ),
   );
-  processedColumnExpressions.values = columnExpressions.values.map((value) => {
+  let colExpressionValues: V1_ValueSpecification[] = [];
+  if (columnExpressions instanceof V1_Lambda) {
+    colExpressionValues = [columnExpressions];
+  } else {
+    colExpressionValues = columnExpressions.values;
+  }
+  processedColumnExpressions.values = colExpressionValues.map((value) => {
     try {
       return buildProjectionColumnLambda(
         value,

package/src/stores/QueryBuilderStateBuilder.ts

@@ -68,6 +68,7 @@ import {
   processInternalizeExpression,
 } from './fetch-structure/graph-fetch/QueryBuilderGraphFetchTreeStateBuilder.js';
 import {
+  processTDSColExpression,
   processTDSDistinctExpression,
   processTDSProjectExpression,
   processTDSProjectionColumnPropertyExpression,
@@ -661,7 +662,11 @@ export class QueryBuilderValueSpecificationProcessor
           this.parentLambda,
         );
       }
-
+      return;
+    } else if (
+      matchFunctionName(functionName, QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_COL)
+    ) {
+      processTDSColExpression(valueSpecification, this.queryBuilderState);
       return;
     } else if (
       matchFunctionName(

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -86,7 +86,7 @@ export const getCollectionValueSpecificationType = (
 ): Type | undefined => {
   if (values.every((val) => val instanceof PrimitiveInstanceValue)) {
     const valuePrimitiveTypes: (PrimitiveType | undefined)[] = [];
-    (values as PrimitiveInstanceValue[]).forEach((val) => {
+    values.forEach((val) => {
       const primitiveType = val.genericType.value.rawType;
       switch (primitiveType.path) {
         case PRIMITIVE_TYPE.STRING:
@@ -118,7 +118,7 @@ export const getCollectionValueSpecificationType = (
     return valuePrimitiveTypes[0] as PrimitiveType;
   } else if (values.every((val) => val instanceof EnumValueInstanceValue)) {
     const valueEnumerationTypes: Enumeration[] = [];
-    (values as EnumValueInstanceValue[]).forEach((val) => {
+    values.forEach((val) => {
       addUniqueEntry(
         valueEnumerationTypes,
         guaranteeNonNullable(val.values[0]).value._OWNER,

package/src/stores/fetch-structure/tds/QueryBuilderTDSState.ts

@@ -122,6 +122,7 @@ export class QueryBuilderTDSState
   isConvertDerivationProjectionObjects = false;
   showPostFilterPanel: boolean;
   showWindowFuncPanel = false;
+  useColFunc = false;
 
   postFilterOperators: QueryBuilderPostFilterOperator[] =
     getQueryBuilderCorePostFilterOperators();
@@ -144,6 +145,7 @@ export class QueryBuilderTDSState
       isConvertDerivationProjectionObjects: observable,
       showPostFilterPanel: observable,
       showWindowFuncPanel: observable,
+      useColFunc: observable,
       TEMPORARY__showPostFetchStructurePanel: computed,
       derivations: computed,
       hasParserError: computed,
@@ -157,6 +159,7 @@ export class QueryBuilderTDSState
       initializeWithQuery: action,
       setShowPostFilterPanel: action,
       setShowWindowFuncPanel: action,
+      setUseColFunc: action,
       checkBeforeChangingImplementation: action,
       convertDerivationProjectionObjects: flow,
       fetchDerivedReturnTypes: flow,
@@ -459,6 +462,10 @@ export class QueryBuilderTDSState
     this.showWindowFuncPanel = val;
   }
 
+  setUseColFunc(val: boolean): void {
+    this.useColFunc = val;
+  }
+
   *convertDerivationProjectionObjects(): GeneratorFn<void> {
     const lambdas = new Map<string, RawLambda>();
     const derivationProjectionColumnStateMap = new Map<