@finos/legend-query-builder 3.0.7 → 3.1.0

package/src/components/filter/QueryBuilderFilterPanel.tsx

@@ -43,6 +43,9 @@ import {
   PanelEntryDropZonePlaceholder,
   useDragPreviewLayer,
   PanelContent,
+  MoreVerticalIcon,
+  MenuContentItemIcon,
+  MenuContentItemLabel,
 } from '@finos/legend-art';
 import {
   type QueryBuilderFilterConditionDragSource,
@@ -84,6 +87,7 @@ import {
   type QueryBuilderVariableDragSource,
   QUERY_BUILDER_VARIABLE_DND_TYPE,
 } from '../shared/BasicValueSpecificationEditor.js';
+import { QueryBuilderTelemetryHelper } from '../../__lib__/QueryBuilderTelemetryHelper.js';
 
 const QueryBuilderFilterGroupConditionEditor = observer(
   (props: {
@@ -335,6 +339,10 @@ const QueryBuilderFilterConditionContextMenu = observer(
       filterState.addGroupConditionNodeFromNode(node);
     };
     const newGroupWithCondition = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCreateGroupFromConditionLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
+
       filterState.suppressClickawayEventListener();
       filterState.newGroupWithConditionFromNode(undefined, node);
     };
@@ -677,26 +685,42 @@ const QueryBuilderFilterTree = observer(
 export const QueryBuilderFilterPanel = observer(
   (props: { queryBuilderState: QueryBuilderState }) => {
     const { queryBuilderState } = props;
+
     const applicationStore = useApplicationStore();
     const filterState = queryBuilderState.filterState;
     const rootNode = filterState.getRootNode();
     const collapseTree = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCollapseTreeLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.setSelectedNode(undefined);
       filterState.collapseTree();
     };
     const expandTree = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterExpandTreeLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.setSelectedNode(undefined);
       filterState.expandTree();
     };
     const pruneTree = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCleanupTreeLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.suppressClickawayEventListener();
       filterState.pruneTree();
     };
     const simplifyTree = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterSimplifyTreeLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.suppressClickawayEventListener();
       filterState.simplifyTree();
     };
     const createCondition = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCreateConditionLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.suppressClickawayEventListener();
       filterState.addNodeFromNode(
         new QueryBuilderFilterTreeBlankConditionNodeData(undefined),
@@ -709,12 +733,18 @@ export const QueryBuilderFilterPanel = observer(
         (filterState.selectedNode !== rootNode || // either not a root node
           rootNode instanceof QueryBuilderFilterTreeGroupNodeData)); // or if it is the root note, it has to be a group node
     const createGroupCondition = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCreateLogicalGroupLaunched(
+        queryBuilderState.applicationStore.telemetryService,
+      );
       filterState.suppressClickawayEventListener();
       if (allowGroupCreation) {
         filterState.addGroupConditionNodeFromNode(filterState.selectedNode);
       }
     };
     const newGroupWithCondition = (): void => {
+      QueryBuilderTelemetryHelper.logEvent_FilterCreateLogicalGroupLaunched(
+        applicationStore.telemetryService,
+      );
       filterState.suppressClickawayEventListener();
       if (
         filterState.selectedNode instanceof
@@ -812,70 +842,82 @@ export const QueryBuilderFilterPanel = observer(
           <div className="panel__header__title">
             <div className="panel__header__title__label">filter</div>
           </div>
+
           <div className="panel__header__actions">
-            <button
-              className="panel__header__action"
-              onClick={createCondition}
-              tabIndex={-1}
-              title="Create Condition"
-            >
-              <PlusIcon />
-            </button>
-            <button
+            <DropdownMenu
               className="panel__header__action"
-              disabled={
-                !(
-                  filterState.selectedNode instanceof
-                  QueryBuilderFilterTreeConditionNodeData
-                )
+              title="Show Filter Options Menu..."
+              content={
+                <MenuContent>
+                  <MenuContentItem onClick={createCondition}>
+                    <MenuContentItemIcon>
+                      <PlusIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>
+                      Create Condition
+                    </MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem
+                    disabled={
+                      !(
+                        filterState.selectedNode instanceof
+                        QueryBuilderFilterTreeConditionNodeData
+                      )
+                    }
+                    onClick={newGroupWithCondition}
+                  >
+                    <MenuContentItemIcon>
+                      <PlusCircleIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>
+                      Create Group From Condition
+                    </MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem
+                    disabled={!allowGroupCreation}
+                    title={
+                      !allowGroupCreation
+                        ? 'Please select a filter node first to create logical group'
+                        : ''
+                    }
+                    onClick={createGroupCondition}
+                  >
+                    <MenuContentItemIcon>
+                      <NewFolderIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>
+                      Create Logical Group
+                    </MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem onClick={pruneTree}>
+                    <MenuContentItemIcon>
+                      <TrashIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>Cleanup Tree</MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem onClick={simplifyTree}>
+                    <MenuContentItemIcon>
+                      <CircleIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>Simplify Tree</MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem onClick={collapseTree}>
+                    <MenuContentItemIcon>
+                      <CompressIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>Collapse Tree</MenuContentItemLabel>
+                  </MenuContentItem>
+                  <MenuContentItem onClick={expandTree}>
+                    <MenuContentItemIcon>
+                      <ExpandIcon />
+                    </MenuContentItemIcon>
+                    <MenuContentItemLabel>Expand Tree</MenuContentItemLabel>
+                  </MenuContentItem>
+                </MenuContent>
               }
-              onClick={newGroupWithCondition}
-              tabIndex={-1}
-              title="Create Group From Condition"
             >
-              <PlusCircleIcon />
-            </button>
-            <button
-              className="panel__header__action"
-              disabled={!allowGroupCreation}
-              onClick={createGroupCondition}
-              tabIndex={-1}
-              title="Create Logical Group"
-            >
-              <NewFolderIcon />
-            </button>
-            <button
-              className="panel__header__action"
-              onClick={pruneTree}
-              tabIndex={-1}
-              title="Cleanup Tree"
-            >
-              <TrashIcon />
-            </button>
-            <button
-              className="panel__header__action"
-              onClick={simplifyTree}
-              tabIndex={-1}
-              title="Simplify Tree"
-            >
-              <CircleIcon />
-            </button>
-            <button
-              className="panel__header__action"
-              onClick={collapseTree}
-              tabIndex={-1}
-              title="Collapse Tree"
-            >
-              <CompressIcon />
-            </button>
-            <button
-              className="panel__header__action"
-              onClick={expandTree}
-              tabIndex={-1}
-              title="Expand Tree"
-            >
-              <ExpandIcon />
-            </button>
+              <MoreVerticalIcon className="query-builder__icon__more-options" />
+            </DropdownMenu>
           </div>
         </div>
         <PanelContent>

package/src/components/shared/LambdaParameterValuesEditor.tsx

@@ -30,6 +30,7 @@ import {
   type ObserverContext,
   PrimitiveType,
 } from '@finos/legend-graph';
+import { prettyCONSTName } from '@finos/legend-shared';
 import { observer } from 'mobx-react-lite';
 import { useState } from 'react';
 import type { LambdaParametersState } from '../../stores/shared/LambdaParameterState.js';
@@ -123,7 +124,7 @@ export const LambdaParameterValuesEditor = observer(
                   isSubmitAction ? `${submitAction.label}...` : undefined
                 }
                 onClick={submit}
-                text={submitAction.label}
+                text={prettyCONSTName(submitAction.label)}
               />
             )}
             <ModalFooterButton

package/src/graph/QueryBuilderMetaModelConst.ts

@@ -28,6 +28,40 @@ export enum QUERY_BUILDER_PURE_PATH {
   SERIALIZE_CONFIG = 'meta::pure::graphFetch::execution::AlloySerializationConfig',
 }
 
+export enum QUERY_BUILDER_SUPPORTED_CALENDAR_AGGREGATION_FUNCTIONS {
+  CALENDAR_ANNUALIZED = 'meta::pure::functions::date::calendar::annualized',
+  CALENDAR_CME = ' meta::pure::functions::date::calendar::cme',
+  CALENDAR_CW = 'meta::pure::functions::date::calendar::cw',
+  CALENDAR_CW_FM = 'meta::pure::functions::date::calendar::cw_fm',
+  CALENDAR_CY_MINUS2 = 'meta::pure::functions::date::calendar::CYMinus2',
+  CALENDAR_CY_MINUS3 = 'meta::pure::functions::date::calendar::CYMinus3',
+  CALENDAR_MTD = 'meta::pure::functions::date::calendar::mtd',
+  CALENDAR_P12WA = 'meta::pure::functions::date::calendar::p12wa',
+  CALENDAR_P12WTD = 'meta::pure::functions::date::calendar::p12wtd',
+  CALENDAR_P4WA = 'meta::pure::functions::date::calendar::p4wa',
+  CALENDAR_P4WTD = 'meta::pure::functions::date::calendar::p4wtd',
+  CALENDAR_P52WTD = 'meta::pure::functions::date::calendar::p52wtd',
+  CALENDAR_P52WA = 'meta::pure::functions::date::calendar::p52wa',
+  CALENDAR_PMA = 'meta::pure::functions::date::calendar::pma',
+  CALENDAR_PMTD = 'meta::pure::functions::date::calendar::pmtd',
+  CALENDAR_PQTD = 'meta::pure::functions::date::calendar::pqtd',
+  CALENDAR_PRIOR_DAY = 'meta::pure::functions::date::calendar::priorDay',
+  CALENDAR_PRIOR_YEAR = 'meta::pure::functions::date::calendar::priorYear',
+  CALENDAR_PW = 'meta::pure::functions::date::calendar::pw',
+  CALENDAR_PW_FM = 'meta::pure::functions::date::calendar::pw_fm',
+  CALENDAR_PWA = 'meta::pure::functions::date::calendar::pwa',
+  CALENDAR_PWTD = 'meta::pure::functions::date::calendar::pwtd',
+  CALENDAR_PYMTD = 'meta::pure::functions::date::calendar::pymtd',
+  CALENDAR_PYQTD = 'meta::pure::functions::date::calendar::pyqtd',
+  CALENDAR_PYTD = 'meta::pure::functions::date::calendar::pytd',
+  CALENDAR_PYWA = 'meta::pure::functions::date::calendar::pywa',
+  CALENDAR_PYWTD = 'meta::pure::functions::date::calendar::pywtd',
+  CALENDAR_QTD = 'meta::pure::functions::date::calendar::qtd',
+  CALENDAR_REPORT_END_DAY = 'meta::pure::functions::date::calendar::reportEndDay',
+  CALENDAR_WTD = 'meta::pure::functions::date::calendar::wtd',
+  CALENDAR_YTD = 'meta::pure::functions::date::calendar::ytd',
+}
+
 export enum QUERY_BUILDER_SUPPORTED_FUNCTIONS {
   AND = 'meta::pure::functions::boolean::and',
   EXISTS = 'meta::pure::functions::collection::exists',

package/src/graph-manager/QueryBuilderConst.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+export enum QUERY_BUILDER_CALENDAR_TYPE {
+  NY = 'NY',
+  LDN = 'LDN',
+}

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

@@ -87,6 +87,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   readonly changeDetectionState: QueryBuilderChangeDetectionState;
   readonly queryCompileState = ActionState.create();
   readonly observerContext: ObserverContext;
+  readonly saveQueryProgressState = ActionState.create();
 
   explorerState: QueryBuilderExplorerState;
   functionsExplorerState: QueryFunctionsExplorerState;
@@ -102,12 +103,11 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   resultState: QueryBuilderResultState;
   textEditorState: QueryBuilderTextEditorState;
   unsupportedQueryState: QueryBuilderUnsupportedQueryState;
-
-  titleOfQuery: string | undefined;
   showFunctionsExplorerPanel = false;
   showParametersPanel = false;
   isEditingWatermark = false;
   isCheckingEntitlments = false;
+  isCalendarEnabled = false;
 
   class?: Class | undefined;
   mapping?: Mapping | undefined;
@@ -129,7 +129,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       fetchStructureState: observable,
       filterState: observable,
       watermarkState: observable,
-      titleOfQuery: observable,
       checkEntitlementsState: observable,
       resultState: observable,
       textEditorState: observable,
@@ -138,6 +137,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       showParametersPanel: observable,
       isEditingWatermark: observable,
       isCheckingEntitlments: observable,
+      isCalendarEnabled: observable,
       changeDetectionState: observable,
       class: observable,
       mapping: observable,
@@ -150,13 +150,12 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       setShowFunctionsExplorerPanel: action,
       setShowParametersPanel: action,
       setIsEditingWatermark: action,
+      setIsCalendarEnabled: action,
       setIsCheckingEntitlments: action,
       setClass: action,
       setMapping: action,
       setRuntimeValue: action,
 
-      setTitleOfQuery: action,
-
       resetQueryResult: action,
       resetQueryContent: action,
       changeClass: action,
@@ -247,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;
   }
@@ -259,10 +262,6 @@ export abstract class QueryBuilderState implements CommandRegistrar {
     this.runtimeValue = val;
   }
 
-  setTitleOfQuery(val: string | undefined): void {
-    this.titleOfQuery = val;
-  }
-
   get isQuerySupported(): boolean {
     return !this.unsupportedQueryState.rawLambda;
   }
@@ -324,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;
@@ -455,6 +455,7 @@ export abstract class QueryBuilderState implements CommandRegistrar {
   async saveQuery(
     onSaveQuery: (lambda: RawLambda) => Promise<void>,
   ): Promise<void> {
+    this.saveQueryProgressState.inProgress();
     try {
       const query = this.buildQuery();
       await onSaveQuery(query);
@@ -463,6 +464,8 @@ export abstract class QueryBuilderState implements CommandRegistrar {
       this.applicationStore.notificationService.notifyError(
         `Can't save query: ${error.message}`,
       );
+    } finally {
+      this.saveQueryProgressState.complete();
     }
   }
 

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',
 }