@finos/legend-query-builder 3.2.10 → 4.0.0

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

@@ -52,6 +52,11 @@ import {
   PrimitiveType,
   V1_CStrictDate,
   V1_CString,
+  CORE_PURE_PATH,
+  FunctionType,
+  LambdaFunction,
+  LambdaFunctionInstanceValue,
+  PackageableElementExplicitReference,
 } from '@finos/legend-graph';
 import {
   QUERY_BUILDER_PURE_PATH,
@@ -91,81 +96,41 @@ const buildProjectionColumnLambda = (
   let currentPropertyExpression: V1_ValueSpecification = valueSpecification
     .body[0] as V1_ValueSpecification;
 
-  // calendar
-  if (
-    currentPropertyExpression instanceof V1_AppliedFunction &&
-    matchFunctionName(
-      currentPropertyExpression.function,
-      Object.values(QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS),
-    )
-  ) {
-    assertTrue(
-      currentPropertyExpression.parameters.length === 4,
-      `Can't build projection column: only support calendar function with four parameters`,
-    );
-    assertType(
-      currentPropertyExpression.parameters[0],
-      V1_AppliedProperty,
-      `Can't build projection column: only support first parameter of calendar function as property expression`,
-    );
-    const calendarType = guaranteeType(
-      currentPropertyExpression.parameters[1],
-      V1_CString,
-      `Can't build projection column: only support second parameter of calendar function as String`,
-    );
+  assertType(
+    currentPropertyExpression,
+    V1_AppliedProperty,
+    `Can't build projection column: only support lambda body as property expression`,
+  );
+  while (currentPropertyExpression instanceof V1_AppliedProperty) {
     assertTrue(
-      Object.values(QUERY_BUILDER_CALENDAR_TYPE).find(
-        (val) => val === calendarType.value,
-      ) !== undefined,
-      `Can't build projection column: ${calendarType.value} is not a supported calendar type`,
-    );
-    guaranteeType(
-      currentPropertyExpression.parameters[2],
-      V1_CStrictDate,
-      `Can't build projection column: only support third parameter of calendar function as StrictDate`,
-    );
-    assertType(
-      currentPropertyExpression.parameters[3],
-      V1_AppliedProperty,
-      `Can't build projection column: only support fourth parameter of calendar function as property expression`,
-    );
-  } else {
-    assertType(
-      currentPropertyExpression,
-      V1_AppliedProperty,
+      currentPropertyExpression.parameters.length >= 1,
       `Can't build projection column: only support lambda body as property expression`,
     );
-    while (currentPropertyExpression instanceof V1_AppliedProperty) {
-      assertTrue(
-        currentPropertyExpression.parameters.length >= 1,
-        `Can't build projection column: only support lambda body as property expression`,
-      );
+    currentPropertyExpression = currentPropertyExpression
+      .parameters[0] as V1_ValueSpecification;
+    // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
+    // $x.employees->subType(@Person)->subType(@Staff)
+    while (
+      currentPropertyExpression instanceof V1_AppliedFunction &&
+      matchFunctionName(
+        currentPropertyExpression.function,
+        QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
+      )
+    ) {
       currentPropertyExpression = currentPropertyExpression
         .parameters[0] as V1_ValueSpecification;
-      // Take care of chains of subtype (a pattern that is not useful, but we want to support and rectify)
-      // $x.employees->subType(@Person)->subType(@Staff)
-      while (
-        currentPropertyExpression instanceof V1_AppliedFunction &&
-        matchFunctionName(
-          currentPropertyExpression.function,
-          QUERY_BUILDER_SUPPORTED_FUNCTIONS.SUBTYPE,
-        )
-      ) {
-        currentPropertyExpression = currentPropertyExpression
-          .parameters[0] as V1_ValueSpecification;
-      }
     }
-    // check lambda variable and parameter match
-    assertType(
-      currentPropertyExpression,
-      V1_Variable,
-      `Can't build projection column: only support lambda body as property expression`,
-    );
-    assertTrue(
-      columnLambdaParameter.name === currentPropertyExpression.name,
-      `Can't build column lambda: expects variable used in lambda body '${currentPropertyExpression.name}' to match lambda parameter '${columnLambdaParameter.name}'`,
-    );
   }
+  // check lambda variable and parameter match
+  assertType(
+    currentPropertyExpression,
+    V1_Variable,
+    `Can't build projection column: only support lambda body as property expression`,
+  );
+  assertTrue(
+    columnLambdaParameter.name === currentPropertyExpression.name,
+    `Can't build column lambda: expects variable used in lambda body '${currentPropertyExpression.name}' to match lambda parameter '${columnLambdaParameter.name}'`,
+  );
   return valueSpecification.accept_ValueSpecificationVisitor(
     new V1_ValueSpecificationBuilder(
       compileContext,
@@ -175,6 +140,138 @@ const buildProjectionColumnLambda = (
   );
 };
 
+const buildCalendarFunctionExpression = (
+  valueSpecification: V1_ValueSpecification,
+  openVariables: string[],
+  compileContext: V1_GraphBuilderContext,
+  processingContext: V1_ProcessingContext,
+): ValueSpecification => {
+  assertType(
+    valueSpecification,
+    V1_Lambda,
+    `Can't build calendar aggregation column: only support lambda`,
+  );
+
+  // lambda parameter
+  assertTrue(
+    valueSpecification.parameters.length === 1,
+    `Can't build calendar aggregation column: only support lambda with 1 parameter`,
+  );
+
+  // lambda body
+  assertTrue(
+    valueSpecification.body.length === 1,
+    `Can't build calendar aggregation column: only support lambda body with 1 expression`,
+  );
+  const columnLambdaParameter = guaranteeType(
+    valueSpecification.parameters[0],
+    V1_Variable,
+    `Can't build calendar aggregation column: only support lambda with 1 parameter`,
+  );
+  const currentPropertyExpression = guaranteeType(
+    valueSpecification.body[0],
+    V1_AppliedFunction,
+    `Can't build calendar aggregation column: only support applied function`,
+  );
+  assertTrue(
+    matchFunctionName(
+      currentPropertyExpression.function,
+      Object.values(QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS),
+    ),
+    `Can't build calendar aggregation columnn: unsupported calenddar function`,
+  );
+
+  assertTrue(
+    currentPropertyExpression.parameters.length === 4,
+    `Can't build calendar aggregation column: only support calendar function with four parameters`,
+  );
+  assertType(
+    currentPropertyExpression.parameters[0],
+    V1_AppliedProperty,
+    `Can't build calendar aggregation column: only support first parameter of calendar function as property expression`,
+  );
+  const calendarType = guaranteeType(
+    currentPropertyExpression.parameters[1],
+    V1_CString,
+    `Can't build calendar aggregation column: only support second parameter of calendar function as String`,
+  );
+  assertTrue(
+    Object.values(QUERY_BUILDER_CALENDAR_TYPE).find(
+      (val) => val === calendarType.value,
+    ) !== undefined,
+    `Can't build calendar aggregation column: ${calendarType.value} is not a supported calendar type`,
+  );
+  guaranteeType(
+    currentPropertyExpression.parameters[2],
+    V1_CStrictDate,
+    `Can't build calendar aggregation column: only support third parameter of calendar function as StrictDate`,
+  );
+  const dateColumn =
+    currentPropertyExpression.parameters[0].accept_ValueSpecificationVisitor(
+      new V1_ValueSpecificationBuilder(
+        compileContext,
+        processingContext,
+        openVariables,
+      ),
+    );
+  const calendarTypeValueSpec = guaranteeNonNullable(
+    currentPropertyExpression.parameters[1],
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  const endDate = guaranteeNonNullable(
+    currentPropertyExpression.parameters[2],
+  ).accept_ValueSpecificationVisitor(
+    new V1_ValueSpecificationBuilder(
+      compileContext,
+      processingContext,
+      openVariables,
+    ),
+  );
+  const columnLambda = guaranteeNonNullable(
+    currentPropertyExpression.parameters[3],
+  );
+  const targetColumn =
+    returnUndefOnError(() =>
+      columnLambda.accept_ValueSpecificationVisitor(
+        new V1_ValueSpecificationBuilder(
+          compileContext,
+          processingContext,
+          openVariables,
+        ),
+      ),
+    ) ??
+    new INTERNAL__UnknownValueSpecification(
+      V1_serializeValueSpecification(
+        columnLambda,
+        compileContext.extensions.plugins,
+      ),
+    );
+  const calendarFunctionExpression = V1_buildBaseSimpleFunctionExpression(
+    [dateColumn, calendarTypeValueSpec, endDate, targetColumn],
+    currentPropertyExpression.function,
+    compileContext,
+  );
+  const functionInstanceValue = new LambdaFunctionInstanceValue();
+  const functionType = new FunctionType(
+    PackageableElementExplicitReference.create(
+      compileContext.graph.getType(CORE_PURE_PATH.ANY),
+    ),
+    Multiplicity.ONE,
+  );
+  functionType.parameters.push(
+    new VariableExpression(columnLambdaParameter.name, Multiplicity.ONE),
+  );
+  const lambdaFunction = new LambdaFunction(functionType);
+  lambdaFunction.expressionSequence = [calendarFunctionExpression];
+  functionInstanceValue.values.push(lambdaFunction);
+  return functionInstanceValue;
+};
+
 const buildAggregationExpression = (
   valueSpecification: V1_ValueSpecification,
   openVariables: string[],
@@ -205,21 +302,46 @@ const buildAggregationExpression = (
     V1_Lambda,
     `Can't build agg() expression: agg() expects argument #1 as a lambda`,
   );
-  const processedColumnLambda =
-    returnUndefOnError(() =>
-      buildProjectionColumnLambda(
-        columnLambda,
-        openVariables,
-        compileContext,
-        processingContext,
-      ),
-    ) ??
-    new INTERNAL__UnknownValueSpecification(
-      V1_serializeValueSpecification(
-        columnLambda,
-        compileContext.extensions.plugins,
-      ),
-    );
+  let processedColumnLambda;
+  if (
+    columnLambda.body[0] instanceof V1_AppliedFunction &&
+    matchFunctionName(
+      columnLambda.body[0].function,
+      Object.values(QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS),
+    )
+  ) {
+    processedColumnLambda =
+      returnUndefOnError(() =>
+        buildCalendarFunctionExpression(
+          columnLambda,
+          openVariables,
+          compileContext,
+          processingContext,
+        ),
+      ) ??
+      new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(
+          columnLambda,
+          compileContext.extensions.plugins,
+        ),
+      );
+  } else {
+    processedColumnLambda =
+      returnUndefOnError(() =>
+        buildProjectionColumnLambda(
+          columnLambda,
+          openVariables,
+          compileContext,
+          processingContext,
+        ),
+      ) ??
+      new INTERNAL__UnknownValueSpecification(
+        V1_serializeValueSpecification(
+          columnLambda,
+          compileContext.extensions.plugins,
+        ),
+      );
+  }
 
   // aggregate lambda
   const aggregateLambda = guaranteeType(

package/src/stores/QueryBuilderStateBuilder.ts

@@ -40,7 +40,7 @@ import {
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
   type VariableExpression,
-  AbstractPropertyExpression,
+  type AbstractPropertyExpression,
   getMilestoneTemporalStereotype,
   type INTERNAL__PropagatedValue,
   type ValueSpecification,
@@ -143,22 +143,6 @@ const processLetExpression = (
   queryBuilderState.constantState.addConstant(constantExpression);
 };
 
-const processCalendarFunction = (
-  expression: SimpleFunctionExpression,
-  queryBuilderState: QueryBuilderState,
-  parentLambda: LambdaFunction,
-): void => {
-  queryBuilderState.isCalendarEnabled = true;
-  assertTrue(
-    expression.parametersValues.length === 4,
-    'Calendar function expected to have four parameters',
-  );
-  processTDSProjectionColumnPropertyExpression(
-    guaranteeType(expression.parametersValues[3], AbstractPropertyExpression),
-    queryBuilderState,
-  );
-};
-
 /**
  * This is the value specification processor (a.k.a state builder) for query builder.
  *
@@ -297,6 +281,9 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
+        ...Object.values(
+          QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+        ),
       ])
     ) {
       processTDSProjectionDerivationExpression(
@@ -561,10 +548,16 @@ export class QueryBuilderValueSpecificationProcessor
         Object.values(QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS),
       )
     ) {
-      processCalendarFunction(
+      this.queryBuilderState.isCalendarEnabled = true;
+      assertTrue(
+        valueSpecification.parametersValues.length === 4,
+        'Calendar function expected to have four parameters',
+      );
+      QueryBuilderValueSpecificationProcessor.processChild(
+        guaranteeNonNullable(valueSpecification.parametersValues[3]),
         valueSpecification,
-        this.queryBuilderState,
         this.parentLambda,
+        this.queryBuilderState,
       );
       return;
     }
@@ -590,6 +583,9 @@ export class QueryBuilderValueSpecificationProcessor
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_PROJECT,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_GROUP_BY,
         QUERY_BUILDER_SUPPORTED_FUNCTIONS.TDS_AGG,
+        ...Object.values(
+          QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+        ),
       ])
     ) {
       processTDSProjectionColumnPropertyExpression(

package/src/stores/QueryBuilderValueSpecificationHelper.ts

@@ -215,6 +215,7 @@ export const generateDefaultValueForPrimitiveType = (
     case PRIMITIVE_TYPE.DECIMAL:
     case PRIMITIVE_TYPE.FLOAT:
     case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.BYTE:
     case PRIMITIVE_TYPE.BINARY:
       return 0;
     case PRIMITIVE_TYPE.DATE:

package/src/stores/fetch-structure/tds/aggregation/QueryBuilderAggregateCalendarFunction.ts

@@ -14,16 +14,23 @@
  * limitations under the License.
  */
 
-import { type Hashable, guaranteeType } from '@finos/legend-shared';
-import type {
+import {
+  type Hashable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import {
   AbstractPropertyExpression,
-  PrimitiveInstanceValue,
-  SimpleFunctionExpression,
-  ValueSpecification,
+  INTERNAL__UnknownValueSpecification,
+  LambdaFunctionInstanceValue,
+  type PrimitiveInstanceValue,
+  type SimpleFunctionExpression,
+  type ValueSpecification,
 } from '@finos/legend-graph';
 import {
   type QueryBuilderProjectionColumnState,
   QueryBuilderSimpleProjectionColumnState,
+  QueryBuilderDerivationProjectionColumnState,
 } from '../projection/QueryBuilderProjectionColumnState.js';
 import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
 import { computed, makeObservable, observable, action } from 'mobx';
@@ -59,18 +66,43 @@ export abstract class QueryBuilderAggregateCalendarFunction
   ): boolean;
 
   abstract buildCalendarFunctionExpression(
-    propertyExpression: AbstractPropertyExpression,
+    propertyExpression:
+      | AbstractPropertyExpression
+      | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification;
 
   buildCalendarFunctionExpressionFromState(
     aggregateColumnState: QueryBuilderAggregateColumnState,
+    columnLambda: ValueSpecification,
   ): ValueSpecification {
-    return this.buildCalendarFunctionExpression(
-      guaranteeType(
-        aggregateColumnState.projectionColumnState,
-        QueryBuilderSimpleProjectionColumnState,
-      ).propertyExpressionState.propertyExpression,
-    );
+    let targetColumn:
+      | AbstractPropertyExpression
+      | INTERNAL__UnknownValueSpecification
+      | undefined;
+    if (
+      aggregateColumnState.projectionColumnState instanceof
+        QueryBuilderSimpleProjectionColumnState &&
+      columnLambda instanceof LambdaFunctionInstanceValue
+    ) {
+      targetColumn = guaranteeType(
+        columnLambda.values[0]?.expressionSequence[0],
+        AbstractPropertyExpression,
+      );
+    } else if (
+      aggregateColumnState.projectionColumnState instanceof
+      QueryBuilderDerivationProjectionColumnState
+    ) {
+      targetColumn = guaranteeType(
+        columnLambda,
+        INTERNAL__UnknownValueSpecification,
+      );
+    }
+    if (!targetColumn) {
+      throw new UnsupportedOperationError(
+        "Can't build calendar aggregation column: target column should be defined",
+      );
+    }
+    return this.buildCalendarFunctionExpression(targetColumn);
   }
 
   abstract updateAggregateColumnState(

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunctionValueSpecificationBuilder.ts

@@ -26,6 +26,7 @@ import {
   PrimitiveType,
   PRIMITIVE_TYPE,
   VariableExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import {
   guaranteeType,
@@ -41,7 +42,9 @@ export const buildCalendarFunctionExpression = (
   dateColumn: AbstractPropertyExpression | undefined,
   calendarType: QUERY_BUILDER_CALENDAR_TYPE,
   endDate: PrimitiveInstanceValue,
-  targetColumn: AbstractPropertyExpression,
+  targetColumn:
+    | AbstractPropertyExpression
+    | INTERNAL__UnknownValueSpecification,
 ): ValueSpecification => {
   const expression = new SimpleFunctionExpression(
     extractElementNameFromPath(calendarFunctionFullPath),
@@ -50,7 +53,7 @@ export const buildCalendarFunctionExpression = (
     expression.parametersValues.push(dateColumn);
   } else {
     throw new UnsupportedOperationError(
-      `Please specify date column for calendar Function for column ${targetColumn.func.value.name}`,
+      `Please specify date column for calendar function for column`,
     );
   }
   const calendarTypeParameter = new PrimitiveInstanceValue(
@@ -147,16 +150,6 @@ export const updateAggregateColumnState = (
       )}() with third parameter of type StrictDate`,
     );
 
-    guaranteeType(
-      expression.parametersValues[3],
-      AbstractPropertyExpression,
-      `Can't process ${extractElementNameFromPath(
-        calendarFunctionFullPath,
-      )}() expression: only support ${extractElementNameFromPath(
-        calendarFunctionFullPath,
-      )}() fourth parameter as property expression`,
-    );
-
     calendarFunction.calendarType = calendarTypeParameter
       .values[0] as QUERY_BUILDER_CALENDAR_TYPE;
     calendarFunction.endDate = endDate;

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Annualized.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Annualized
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_ANNUALIZED,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cme.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Cme
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CME,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cw.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Cw
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CW,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cw_Fm.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -65,7 +66,7 @@ export class QueryBuilderAggregateCalendarFunction_Cw_Fm
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CW_FM,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cy_Minus2.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Cy_Minus2
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CY_MINUS2,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Cy_Minus3.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Cy_Minus3
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_CY_MINUS3,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_Mtd.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_Mtd
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_MTD,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_P12Wa.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_P12Wa
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_P12WA,

package/src/stores/fetch-structure/tds/aggregation/calendarFunctions/QueryBuilderAggregateCalendarFunction_P12Wtd.ts

@@ -19,6 +19,7 @@ import {
   type ValueSpecification,
   type SimpleFunctionExpression,
   type AbstractPropertyExpression,
+  type INTERNAL__UnknownValueSpecification,
 } from '@finos/legend-graph';
 import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
 import {
@@ -64,7 +65,7 @@ export class QueryBuilderAggregateCalendarFunction_P12Wtd
   }
 
   buildCalendarFunctionExpression(
-    p: AbstractPropertyExpression,
+    p: AbstractPropertyExpression | INTERNAL__UnknownValueSpecification,
   ): ValueSpecification {
     return buildCalendarFunctionExpression(
       QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS.CALENDAR_P12WTD,