@adaptabletools/adaptable 11.0.0-canary.6 → 11.0.1

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);

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>;
     evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): Observable<DataChangedInfo>;
+    evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule): AggregationParameter;
     validateBoolean(expression: string, module: AdaptableModule, config?: {
         force?: boolean;
     }): {
@@ -23,6 +25,10 @@ export interface IQueryLanguageService extends IAdaptableService {
         isValid: boolean;
         errorMessage: string;
     };
+    validateAggregatedScalar(expression: string, module: AdaptableModule): {
+        isValid: boolean;
+        errorMessage: string;
+    };
     getModuleExpressionFunctions(module: AdaptableModule): ModuleExpressionFunctions;
     getColumnsFromExpression(input: string): string[];
     getNamedQueryNamesFromExpression(input: string): 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,16 +4,19 @@ 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>;
     evaluateAggregatedBooleanExpression(aggregationExpression: string, module: AdaptableModule): Observable<DataChangedInfo>;
     validateBoolean(expressionInput: string, module: AdaptableModule, config?: {
@@ -30,6 +33,10 @@ export declare class QueryLanguageService implements IQueryLanguageService {
         isValid: boolean;
         errorMessage: string;
     };
+    validateAggregatedScalar(expressionInput: string, module: AdaptableModule): {
+        isValid: boolean;
+        errorMessage: string;
+    };
     getColumnsFromExpression(input?: string): string[];
     getNamedQueryNamesFromExpression(input?: string): string[];
     getModuleExpressionFunctions(module: AdaptableModule): ModuleExpressionFunctions;

package/src/Utilities/Services/QueryLanguageService.js

@@ -10,7 +10,8 @@ class QueryLanguageService {
         this.adaptable = adaptable;
         this.cacheBooleanValidation = new Map();
         this.cacheObservableValidation = new Map();
-        this.cacheAggregationValidation = new Map();
+        this.cacheAggregatedBooleanValidation = new Map();
+        this.cacheAggregatedScalarValidation = new Map();
         this.cacheModuleSpecificExpressionFunctions = new Map();
     }
     evaluateBooleanExpression(expression, module, rowNode) {
@@ -26,6 +27,14 @@ class QueryLanguageService {
         // currently scalar and boolean expressions are evaluated the same
         return this.evaluateBooleanExpression(expression, module, rowNode);
     }
+    evaluateAggregatedScalarExpression(expression, module) {
+        const aggregatedScalarFunctions = this.getModuleExpressionFunctions(module).aggregatedScalarFunctions;
+        return parser.evaluate(expression, {
+            node: null,
+            api: this.adaptable.api,
+            functions: aggregatedScalarFunctions,
+        });
+    }
     evaluateObservableExpression(reactiveExpression, module) {
         const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
@@ -66,7 +75,7 @@ class QueryLanguageService {
             }
             const force = (_a = config === null || config === void 0 ? void 0 : config.force) !== null && _a !== void 0 ? _a : false;
             // get searchOptions to see if validation should be performed
-            if (!this.adaptable.api.internalApi.getAdaptableOptions().queryLanguageOptions
+            if (!this.adaptable.api.internalApi.getAdaptableOptions().adaptableQLOptions.expressionOptions
                 .performExpressionValidation &&
                 !force) {
                 const result = { isValid: true, errorMessage: '' };
@@ -148,30 +157,68 @@ class QueryLanguageService {
     }
     validateAggregatedBoolean(expressionInput = '', module) {
         const cacheKey = this.getExpressionCacheKey(expressionInput, module);
-        if (this.cacheAggregationValidation.has(cacheKey)) {
-            return this.cacheAggregationValidation.get(cacheKey);
+        if (this.cacheAggregatedBooleanValidation.has(cacheKey)) {
+            return this.cacheAggregatedBooleanValidation.get(cacheKey);
+        }
+        const expression = expressionInput.trim();
+        if (expression === '') {
+            const result = {
+                isValid: false,
+                errorMessage: 'empty AggregatedBoolean expression',
+            };
+            this.cacheAggregatedBooleanValidation.set(cacheKey, result);
+            return result;
+        }
+        try {
+            const aggregatedBooleanExpressionEvaluation = this.evaluateAggregatedBooleanExpression(expression, module);
+            if (!rxjs_1.isObservable(aggregatedBooleanExpressionEvaluation)) {
+                const result = {
+                    isValid: false,
+                    errorMessage: `provided AggregatedBoolean expression does not evaluate to an Observable`,
+                };
+                this.cacheAggregatedBooleanValidation.set(cacheKey, result);
+                return result;
+            }
+            const result = { isValid: true, errorMessage: '' };
+            this.cacheAggregatedBooleanValidation.set(cacheKey, result);
+            return result;
+        }
+        catch (error) {
+            const result = {
+                isValid: false,
+                errorMessage: error,
+            };
+            this.cacheAggregatedBooleanValidation.set(cacheKey, result);
+            return result;
+        }
+    }
+    validateAggregatedScalar(expressionInput = '', module) {
+        const cacheKey = this.getExpressionCacheKey(expressionInput, module);
+        if (this.cacheAggregatedScalarValidation.has(cacheKey)) {
+            return this.cacheAggregatedScalarValidation.get(cacheKey);
         }
         const expression = expressionInput.trim();
         if (expression === '') {
             const result = {
                 isValid: false,
-                errorMessage: 'empty aggregation expression',
+                errorMessage: 'empty AggregatedScalar expression',
             };
-            this.cacheAggregationValidation.set(cacheKey, result);
+            this.cacheAggregatedScalarValidation.set(cacheKey, result);
             return result;
         }
         try {
-            const aggregationExpression = this.evaluateAggregatedBooleanExpression(expression, module);
-            if (!rxjs_1.isObservable(aggregationExpression)) {
+            const evaluationResult = this.evaluateAggregatedScalarExpression(expression, module);
+            if (evaluationResult.type !== 'aggregation') {
                 const result = {
                     isValid: false,
-                    errorMessage: `provided aggregation expression does not evaluate to an Observable`,
+                    errorMessage: 'provided AggregatedScalar expression does not evaluate to a supported aggregation',
                 };
-                this.cacheAggregationValidation.set(cacheKey, result);
+                this.cacheAggregatedScalarValidation.set(cacheKey, result);
                 return result;
             }
+            // no exception,so everything seems to be fine
             const result = { isValid: true, errorMessage: '' };
-            this.cacheAggregationValidation.set(cacheKey, result);
+            this.cacheAggregatedScalarValidation.set(cacheKey, result);
             return result;
         }
         catch (error) {
@@ -179,7 +226,7 @@ class QueryLanguageService {
                 isValid: false,
                 errorMessage: error,
             };
-            this.cacheAggregationValidation.set(cacheKey, result);
+            this.cacheAggregatedScalarValidation.set(cacheKey, result);
             return result;
         }
     }
@@ -192,26 +239,38 @@ class QueryLanguageService {
     // Returns the ExpressionFunctions available for the given Module as specified in the `QueryLanguageOptions.moduleExpressionFunctions`
     // if there are no specific functions defined, it falls back to the default values
     getModuleExpressionFunctions(module) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         if (!module) {
             LoggingHelper_1.LogAdaptableInfo(`QueryLanguageService.getModuleExpressionFunctions() was called with an undefined 'module' param, this should never happen`);
             return {
-                booleanFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultBooleanFunctions,
-                scalarFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultScalarFunctions,
-                observableFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultObservableFunctions,
-                aggregatedBooleanFunctions: this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregatedBooleanFunctions,
+                booleanFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                    .defaultBooleanFunctions,
+                scalarFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                    .defaultScalarFunctions,
+                observableFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                    .defaultObservableFunctions,
+                aggregatedBooleanFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                    .defaultAggregatedBooleanFunctions,
+                aggregatedScalarFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                    .defaultAggregatedScalarFunctions,
             };
         }
         let cachedResult = this.cacheModuleSpecificExpressionFunctions.get(module);
         if (cachedResult) {
             return cachedResult;
         }
-        const moduleSpecificOptions = (_b = (_a = this.adaptable.adaptableOptions.queryLanguageOptions.moduleExpressionFunctions) === null || _a === void 0 ? void 0 : _a[module]) !== null && _b !== void 0 ? _b : {};
+        const moduleSpecificOptions = (_b = (_a = this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+            .moduleExpressionFunctions) === null || _a === void 0 ? void 0 : _a[module]) !== null && _b !== void 0 ? _b : {};
         const moduleSpecificFunctions = {
-            booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptable.adaptableOptions.queryLanguageOptions.defaultBooleanFunctions,
-            scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptable.adaptableOptions.queryLanguageOptions.defaultScalarFunctions,
-            observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptable.adaptableOptions.queryLanguageOptions.defaultObservableFunctions,
-            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregatedBooleanFunctions,
+            booleanFunctions: (_c = moduleSpecificOptions.booleanFunctions) !== null && _c !== void 0 ? _c : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                .defaultBooleanFunctions,
+            scalarFunctions: (_d = moduleSpecificOptions.scalarFunctions) !== null && _d !== void 0 ? _d : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions.defaultScalarFunctions,
+            observableFunctions: (_e = moduleSpecificOptions.observableFunctions) !== null && _e !== void 0 ? _e : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                .defaultObservableFunctions,
+            aggregatedBooleanFunctions: (_f = moduleSpecificOptions.aggregatedBooleanFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                .defaultAggregatedBooleanFunctions,
+            aggregatedScalarFunctions: (_g = moduleSpecificOptions.aggregatedScalarFunctions) !== null && _g !== void 0 ? _g : this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
+                .defaultAggregatedScalarFunctions,
         };
         this.cacheModuleSpecificExpressionFunctions.set(module, moduleSpecificFunctions);
         return moduleSpecificFunctions;

package/src/View/AdaptableWizardView/AdaptableConfigurationDialog/ConfigurationForm.js

@@ -13,6 +13,7 @@ const ConfigurationForm = (props) => {
     let abOptions = props.adaptableOptions;
     const layoutOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.layoutOptions), abOptions.layoutOptions);
     const generalOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.generalOptions), abOptions.generalOptions);
+    const adaptableQLOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.adaptableQLOptions), abOptions.adaptableQLOptions);
     const userInterfaceOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.userInterfaceOptions), abOptions.userInterfaceOptions);
     const searchOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.searchOptions), abOptions.searchOptions);
     const filterOptions = Object.assign(Object.assign({}, DefaultAdaptableOptions_1.DefaultAdaptableOptions.filterOptions), abOptions.filterOptions);
@@ -72,10 +73,11 @@ const ConfigurationForm = (props) => {
         React.createElement(HelpBlock_1.default, null, "Search Options"),
         React.createElement(FormLayout_1.default, { margin: 2, columns: [{ name: 'children' }, { name: 'label', style: { textAlign: 'start' } }] },
             React.createElement(FormLayout_1.FormRow, { label: "Case Sensitive Text Comparison" },
-                React.createElement(CheckBox_1.CheckBox, { checked: generalOptions.caseSensitiveTextComparisons, onChange: (caseSensitiveTextComparisons) => {
+                React.createElement(CheckBox_1.CheckBox, { checked: adaptableQLOptions.caseSensitiveTextComparisons, onChange: (caseSensitiveTextComparisons) => {
                         abOptions = Object.assign({}, abOptions);
-                        abOptions.generalOptions = Object.assign({}, abOptions.generalOptions);
-                        abOptions.generalOptions.caseSensitiveTextComparisons = caseSensitiveTextComparisons;
+                        abOptions.adaptableQLOptions = Object.assign({}, abOptions.adaptableQLOptions);
+                        abOptions.adaptableQLOptions.caseSensitiveTextComparisons =
+                            caseSensitiveTextComparisons;
                         props.onChangeadaptableOptions(abOptions);
                     } })),
             React.createElement(FormLayout_1.FormRow, { label: "Use AG Grid Filter Form Style" },