@adaptabletools/adaptable 11.0.0-canary.5 → 11.0.0

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -11,6 +11,8 @@ function assignAdaptableOptions(adaptableOptions) {
     var _a;
     const returnedAdaptableOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions, adaptableOptions);
     returnedAdaptableOptions.adaptableStateKey = (_a = returnedAdaptableOptions.adaptableStateKey) !== null && _a !== void 0 ? _a : returnedAdaptableOptions.adaptableId;
+    returnedAdaptableOptions.adaptableQLOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions, adaptableOptions.adaptableQLOptions);
+    returnedAdaptableOptions.adaptableQLOptions.expressionOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions.expressionOptions, returnedAdaptableOptions.adaptableQLOptions.expressionOptions);
     returnedAdaptableOptions.layoutOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions, adaptableOptions.layoutOptions);
     returnedAdaptableOptions.notificationsOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.notificationsOptions, adaptableOptions.notificationsOptions);
     returnedAdaptableOptions.alertOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.alertOptions, adaptableOptions.alertOptions);
@@ -29,7 +31,6 @@ function assignAdaptableOptions(adaptableOptions) {
     returnedAdaptableOptions.exportOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.exportOptions, adaptableOptions.exportOptions);
     returnedAdaptableOptions.teamSharingOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.teamSharingOptions, adaptableOptions.teamSharingOptions);
     returnedAdaptableOptions.toolPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.toolPanelOptions, adaptableOptions.toolPanelOptions);
-    returnedAdaptableOptions.queryLanguageOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.queryLanguageOptions, adaptableOptions.queryLanguageOptions);
     returnedAdaptableOptions.dataChangeHistoryOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.dataChangeHistoryOptions, adaptableOptions.dataChangeHistoryOptions);
     returnedAdaptableOptions.settingsPanelOptions = Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.settingsPanelOptions, adaptableOptions.settingsPanelOptions);
     const { predefinedConfig } = returnedAdaptableOptions;

package/src/Utilities/Services/AlertService.js

@@ -16,8 +16,12 @@ class AlertService {
         this.emitter = new Emitter_1.default();
     }
     createReactiveAlert(alertDefinition) {
-        // if there is already an reactive alert for this definition, delete it (possible in case of editing definitions),
+        // if there is already a reactive alert for this definition, delete it (possible in case of editing definitions),
         this.deleteReactiveAlert(alertDefinition);
+        if (!alertDefinition.Rule.ObservableExpression &&
+            !alertDefinition.Rule.AggregatedBooleanExpression) {
+            return;
+        }
         const isValidExpression = this.isValidExpression(alertDefinition.Rule);
         if (!isValidExpression) {
             LoggingHelper_1.LogAdaptableWarning(`Could NOT create reactive alert due to invalid Rule definition!`, alertDefinition.Rule);
@@ -55,8 +59,8 @@ class AlertService {
     isValidExpression(rule) {
         return rule.ObservableExpression
             ? this.adaptable.api.queryLanguageApi.isValidObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with observable expression `)
-            : rule.AggregationExpression
-                ? this.adaptable.api.queryLanguageApi.isValidAggregationExpression(rule.AggregationExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
+            : rule.AggregatedBooleanExpression
+                ? this.adaptable.api.queryLanguageApi.isValidAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId, `Invalid Alert rule with aggregation expression `)
                 : false;
     }
     evaluateReactiveExpression(rule) {
@@ -66,7 +70,7 @@ class AlertService {
                 .evaluateObservableExpression(rule.ObservableExpression, ModuleConstants_1.AlertModuleId)
             : this.adaptable.api.internalApi
                 .getQueryLanguageService()
-                .evaluateAggregationExpression(rule.AggregationExpression, ModuleConstants_1.AlertModuleId);
+                .evaluateAggregatedBooleanExpression(rule.AggregatedBooleanExpression, ModuleConstants_1.AlertModuleId);
     }
 }
 exports.AlertService = AlertService;

package/src/Utilities/Services/CalculatedColumnExpressionService.d.ts

@@ -1,11 +1,15 @@
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ICalculatedColumnExpressionService } from './Interface/ICalculatedColumnExpressionService';
 import { RowNode } from '@ag-grid-community/all-modules';
+import { AdaptableCalculatedColumnQuery, CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
 export declare class CalculatedColumnExpressionService implements ICalculatedColumnExpressionService {
     private adaptable;
+    private aggregatedScalarCalculatedColumnsMap;
     constructor(adaptable: IAdaptable);
-    GetCalculatedColumnDataType(expression: string): 'String' | 'Number' | 'Boolean' | 'Date';
-    IsExpressionValid(expression: string): boolean;
-    ComputeExpressionValue(expression: string, node: RowNode): any;
+    getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
+    isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
+    evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, node: RowNode): any;
+    createAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    destroyAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
     destroy(): void;
 }

package/src/Utilities/Services/CalculatedColumnExpressionService.js

@@ -4,17 +4,45 @@ exports.CalculatedColumnExpressionService = void 0;
 const Enums_1 = require("../../PredefinedConfig/Common/Enums");
 const LoggingHelper_1 = require("../Helpers/LoggingHelper");
 const ModuleConstants_1 = require("../Constants/ModuleConstants");
+const scalarAggregationHelper_1 = require("../ExpressionFunctions/scalarAggregationHelper");
 class CalculatedColumnExpressionService {
     constructor(adaptable) {
         this.adaptable = adaptable;
+        this.aggregatedScalarCalculatedColumnsMap = new Map();
         this.adaptable = adaptable;
+        this.adaptable.api.internalApi
+            .getDataService()
+            .on('DataChanged', (dataChangedInfo) => {
+            if (dataChangedInfo.trigger === 'aggChange') {
+                // do NOT handle changes on group rows
+                return;
+            }
+            const refreshedCalculatedColumns = [];
+            this.aggregatedScalarCalculatedColumnsMap.forEach((aggregatedScalarCalculatedColumn) => {
+                if (aggregatedScalarCalculatedColumn
+                    .getColumnDependencies()
+                    .includes(dataChangedInfo.column.columnId)) {
+                    aggregatedScalarCalculatedColumn.refreshAggregatedColumnValue();
+                    refreshedCalculatedColumns.push(aggregatedScalarCalculatedColumn.getCalculatedColumnId());
+                }
+            });
+            if (refreshedCalculatedColumns.length) {
+                this.adaptable.api.gridApi.refreshCells(null, refreshedCalculatedColumns);
+            }
+        });
     }
-    GetCalculatedColumnDataType(expression) {
+    getCalculatedColumnDataType(calculatedColumnQuery) {
         try {
+            if (calculatedColumnQuery.AggregatedScalarExpression) {
+                // currently AggregatedScalarExpression support only numerical values
+                // TODO AFL try to derive the type from the aggregatedColumn?
+                // we definitely don't want to aggregate everything only to get the data type
+                return Enums_1.DataType.Number;
+            }
             let firstRowNode = this.adaptable.api.gridApi.getFirstRowNode();
             let firstRowValue = this.adaptable.api.internalApi
                 .getQueryLanguageService()
-                .evaluateScalarExpression(expression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
+                .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
             if (firstRowValue instanceof Date) {
                 return Enums_1.DataType.Date;
             }
@@ -29,40 +57,137 @@ class CalculatedColumnExpressionService {
             }
         }
         catch (e) {
-            LoggingHelper_1.LogAdaptableWarning(`Invalid CalculatedColumn expression ${expression} :: ${e}`);
+            LoggingHelper_1.LogAdaptableWarning(`Invalid CalculatedColumn expression ${this.adaptable.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumnQuery)} :: ${e}`);
             return Enums_1.DataType.Number;
         }
     }
-    IsExpressionValid(expression) {
-        try {
-            let firstRowNode = this.adaptable.getFirstRowNode();
-            this.adaptable.api.internalApi
-                .getQueryLanguageService()
-                .evaluateScalarExpression(expression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
-            return true;
+    isCalculatedColumnQueryValid(calculatedColumnQuery) {
+        if (calculatedColumnQuery.ScalarExpression) {
+            try {
+                // TODO AFL add a cached validation for ScalarExpression, just like for all the other types
+                let firstRowNode = this.adaptable.getFirstRowNode();
+                this.adaptable.api.internalApi
+                    .getQueryLanguageService()
+                    .evaluateScalarExpression(calculatedColumnQuery.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, firstRowNode);
+                return true;
+            }
+            catch (e) {
+                // no logging as this method is used only in the UI
+                return false;
+            }
         }
-        catch (e) {
-            // no logging as this method is used only in the UI
-            return false;
+        if (calculatedColumnQuery.AggregatedScalarExpression) {
+            const validationResult = this.adaptable.api.internalApi
+                .getQueryLanguageService()
+                .validateAggregatedScalar(calculatedColumnQuery.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+            return validationResult.isValid;
         }
+        // if query has neither a ScalarExpression nor an AggregatedScalarExpression => it can only be false
+        return false;
     }
-    ComputeExpressionValue(expression, node) {
+    evaluateCalculatedColumnQuery(calculatedColumn, node) {
+        var _a, _b, _c, _d, _e;
         try {
             if (this.adaptable.api.gridApi.isGroupRowNode(node)) {
                 return undefined;
             }
             // no validation here, this function has to be as performant as possible
-            return this.adaptable.api.internalApi
-                .getQueryLanguageService()
-                .evaluateScalarExpression(expression, ModuleConstants_1.CalculatedColumnModuleId, node);
+            if ((_a = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression) {
+                return this.adaptable.api.internalApi
+                    .getQueryLanguageService()
+                    .evaluateScalarExpression(calculatedColumn.Query.ScalarExpression, ModuleConstants_1.CalculatedColumnModuleId, node);
+            }
+            if ((_b = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _b === void 0 ? void 0 : _b.AggregatedScalarExpression) {
+                const aggregatedScalarCalculatedColumn = this.aggregatedScalarCalculatedColumnsMap.get(calculatedColumn.Uuid);
+                return aggregatedScalarCalculatedColumn === null || aggregatedScalarCalculatedColumn === void 0 ? void 0 : aggregatedScalarCalculatedColumn.getAggregatedColumnValue(node);
+            }
         }
         catch (error) {
-            LoggingHelper_1.LogAdaptableError(`Invalid CalculatedColumn scalar expression ${expression} :: ${error}`);
+            LoggingHelper_1.LogAdaptableError(`Invalid CalculatedColumn expression ${(_d = (_c = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _c === void 0 ? void 0 : _c.ScalarExpression) !== null && _d !== void 0 ? _d : (_e = calculatedColumn === null || calculatedColumn === void 0 ? void 0 : calculatedColumn.Query) === null || _e === void 0 ? void 0 : _e.AggregatedScalarExpression} :: ${error}`);
             return null;
         }
     }
+    createAggregatedScalarCalculatedColumn(calculatedColumn) {
+        var _a;
+        // if there is already an aggregated scalar, delete it (possible when editing)
+        this.destroyAggregatedScalarCalculatedColumn(calculatedColumn);
+        if ((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.AggregatedScalarExpression) {
+            const aggregationConfig = this.adaptable.api.internalApi
+                .getQueryLanguageService()
+                .evaluateAggregatedScalarExpression(calculatedColumn.Query.AggregatedScalarExpression, ModuleConstants_1.CalculatedColumnModuleId);
+            const aggregatedScalarCalculatedColumn = new AggregatedScalarCalculatedColumn(aggregationConfig.value, calculatedColumn, this.adaptable);
+            this.aggregatedScalarCalculatedColumnsMap.set(calculatedColumn.Uuid, aggregatedScalarCalculatedColumn);
+        }
+    }
+    destroyAggregatedScalarCalculatedColumn(calculatedColumn) {
+        this.aggregatedScalarCalculatedColumnsMap.delete(calculatedColumn.Uuid);
+    }
     destroy() {
         // TO DO
     }
 }
 exports.CalculatedColumnExpressionService = CalculatedColumnExpressionService;
+class AggregatedScalarCalculatedColumn {
+    constructor(expressionEvaluation, calculatedColumn, adaptable) {
+        this.expressionEvaluation = expressionEvaluation;
+        this.calculatedColumn = calculatedColumn;
+        this.adaptable = adaptable;
+        this.aggregationResult = this.computeAggregatedValue(expressionEvaluation);
+        // currently we support only one reducer
+        this.aggregationReducerName = Object.keys(expressionEvaluation.aggregationParams.reducers)[0];
+    }
+    getAggregatedColumnValue(rowNode) {
+        const aggregationValue = this.getAggregationValue(rowNode);
+        if (this.expressionEvaluation.rowValueGetter) {
+            return this.expressionEvaluation.rowValueGetter(rowNode, aggregationValue);
+        }
+        return aggregationValue;
+    }
+    refreshAggregatedColumnValue() {
+        this.aggregationResult = this.computeAggregatedValue(this.expressionEvaluation);
+    }
+    getCalculatedColumnId() {
+        return this.calculatedColumn.ColumnId;
+    }
+    getColumnDependencies() {
+        return this.expressionEvaluation.columnDependencies;
+    }
+    computeAggregatedValue(expressionEvaluation) {
+        const gridData = this.adaptable.api.gridApi.getGridData();
+        if (!expressionEvaluation.cumulateOver) {
+            return scalarAggregationHelper_1.aggregate(expressionEvaluation.aggregationParams, gridData);
+        }
+        else {
+            // 1. sort grid data by given OVER column
+            const sortByColumn = expressionEvaluation.cumulateOver;
+            // currently we support only ascending sorting
+            gridData.sort((first, second) => {
+                if (first[sortByColumn] < second[sortByColumn]) {
+                    return -1;
+                }
+                if (first[sortByColumn] > second[sortByColumn]) {
+                    return 1;
+                }
+                return 0;
+            });
+            // 2. add primary key column as the most specific groupBy
+            if (!expressionEvaluation.aggregationParams.groupBy) {
+                expressionEvaluation.aggregationParams.groupBy = [];
+            }
+            const gridPrimaryKey = this.adaptable.adaptableOptions.primaryKey;
+            // !! aggregationParams mutated
+            expressionEvaluation.aggregationParams.groupBy.push({ field: gridPrimaryKey });
+            // 3. cumulate
+            return scalarAggregationHelper_1.cumulate(expressionEvaluation.aggregationParams, gridData);
+        }
+    }
+    getAggregationValue(rowNode) {
+        var _a, _b;
+        if ((_a = this.expressionEvaluation.aggregationParams.groupBy) === null || _a === void 0 ? void 0 : _a.length) {
+            const groupColumns = this.expressionEvaluation.aggregationParams.groupBy.map((groupByParam) => groupByParam.field);
+            const groupKeys = groupColumns.map((groupColumnName) => this.adaptable.api.gridApi.getRawValueFromRowNode(rowNode, groupColumnName));
+            return (_b = this.aggregationResult.deepMap.get(groupKeys)) === null || _b === void 0 ? void 0 : _b.reducerResults[this.aggregationReducerName];
+        }
+        return this.aggregationResult.reducerResults[this.aggregationReducerName];
+    }
+}

package/src/Utilities/Services/Interface/IAdaptableService.d.ts

@@ -1,3 +1,3 @@
 export interface IAdaptableService {
-    destroy(): void;
+    destroy?(): void;
 }

package/src/Utilities/Services/Interface/ICalculatedColumnExpressionService.d.ts

@@ -1,7 +1,10 @@
 import { IAdaptableService } from './IAdaptableService';
 import { RowNode } from '@ag-grid-community/all-modules';
+import { AdaptableCalculatedColumnQuery, CalculatedColumn } from '../../../PredefinedConfig/CalculatedColumnState';
 export interface ICalculatedColumnExpressionService extends IAdaptableService {
-    IsExpressionValid(expression: string): boolean;
-    ComputeExpressionValue(expression: string, rowNode: RowNode): any;
-    GetCalculatedColumnDataType(expression: string): 'String' | 'Number' | 'Boolean' | 'Date';
+    isCalculatedColumnQueryValid(calculatedColumnQuery: AdaptableCalculatedColumnQuery): boolean;
+    evaluateCalculatedColumnQuery(calculatedColumn: CalculatedColumn, rowNode: RowNode): any;
+    getCalculatedColumnDataType(calculatedColumnQuery: AdaptableCalculatedColumnQuery): 'String' | 'Number' | 'Boolean' | 'Date';
+    createAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
+    destroyAggregatedScalarCalculatedColumn(calculatedColumn: CalculatedColumn): void;
 }

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -3,12 +3,14 @@ import { IAdaptableService } from './IAdaptableService';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { DataChangedInfo } from '../../../PredefinedConfig/Common/DataChangedInfo';
 import { AdaptableModule } from '../../../PredefinedConfig/Common/Types';
-import { ModuleExpressionFunctions } from '../../../AdaptableOptions/QueryLanguageOptions';
+import { AggregationParameter } from '../../ExpressionFunctions/aggregatedScalarExpressionFunctions';
+import { ModuleExpressionFunctions } from '../../../AdaptableOptions/AdaptableQLOptions';
 export interface IQueryLanguageService extends IAdaptableService {
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: RowNode): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
     evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregationExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -19,7 +21,11 @@ export interface IQueryLanguageService extends IAdaptableService {
         isValid: boolean;
         errorMessage: string;
     };
-    validateAggregation(expression: string, module: AdaptableModule): {
+    validateAggregatedBoolean(expression: string, module: AdaptableModule): {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    validateAggregatedScalar(expression: string, module: AdaptableModule): {
         isValid: boolean;
         errorMessage: string;
     };

package/src/Utilities/Services/LicenseService.js

@@ -23,7 +23,7 @@ var LicenseValidityType;
     LicenseValidityType["COMMERCIAL_EXPIRED_IN_SCOPE"] = "COMMERCIAL_EXPIRED_IN_SCOPE";
     LicenseValidityType["COMMERCIAL_EXPIRED_OUT_OF_SCOPE"] = "COMMERCIAL_EXPIRED_OUT_OF_SCOPE";
 })(LicenseValidityType = exports.LicenseValidityType || (exports.LicenseValidityType = {}));
-const SANDPACK_REGEX = /(https):\/\/\d+\-\d+\-\d\-(sandpack\.codesandbox\.io)/g;
+const SANDPACK_REGEX = /(https):\/\/\d+\-\d+\-\d+\-(sandpack\.codesandbox\.io)/g;
 const SANDBOX_REGEX = /(https):\/\/\S+(\.csb\.app)/g;
 const origin = typeof window !== 'undefined' ? window.location.origin : '';
 const isInsideSandpack = () => {

package/src/Utilities/Services/ModuleService.js

@@ -76,75 +76,68 @@ class ModuleService {
     }
     getModuleDocumentationPageByModule(adaptableModule) {
         let url = `${DocumentationLinkConstants_1.HOST_URL_DOCS}/`;
-        let notificationUrl = url + 'notifications/';
-        let editingUrl = url + 'editing/';
-        let searchingUrl = url + 'searching/';
-        let filteringUrl = url + 'filtering/';
-        let themingUrl = url + 'theming/';
-        let stylingUrl = url + 'styling/';
-        let advancedFeaturesUrl = url + 'advanced-features/';
-        let gridManagementUrl = url + 'grid-management/';
-        let userInterfaceUrl = url + 'user-interface/';
-        let pluginUrl = url + 'plugins/';
+        let learnUrl = url + 'learn/';
         switch (adaptableModule) {
             case 'Alert':
-                return notificationUrl + 'alerts-module';
+                return learnUrl + 'handbook-alerting';
             case 'BulkUpdate':
-                return editingUrl + 'bulk-update-module';
+                return url + 'handbook-editing#bulk-update';
             case 'CalculatedColumn':
-                return advancedFeaturesUrl + 'calculated-column-module';
+                return learnUrl + 'handbook-calculated-column';
             case 'CellSummary':
-                return advancedFeaturesUrl + 'cell-summary-module';
+                return learnUrl + 'handbook-summarising#cell-summary-information';
             case 'ConditionalStyle':
-                return stylingUrl + 'conditional-style-module';
+                return learnUrl + 'handbook-conditional-styling';
             case 'CustomSort':
-                return advancedFeaturesUrl + 'custom-sort-module';
+                return learnUrl + 'handbook-sorting';
             case 'Dashboard':
-                return userInterfaceUrl + 'dashboard';
+                return learnUrl + 'ui-dashboard';
             case 'DataSource':
-                return searchingUrl + 'data-source-module';
+                return learnUrl + 'handbook-data-sources';
+            case 'DataChangeHistory':
+                return learnUrl + 'handbook-monitoring#data-change-history';
             case 'Export':
-                return gridManagementUrl + 'export-module';
+                return learnUrl + 'handbook-exporting';
             case 'Filter':
-                return filteringUrl + 'filter-module';
+                return learnUrl + 'handbook-filtering';
+            case 'FlashingCell':
+                return learnUrl + 'handbook-cell-flashing';
             case 'FormatColumn':
-                return stylingUrl + 'format-column-module';
+                return learnUrl + 'handbook-column-formatting';
             case 'FreeTextColumn':
-                return advancedFeaturesUrl + 'freetext-column-module';
+                return learnUrl + 'handbook-freetext-column';
             case 'GridInfo':
-                return advancedFeaturesUrl + 'grid-info-module';
+                return learnUrl + 'handbook-monitoring#grid-info-panel';
             case 'Layout':
-                return advancedFeaturesUrl + 'layout-module';
+                return learnUrl + 'handbook-layouts';
             case 'PlusMinus':
-                return editingUrl + 'plus-minus-module';
+                return learnUrl + 'handbook-editing#plus-minus';
             case 'Query':
-                return searchingUrl + 'query-module';
+                return learnUrl + 'handbook-querying';
             case 'QuickSearch':
-                return searchingUrl + 'quick-search-module';
+                return learnUrl + 'handbook-searching';
             case 'Schedule':
-                return advancedFeaturesUrl + 'schedule-module';
+                return learnUrl + 'handbook-scheduling';
             case 'Shortcut':
-                return editingUrl + 'shortcut-module';
+                return learnUrl + 'handbook-editing#shortcuts';
             case 'SmartEdit':
-                return editingUrl + 'smart-edit-module';
+                return learnUrl + 'handbook-editing#smart-edit';
             case 'StateManagement':
-                return advancedFeaturesUrl + 'adaptable-state-overview';
+                return learnUrl + 'dev-guide-adaptable-state';
             case 'SystemStatus':
-                return notificationUrl + 'system-status-module';
+                return learnUrl + 'handbook-notifying';
             case 'TeamSharing':
-                return url + 'key-topics/team-sharing';
+                return url + 'handbook-collaborating';
             case 'Theme':
-                return themingUrl + 'using-themes';
+                return learnUrl + 'handbook-theming';
             case 'ToolPanel':
-                return userInterfaceUrl + 'tool-panel';
-            case 'DataChangeHistory':
-                return editingUrl + 'change-history-module';
+                return learnUrl + 'ui-tool-panel';
             case 'Glue42':
-                return pluginUrl + 'glue42/glue42-plugin';
+                return learnUrl + 'integrations-glue42';
             case 'IPushPull':
-                return pluginUrl + 'ipushpull/ipushpull-plugin';
+                return learnUrl + 'integrations-ipushpull';
             case 'OpenFin':
-                return pluginUrl + 'openfin/openfin-plugin';
+                return learnUrl + 'integrations-openfin';
             default:
                 return 'good';
         }

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -4,18 +4,21 @@ import { Observable } from 'rxjs';
 import { DataChangedInfo } from '../../PredefinedConfig/Common/DataChangedInfo';
 import { RowNode } from '@ag-grid-community/all-modules';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
-import { ModuleExpressionFunctions } from '../../AdaptableOptions/QueryLanguageOptions';
+import { ModuleExpressionFunctions } from '../../AdaptableOptions/AdaptableQLOptions';
+import { AggregationParameter } from '../ExpressionFunctions/aggregatedScalarExpressionFunctions';
 export declare class QueryLanguageService implements IQueryLanguageService {
     private adaptable;
     private cacheBooleanValidation;
     private cacheObservableValidation;
-    private cacheAggregationValidation;
+    private cacheAggregatedBooleanValidation;
+    private cacheAggregatedScalarValidation;
     private cacheModuleSpecificExpressionFunctions;
     constructor(adaptable: IAdaptable);
     evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: RowNode): any;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
-    evaluateAggregationExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -26,7 +29,11 @@ export declare class QueryLanguageService implements IQueryLanguageService {
         isValid: boolean;
         errorMessage: string;
     };
-    validateAggregation(expressionInput: string, module: AdaptableModule): {
+    validateAggregatedBoolean(expressionInput: string, module: AdaptableModule): {
+        isValid: boolean;
+        errorMessage: string;
+    };
+    validateAggregatedScalar(expressionInput: string, module: AdaptableModule): {
         isValid: boolean;
         errorMessage: string;
     };