@adaptabletools/adaptable 11.0.0-canary.6 → 11.0.0-canary.7

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/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" },

package/src/View/Alert/Wizard/AlertDisplayWizardSection.d.ts

@@ -9,6 +9,7 @@ export declare const renderAlertDisplaySummary: () => JSX.Element;
 interface AlertPreviewProps extends BoxProps {
     api: AdaptableApi;
     alertDefinition: AlertDefinition;
+    focusFirstButton?: boolean;
 }
 export declare const AlertPreview: React.FunctionComponent<AlertPreviewProps>;
 export declare const AlertDisplayWizardSection: (props: AlertDisplayWizardSectionProps) => JSX.Element;

package/src/View/Alert/Wizard/AlertDisplayWizardSection.js

@@ -32,7 +32,7 @@ exports.renderAlertDisplaySummary = () => {
     return React.createElement(exports.AlertPreview, { api: api, alertDefinition: data });
 };
 exports.AlertPreview = (_a) => {
-    var { alertDefinition, api } = _a, boxProps = tslib_1.__rest(_a, ["alertDefinition", "api"]);
+    var { alertDefinition, api, focusFirstButton } = _a, boxProps = tslib_1.__rest(_a, ["alertDefinition", "api", "focusFirstButton"]);
     const mapButtons = React.useCallback((button) => {
         let buttonStyle = button.ButtonStyle;
         if (buttonStyle && buttonStyle.tone == null && (alertDefinition === null || alertDefinition === void 0 ? void 0 : alertDefinition.MessageType)) {
@@ -52,7 +52,7 @@ exports.AlertPreview = (_a) => {
         return result;
     }, [alertDefinition]);
     return (React.createElement(rebass_1.Box, Object.assign({}, boxProps, { style: Object.assign({ border: '1px solid var(--ab-color-inputborder)' }, boxProps.style) }),
-        React.createElement(AdaptablePopupAlert_1.AdaptablePopupAlert, { headless: true, adaptableAlert: alertToPreview, api: api, onClose: () => { } })));
+        React.createElement(AdaptablePopupAlert_1.AdaptablePopupAlert, { headless: true, focusFirstButton: focusFirstButton, adaptableAlert: alertToPreview, api: api, onClose: () => { } })));
 };
 exports.AlertDisplayWizardSection = (props) => {
     var _a, _b, _c, _d;

package/src/View/CalculatedColumn/CalculatedColumnSharedEntity.js

@@ -7,14 +7,14 @@ const rebass_1 = require("rebass");
 const CodeBlock_1 = require("../../components/CodeBlock");
 class CalculatedColumnSharedEntity extends React.Component {
     render() {
-        var _a;
+        // TODO AFL TTT
         let calcCol = this.props.entity;
         return (React.createElement(rebass_1.Flex, { flexDirection: "row", alignItems: "center" },
             React.createElement(rebass_1.Flex, { flex: 4 }, calcCol.ColumnId),
             React.createElement(rebass_1.Flex, { flex: 8 },
                 React.createElement(CodeBlock_1.CodeBlock, null,
-                    " ", (_a = calcCol.Query) === null || _a === void 0 ? void 0 :
-                    _a.ScalarExpression))));
+                    ' ',
+                    this.props.api.queryLanguageApi.getAdaptableQueryExpression(calcCol.Query)))));
     }
 }
 exports.CalculatedColumnSharedEntity = CalculatedColumnSharedEntity;

package/src/View/CalculatedColumn/CalculatedColumnSummary.js

@@ -28,9 +28,8 @@ class CalculatedColumnSummaryComponent extends React.Component {
         let detailRow;
         let sharing = this.props.teamSharingActivated;
         this.props.CalculatedColumns.map((item, index) => {
-            var _a;
             if (item.ColumnId == this.props.summarisedColumn.columnId) {
-                detailRow = (React.createElement(ModuleDetail_1.ModuleDetail, { key: 'UF' + index, item1: this.props.moduleInfo.FriendlyName, item2: (_a = item.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression, configEnity: item, showShare: this.props.teamSharingActivated, moduleInfo: this.props.moduleInfo, onEdit: () => this.onEdit(item), onShare: (config) => this.props.onShare(item, config), onDelete: CalculatedColumnRedux.CalculatedColumnDelete(item), showBold: true, accessLevel: this.props.accessLevel }));
+                detailRow = (React.createElement(ModuleDetail_1.ModuleDetail, { key: 'UF' + index, item1: this.props.moduleInfo.FriendlyName, item2: this.props.api.queryLanguageApi.getAdaptableQueryExpression(item.Query), configEnity: item, showShare: this.props.teamSharingActivated, moduleInfo: this.props.moduleInfo, onEdit: () => this.onEdit(item), onShare: (config) => this.props.onShare(item, config), onDelete: CalculatedColumnRedux.CalculatedColumnDelete(item), showBold: true, accessLevel: this.props.accessLevel }));
             }
         });
         return (React.createElement("div", null,
@@ -52,10 +51,9 @@ class CalculatedColumnSummaryComponent extends React.Component {
         });
     }
     canFinishWizard() {
-        var _a;
         let calculatedColumn = this.state.editedAdaptableObject;
         return (StringExtensions_1.StringExtensions.IsNotNullOrEmpty(calculatedColumn.ColumnId) &&
-            StringExtensions_1.StringExtensions.IsNotNullOrEmpty((_a = calculatedColumn.Query) === null || _a === void 0 ? void 0 : _a.ScalarExpression));
+            StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.props.api.queryLanguageApi.getAdaptableQueryExpression(calculatedColumn.Query)));
     }
 }
 exports.CalculatedColumnSummaryComponent = CalculatedColumnSummaryComponent;