@finos/legend-query-builder 3.0.8 → 3.2.0

package/src/stores/QueryLoaderState.ts

@@ -0,0 +1,298 @@
+/**
+ * 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 {
+  DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
+  type GenericLegendApplicationStore,
+} from '@finos/legend-application';
+import {
+  type LightQuery,
+  QuerySearchSpecification,
+  type QueryInfo,
+  type BasicGraphManagerState,
+  type Query,
+} from '@finos/legend-graph';
+import {
+  ActionState,
+  type GeneratorFn,
+  assertErrorThrown,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import { makeObservable, observable, action, flow } from 'mobx';
+import type { QueryBuilderState } from './QueryBuilderState.js';
+import type {
+  LoadQueryFilterOption,
+  QueryBuilder_LegendApplicationPlugin_Extension,
+} from './QueryBuilder_LegendApplicationPlugin_Extension.js';
+
+export const QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT = 20;
+
+export class QueryLoaderState {
+  readonly applicationStore: GenericLegendApplicationStore;
+  readonly graphManagerState: BasicGraphManagerState;
+
+  readonly searchQueriesState = ActionState.create();
+  readonly renameQueryState = ActionState.create();
+  readonly deleteQueryState = ActionState.create();
+  readonly previewQueryState = ActionState.create();
+
+  readonly decorateSearchSpecification?:
+    | ((val: QuerySearchSpecification) => QuerySearchSpecification)
+    | undefined;
+
+  readonly loadQuery: (query: LightQuery) => void;
+  readonly fetchDefaultQueries?: (() => Promise<LightQuery[]>) | undefined;
+  readonly generateDefaultQueriesSummaryText?:
+    | ((queries: LightQuery[]) => string)
+    | undefined;
+
+  readonly isReadOnly?: boolean | undefined;
+  readonly onQueryRenamed?: ((query: LightQuery) => void) | undefined;
+  readonly onQueryDeleted?: ((query: LightQuery) => void) | undefined;
+
+  queryBuilderState?: QueryBuilderState | undefined;
+
+  searchText = '';
+  showCurrentUserQueriesOnly = false; // TODO: if we start having more native filters, we should make them part of `extraFilters`
+  extraFilters = new Map<string, boolean>();
+  extraFilterOptions: LoadQueryFilterOption[] = [];
+  queries: LightQuery[] = [];
+
+  isQueryLoaderDialogOpen = false;
+  showingDefaultQueries = true;
+  showPreviewViewer = false;
+  queryPreviewContent?: QueryInfo;
+
+  constructor(
+    applicationStore: GenericLegendApplicationStore,
+    graphManagerState: BasicGraphManagerState,
+    options: {
+      decorateSearchSpecification?:
+        | ((val: QuerySearchSpecification) => QuerySearchSpecification)
+        | undefined;
+
+      loadQuery: (query: LightQuery) => void;
+      fetchDefaultQueries?: (() => Promise<LightQuery[]>) | undefined;
+      generateDefaultQueriesSummaryText?:
+        | ((queries: LightQuery[]) => string)
+        | undefined;
+
+      isReadOnly?: boolean | undefined;
+      onQueryRenamed?: ((query: LightQuery) => void) | undefined;
+      onQueryDeleted?: ((query: LightQuery) => void) | undefined;
+    },
+  ) {
+    makeObservable(this, {
+      isQueryLoaderDialogOpen: observable,
+      queryPreviewContent: observable,
+      showingDefaultQueries: observable,
+      queries: observable,
+      showCurrentUserQueriesOnly: observable,
+      showPreviewViewer: observable,
+      searchText: observable,
+      setSearchText: action,
+      setQueryLoaderDialogOpen: action,
+      setQueries: action,
+      setShowCurrentUserQueriesOnly: action,
+      setShowPreviewViewer: action,
+      searchQueries: flow,
+      getPreviewQueryContent: flow,
+      deleteQuery: flow,
+      renameQuery: flow,
+      initialize: flow,
+    });
+
+    this.applicationStore = applicationStore;
+    this.graphManagerState = graphManagerState;
+
+    this.loadQuery = options.loadQuery;
+    this.fetchDefaultQueries = options.fetchDefaultQueries;
+    this.generateDefaultQueriesSummaryText =
+      options.generateDefaultQueriesSummaryText;
+    this.decorateSearchSpecification = options.decorateSearchSpecification;
+    this.isReadOnly = options.isReadOnly;
+    this.onQueryRenamed = options.onQueryRenamed;
+    this.onQueryDeleted = options.onQueryDeleted;
+  }
+
+  setSearchText(val: string): void {
+    this.searchText = val;
+  }
+
+  setQueryLoaderDialogOpen(val: boolean): void {
+    this.isQueryLoaderDialogOpen = val;
+  }
+
+  setQueries(val: LightQuery[]): void {
+    this.queries = val;
+  }
+
+  setShowPreviewViewer(val: boolean): void {
+    this.showPreviewViewer = val;
+  }
+
+  setShowCurrentUserQueriesOnly(val: boolean): void {
+    this.showCurrentUserQueriesOnly = val;
+  }
+
+  reset(): void {
+    this.setShowCurrentUserQueriesOnly(false);
+  }
+
+  *initialize(queryBuilderState: QueryBuilderState): GeneratorFn<void> {
+    this.queryBuilderState = queryBuilderState;
+    this.extraFilterOptions = this.applicationStore.pluginManager
+      .getApplicationPlugins()
+      .flatMap(
+        (plugin) =>
+          (
+            plugin as QueryBuilder_LegendApplicationPlugin_Extension
+          ).getExtraLoadQueryFilterOptions?.() ?? [],
+      );
+    const extraFilters = this.extraFilterOptions.map((filterOption) =>
+      filterOption.label(guaranteeNonNullable(this.queryBuilderState)),
+    );
+    extraFilters.forEach(
+      (filter) => filter && this.extraFilters.set(filter, false),
+    );
+  }
+
+  *searchQueries(searchText: string): GeneratorFn<void> {
+    if (
+      searchText.length < DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH &&
+      !this.showCurrentUserQueriesOnly &&
+      Array.from(this.extraFilters.values()).every((value) => value === false)
+    ) {
+      // if no search text is specified, use fetch the default queries
+      if (!searchText) {
+        this.showingDefaultQueries = true;
+        this.searchQueriesState.inProgress();
+        this.queries = [];
+        try {
+          if (!this.fetchDefaultQueries) {
+            return;
+          }
+          this.queries = (yield this.fetchDefaultQueries()) as LightQuery[];
+          this.searchQueriesState.pass();
+        } catch (error) {
+          this.searchQueriesState.fail();
+          assertErrorThrown(error);
+          this.applicationStore.notificationService.notifyError(error);
+        }
+      }
+
+      // skip otherwise
+      return;
+    }
+
+    // search using the search term
+    this.showingDefaultQueries = false;
+    this.searchQueriesState.inProgress();
+    try {
+      let searchSpecification = new QuerySearchSpecification();
+      searchSpecification.searchTerm = searchText;
+      searchSpecification.limit = QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT + 1;
+      searchSpecification.showCurrentUserQueriesOnly =
+        this.showCurrentUserQueriesOnly;
+      if (this.queryBuilderState) {
+        Array.from(this.extraFilters.entries()).forEach(([key, value]) => {
+          if (value) {
+            const filterOption = this.extraFilterOptions.find(
+              (option) =>
+                option.label(guaranteeNonNullable(this.queryBuilderState)) ===
+                key,
+            );
+            if (filterOption) {
+              searchSpecification = filterOption.filterFunction(
+                searchSpecification,
+                guaranteeNonNullable(this.queryBuilderState),
+              );
+            }
+          }
+        });
+      }
+      searchSpecification =
+        this.decorateSearchSpecification?.(searchSpecification) ??
+        searchSpecification;
+      this.queries = (yield this.graphManagerState.graphManager.searchQueries(
+        searchSpecification,
+      )) as LightQuery[];
+      this.searchQueriesState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+      this.searchQueriesState.fail();
+    }
+  }
+
+  *renameQuery(queryId: string, name: string): GeneratorFn<void> {
+    this.renameQueryState.inProgress();
+    try {
+      const query = (yield this.graphManagerState.graphManager.renameQuery(
+        queryId,
+        name,
+      )) as Query;
+      this.onQueryRenamed?.(query);
+      this.applicationStore.notificationService.notify(
+        'Renamed query successfully',
+      );
+      this.renameQueryState.pass();
+      this.searchQueries(this.searchText); // trigger a search to refresh the query list
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+      this.renameQueryState.fail();
+    }
+  }
+
+  *deleteQuery(queryId: string): GeneratorFn<void> {
+    this.deleteQueryState.inProgress();
+    try {
+      const query = (yield this.graphManagerState.graphManager.deleteQuery(
+        queryId,
+      )) as Query;
+      this.onQueryDeleted?.(query);
+      this.applicationStore.notificationService.notify(
+        'Deleted query successfully',
+      );
+      this.deleteQueryState.pass();
+      this.searchQueries(this.searchText); // trigger a search to refresh the query list
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+      this.deleteQueryState.fail();
+    }
+  }
+
+  *getPreviewQueryContent(queryId: string): GeneratorFn<void> {
+    this.previewQueryState.inProgress();
+    try {
+      const queryInfo = (yield this.graphManagerState.graphManager.getQueryInfo(
+        queryId,
+      )) as QueryInfo;
+      this.queryPreviewContent = queryInfo;
+      this.queryPreviewContent.content =
+        (yield this.graphManagerState.graphManager.prettyLambdaContent(
+          queryInfo.content,
+        )) as string;
+      this.previewQueryState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyError(error);
+      this.previewQueryState.fail();
+    }
+  }
+}

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,