@finos/legend-query-builder 3.0.7 → 3.1.0

package/src/stores/QueryBuilderTextEditorState.ts

@@ -169,24 +169,31 @@ export class QueryBuilderTextEditorState extends LambdaEditorState {
   }
 
   openModal(mode: QueryBuilderTextEditorMode): void {
-    const rawLambda = this.queryBuilderState.buildQuery();
-    if (mode === QueryBuilderTextEditorMode.TEXT) {
-      this.setQueryRawLambdaState(new QueryBuilderRawLambdaState(rawLambda));
-    }
-    if (mode === QueryBuilderTextEditorMode.JSON) {
-      this.setLambdaJson(
-        JSON.stringify(
-          pruneSourceInformation(
-            this.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
-              rawLambda,
+    try {
+      const rawLambda = this.queryBuilderState.buildQuery();
+      if (mode === QueryBuilderTextEditorMode.TEXT) {
+        this.setQueryRawLambdaState(new QueryBuilderRawLambdaState(rawLambda));
+      }
+      if (mode === QueryBuilderTextEditorMode.JSON) {
+        this.setLambdaJson(
+          JSON.stringify(
+            pruneSourceInformation(
+              this.queryBuilderState.graphManagerState.graphManager.serializeRawValueSpecification(
+                rawLambda,
+              ),
             ),
+            null,
+            DEFAULT_TAB_SIZE,
           ),
-          null,
-          DEFAULT_TAB_SIZE,
-        ),
+        );
+      }
+      this.setMode(mode);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.queryBuilderState.applicationStore.notificationService.notifyError(
+        error,
       );
     }
-    this.setMode(mode);
   }
 
   *closeModal(): GeneratorFn<void> {

package/src/stores/explorer/QueryBuilderExplorerState.ts

@@ -193,12 +193,13 @@ export class QueryBuilderExplorerTreeSubTypeNodeData extends QueryBuilderExplore
 export const buildPropertyExpressionFromExplorerTreeNodeData = (
   node: QueryBuilderExplorerTreePropertyNodeData,
   explorerState: QueryBuilderExplorerState,
+  lambdaParameterName?: string,
 ): AbstractPropertyExpression => {
   const treeData = explorerState.nonNullableTreeData;
   const propertySearchIndexedTreeNodes =
     explorerState.propertySearchState.indexedExplorerTreeNodes;
   const projectionColumnLambdaVariable = new VariableExpression(
-    DEFAULT_LAMBDA_VARIABLE_NAME,
+    lambdaParameterName ?? DEFAULT_LAMBDA_VARIABLE_NAME,
     Multiplicity.ONE,
   );
   const propertyExpression = new AbstractPropertyExpression('');

package/src/stores/fetch-structure/QueryBuilderFetchStructureState.ts

@@ -62,6 +62,7 @@ export class QueryBuilderFetchStructureState {
         break;
       }
       case FETCH_STRUCTURE_IMPLEMENTATION.GRAPH_FETCH: {
+        this.queryBuilderState.setIsCalendarEnabled(false);
         this.implementation = new QueryBuilderGraphFetchTreeState(
           this.queryBuilderState,
           this,

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

@@ -101,6 +101,8 @@ import { getQueryBuilderCoreWindowOperators } from './window/QueryBuilderWindowG
 import type { QueryBuilderTDSColumnState } from './QueryBuilderTDSColumnState.js';
 import { QUERY_BUILDER_SETTING_KEY } from '../../../__lib__/QueryBuilderSetting.js';
 import type { ExportDataInfo } from '../../QueryBuilderResultState.js';
+import type { QueryBuilderAggregateCalendarFunction } from './aggregation/QueryBuilderAggregateCalendarFunction.js';
+import { getQueryBuilderCoreAggregrationCalendarFunctions } from './aggregation/QueryBuilderAggregateCalendarFunctionLoader.js';
 
 // TODO: should we support raw once externalize() is supported on TDS ?
 export enum TDS_EXECUTION_SERIALIZATION_FORMAT {
@@ -124,6 +126,8 @@ export class QueryBuilderTDSState
     getQueryBuilderCorePostFilterOperators();
   aggregationOperators: QueryBuilderAggregateOperator[] =
     getQueryBuilderCoreAggregrationOperators();
+  aggregationCalendarFunctions: QueryBuilderAggregateCalendarFunction[] =
+    getQueryBuilderCoreAggregrationCalendarFunctions();
   windowFuncOperators: QueryBuilderTDS_WindowOperator[] =
     getQueryBuilderCoreWindowOperators();
 
@@ -158,6 +162,7 @@ export class QueryBuilderTDSState
     this.aggregationState = new QueryBuilderAggregationState(
       this,
       this.aggregationOperators,
+      this.aggregationCalendarFunctions,
     );
     this.windowState = new QueryBuilderWindowState(
       this,
@@ -268,19 +273,33 @@ export class QueryBuilderTDSState
   }
 
   get fetchStructureValidationIssues(): string[] {
+    const validationIssues: string[] = [];
+    const hasInValidCalendarAggregateColumns =
+      this.aggregationState.columns.some(
+        (column) =>
+          column.calendarFunction &&
+          column.calendarFunction.dateColumn === undefined,
+      );
+    if (hasInValidCalendarAggregateColumns) {
+      validationIssues.push(
+        'Query has calendar function with no date column specified',
+      );
+    }
     const hasDuplicatedProjectionColumns = this.projectionColumns.some(
       (column) =>
         this.projectionColumns.filter((c) => c.columnName === column.columnName)
           .length > 1,
     );
     if (hasDuplicatedProjectionColumns) {
-      return ['Query has duplicated projection columns'];
+      validationIssues.push('Query has duplicated projection columns');
+      return validationIssues;
     }
     const hasNoProjectionColumns = this.projectionColumns.length === 0;
     if (hasNoProjectionColumns) {
-      return ['Query has no projection columns'];
+      validationIssues.push('Query has no projection columns');
+      return validationIssues;
     }
-    return [];
+    return validationIssues;
   }
 
   get allValidationIssues(): string[] {

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

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type Hashable, guaranteeType } from '@finos/legend-shared';
+import type {
+  AbstractPropertyExpression,
+  PrimitiveInstanceValue,
+  SimpleFunctionExpression,
+  ValueSpecification,
+} from '@finos/legend-graph';
+import {
+  type QueryBuilderProjectionColumnState,
+  QueryBuilderSimpleProjectionColumnState,
+} from '../projection/QueryBuilderProjectionColumnState.js';
+import type { QueryBuilderAggregateColumnState } from './QueryBuilderAggregationState.js';
+import { computed, makeObservable, observable, action } from 'mobx';
+import type { QUERY_BUILDER_CALENDAR_TYPE } from '../../../../graph-manager/QueryBuilderConst.js';
+import { DEFAULT_LAMBDA_VARIABLE_NAME } from '../../../QueryBuilderConfig.js';
+
+export abstract class QueryBuilderAggregateCalendarFunction
+  implements Hashable
+{
+  dateColumn?: AbstractPropertyExpression | undefined;
+  calendarType!: QUERY_BUILDER_CALENDAR_TYPE;
+  endDate!: PrimitiveInstanceValue;
+  lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
+
+  constructor() {
+    makeObservable(this, {
+      dateColumn: observable,
+      lambdaParameterName: observable,
+      calendarType: observable,
+      endDate: observable,
+      setDateColumn: action,
+      setCalendarType: action,
+      setLambdaParameterName: action,
+      setEndDate: action,
+      hashCode: computed,
+    });
+  }
+
+  abstract getLabel(): string;
+
+  abstract isCompatibleWithColumn(
+    projectionColumnState: QueryBuilderProjectionColumnState,
+  ): boolean;
+
+  abstract buildCalendarFunctionExpression(
+    propertyExpression: AbstractPropertyExpression,
+  ): ValueSpecification;
+
+  buildCalendarFunctionExpressionFromState(
+    aggregateColumnState: QueryBuilderAggregateColumnState,
+  ): ValueSpecification {
+    return this.buildCalendarFunctionExpression(
+      guaranteeType(
+        aggregateColumnState.projectionColumnState,
+        QueryBuilderSimpleProjectionColumnState,
+      ).propertyExpressionState.propertyExpression,
+    );
+  }
+
+  abstract updateAggregateColumnState(
+    expression: SimpleFunctionExpression,
+    aggregationColumnState: QueryBuilderAggregateColumnState,
+  ): void;
+
+  setDateColumn(val: AbstractPropertyExpression): void {
+    this.dateColumn = val;
+  }
+
+  setLambdaParameterName(val: string): void {
+    this.lambdaParameterName = val;
+  }
+
+  setCalendarType(val: QUERY_BUILDER_CALENDAR_TYPE): void {
+    this.calendarType = val;
+  }
+
+  setEndDate(val: PrimitiveInstanceValue): void {
+    this.endDate = val;
+  }
+
+  abstract get hashCode(): string;
+}

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

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { QueryBuilderAggregateCalendarFunction_Ytd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Ytd.js';
+import { QueryBuilderAggregateCalendarFunction_Annualized } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Annualized.js';
+import type { QueryBuilderAggregateCalendarFunction } from './QueryBuilderAggregateCalendarFunction.js';
+import { QueryBuilderAggregateCalendarFunction_Cme } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Cme.js';
+import { QueryBuilderAggregateCalendarFunction_Cw } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Cw.js';
+import { QueryBuilderAggregateCalendarFunction_Cw_Fm } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Cw_Fm.js';
+import { QueryBuilderAggregateCalendarFunction_Cy_Minus2 } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Cy_Minus2.js';
+import { QueryBuilderAggregateCalendarFunction_Cy_Minus3 } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Cy_Minus3.js';
+import { QueryBuilderAggregateCalendarFunction_Mtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Mtd.js';
+import { QueryBuilderAggregateCalendarFunction_P12Wa } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P12Wa.js';
+import { QueryBuilderAggregateCalendarFunction_P12Wtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P12Wtd.js';
+import { QueryBuilderAggregateCalendarFunction_P4Wa } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P4Wa.js';
+import { QueryBuilderAggregateCalendarFunction_P4Wtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P4Wtd.js';
+import { QueryBuilderAggregateCalendarFunction_P52Wa } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P52Wa.js';
+import { QueryBuilderAggregateCalendarFunction_P52Wtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_P52Wtd.js';
+import { QueryBuilderAggregateCalendarFunction_Pma } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pma.js';
+import { QueryBuilderAggregateCalendarFunction_Pmtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pmtd.js';
+import { QueryBuilderAggregateCalendarFunction_Pqtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pqtd.js';
+import { QueryBuilderAggregateCalendarFunction_PriorDay } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_PriorDay.js';
+import { QueryBuilderAggregateCalendarFunction_PriorYear } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_PriorYear.js';
+import { QueryBuilderAggregateCalendarFunction_Pw } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pw.js';
+import { QueryBuilderAggregateCalendarFunction_Pw_Fm } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pw_Fm.js';
+import { QueryBuilderAggregateCalendarFunction_Pwa } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pwa.js';
+import { QueryBuilderAggregateCalendarFunction_Pwtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pwtd.js';
+import { QueryBuilderAggregateCalendarFunction_Pymtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pymtd.js';
+import { QueryBuilderAggregateCalendarFunction_Pyqtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pyqtd.js';
+import { QueryBuilderAggregateCalendarFunction_Pytd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pytd.js';
+import { QueryBuilderAggregateCalendarFunction_Pywa } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pywa.js';
+import { QueryBuilderAggregateCalendarFunction_Pywtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Pywtd.js';
+import { QueryBuilderAggregateCalendarFunction_Qtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Qtd.js';
+import { QueryBuilderAggregateCalendarFunction_ReportEndDay } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_ReportEndDay.js';
+import { QueryBuilderAggregateCalendarFunction_Wtd } from './calendarFunctions/QueryBuilderAggregateCalendarFunction_Wtd.js';
+
+export const getQueryBuilderCoreAggregrationCalendarFunctions =
+  (): QueryBuilderAggregateCalendarFunction[] => [
+    new QueryBuilderAggregateCalendarFunction_Annualized(),
+    new QueryBuilderAggregateCalendarFunction_Ytd(),
+    new QueryBuilderAggregateCalendarFunction_Cme(),
+    new QueryBuilderAggregateCalendarFunction_Cw(),
+    new QueryBuilderAggregateCalendarFunction_Cw_Fm(),
+    new QueryBuilderAggregateCalendarFunction_Cy_Minus2(),
+    new QueryBuilderAggregateCalendarFunction_Cy_Minus3(),
+    new QueryBuilderAggregateCalendarFunction_Mtd(),
+    new QueryBuilderAggregateCalendarFunction_P12Wa(),
+    new QueryBuilderAggregateCalendarFunction_P12Wtd(),
+    new QueryBuilderAggregateCalendarFunction_P4Wa(),
+    new QueryBuilderAggregateCalendarFunction_P4Wtd(),
+    new QueryBuilderAggregateCalendarFunction_P52Wa(),
+    new QueryBuilderAggregateCalendarFunction_P52Wtd(),
+    new QueryBuilderAggregateCalendarFunction_Pma(),
+    new QueryBuilderAggregateCalendarFunction_Pmtd(),
+    new QueryBuilderAggregateCalendarFunction_Pqtd(),
+    new QueryBuilderAggregateCalendarFunction_PriorDay(),
+    new QueryBuilderAggregateCalendarFunction_PriorYear(),
+    new QueryBuilderAggregateCalendarFunction_Pw(),
+    new QueryBuilderAggregateCalendarFunction_Pw_Fm(),
+    new QueryBuilderAggregateCalendarFunction_Pwa(),
+    new QueryBuilderAggregateCalendarFunction_Pwtd(),
+    new QueryBuilderAggregateCalendarFunction_Pymtd(),
+    new QueryBuilderAggregateCalendarFunction_Pyqtd(),
+    new QueryBuilderAggregateCalendarFunction_Pytd(),
+    new QueryBuilderAggregateCalendarFunction_Pywa(),
+    new QueryBuilderAggregateCalendarFunction_Pywtd(),
+    new QueryBuilderAggregateCalendarFunction_Qtd(),
+    new QueryBuilderAggregateCalendarFunction_ReportEndDay(),
+    new QueryBuilderAggregateCalendarFunction_Wtd(),
+  ];

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

@@ -28,6 +28,7 @@ import type { QueryBuilderAggregateOperator } from './QueryBuilderAggregateOpera
 import type { QueryBuilderProjectionColumnState } from '../projection/QueryBuilderProjectionColumnState.js';
 import { QUERY_BUILDER_STATE_HASH_STRUCTURE } from '../../../QueryBuilderStateHashUtils.js';
 import { QueryBuilderTDSColumnState } from '../QueryBuilderTDSColumnState.js';
+import type { QueryBuilderAggregateCalendarFunction } from './QueryBuilderAggregateCalendarFunction.js';
 
 export class QueryBuilderAggregateColumnState
   extends QueryBuilderTDSColumnState
@@ -37,6 +38,8 @@ export class QueryBuilderAggregateColumnState
   projectionColumnState: QueryBuilderProjectionColumnState;
   lambdaParameterName: string = DEFAULT_LAMBDA_VARIABLE_NAME;
   operator: QueryBuilderAggregateOperator;
+  calendarFunction?: QueryBuilderAggregateCalendarFunction | undefined;
+  hideCalendarColumnState = true;
 
   constructor(
     aggregationState: QueryBuilderAggregationState,
@@ -47,10 +50,14 @@ export class QueryBuilderAggregateColumnState
     makeObservable(this, {
       projectionColumnState: observable,
       lambdaParameterName: observable,
+      calendarFunction: observable,
+      hideCalendarColumnState: observable,
       operator: observable,
+      setHideCalendarColumnState: action,
       setColumnState: action,
       setLambdaParameterName: action,
       setOperator: action,
+      setCalendarFunction: action,
       hashCode: computed,
     });
 
@@ -58,6 +65,7 @@ export class QueryBuilderAggregateColumnState
     this.projectionColumnState = projectionColumnState;
     this.operator = operator;
   }
+
   setColumnState(val: QueryBuilderProjectionColumnState): void {
     this.projectionColumnState = val;
   }
@@ -66,6 +74,16 @@ export class QueryBuilderAggregateColumnState
     this.lambdaParameterName = val;
   }
 
+  setHideCalendarColumnState(val: boolean): void {
+    this.hideCalendarColumnState = val;
+  }
+
+  setCalendarFunction(
+    val: QueryBuilderAggregateCalendarFunction | undefined,
+  ): void {
+    this.calendarFunction = val;
+  }
+
   setOperator(val: QueryBuilderAggregateOperator): void {
     this.operator = val;
   }
@@ -78,6 +96,7 @@ export class QueryBuilderAggregateColumnState
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATE_COLUMN_STATE,
       this.operator,
+      this.calendarFunction ?? '',
     ]);
   }
 
@@ -89,22 +108,26 @@ export class QueryBuilderAggregateColumnState
 export class QueryBuilderAggregationState implements Hashable {
   readonly tdsState: QueryBuilderTDSState;
   readonly operators: QueryBuilderAggregateOperator[] = [];
+  readonly calendarFunctions: QueryBuilderAggregateCalendarFunction[];
   columns: QueryBuilderAggregateColumnState[] = [];
 
   constructor(
     tdsState: QueryBuilderTDSState,
     operators: QueryBuilderAggregateOperator[],
+    calendarFunctions: QueryBuilderAggregateCalendarFunction[],
   ) {
     makeObservable(this, {
       columns: observable,
       removeColumn: action,
       addColumn: action,
       changeColumnAggregateOperator: action,
+      disableCalendar: action,
       hashCode: computed,
     });
 
     this.tdsState = tdsState;
     this.operators = operators;
+    this.calendarFunctions = calendarFunctions;
   }
 
   removeColumn(val: QueryBuilderAggregateColumnState): void {
@@ -163,6 +186,14 @@ export class QueryBuilderAggregationState implements Hashable {
     }
   }
 
+  disableCalendar(): void {
+    this.tdsState.queryBuilderState.setIsCalendarEnabled(false);
+    this.columns.forEach((column) => {
+      column.setCalendarFunction(undefined);
+      column.setHideCalendarColumnState(true);
+    });
+  }
+
   get hashCode(): string {
     return hashArray([
       QUERY_BUILDER_STATE_HASH_STRUCTURE.AGGREGATION_STATE,

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

@@ -104,6 +104,28 @@ export const processTDSAggregateExpression = (
       `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
     );
 
+    let calendarExpression: SimpleFunctionExpression | undefined;
+    if (queryBuilderState.isCalendarEnabled) {
+      const childExpression = expression.parametersValues[0];
+      assertType(
+        childExpression,
+        LambdaFunctionInstanceValue,
+        `Can't process agg() expression: agg() expects argument #0 to be a lambda function`,
+      );
+      const lambdaFunc1 = guaranteeNonNullable(
+        childExpression.values[0],
+        `Can't process agg() lambda: agg() lambda function is missing`,
+      );
+      assertTrue(
+        lambdaFunc1.expressionSequence.length === 1,
+        `Can't process agg() lambda: only support agg() lambda body with 1 expression`,
+      );
+      calendarExpression =
+        lambdaFunc1.expressionSequence[0] instanceof SimpleFunctionExpression
+          ? lambdaFunc1.expressionSequence[0]
+          : undefined;
+    }
+
     assertTrue(
       lambdaFunc.functionType.parameters.length === 1,
       `Can't process agg() lambda: only support agg() lambda with 1 parameter`,
@@ -128,6 +150,25 @@ export const processTDSAggregateExpression = (
       );
       if (aggregateColumnState) {
         aggregationState.addColumn(aggregateColumnState);
+        if (
+          queryBuilderState.isCalendarEnabled &&
+          calendarExpression !== undefined
+        ) {
+          for (const calendarFunction of aggregationState.calendarFunctions) {
+            // NOTE: this allow plugin author to either return `undefined` or throw error
+            // if there is a problem with building the lambda. Either case, the plugin is
+            // considered as not supporting the lambda.
+            returnUndefOnError(() =>
+              calendarFunction.updateAggregateColumnState(
+                guaranteeNonNullable(calendarExpression),
+                aggregateColumnState,
+              ),
+            );
+          }
+        }
+        if (!aggregateColumnState.calendarFunction) {
+          aggregateColumnState.setHideCalendarColumnState(true);
+        }
         return;
       }
     }

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

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type ValueSpecification,
+  SimpleFunctionExpression,
+  extractElementNameFromPath,
+  matchFunctionName,
+  AbstractPropertyExpression,
+  PrimitiveInstanceValue,
+  GenericType,
+  GenericTypeExplicitReference,
+  PrimitiveType,
+  PRIMITIVE_TYPE,
+  VariableExpression,
+} from '@finos/legend-graph';
+import {
+  guaranteeType,
+  assertTrue,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import type { QueryBuilderAggregateColumnState } from '../QueryBuilderAggregationState.js';
+import { type QueryBuilderAggregateCalendarFunction } from '../QueryBuilderAggregateCalendarFunction.js';
+import { QUERY_BUILDER_CALENDAR_TYPE } from '../../../../../graph-manager/QueryBuilderConst.js';
+
+export const buildCalendarFunctionExpression = (
+  calendarFunctionFullPath: string,
+  dateColumn: AbstractPropertyExpression | undefined,
+  calendarType: QUERY_BUILDER_CALENDAR_TYPE,
+  endDate: PrimitiveInstanceValue,
+  targetColumn: AbstractPropertyExpression,
+): ValueSpecification => {
+  const expression = new SimpleFunctionExpression(
+    extractElementNameFromPath(calendarFunctionFullPath),
+  );
+  if (dateColumn) {
+    expression.parametersValues.push(dateColumn);
+  } else {
+    throw new UnsupportedOperationError(
+      `Please specify date column for calendar Function for column ${targetColumn.func.value.name}`,
+    );
+  }
+  const calendarTypeParameter = new PrimitiveInstanceValue(
+    GenericTypeExplicitReference.create(new GenericType(PrimitiveType.STRING)),
+  );
+  calendarTypeParameter.values = [calendarType];
+  expression.parametersValues.push(calendarTypeParameter);
+  expression.parametersValues.push(endDate);
+  expression.parametersValues.push(targetColumn);
+  return expression;
+};
+
+export const updateAggregateColumnState = (
+  expression: SimpleFunctionExpression,
+  calendarFunctionFullPath: string,
+  calendarFunction: QueryBuilderAggregateCalendarFunction,
+  aggregateColumnState: QueryBuilderAggregateColumnState,
+): void => {
+  if (matchFunctionName(expression.functionName, calendarFunctionFullPath)) {
+    assertTrue(
+      expression.parametersValues.length === 4,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expects four arguments`,
+    );
+
+    const dateColumn = guaranteeType(
+      expression.parametersValues[0],
+      AbstractPropertyExpression,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with first parameter as property expression`,
+    );
+    assertTrue(
+      dateColumn.func.value.genericType.value.rawType.name ===
+        PRIMITIVE_TYPE.STRICTDATE ||
+        dateColumn.func.value.genericType.value.rawType.name ===
+          PRIMITIVE_TYPE.DATE,
+
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with first parameter as property expression of type StrictDate`,
+    );
+    const lambdaParameterName = guaranteeType(
+      dateColumn.parametersValues[0],
+      VariableExpression,
+    ).name;
+    calendarFunction.setLambdaParameterName(lambdaParameterName);
+
+    const calendarTypeParameter = guaranteeType(
+      expression.parametersValues[1],
+      PrimitiveInstanceValue,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with second parameter as PrimitiveInstancevalue`,
+    );
+    assertTrue(
+      Object.values(QUERY_BUILDER_CALENDAR_TYPE).find(
+        (val) => val === calendarTypeParameter.values[0],
+      ) !== undefined,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() calendar types NY and LDN`,
+    );
+
+    const endDate = guaranteeType(
+      expression.parametersValues[2],
+      PrimitiveInstanceValue,
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() with third parameter as PrimitiveInstancevalue`,
+    );
+    assertTrue(
+      endDate.genericType.value.rawType.name === PRIMITIVE_TYPE.STRICTDATE ||
+        dateColumn.func.value.genericType.value.rawType.name ===
+          PRIMITIVE_TYPE.DATE,
+
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: only support ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() 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;
+    calendarFunction.dateColumn = dateColumn;
+    assertTrue(
+      calendarFunction.isCompatibleWithColumn(
+        aggregateColumnState.projectionColumnState,
+      ),
+      `Can't process ${extractElementNameFromPath(
+        calendarFunctionFullPath,
+      )}() expression: property is not compatible with calendar function`,
+    );
+    aggregateColumnState.setHideCalendarColumnState(false);
+    aggregateColumnState.setCalendarFunction(calendarFunction);
+  }
+};