@finos/legend-query-builder 3.0.8 → 3.1.0

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

@@ -42,7 +42,10 @@ import {
   GenericTypeExplicitReference,
   PrimitiveType,
 } from '@finos/legend-graph';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../../../graph/QueryBuilderMetaModelConst.js';
+import {
+  QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+} from '../../../graph/QueryBuilderMetaModelConst.js';
 
 export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
   constructor() {
@@ -207,6 +210,12 @@ export class QueryBuilder_PureProtocolProcessorPlugin extends PureProtocolProces
           matchFunctionName(
             functionName,
             Object.values(QUERY_BUILDER_SUPPORTED_FUNCTIONS),
+          ) ||
+          matchFunctionName(
+            functionName,
+            Object.values(
+              QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+            ),
           )
         ) {
           // NOTE: this is a catch-all builder that is only meant for basic function expression

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

@@ -50,11 +50,15 @@ import {
   VariableExpression,
   Multiplicity,
   PrimitiveType,
+  V1_CStrictDate,
+  V1_CString,
 } from '@finos/legend-graph';
 import {
   QUERY_BUILDER_PURE_PATH,
   QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
 } from '../../../../graph/QueryBuilderMetaModelConst.js';
+import { QUERY_BUILDER_CALENDAR_TYPE } from '../../../QueryBuilderConst.js';
 
 const buildProjectionColumnLambda = (
   valueSpecification: V1_ValueSpecification,
@@ -86,41 +90,82 @@ const buildProjectionColumnLambda = (
   );
   let currentPropertyExpression: V1_ValueSpecification = valueSpecification
     .body[0] as V1_ValueSpecification;
-  assertType(
-    currentPropertyExpression,
-    V1_AppliedProperty,
-    `Can't build projection column: only support lambda body as property expression`,
-  );
-  while (currentPropertyExpression instanceof V1_AppliedProperty) {
+
+  // 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`,
+    );
     assertTrue(
-      currentPropertyExpression.parameters.length >= 1,
+      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,
       `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,
-      )
-    ) {
+    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;
+      }
     }
+    // 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,

package/src/stores/QueryBuilderState.ts

@@ -107,6 +107,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   showParametersPanel = false;
   isEditingWatermark = false;
   isCheckingEntitlments = false;
+  isCalendarEnabled = false;
 
   class?: Class | undefined;
   mapping?: Mapping | undefined;
@@ -136,6 +137,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       showParametersPanel: observable,
       isEditingWatermark: observable,
       isCheckingEntitlments: observable,
+      isCalendarEnabled: observable,
       changeDetectionState: observable,
       class: observable,
       mapping: observable,
@@ -148,6 +150,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setShowFunctionsExplorerPanel: action,
       setShowParametersPanel: action,
       setIsEditingWatermark: action,
+      setIsCalendarEnabled: action,
       setIsCheckingEntitlments: action,
       setClass: action,
       setMapping: action,
@@ -243,6 +246,10 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.isCheckingEntitlments = val;
   }
 
+  setIsCalendarEnabled(val: boolean): void {
+    this.isCalendarEnabled = val;
+  }
+
   setClass(val: Class | undefined): void {
     this.class = val;
   }
@@ -316,6 +323,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.filterState = new QueryBuilderFilterState(this, this.filterOperators);
     this.watermarkState = new QueryBuilderWatermarkState(this);
     this.checkEntitlementsState = new QueryBuilderCheckEntitlementsState(this);
+    this.isCalendarEnabled = false;
 
     const currentFetchStructureImplementationType =
       this.fetchStructureState.implementation.type;

package/src/stores/QueryBuilderStateBuilder.ts

@@ -40,7 +40,7 @@ import {
   PrimitiveInstanceValue,
   SimpleFunctionExpression,
   type VariableExpression,
-  type AbstractPropertyExpression,
+  AbstractPropertyExpression,
   getMilestoneTemporalStereotype,
   type INTERNAL__PropagatedValue,
   type ValueSpecification,
@@ -66,7 +66,10 @@ import {
   processTDSSortExpression,
   processTDSTakeExpression,
 } from './fetch-structure/tds/projection/QueryBuilderProjectionStateBuilder.js';
-import { QUERY_BUILDER_SUPPORTED_FUNCTIONS } from '../graph/QueryBuilderMetaModelConst.js';
+import {
+  QUERY_BUILDER_SUPPORTED_FUNCTIONS,
+  QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS,
+} from '../graph/QueryBuilderMetaModelConst.js';
 import { LambdaParameterState } from './shared/LambdaParameterState.js';
 import { processTDS_OLAPGroupByExpression } from './fetch-structure/tds/window/QueryBuilderWindowStateBuilder.js';
 import { processWatermarkExpression } from './watermark/QueryBuilderWatermarkStateBuilder.js';
@@ -140,6 +143,22 @@ 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.
  *
@@ -536,6 +555,18 @@ export class QueryBuilderValueSpecificationProcessor
         this.parentLambda,
       );
       return;
+    } else if (
+      matchFunctionName(
+        functionName,
+        Object.values(QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS),
+      )
+    ) {
+      processCalendarFunction(
+        valueSpecification,
+        this.queryBuilderState,
+        this.parentLambda,
+      );
+      return;
     }
     throw new UnsupportedOperationError(
       `Can't process expression of function ${functionName}()`,

package/src/stores/QueryBuilderStateHashUtils.ts

@@ -115,4 +115,37 @@ export enum QUERY_BUILDER_STATE_HASH_STRUCTURE {
   QUERY_BUILDER_STATE = 'QUERY_BUILDER_STATE',
 
   CHECK_ENTITLEMENTS_STATE = 'CHECK_ENTITLEMENTS_STATE',
+
+  // calendar
+  AGGREGATE_CALENDAR_FUNCTION_ANNUALIZED = 'AGGREGATE_CALENDAR_FUNCTION_ANNUALIZED',
+  AGGREGATE_CALENDAR_FUNCTION_CME = 'AGGREGATE_CALENDAR_FUNCTION_CME',
+  AGGREGATE_CALENDAR_FUNCTION_CW = 'AGGREGATE_CALENDAR_FUNCTION_CW',
+  AGGREGATE_CALENDAR_FUNCTION_CW_FM = 'AGGREGATE_CALENDAR_FUNCTION_CW_FM',
+  AGGREGATE_CALENDAR_FUNCTION_CY_MINUS2 = 'AGGREGATE_CALENDAR_FUNCTION_CY_MINUS2',
+  AGGREGATE_CALENDAR_FUNCTION_CY_MINUS3 = 'AGGREGATE_CALENDAR_FUNCTION_CY_MINUS3',
+  AGGREGATE_CALENDAR_FUNCTION_MTD = 'AGGREGATE_CALENDAR_FUNCTION_MTD',
+  AGGREGATE_CALENDAR_FUNCTION_P12WA = 'AGGREGATE_CALENDAR_FUNCTION_P12WA',
+  AGGREGATE_CALENDAR_FUNCTION_P12WTD = 'AGGREGATE_CALENDAR_FUNCTION_P12WTD',
+  AGGREGATE_CALENDAR_FUNCTION_P4WA = 'AGGREGATE_CALENDAR_FUNCTION_P4WA',
+  AGGREGATE_CALENDAR_FUNCTION_P4WTD = 'AGGREGATE_CALENDAR_FUNCTION_P4WTD',
+  AGGREGATE_CALENDAR_FUNCTION_P52WTD = 'AGGREGATE_CALENDAR_FUNCTION_P5WTD',
+  AGGREGATE_CALENDAR_FUNCTION_P52WA = 'AGGREGATE_CALENDAR_FUNCTION_P52WA',
+  AGGREGATE_CALENDAR_FUNCTION_PMA = 'AGGREGATE_CALENDAR_FUNCTION_PMA',
+  AGGREGATE_CALENDAR_FUNCTION_PMTD = 'AGGREGATE_CALENDAR_FUNCTION_PMTD',
+  AGGREGATE_CALENDAR_FUNCTION_PQTD = 'AGGREGATE_CALENDAR_FUNCTION_PQTD',
+  AGGREGATE_CALENDAR_FUNCTION_PRIOR_DAY = 'AGGREGATE_CALENDAR_FUNCTION_PRIOR_DAY',
+  AGGREGATE_CALENDAR_FUNCTION_PRIOR_YEAR = 'AGGREGATE_CALENDAR_FUNCTION_PRIOR_YEAR',
+  AGGREGATE_CALENDAR_FUNCTION_PW = 'AGGREGATE_CALENDAR_FUNCTION_PW',
+  AGGREGATE_CALENDAR_FUNCTION_PW_FM = 'AGGREGATE_CALENDAR_FUNCTION_PW_FM',
+  AGGREGATE_CALENDAR_FUNCTION_PWA = 'AGGREGATE_CALENDAR_FUNCTION_PWA',
+  AGGREGATE_CALENDAR_FUNCTION_PWTD = 'AGGREGATE_CALENDAR_FUNCTION_PWTD',
+  AGGREGATE_CALENDAR_FUNCTION_PYMTD = 'AGGREGATE_CALENDAR_FUNCTION_PYMTD',
+  AGGREGATE_CALENDAR_FUNCTION_PYQTD = 'AGGREGATE_CALENDAR_FUNCTION_PYQTD',
+  AGGREGATE_CALENDAR_FUNCTION_PYTD = 'AGGREGATE_CALENDAR_FUNCTION_PYTD',
+  AGGREGATE_CALENDAR_FUNCTION_PYWA = 'AGGREGATE_CALENDAR_FUNCTION_PYWA',
+  AGGREGATE_CALENDAR_FUNCTION_PYWTD = 'AGGREGATE_CALENDAR_FUNCTION_PYWTD',
+  AGGREGATE_CALENDAR_FUNCTION_QTD = 'AGGREGATE_CALENDAR_FUNCTION_QTD',
+  AGGREGATE_CALENDAR_FUNCTION_REPORT_END_DAY = 'AGGREGATE_CALENDAR_FUNCTION_REPORT_END_DAY',
+  AGGREGATE_CALENDAR_FUNCTION_WTD = 'AGGREGATE_CALENDAR_FUNCTION_WTD',
+  AGGREGATE_CALENDAR_FUNCTION_YTD = 'AGGREGATE_CALENDAR_FUNCTION_YTD',
 }

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(),
+  ];