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

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/DataService.js

@@ -58,7 +58,12 @@ class DataService {
         return result;
     }
     getUndoChangeKey(primaryKeyValue, columnId, previousValue, newValue) {
-        return JSON.stringify({ primaryKeyValue, columnId, previousValue, newValue });
+        return JSON.stringify({
+            primaryKeyValue,
+            columnId,
+            previousValue,
+            newValue,
+        });
     }
     logDataChange(dataChangedInfo) {
         const dataChangeLogEntry = this.extractDataChangeLogEntry(dataChangedInfo);

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/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;
     };

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);
@@ -37,13 +46,13 @@ class QueryLanguageService {
         });
         return reactiveExpression$;
     }
-    evaluateAggregationExpression(aggregationExpression, module) {
+    evaluateAggregatedBooleanExpression(aggregationExpression, module) {
         const moduleExpressionFunctions = this.getModuleExpressionFunctions(module);
         const booleanAndScalarFunctions = this.getBooleanAndScalarFunctions(moduleExpressionFunctions);
         const aggregationExpression$ = parser.evaluate(aggregationExpression, {
             node: aggregationExpression,
             api: this.adaptable.api,
-            functions: moduleExpressionFunctions.aggregationFunctions,
+            functions: moduleExpressionFunctions.aggregatedBooleanFunctions,
             whereClauseFunctions: booleanAndScalarFunctions,
         });
         return aggregationExpression$;
@@ -57,13 +66,16 @@ class QueryLanguageService {
             }
             const expression = expressionInput.trim();
             if (expression === '') {
-                const result = { isValid: false, errorMessage: 'empty boolean expression' };
+                const result = {
+                    isValid: false,
+                    errorMessage: 'empty boolean expression',
+                };
                 this.cacheBooleanValidation.set(cacheKey, result);
                 return result;
             }
             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: '' };
@@ -113,7 +125,10 @@ class QueryLanguageService {
         }
         const expression = expressionInput.trim();
         if (expression === '') {
-            const result = { isValid: false, errorMessage: 'empty observable expression' };
+            const result = {
+                isValid: false,
+                errorMessage: 'empty observable expression',
+            };
             this.cacheObservableValidation.set(cacheKey, result);
             return result;
         }
@@ -140,29 +155,70 @@ class QueryLanguageService {
             return result;
         }
     }
-    validateAggregation(expressionInput = '', module) {
+    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 aggregation expression' };
-            this.cacheAggregationValidation.set(cacheKey, result);
+            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 AggregatedScalar expression',
+            };
+            this.cacheAggregatedScalarValidation.set(cacheKey, result);
             return result;
         }
         try {
-            const aggregationExpression = this.evaluateAggregationExpression(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) {
@@ -170,7 +226,7 @@ class QueryLanguageService {
                 isValid: false,
                 errorMessage: error,
             };
-            this.cacheAggregationValidation.set(cacheKey, result);
+            this.cacheAggregatedScalarValidation.set(cacheKey, result);
             return result;
         }
     }
@@ -183,30 +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
+                booleanFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
                     .defaultBooleanFunctions,
-                scalarFunctions: this.adaptable.adaptableOptions.queryLanguageOptions
+                scalarFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
                     .defaultScalarFunctions,
-                observableFunctions: this.adaptable.adaptableOptions.queryLanguageOptions
+                observableFunctions: this.adaptable.adaptableOptions.adaptableQLOptions.expressionOptions
                     .defaultObservableFunctions,
-                aggregationFunctions: this.adaptable.adaptableOptions.queryLanguageOptions
-                    .defaultAggregationFunctions,
+                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,
-            aggregationFunctions: (_f = moduleSpecificOptions.aggregationFunctions) !== null && _f !== void 0 ? _f : this.adaptable.adaptableOptions.queryLanguageOptions.defaultAggregationFunctions,
+            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/Utilities/Services/ReportService.js

@@ -305,7 +305,9 @@ class ReportService {
         // if this is a date column and there is a custom export date format provided, that will take precedence
         if (columnType === 'Date' && !!this.getCustomExportDateFormat()) {
             const exportDateFormat = this.getCustomExportDateFormat();
-            return FormatHelper_1.default.DateFormatter(cellRawValue, { Pattern: exportDateFormat });
+            return FormatHelper_1.default.DateFormatter(cellRawValue, {
+                Pattern: exportDateFormat,
+            });
         }
         // otherwise check the general export format types
         let cellExportFormat = this.computeCellExportValueFormat(columnType);
@@ -314,7 +316,9 @@ class ReportService {
     getReportFileName(reportName) {
         let fileName = StringExtensions_1.default.ReplaceEmptySpacesWithUnderscore(reportName);
         if (this.adaptable.adaptableOptions.exportOptions.appendFileTimestamp) {
-            fileName = `${fileName}_${FormatHelper_1.DateFormatter(new Date(), { Pattern: 'yyyyMMdd_HHmmss' })}`;
+            fileName = `${fileName}_${FormatHelper_1.DateFormatter(new Date(), {
+                Pattern: 'yyyyMMdd_HHmmss',
+            })}`;
         }
         return fileName;
     }

package/src/Utilities/Services/TeamSharingService.js

@@ -45,7 +45,10 @@ class TeamSharingService {
             .includes(reference.Reference.Uuid));
         const newSharedEntityDependencies = [];
         freshReferences.forEach((reference) => {
-            this.createSharedEntity(reference.Reference, reference.Module, { description: activeSharedEntity.Description, type: activeSharedEntity.Type }, activeSharedEntity.UserName, Date.now(), newSharedEntityDependencies);
+            this.createSharedEntity(reference.Reference, reference.Module, {
+                description: activeSharedEntity.Description,
+                type: activeSharedEntity.Type,
+            }, activeSharedEntity.UserName, Date.now(), newSharedEntityDependencies);
         });
         updatedEntityDependencyIds.push(...newSharedEntityDependencies.map((sharedEntity) => sharedEntity.Uuid));
         activeSharedEntity.EntityDependencyIds = updatedEntityDependencyIds;
@@ -84,8 +87,7 @@ class TeamSharingService {
     }
     getStaleActiveSharedEntities() {
         const sharedEntities = this.adaptable.api.teamSharingApi.getSharedEntities();
-        const activeEntities = this.adaptable.api.teamSharingApi.getTeamSharingState()
-            .ActiveSharedEntityMap;
+        const activeEntities = this.adaptable.api.teamSharingApi.getTeamSharingState().ActiveSharedEntityMap;
         const result = {};
         sharedEntities
             .filter((sharedEntity) => sharedEntity.Type === 'Active')

package/src/View/AdaptablePopover/index.js

@@ -17,7 +17,12 @@ class AdaptablePopover extends React.Component {
         const title = StringExtensions_1.StringExtensions.IsNotNullOrEmpty(this.props.headerText)
             ? this.props.headerText
             : '';
-        const popoverClickRootClose = (React.createElement(rebass_1.Box, { className: "ab-Popover", style: { margin: '0px', padding: '0px', minWidth: popoverMinWidth, maxWidth: 300 } },
+        const popoverClickRootClose = (React.createElement(rebass_1.Box, { className: "ab-Popover", style: {
+                margin: '0px',
+                padding: '0px',
+                minWidth: popoverMinWidth,
+                maxWidth: 300,
+            } },
             title ? (React.createElement(rebass_1.Text, { fontSize: 2, padding: 2 },
                 React.createElement("b", null, title))) : null,
             React.createElement(rebass_1.Box, { padding: 2 }, this.props.bodyText.map((textOrHTML, index) => (React.createElement("span", { key: index }, textOrHTML))))));

package/src/View/AdaptableView.js

@@ -22,7 +22,7 @@ class AdaptableView extends React.Component {
         return (React.createElement("div", null,
             this.props.AdaptableApi.internalApi.getModuleService().isModuleAvailable('Dashboard') && (React.createElement(Dashboard_1.Dashboard, { api: this.props.AdaptableApi })),
             React.createElement(AdaptableLoadingScreen_1.AdaptableLoadingScreen, { onClose: this.props.onCloseLoadingPopup, showLoadingScreen: this.props.PopupState.LoadingPopup.ShowLoadingPopup }),
-            React.createElement(AdaptablePopupPrompt_1.AdaptablePopupPrompt, { message: this.props.PopupState.PromptPopup.Message, header: this.props.PopupState.PromptPopup.Header, onClose: this.props.onClosePromptPopup, onConfirm: this.props.onConfirmPromptPopup, showPopup: this.props.PopupState.PromptPopup.ShowPromptPopup }),
+            this.props.PopupState.PromptPopup.ShowPromptPopup && (React.createElement(AdaptablePopupPrompt_1.AdaptablePopupPrompt, { message: this.props.PopupState.PromptPopup.Message, header: this.props.PopupState.PromptPopup.Header, onClose: this.props.onClosePromptPopup, onConfirm: this.props.onConfirmPromptPopup, onConfirmActionCreator: this.props.PopupState.PromptPopup.ConfirmActionCreator, defaultValue: this.props.PopupState.PromptPopup.DefaultValue })),
             React.createElement(AdaptablePopupConfirmation_1.AdaptablePopupConfirmation, { header: this.props.PopupState.ConfirmationPopup.Header, messsage: this.props.PopupState.ConfirmationPopup.Msg, showPopup: this.props.PopupState.ConfirmationPopup.ShowConfirmationPopup, cancelButtonText: this.props.PopupState.ConfirmationPopup.CancelButtonText, confirmButtonText: this.props.PopupState.ConfirmationPopup.ConfirmButtonText, onCancel: this.props.onCancelConfirmationPopup, onConfirm: this.props.onConfirmConfirmationPopup, showInputBox: this.props.PopupState.ConfirmationPopup.ShowInputBox, messageType: this.props.PopupState.ConfirmationPopup.MessageType, api: this.props.AdaptableApi }),
             Boolean(this.props.PopupState.ScreenPopup.ShowScreenPopup) && (React.createElement(AdaptablePopup_1.AdaptablePopup, { componentName: this.props.PopupState.ScreenPopup.ComponentName, componentModule: this.props.PopupState.ScreenPopup.ComponentModule, onHide: this.props.onCloseScreenPopup, api: this.props.AdaptableApi, onClearParams: () => this.props.onClearPopupParams(), moduleParams: this.props.PopupState.ScreenPopup.Params, moduleProps: this.props.PopupState.ScreenPopup.PopupProps })),
             React.createElement(ExportCustomDestinationFormPopups_1.ExportCustomDestinationFormPopups, { api: this.props.AdaptableApi }),

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

@@ -26,7 +26,11 @@ const dataTypes = [
         label: 'Boolean',
     },
 ];
-const inputStyle = { width: '100%', minWidth: 50, textAlign: 'start' };
+const inputStyle = {
+    width: '100%',
+    minWidth: 50,
+    textAlign: 'start',
+};
 const useForceRender = () => {
     const [, setNow] = react_1.useState(Date.now());
     return () => {