@finos/legend-data-cube 0.0.43 → 0.0.45

package/src/stores/core/DataCubeQueryBuilder.ts

@@ -23,7 +23,7 @@
 
 import { PRIMITIVE_TYPE, type V1_AppliedFunction } from '@finos/legend-graph';
 import { type DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import { at } from '@finos/legend-shared';
 import {
   DataCubeFunction,
   DataCubeQuerySortDirection,
@@ -50,6 +50,7 @@ import {
 } from './DataCubeQueryBuilderUtils.js';
 import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
 import type { DataCubeSource } from './model/DataCubeSource.js';
+import { _findCol } from './model/DataCubeColumn.js';
 
 export function buildExecutableQuery(
   snapshot: DataCubeQuerySnapshot,
@@ -93,24 +94,20 @@ export function buildExecutableQuery(
   // --------------------------------- LEAF-LEVEL EXTEND ---------------------------------
 
   if (data.leafExtendedColumns.length) {
-    const leafExtendedFuncs = data.leafExtendedColumns.map((col) =>
-      _function(DataCubeFunction.EXTEND, [
-        _cols([
-          _colSpec(
-            col.name,
-            _deserializeLambda(col.mapFn),
-            col.reduceFn ? _deserializeLambda(col.reduceFn) : undefined,
-          ),
+    _process(
+      'leafExtend',
+      data.leafExtendedColumns.map((col) =>
+        _function(DataCubeFunction.EXTEND, [
+          _cols([
+            _colSpec(
+              col.name,
+              _deserializeLambda(col.mapFn),
+              col.reduceFn ? _deserializeLambda(col.reduceFn) : undefined,
+            ),
+          ]),
         ]),
-      ]),
+      ),
     );
-    // instead of batching all the extend() functions, we sequence them to allow for
-    // different flavors of extend (e.g. with and without window), and reference the first
-    // one in the function map
-    _process('leafExtend', guaranteeNonNullable(leafExtendedFuncs[0]));
-    leafExtendedFuncs.slice(1).forEach((func) => {
-      sequence.push(func);
-    });
   }
 
   // --------------------------------- FILTER ---------------------------------
@@ -146,7 +143,13 @@ export function buildExecutableQuery(
       _function(DataCubeFunction.SORT, [
         _collection(
           data.pivot.columns.map((col) =>
-            _function(DataCubeFunction.ASCENDING, [_col(col.name)]),
+            _function(
+              _findCol(configuration.columns, col.name)?.pivotSortDirection ===
+                DataCubeQuerySortDirection.DESCENDING
+                ? DataCubeFunction.DESCENDING
+                : DataCubeFunction.ASCENDING,
+              [_col(col.name)],
+            ),
           ),
         ),
       ]),
@@ -217,24 +220,20 @@ export function buildExecutableQuery(
   // --------------------------------- GROUP-LEVEL EXTEND ---------------------------------
 
   if (data.groupExtendedColumns.length) {
-    const groupExtendedFuncs = data.groupExtendedColumns.map((col) =>
-      _function(DataCubeFunction.EXTEND, [
-        _cols([
-          _colSpec(
-            col.name,
-            _deserializeLambda(col.mapFn),
-            col.reduceFn ? _deserializeLambda(col.reduceFn) : undefined,
-          ),
+    _process(
+      'groupExtend',
+      data.groupExtendedColumns.map((col) =>
+        _function(DataCubeFunction.EXTEND, [
+          _cols([
+            _colSpec(
+              col.name,
+              _deserializeLambda(col.mapFn),
+              col.reduceFn ? _deserializeLambda(col.reduceFn) : undefined,
+            ),
+          ]),
         ]),
-      ]),
+      ),
     );
-    // instead of batching all the extend() functions, we sequence them to allow for
-    // different flavors of extend (e.g. with and without window), and reference the first
-    // one in the function map
-    _process('groupExtend', guaranteeNonNullable(groupExtendedFuncs[0]));
-    groupExtendedFuncs.slice(1).forEach((func) => {
-      sequence.push(func);
-    });
   }
 
   // --------------------------------- SORT ---------------------------------
@@ -299,9 +298,9 @@ export function buildExecutableQuery(
     return source.query;
   }
   for (let i = 0; i < sequence.length; i++) {
-    guaranteeNonNullable(sequence[i]).parameters.unshift(
-      i === 0 ? source.query : guaranteeNonNullable(sequence[i - 1]),
+    at(sequence, i).parameters.unshift(
+      i === 0 ? source.query : at(sequence, i - 1),
     );
   }
-  return guaranteeNonNullable(sequence[sequence.length - 1]);
+  return at(sequence, sequence.length - 1);
 }

package/src/stores/core/DataCubeQueryBuilderUtils.ts

@@ -60,7 +60,7 @@ import {
   type DataCubeQuerySnapshotFilter,
   type DataCubeQuerySnapshot,
 } from './DataCubeQuerySnapshot.js';
-import { type DataCubeColumn } from './model/DataCubeColumn.js';
+import { _findCol, type DataCubeColumn } from './model/DataCubeColumn.js';
 import {
   guaranteeNonNullable,
   guaranteeIsString,
@@ -95,9 +95,24 @@ export function _functionCompositionProcessor(
   sequence: V1_AppliedFunction[],
   funcMap: DataCubeQueryFunctionMap,
 ) {
-  return (key: keyof DataCubeQueryFunctionMap, func: V1_AppliedFunction) => {
-    sequence.push(func);
-    funcMap[key] = func;
+  return (
+    key: keyof DataCubeQueryFunctionMap,
+    data: V1_AppliedFunction | V1_AppliedFunction[],
+  ) => {
+    switch (key) {
+      case 'leafExtend':
+      case 'groupExtend': {
+        if (Array.isArray(data)) {
+          data.forEach((func) => sequence.push(func));
+          funcMap[key] = data;
+        }
+        break;
+      }
+      default: {
+        funcMap[key] = data as V1_AppliedFunction;
+        sequence.push(data as V1_AppliedFunction);
+      }
+    }
   };
 }
 
@@ -106,9 +121,13 @@ export function _functionCompositionUnProcessor(
   funcMap: DataCubeQueryFunctionMap,
 ) {
   return (key: keyof DataCubeQueryFunctionMap) => {
-    const func = funcMap[key];
-    if (func) {
-      sequence.splice(sequence.indexOf(func), 1);
+    const data = funcMap[key];
+    if (data) {
+      if (Array.isArray(data)) {
+        data.forEach((func) => sequence.splice(sequence.indexOf(func), 1));
+      } else {
+        sequence.splice(sequence.indexOf(data), 1);
+      }
       funcMap[key] = undefined;
     }
   };
@@ -135,16 +154,17 @@ export function _deserializeFunction(json: PlainObject<V1_Lambda>) {
   );
 }
 
-export function _var(name?: string | undefined) {
+export function _var() {
   const variable = new V1_Variable();
-  variable.name = name ?? DEFAULT_LAMBDA_VARIABLE_NAME;
+  // NOTE: we simplify processing logic by forcing all variable names to default value, i.e. x
+  variable.name = DEFAULT_LAMBDA_VARIABLE_NAME;
   return variable;
 }
 
-export function _property(name: string, variable?: V1_Variable | undefined) {
+export function _property(name: string) {
   const property = new V1_AppliedProperty();
   property.property = name;
-  property.parameters.push(variable ?? _var());
+  property.parameters.push(_var());
   return property;
 }
 
@@ -285,10 +305,7 @@ export function _colSpec(
   return colSpec;
 }
 
-export function _value(
-  value: DataCubeOperationValue,
-  variable?: V1_Variable | undefined,
-) {
+export function _value(value: DataCubeOperationValue) {
   switch (value.type) {
     case PRIMITIVE_TYPE.STRING:
     case PRIMITIVE_TYPE.BOOLEAN:
@@ -308,7 +325,7 @@ export function _value(
       return _primitiveValue(value.type, value.value);
     }
     case DataCubeOperationAdvancedValueType.COLUMN:
-      return _property(guaranteeIsString(value.value), variable);
+      return _property(guaranteeIsString(value.value));
     default:
       throw new UnsupportedOperationError(
         `Can't build value instance for unsupported type '${value.type}'`,
@@ -345,6 +362,13 @@ export function _selectFunction(columns: DataCubeColumn[]) {
   ]);
 }
 
+export function _synthesizeMinimalSourceQuery(columns: DataCubeColumn[]) {
+  return _function(DataCubeFunction.CAST, [
+    _primitiveValue(PRIMITIVE_TYPE.STRING, ''),
+    _castCols(columns),
+  ]);
+}
+
 export function _extendRootAggregation(columnName: string) {
   return _function(DataCubeFunction.EXTEND, [
     _col(
@@ -367,7 +391,7 @@ export function _extendRootAggregation(columnName: string) {
 const INTERNAL__FILLER_COUNT_AGG_COLUMN_NAME =
   'INTERNAL__filler_count_agg_column';
 // if no aggregates are specified, add a dummy count() aggregate to satisfy compiler
-function fixEmptyAggCols(aggCols: V1_ColSpec[]) {
+function _fixEmptyAggCols(aggCols: V1_ColSpec[]) {
   const variable = _var();
   return aggCols.length
     ? aggCols
@@ -380,12 +404,24 @@ function fixEmptyAggCols(aggCols: V1_ColSpec[]) {
       ];
 }
 
-export function _aggCol_basic(column: DataCubeColumn, func: string) {
+export function _aggCol_base(
+  column: DataCubeColumn,
+  func: string,
+  paramterValues?: DataCubeOperationValue[] | undefined,
+) {
   const variable = _var();
   return _colSpec(
     column.name,
-    _lambda([variable], [_property(column.name, variable)]),
-    _lambda([variable], [_function(_functionName(func), [variable])]),
+    _lambda([variable], [_property(column.name)]),
+    _lambda(
+      [variable],
+      [
+        _function(_functionName(func), [
+          variable,
+          ...(paramterValues ?? []).map((value) => _value(value)),
+        ]),
+      ],
+    ),
   );
 }
 
@@ -401,18 +437,16 @@ export function _pivotAggCols(
       // unlike groupBy, pivot aggreation on dimension columns (e.g. unique values aggregator)
       // are not helpful and therefore excluded
       column.kind === DataCubeColumnKind.MEASURE &&
-      !pivotColumns.find((col) => col.name === column.name) &&
+      !_findCol(pivotColumns, column.name) &&
       !column.excludedFromPivot &&
-      !snapshot.data.groupExtendedColumns.find(
-        (col) => col.name === column.name,
-      ),
+      !_findCol(snapshot.data.groupExtendedColumns, column.name),
   );
-  return fixEmptyAggCols(
+  return _fixEmptyAggCols(
     aggColumns.map((agg) => {
       const operation = aggregateOperations.find(
         (op) => op.operator === agg.aggregateOperator,
       );
-      const aggCol = operation?.buildAggregateColumn(agg);
+      const aggCol = operation?.buildAggregateColumnExpression(agg);
       if (!aggCol) {
         throw new UnsupportedOperationError(
           `Can't build aggregate column for unsupported operator '${agg.aggregateOperator}'`,
@@ -452,17 +486,15 @@ export function _groupByAggCols(
     const aggColumns = configuration.columns.filter(
       (column) =>
         column.isSelected &&
-        !groupByColumns.find((col) => col.name === column.name) &&
-        !snapshot.data.groupExtendedColumns.find(
-          (col) => col.name === column.name,
-        ),
+        !_findCol(groupByColumns, column.name) &&
+        !_findCol(snapshot.data.groupExtendedColumns, column.name),
     );
-    return fixEmptyAggCols(
+    return _fixEmptyAggCols(
       aggColumns.map((agg) => {
         const operation = aggregateOperations.find(
           (op) => op.operator === agg.aggregateOperator,
         );
-        const aggCol = operation?.buildAggregateColumn(agg);
+        const aggCol = operation?.buildAggregateColumnExpression(agg);
         if (!aggCol) {
           throw new UnsupportedOperationError(
             `Can't build aggregate column for unsupported operator '${agg.aggregateOperator}'`,
@@ -479,15 +511,16 @@ export function _groupByAggCols(
   const pivotGroupByColumns = pivot.castColumns.filter(
     (col) => !isPivotResultColumnName(col.name),
   );
-  return fixEmptyAggCols([
+  return _fixEmptyAggCols([
     // for pivot result columns, resolve the base aggregate column to get aggregate configuration
     ...pivotResultColumns
       .map((column) => {
         const baseAggColName = getPivotResultColumnBaseColumnName(column.name);
         return {
           ...column,
-          matchingColumnConfiguration: configuration.columns.find(
-            (col) => col.name === baseAggColName,
+          matchingColumnConfiguration: _findCol(
+            configuration.columns,
+            baseAggColName,
           ),
         };
       })
@@ -503,7 +536,8 @@ export function _groupByAggCols(
         const operation = aggregateOperations.find(
           (op) => op.operator === columnConfiguration.aggregateOperator,
         );
-        const aggCol = operation?.buildAggregateColumn(columnConfiguration);
+        const aggCol =
+          operation?.buildAggregateColumnExpression(columnConfiguration);
         if (!aggCol) {
           throw new UnsupportedOperationError(
             `Can't build aggregate column for unsupported operator '${columnConfiguration.aggregateOperator}'`,
@@ -514,17 +548,16 @@ export function _groupByAggCols(
     // these are the columns which are available for groupBy but not selected for groupBy
     // operation, they would be aggregated as well
     ...pivotGroupByColumns
-      .filter(
-        (column) => !groupByColumns.find((col) => col.name === column.name),
-      )
+      .filter((column) => !_findCol(groupByColumns, column.name))
       .map((column) => {
         const columnConfiguration = guaranteeNonNullable(
-          configuration.columns.find((col) => col.name === column.name),
+          _findCol(configuration.columns, column.name),
         );
         const operation = aggregateOperations.find(
           (op) => op.operator === columnConfiguration.aggregateOperator,
         );
-        const aggCol = operation?.buildAggregateColumn(columnConfiguration);
+        const aggCol =
+          operation?.buildAggregateColumnExpression(columnConfiguration);
         if (!aggCol) {
           throw new UnsupportedOperationError(
             `Can't build aggregate column for unsupported operator '${columnConfiguration.aggregateOperator}'`,

package/src/stores/core/DataCubeQueryEngine.ts

@@ -15,8 +15,19 @@
  */
 
 import { TailwindCSSPalette } from '@finos/legend-art';
-import { PRIMITIVE_TYPE, type V1_AppliedFunction } from '@finos/legend-graph';
-import { IllegalStateError } from '@finos/legend-shared';
+import {
+  DATE_FORMAT,
+  PRIMITIVE_TYPE,
+  type V1_AppliedFunction,
+} from '@finos/legend-graph';
+import {
+  guaranteeNonNullable,
+  IllegalStateError,
+  UnsupportedOperationError,
+  formatDate,
+} from '@finos/legend-shared';
+import type { DataCubeQueryFilterOperation } from './filter/DataCubeQueryFilterOperation.js';
+import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
 
 export enum DataCubeFunction {
   // relation
@@ -25,10 +36,10 @@ export enum DataCubeFunction {
   GROUP_BY = 'meta::pure::functions::relation::groupBy',
   LIMIT = 'meta::pure::functions::relation::limit',
   PIVOT = 'meta::pure::functions::relation::pivot',
-  // RENAME = 'meta::pure::functions::relation::rename',
   SELECT = 'meta::pure::functions::relation::select',
   SLICE = 'meta::pure::functions::relation::slice',
   SORT = 'meta::pure::functions::relation::sort',
+  OVER = 'meta::pure::functions::relation::over',
 
   // generic
   CAST = 'meta::pure::functions::lang::cast',
@@ -75,14 +86,14 @@ export enum DataCubeFunction {
 }
 
 export type DataCubeQueryFunctionMap = {
-  leafExtend?: V1_AppliedFunction | undefined;
+  leafExtend?: V1_AppliedFunction[] | undefined;
   filter?: V1_AppliedFunction | undefined;
   pivotSort?: V1_AppliedFunction | undefined;
   pivot?: V1_AppliedFunction | undefined;
   pivotCast?: V1_AppliedFunction | undefined;
   groupBy?: V1_AppliedFunction | undefined;
   groupBySort?: V1_AppliedFunction | undefined;
-  groupExtend?: V1_AppliedFunction | undefined;
+  groupExtend?: V1_AppliedFunction[] | undefined;
   select?: V1_AppliedFunction | undefined;
   sort?: V1_AppliedFunction | undefined;
   limit?: V1_AppliedFunction | undefined;
@@ -146,21 +157,6 @@ export enum DataCubeOperationAdvancedValueType {
   // PARAMETER
 }
 
-export function isPrimitiveType(type: string) {
-  return (
-    [
-      PRIMITIVE_TYPE.NUMBER,
-      PRIMITIVE_TYPE.INTEGER,
-      PRIMITIVE_TYPE.DECIMAL,
-      PRIMITIVE_TYPE.FLOAT,
-      PRIMITIVE_TYPE.DATE,
-      PRIMITIVE_TYPE.STRICTDATE,
-      PRIMITIVE_TYPE.DATETIME,
-      PRIMITIVE_TYPE.STRING,
-    ] as string[]
-  ).includes(type);
-}
-
 export type DataCubeOperationValue = {
   value?: unknown;
   type: string;
@@ -272,48 +268,8 @@ export enum DataCubeColumnDataType {
   TIME = 'Time',
 }
 
-export function getDataType(type: string): DataCubeColumnDataType {
-  switch (type) {
-    case PRIMITIVE_TYPE.NUMBER:
-    case PRIMITIVE_TYPE.INTEGER:
-    case PRIMITIVE_TYPE.DECIMAL:
-    case PRIMITIVE_TYPE.FLOAT:
-      return DataCubeColumnDataType.NUMBER;
-    case PRIMITIVE_TYPE.DATE:
-    case PRIMITIVE_TYPE.STRICTDATE:
-      return DataCubeColumnDataType.DATE;
-    case PRIMITIVE_TYPE.DATETIME:
-      return DataCubeColumnDataType.TIME;
-    case PRIMITIVE_TYPE.STRING:
-    default:
-      return DataCubeColumnDataType.TEXT;
-  }
-}
-
-export function ofDataType(
-  type: string,
-  dataTypes: DataCubeColumnDataType[],
-): boolean {
-  return dataTypes.includes(getDataType(type));
-}
-
 export const PIVOT_COLUMN_NAME_VALUE_SEPARATOR = '__|__';
 
-export function isPivotResultColumnName(columnName: string) {
-  return columnName.includes(PIVOT_COLUMN_NAME_VALUE_SEPARATOR);
-}
-export function getPivotResultColumnBaseColumnName(columnName: string) {
-  if (!isPivotResultColumnName(columnName)) {
-    throw new IllegalStateError(
-      `Column '${columnName}' is not a pivot result column`,
-    );
-  }
-  return columnName.substring(
-    columnName.lastIndexOf(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) +
-      PIVOT_COLUMN_NAME_VALUE_SEPARATOR.length,
-  );
-}
-
 export const TREE_COLUMN_VALUE_SEPARATOR = '__/__';
 export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
 
@@ -321,6 +277,8 @@ export const DEFAULT_REPORT_NAME = 'New Report';
 export const DEFAULT_TREE_COLUMN_SORT_DIRECTION =
   DataCubeQuerySortDirection.ASCENDING;
 export const DEFAULT_PIVOT_STATISTIC_COLUMN_NAME = 'Total';
+export const DEFAULT_PIVOT_COLUMN_SORT_DIRECTION =
+  DataCubeQuerySortDirection.ASCENDING;
 export const DEFAULT_ROOT_AGGREGATION_COLUMN_VALUE = '[ROOT]';
 
 export const DEFAULT_URL_LABEL_QUERY_PARAM = 'dataCube.linkLabel';
@@ -354,3 +312,105 @@ export const DATE_TIME_FORMAT = "yyyy-MM-dd'T'HH:mm:ss";
 export const TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH = 3;
 export const TYPEAHEAD_SEARCH_LIMIT = 10;
 export const EMPTY_VALUE_PLACEHOLDER = '(None)';
+
+// --------------------------------- UTILITIES ---------------------------------
+
+export function _defaultPrimitiveTypeValue(type: string): unknown {
+  switch (type) {
+    case PRIMITIVE_TYPE.STRING:
+      return '';
+    case PRIMITIVE_TYPE.BOOLEAN:
+      return false;
+    case PRIMITIVE_TYPE.BYTE:
+      return btoa('');
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.BINARY:
+      return 0;
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return formatDate(new Date(Date.now()), DATE_FORMAT);
+    case PRIMITIVE_TYPE.DATETIME:
+      return formatDate(new Date(Date.now()), DATE_TIME_FORMAT);
+    default:
+      throw new UnsupportedOperationError(
+        `Can't generate value for type '${type}'`,
+      );
+  }
+}
+
+export function getFilterOperation(
+  operator: string,
+  operators: DataCubeQueryFilterOperation[],
+) {
+  return guaranteeNonNullable(
+    operators.find((op) => op.operator === operator),
+    `Can't find filter operation '${operator}'`,
+  );
+}
+
+export function getAggregateOperation(
+  operator: string,
+  aggregateOperations: DataCubeQueryAggregateOperation[],
+) {
+  return guaranteeNonNullable(
+    aggregateOperations.find((op) => op.operator === operator),
+    `Can't find aggregate operation '${operator}'`,
+  );
+}
+
+export function getDataType(type: string): DataCubeColumnDataType {
+  switch (type) {
+    case PRIMITIVE_TYPE.NUMBER:
+    case PRIMITIVE_TYPE.INTEGER:
+    case PRIMITIVE_TYPE.DECIMAL:
+    case PRIMITIVE_TYPE.FLOAT:
+      return DataCubeColumnDataType.NUMBER;
+    case PRIMITIVE_TYPE.DATE:
+    case PRIMITIVE_TYPE.STRICTDATE:
+      return DataCubeColumnDataType.DATE;
+    case PRIMITIVE_TYPE.DATETIME:
+      return DataCubeColumnDataType.TIME;
+    case PRIMITIVE_TYPE.STRING:
+    default:
+      return DataCubeColumnDataType.TEXT;
+  }
+}
+
+export function ofDataType(
+  type: string,
+  dataTypes: DataCubeColumnDataType[],
+): boolean {
+  return dataTypes.includes(getDataType(type));
+}
+
+export function isPrimitiveType(type: string) {
+  return (
+    [
+      PRIMITIVE_TYPE.NUMBER,
+      PRIMITIVE_TYPE.INTEGER,
+      PRIMITIVE_TYPE.DECIMAL,
+      PRIMITIVE_TYPE.FLOAT,
+      PRIMITIVE_TYPE.DATE,
+      PRIMITIVE_TYPE.STRICTDATE,
+      PRIMITIVE_TYPE.DATETIME,
+      PRIMITIVE_TYPE.STRING,
+    ] as string[]
+  ).includes(type);
+}
+export function isPivotResultColumnName(columnName: string) {
+  return columnName.includes(PIVOT_COLUMN_NAME_VALUE_SEPARATOR);
+}
+export function getPivotResultColumnBaseColumnName(columnName: string) {
+  if (!isPivotResultColumnName(columnName)) {
+    throw new IllegalStateError(
+      `Column '${columnName}' is not a pivot result column`,
+    );
+  }
+  return columnName.substring(
+    columnName.lastIndexOf(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) +
+      PIVOT_COLUMN_NAME_VALUE_SEPARATOR.length,
+  );
+}

package/src/stores/core/DataCubeQuerySnapshot.ts

@@ -51,6 +51,11 @@ export type DataCubeQuerySnapshotExtendedColumn = DataCubeColumn & {
   reduceFn?: PlainObject<V1_Lambda> | undefined;
 };
 
+export type DataCubeQuerySnapshotAggregateColumn = DataCubeColumn & {
+  parameterValues: DataCubeOperationValue[];
+  operator: string;
+};
+
 export type DataCubeQuerySnapshotSortColumn = DataCubeColumn & {
   direction: DataCubeQuerySortDirection;
 };
@@ -64,6 +69,14 @@ export type DataCubeQuerySnapshotPivot = {
   castColumns: DataCubeColumn[];
 };
 
+export type DataCubeQuerySnapshotProcessingContext = {
+  snapshot: DataCubeQuerySnapshot;
+  pivotAggColumns: DataCubeQuerySnapshotAggregateColumn[];
+  pivotSortColumns: DataCubeQuerySnapshotSortColumn[];
+  groupByAggColumns: DataCubeQuerySnapshotAggregateColumn[];
+  groupBySortColumns: DataCubeQuerySnapshotSortColumn[];
+};
+
 export type DataCubeQuerySnapshotData = {
   configuration: PlainObject<DataCubeConfiguration>;
   sourceColumns: DataCubeColumn[];