@resolveio/server-lib 20.10.2 → 20.10.4

package/methods/report-builder.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -42,18 +53,73 @@ var pagination_model_1 = require("../models/pagination.model");
 var resolveio_server_app_1 = require("../resolveio-server-app");
 var common_1 = require("../util/common");
 var schema_report_builder_1 = require("../util/schema-report-builder");
+var ReportBuilderJoinAggregationSchema = new simpl_schema_1.default({
+    fieldPath: {
+        type: String,
+        optional: true
+    },
+    operator: {
+        type: String,
+        allowedValues: ['sum', 'avg', 'min', 'max', 'count']
+    },
+    alias: {
+        type: String
+    }
+});
+var ReportBuilderCollectionJoinSchema = new simpl_schema_1.default({
+    collection: {
+        type: String
+    },
+    alias: {
+        type: String
+    },
+    rootFieldPath: {
+        type: String
+    },
+    foreignField: {
+        type: String
+    },
+    aggregations: {
+        type: Array
+    },
+    'aggregations.$': {
+        type: ReportBuilderJoinAggregationSchema
+    },
+    matchFilters: {
+        type: Array,
+        optional: true
+    },
+    'matchFilters.$': {
+        type: Object,
+        blackbox: true
+    }
+});
+var numberLeafValueTypesTemplate = (0, schema_report_builder_1.getLeafValueTypes)({ rbType: 'Number' }, '');
+var numberLeafFormatTypesTemplate = (0, schema_report_builder_1.getLeafFormatTypes)({ rbType: 'Number' }, '');
 function loadReportBuilderMethods(methodManager) {
     methodManager.methods({
         reportBuilderBuildTree: {
             check: new simpl_schema_1.default({
                 collection_root: {
                     type: String
+                },
+                collectionJoins: {
+                    type: Array,
+                    optional: true
+                },
+                'collectionJoins.$': {
+                    type: ReportBuilderCollectionJoinSchema
                 }
             }),
-            function: function (collection_root) {
+            function: function (collection_root, collectionJoins) {
+                if (collectionJoins === void 0) { collectionJoins = []; }
                 var lookupSchemaData = (0, schema_report_builder_1.getReportLookupSchemas)(collection_root).sort(function (a, b) { return a.collection_name.localeCompare(b.collection_name); });
                 var lookupSchemaTree = lookupSchemaData.find(function (a) { return a.is_root === true; }).tree;
                 var treeItems = (0, schema_report_builder_1.buildTree)(collection_root, lookupSchemaTree);
+                var joinTreeItems = buildCollectionJoinTree(collectionJoins);
+                if (joinTreeItems.length) {
+                    treeItems = treeItems.concat(joinTreeItems).sort(function (a, b) { return a.fieldName.localeCompare(b.fieldName); });
+                }
                 Object.keys(lookupSchemaTree).filter(function (a) { return a.endsWith('(Lookup)'); }).forEach(function (lookup) {
                     var fieldPath = lookup.split('.');
                     var field = null;
@@ -185,9 +251,16 @@ function loadReportBuilderMethods(methodManager) {
                 displayType: {
                     type: String,
                     optional: true
+                },
+                collectionJoins: {
+                    type: Array,
+                    optional: true
+                },
+                'collectionJoins.$': {
+                    type: ReportBuilderCollectionJoinSchema
                 }
             }),
-            function: function (reportType, rootCollectionName, rootOptions, filters, filterArrays, filterArrayFields, selectedFields, customFields, groupsRow, fieldsTotal, fieldsLink, date_field, date_interval, displayType) {
+            function: function (reportType, rootCollectionName, rootOptions, filters, filterArrays, filterArrayFields, selectedFields, customFields, groupsRow, fieldsTotal, fieldsLink, date_field, date_interval, displayType, collectionJoins) {
                 if (filters === void 0) { filters = []; }
                 if (filterArrays === void 0) { filterArrays = []; }
                 if (filterArrayFields === void 0) { filterArrayFields = []; }
@@ -199,6 +272,7 @@ function loadReportBuilderMethods(methodManager) {
                 if (date_field === void 0) { date_field = ''; }
                 if (date_interval === void 0) { date_interval = ''; }
                 if (displayType === void 0) { displayType = ''; }
+                if (collectionJoins === void 0) { collectionJoins = []; }
                 return __awaiter(this, void 0, void 0, function () {
                     var modelCollection, query_1, initialQueryMatchCondition_1, sizes_1, divFields_1, queryMatchConditionLookup_1, queryGroup_1, groupedSorts_1, queryProjection_1, _loop_1, i, res_1, err_1, tmpTotals_1, tmpRes;
                     return __generator(this, function (_a) {
@@ -235,6 +309,7 @@ function loadReportBuilderMethods(methodManager) {
                                 }
                                 // Add count
                                 query_1.push({ $addFields: { count: { $sum: 1 } } });
+                                appendCollectionJoinStages(query_1, collectionJoins);
                                 sizes_1 = [];
                                 filterArrayFields.filter(function (a) { return a.fieldPath; }).forEach(function (filterField) {
                                     var _a, _b;
@@ -837,5 +912,162 @@ function loadReportBuilderMethods(methodManager) {
     });
 }
 exports.loadReportBuilderMethods = loadReportBuilderMethods;
+function appendCollectionJoinStages(query, collectionJoins) {
+    if (!Array.isArray(collectionJoins) || !collectionJoins.length) {
+        return;
+    }
+    collectionJoins.filter(function (join) { return join && Array.isArray(join.aggregations) && join.aggregations.length; }).forEach(function (join, joinIndex) {
+        if (!isValidJoinAlias(join.alias)) {
+            throw new Error('Report builder join alias must not contain "." or "$" characters.');
+        }
+        var normalizedRootField = normalizeFieldPath(join.rootFieldPath);
+        var normalizedForeignField = normalizeFieldPath(join.foreignField);
+        if (!normalizedRootField || !normalizedForeignField) {
+            return;
+        }
+        var validAggregations = join.aggregations.filter(function (agg) { return agg && !!agg.alias && !!agg.operator; });
+        if (!validAggregations.length) {
+            return;
+        }
+        var bindVariable = 'rbJoin_' + joinIndex;
+        var lookupPipeline = [];
+        lookupPipeline.push({
+            $match: {
+                $expr: {
+                    $eq: ['$' + normalizedForeignField, '$$' + bindVariable]
+                }
+            }
+        });
+        if (Array.isArray(join.matchFilters) && join.matchFilters.length) {
+            join.matchFilters.forEach(function (filter) {
+                lookupPipeline.push({ $match: filter });
+            });
+        }
+        var groupStage = {
+            _id: null
+        };
+        var projectStage = {
+            _id: 0
+        };
+        validAggregations.forEach(function (agg) {
+            var _a;
+            var operator = (agg.operator || 'sum').toLowerCase();
+            if (operator !== 'count' && !agg.fieldPath) {
+                throw new Error('Report builder join aggregation requires fieldPath for operator ' + operator);
+            }
+            if (operator === 'count') {
+                groupStage[agg.alias] = { $sum: 1 };
+            }
+            else {
+                var normalizedAggField = normalizeFieldPath(agg.fieldPath);
+                groupStage[agg.alias] = (_a = {}, _a["$".concat(operator)] = '$' + normalizedAggField, _a);
+            }
+            projectStage[agg.alias] = { $ifNull: ['$' + agg.alias, 0] };
+        });
+        lookupPipeline.push({ $group: groupStage });
+        lookupPipeline.push({ $project: projectStage });
+        var lookupStage = {
+            $lookup: {
+                from: join.collection,
+                let: {},
+                pipeline: lookupPipeline,
+                as: join.alias
+            }
+        };
+        lookupStage.$lookup.let[bindVariable] = '$' + normalizedRootField;
+        query.push(lookupStage);
+        var defaults = buildJoinAggregationDefaults(validAggregations);
+        var addFieldsStage = {
+            $addFields: {}
+        };
+        addFieldsStage.$addFields[join.alias] = {
+            $ifNull: [{ $first: '$' + join.alias }, defaults]
+        };
+        query.push(addFieldsStage);
+    });
+}
+function buildJoinAggregationDefaults(aggregations) {
+    return aggregations.reduce(function (defaults, agg) {
+        defaults[agg.alias] = 0;
+        return defaults;
+    }, {});
+}
+function buildCollectionJoinTree(collectionJoins) {
+    var joinNodes = [];
+    if (!Array.isArray(collectionJoins) || !collectionJoins.length) {
+        return joinNodes;
+    }
+    collectionJoins.filter(function (join) { return join && Array.isArray(join.aggregations) && join.aggregations.length; }).forEach(function (join) {
+        var childNodes = join.aggregations.filter(function (agg) { return agg && agg.alias; }).map(function (agg) { return ({
+            collection_name: join.collection,
+            columnName: (0, common_1.toTitleCase)(agg.alias.replace(/\_/g, ' ')),
+            fieldName: agg.alias,
+            fieldType: 'Number',
+            fieldTypeName: 'Number',
+            distinctFieldValues: [],
+            fieldPath: join.alias + '.' + agg.alias,
+            fieldPathName: formatFieldPathName(join.alias + '.' + agg.alias),
+            lookup_collection: '',
+            lookup_local_key: '',
+            lookup_foreign_key: '',
+            lookup_as: '',
+            text: (0, common_1.toTitleCase)(agg.alias.replace(/\_/g, ' ')),
+            value: agg.alias,
+            isLeaf: true,
+            isActive: false,
+            isSelected: false,
+            depth: 0,
+            leafValueType: '',
+            leafValueTypes: cloneNumberLeafValueTypes(),
+            leafFormatType: '',
+            leafFormatTypes: cloneNumberLeafFormatTypes()
+        }); }).sort(function (a, b) { return a.fieldName.localeCompare(b.fieldName); });
+        if (!childNodes.length) {
+            return;
+        }
+        joinNodes.push({
+            collection_name: join.collection,
+            columnName: (0, common_1.toTitleCase)(join.alias.replace(/\_/g, ' ')),
+            fieldName: join.alias,
+            fieldType: 'Group',
+            fieldTypeName: 'Group',
+            distinctFieldValues: [],
+            fieldPath: join.alias,
+            fieldPathName: formatFieldPathName(join.alias),
+            lookup_collection: '',
+            lookup_local_key: '',
+            lookup_foreign_key: '',
+            lookup_as: '',
+            text: (0, common_1.toTitleCase)(join.alias.replace(/\_/g, ' ')),
+            value: join.alias,
+            isLeaf: false,
+            isActive: false,
+            isSelected: false,
+            depth: 0,
+            leafValueType: '',
+            leafFormatType: '',
+            children: childNodes
+        });
+    });
+    return joinNodes.sort(function (a, b) { return a.fieldName.localeCompare(b.fieldName); });
+}
+function cloneNumberLeafValueTypes() {
+    return numberLeafValueTypesTemplate.map(function (type) { return (__assign({}, type)); });
+}
+function cloneNumberLeafFormatTypes() {
+    return numberLeafFormatTypesTemplate.map(function (type) { return (__assign({}, type)); });
+}
+function normalizeFieldPath(fieldPath) {
+    return fieldPath ? fieldPath.replace(/\.\$/g, '') : fieldPath;
+}
+function formatFieldPathName(path) {
+    if (!path) {
+        return '';
+    }
+    return (0, common_1.toTitleCase)(path.replace(/\.\$\./g, ' (List) -> ').replace(/\./g, ' (Group) -> ').replace(/\_/g, ' '));
+}
+function isValidJoinAlias(alias) {
+    return !!alias && !alias.includes('.') && !alias.includes('$');
+}
 
 //# sourceMappingURL=report-builder.js.map