@solidstarters/solid-core 1.2.193 → 1.2.201

package/dist/services/crud-helper.service.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CrudHelperService = exports.FilterCombinator = void 0;
+exports.CrudHelperService = exports.UserIdFields = exports.FilterCombinator = void 0;
 const typeorm_1 = require("typeorm");
 const strings_1 = require("@angular-devkit/core/src/utils/strings");
 const solid_registry_1 = require("../helpers/solid-registry");
@@ -11,6 +11,11 @@ var FilterCombinator;
     FilterCombinator["AND"] = "$and";
     FilterCombinator["OR"] = "$or";
 })(FilterCombinator || (exports.FilterCombinator = FilterCombinator = {}));
+var UserIdFields;
+(function (UserIdFields) {
+    UserIdFields["CREATED_BY"] = "createdBy";
+    UserIdFields["UPDATED_BY"] = "updatedBy";
+})(UserIdFields || (exports.UserIdFields = UserIdFields = {}));
 class CrudHelperService {
     constructor() {
         this.logger = new common_1.Logger(CrudHelperService.name);
@@ -29,6 +34,16 @@ class CrudHelperService {
             const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
             return matchingPermssions.length > 0;
         };
+        this.hasPublishPermissionOnModel = (activeUser, modelName) => {
+            const permissionNames = [`${(0, strings_1.classify)(modelName)}Controller.publish`];
+            const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+            return matchingPermssions.length > 0;
+        };
+        this.hasUnpublishPermissionOnModel = (activeUser, modelName) => {
+            const permissionNames = [`${(0, strings_1.classify)(modelName)}Controller.publish`];
+            const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+            return matchingPermssions.length > 0;
+        };
         this.hasDeletePermissionOnModel = (activeUser, modelName) => {
             const permissionNames = [`${(0, strings_1.classify)(modelName)}Controller.delete`, `${(0, strings_1.classify)(modelName)}Controller.deleteMany`];
             const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
@@ -48,11 +63,21 @@ class CrudHelperService {
     orderOptions(sort = []) {
         const orderOptions = {};
         sort.forEach((s) => {
-            const [field, order] = s.split(':');
-            orderOptions[field] = order?.toUpperCase() ?? 'ASC';
-            if (!['ASC', 'DESC'].includes(orderOptions[field])) {
+            const parts = s.split(':');
+            let order;
+            let field;
+            if (parts.length > 1) {
+                order = parts.pop();
+                field = parts.join(':');
+            }
+            else {
+                field = parts[0];
+            }
+            const normalizedOrder = order ? order.toUpperCase() : 'ASC';
+            if (!['ASC', 'DESC'].includes(normalizedOrder)) {
                 throw new Error(`Invalid sort order provided:  ${order}`);
             }
+            orderOptions[field] = normalizedOrder;
         });
         return orderOptions;
     }
@@ -173,27 +198,31 @@ class CrudHelperService {
             return [];
         return Array.isArray(value) ? value : [value];
     }
+    normalizeAndFilterPopulateAttributes(value) {
+        const normalized = this.normalize(value);
+        return normalized.filter(item => item !== UserIdFields.CREATED_BY && item !== UserIdFields.UPDATED_BY);
+    }
+    extractUserIdFieldsFromPopulate(value) {
+        const normalized = this.normalize(value);
+        return normalized.filter(item => item === UserIdFields.CREATED_BY || item === UserIdFields.UPDATED_BY);
+    }
     isRelationJoined(queryBuilder, joinProperty) {
         return queryBuilder.expressionMap.joinAttributes.some(join => join.entityOrProperty === joinProperty);
     }
     hasJoins(queryBuilder) {
         return queryBuilder.expressionMap.joinAttributes.length > 0;
     }
-    buildFilterQuery(qb, basicFilterDto, entityAlias, internationalisation, draftPublishWorkflow, moduleRef, filterCombinator = FilterCombinator.AND) {
+    buildFilterQuery(qb, basicFilterDto, entityAlias, internationalisation, draftPublishWorkflow, moduleRef, filterCombinator = FilterCombinator.AND, applyPagination = true, applySorting = true) {
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
-        const { fields, sort, groupBy, populate = [], populateMedia = [], locale, status } = basicFilterDto;
+        const { fields, sort, populate = [], populateMedia = [], locale, status } = basicFilterDto;
         const normalizedFields = this.normalize(fields);
-        const normalizedPopulate = this.normalize(populate);
+        const normalizedAndFilteredPopulateAttributes = this.normalizeAndFilterPopulateAttributes(populate);
         const normalizedPopulateMedia = this.normalize(populateMedia);
         const additionalPopulate = this.additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia);
-        normalizedPopulate.push(...additionalPopulate.filter((relation) => !normalizedPopulate.includes(relation)));
+        normalizedAndFilteredPopulateAttributes.push(...additionalPopulate.filter((relation) => !normalizedAndFilteredPopulateAttributes.includes(relation)));
         const normalizedSort = this.normalize(sort);
-        const normalizedGroupBy = this.normalize(groupBy);
-        if (normalizedGroupBy.length > 1) {
-            throw new Error(error_messages_1.ERROR_MESSAGES.GROUP_BY_LIMIT);
-        }
-        if (normalizedPopulate && normalizedPopulate.length) {
-            this.buildPopulateQuery(normalizedPopulate, entityAlias, qb);
+        if (normalizedAndFilteredPopulateAttributes && normalizedAndFilteredPopulateAttributes.length) {
+            this.buildPopulateQuery(normalizedAndFilteredPopulateAttributes, entityAlias, qb);
         }
         if (filters) {
             if (filterCombinator === FilterCombinator.AND) {
@@ -234,7 +263,7 @@ class CrudHelperService {
                 return this.wrapFieldWithAlias(field, entityAlias);
             }));
         }
-        if (normalizedSort && normalizedSort.length) {
+        if (applySorting && normalizedSort && normalizedSort.length) {
             const orderOptions = this.orderOptions(normalizedSort);
             if (orderOptions) {
                 const orderOptionKeys = Object.keys(orderOptions);
@@ -251,15 +280,12 @@ class CrudHelperService {
             qb.withDeleted();
             qb.where(`${entityAlias}.deletedAt IS NOT NULL`);
         }
-        if (normalizedGroupBy && normalizedGroupBy.length) {
-            normalizedGroupBy.forEach((field) => {
-                qb.addGroupBy(`${entityAlias}.${field}`);
-            });
+        if (applyPagination) {
+            if (limit)
+                this.hasJoins(qb) ? qb.take(limit) : qb.limit(limit);
+            if (offset)
+                this.hasJoins(qb) ? qb.skip(offset) : qb.offset(offset);
         }
-        if (limit)
-            this.hasJoins(qb) ? qb.take(limit) : qb.limit(limit);
-        if (offset)
-            this.hasJoins(qb) ? qb.skip(offset) : qb.offset(offset);
         return qb;
     }
     additionalRelationsRequiredForMediaPopulation(normalizedPopulateMedia) {
@@ -278,6 +304,169 @@ class CrudHelperService {
         });
         return qb;
     }
+    sanitizeAlias(alias) {
+        return alias.replace(/[^a-zA-Z0-9_]/g, '_');
+    }
+    isAliasJoined(queryBuilder, alias) {
+        return queryBuilder.expressionMap.joinAttributes.some(join => join.alias?.name === alias);
+    }
+    getExistingJoinAlias(qb, joinProperty) {
+        const existingJoin = qb.expressionMap.joinAttributes.find(join => join.entityOrProperty === joinProperty);
+        return existingJoin?.alias?.name;
+    }
+    ensureRelationPathJoined(qb, rootAlias, pathParts) {
+        const mainAlias = qb.expressionMap?.mainAlias?.name ||
+            qb.expressionMap?.aliases?.find(a => a.metadata)?.name ||
+            qb.expressionMap?.aliases?.[0]?.name;
+        let parentAlias = mainAlias || rootAlias;
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const part = pathParts[i];
+            const joinProperty = `${parentAlias}.${part}`;
+            const existingAlias = this.getExistingJoinAlias(qb, joinProperty);
+            const joinAlias = existingAlias ?? this.sanitizeAlias(`${parentAlias}_${part}`);
+            if (!existingAlias && !this.isRelationJoined(qb, joinProperty) && !this.isAliasJoined(qb, joinAlias)) {
+                qb.leftJoin(joinProperty, joinAlias);
+            }
+            parentAlias = joinAlias;
+        }
+        return { alias: parentAlias, property: pathParts[pathParts.length - 1] };
+    }
+    getDriver(qb) {
+        return qb.connection.options.type;
+    }
+    buildDateGranularityExpression(driver, columnExpr, granularity) {
+        switch (driver) {
+            case 'postgres':
+            case 'cockroachdb':
+                return `DATE_TRUNC('${granularity}', ${columnExpr})`;
+            case 'mysql':
+            case 'mariadb':
+                switch (granularity) {
+                    case 'day': return `DATE(${columnExpr})`;
+                    case 'week': return `STR_TO_DATE(DATE_FORMAT(${columnExpr}, '%x-%v-1'), '%x-%v-%w')`;
+                    case 'month': return `DATE_FORMAT(${columnExpr}, '%Y-%m-01')`;
+                    case 'year': return `DATE_FORMAT(${columnExpr}, '%Y-01-01')`;
+                    default: throw new Error(`Unsupported granularity ${granularity} for driver ${driver}`);
+                }
+            case 'mssql':
+            case 'sqlserver':
+                switch (granularity) {
+                    case 'day': return `CONVERT(date, ${columnExpr})`;
+                    case 'week': return `DATEADD(week, DATEDIFF(week, 0, ${columnExpr}), 0)`;
+                    case 'month': return `DATEFROMPARTS(YEAR(${columnExpr}), MONTH(${columnExpr}), 1)`;
+                    case 'year': return `DATEFROMPARTS(YEAR(${columnExpr}), 1, 1)`;
+                    default: throw new Error(`Unsupported granularity ${granularity} for driver ${driver}`);
+                }
+            default:
+                throw new Error(`Granularity not supported for driver ${driver}`);
+        }
+    }
+    buildGroupByExpression(qb, rootAlias, field) {
+        const parts = field.split(':');
+        const rawField = parts[0];
+        const granularity = parts[1];
+        const format = parts[2];
+        const pathParts = rawField.split('.');
+        const { alias, property } = this.ensureRelationPathJoined(qb, rootAlias, pathParts);
+        const columnExpr = `${alias}.${property}`;
+        const groupExpr = granularity ? this.buildDateGranularityExpression(this.getDriver(qb), columnExpr, granularity) : columnExpr;
+        const selectAlias = this.sanitizeAlias(`${rawField.replace(/\./g, '_')}${granularity ? '_' + granularity : ''}`);
+        return { groupExpr, selectAlias, sourceKey: field, format };
+    }
+    applyGroupBySelections(qb, groupBy, entityAlias) {
+        const aliasMap = {};
+        const formatMap = {};
+        const expressionMap = {};
+        qb.select([]);
+        groupBy.forEach((field) => {
+            const { groupExpr, selectAlias, sourceKey, format } = this.buildGroupByExpression(qb, entityAlias, field);
+            qb.addSelect(groupExpr, selectAlias);
+            qb.addGroupBy(groupExpr);
+            aliasMap[sourceKey] = selectAlias;
+            formatMap[selectAlias] = format;
+            expressionMap[selectAlias] = groupExpr;
+        });
+        return { aliasMap, formatMap, expressionMap };
+    }
+    buildAggregateExpression(qb, rootAlias, aggregate) {
+        const [rawField, rawFn] = aggregate.split(':');
+        const fn = (rawFn || 'count').toLowerCase();
+        if ((!rawField || rawField.toLowerCase() === 'count') && fn === 'count') {
+            return { expression: 'COUNT(*)', selectAlias: 'count' };
+        }
+        if (!rawField)
+            throw new Error(`Invalid aggregate specification: ${aggregate}`);
+        const pathParts = rawField.split('.');
+        const { alias, property } = this.ensureRelationPathJoined(qb, rootAlias, pathParts);
+        const columnExpr = `${alias}.${property}`;
+        const selectAlias = this.sanitizeAlias(`${rawField.replace(/\./g, '_')}_${fn}`);
+        let expression = '';
+        switch (fn) {
+            case 'count':
+                expression = `COUNT(${columnExpr})`;
+                break;
+            case 'count_distinct':
+                expression = `COUNT(DISTINCT ${columnExpr})`;
+                break;
+            case 'sum':
+                expression = `SUM(${columnExpr})`;
+                break;
+            case 'avg':
+                expression = `AVG(${columnExpr})`;
+                break;
+            case 'min':
+                expression = `MIN(${columnExpr})`;
+                break;
+            case 'max':
+                expression = `MAX(${columnExpr})`;
+                break;
+            default: throw new Error(`Unsupported aggregate function ${fn}`);
+        }
+        return { expression, selectAlias, sourceKey: aggregate };
+    }
+    applyAggregates(qb, aggregates, entityAlias) {
+        const aggregateList = this.normalize(aggregates);
+        const aggregateAliasMap = {};
+        if (!aggregateList.length) {
+            qb.addSelect('COUNT(*)', 'count');
+            aggregateAliasMap['count'] = 'count';
+            return aggregateAliasMap;
+        }
+        aggregateList.forEach((agg) => {
+            const { expression, selectAlias, sourceKey } = this.buildAggregateExpression(qb, entityAlias, agg);
+            qb.addSelect(expression, selectAlias);
+            aggregateAliasMap[sourceKey] = selectAlias;
+        });
+        return aggregateAliasMap;
+    }
+    applyGroupSortingAndPagination(qb, sort, aliasMap, limit, offset) {
+        const normalizedSort = this.normalize(sort);
+        if (normalizedSort.length) {
+            const orderOptions = this.orderOptions(normalizedSort);
+            const orderOptionKeys = Object.keys(orderOptions);
+            orderOptionKeys.forEach((key) => {
+                const resolvedKey = aliasMap[key] || key;
+                const value = orderOptions[key];
+                qb.addOrderBy(`"${resolvedKey}"`, value);
+            });
+        }
+        const hasLimit = limit !== undefined && limit !== null;
+        const hasOffset = offset !== undefined && offset !== null;
+        if (hasLimit) {
+            qb.take(limit);
+            qb.limit(limit);
+        }
+        if (hasOffset) {
+            qb.skip(offset);
+            qb.offset(offset);
+        }
+    }
+    async countGroups(qb) {
+        const clone = qb.clone();
+        clone.limit(undefined).offset(undefined).take(undefined).skip(undefined);
+        const rows = await clone.getRawMany();
+        return rows.length;
+    }
     buildJoinQueryForRelation(qb, entityAlias, relation) {
         const relationParts = relation.split('.');
         let parentAlias = entityAlias;
@@ -305,42 +494,92 @@ class CrudHelperService {
     isAggregateField(field) {
         return field.includes('(');
     }
-    isAggregateFieldKey(key, alias) {
-        return !key.startsWith(`${alias}_`);
+    isAggregateFieldKey(key, aggregateAliases) {
+        return aggregateAliases.has(key);
     }
     getFieldFromQueryFieldKey(queryFieldKey, alias) {
         return queryFieldKey.replace(`${alias}_`, '');
     }
-    buildGroupByRecordsQuery(qb, group, alias) {
+    buildGroupByRecordsQuery(qb, group, alias, groupAliasMap = {}, aggregateAliasMap = {}, groupExpressionMap = {}) {
+        const rootAlias = qb.expressionMap?.mainAlias?.name
+            ?? qb.expressionMap?.aliases?.find(a => a.metadata)?.name
+            ?? qb.expressionMap?.aliases?.[0]?.name
+            ?? qb.alias
+            ?? alias;
         qb.andWhere(new typeorm_1.Brackets(qb => {
+            const aggregateAliasSet = new Set(Object.values(aggregateAliasMap));
+            const reverseGroupAliasMap = Object.entries(groupAliasMap).reduce((acc, [sourceKey, aliasKey]) => {
+                acc[aliasKey] = sourceKey;
+                return acc;
+            }, {});
             for (const key in group) {
-                if (group.hasOwnProperty(key) && !this.isAggregateFieldKey(key, alias)) {
+                if (group.hasOwnProperty(key) && !this.isAggregateFieldKey(key, aggregateAliasSet)) {
                     const value = group[key];
-                    const field = this.getFieldFromQueryFieldKey(key, alias);
-                    qb.andWhere(`${alias}.${field} = :${field}`, { [field]: value });
+                    const sourceField = reverseGroupAliasMap[key] || key;
+                    const cleanedField = sourceField.split(':')[0];
+                    const pathParts = cleanedField.split('.');
+                    const { alias: resolvedAlias, property } = this.ensureRelationPathJoined(qb, rootAlias, pathParts);
+                    const paramKey = this.sanitizeAlias(`${resolvedAlias}_${property}_${key}`);
+                    const expr = (sourceField.includes(':') && groupExpressionMap[key])
+                        ? groupExpressionMap[key]
+                        : `${resolvedAlias}.${property}`;
+                    qb.andWhere(`${expr} = :${paramKey}`, { [paramKey]: value });
                 }
             }
         }));
         return qb;
     }
-    getGroupName(group, alias) {
-        return Object.keys(group)
-            .filter(key => !this.isAggregateFieldKey(key, alias))
-            .map(key => group[key])
-            .join('_');
+    formatGroupValue(value, format) {
+        if (!format)
+            return value;
+        if (value === null || value === undefined)
+            return value;
+        const dateVal = value instanceof Date ? value : new Date(value);
+        if (isNaN(dateVal.getTime()))
+            return value;
+        switch (format) {
+            case 'MMM':
+                return dateVal.toLocaleString('en', { month: 'short' });
+            case 'MMMM':
+                return dateVal.toLocaleString('en', { month: 'long' });
+            case 'YYYY':
+                return dateVal.getFullYear();
+            case 'YYYY-MM':
+                return `${dateVal.getFullYear()}-${String(dateVal.getMonth() + 1).padStart(2, '0')}`;
+            case 'YYYY-MM-DD':
+                return `${dateVal.getFullYear()}-${String(dateVal.getMonth() + 1).padStart(2, '0')}-${String(dateVal.getDate()).padStart(2, '0')}`;
+            default:
+                return value;
+        }
+    }
+    getGroupName(group, aggregateAliases, groupByFields, groupAliasMap, groupFormatMap) {
+        const orderedValues = groupByFields
+            .map(field => {
+            const alias = groupAliasMap[field] ?? this.sanitizeAlias(field.replace(/\./g, '_'));
+            const rawVal = group[alias] ?? group[field] ?? group[field.replace(/\./g, '_')];
+            return this.formatGroupValue(rawVal, groupFormatMap[alias]);
+        })
+            .filter(v => v !== undefined && v !== null);
+        if (orderedValues.length === 0) {
+            return Object.keys(group)
+                .filter(key => !this.isAggregateFieldKey(key, aggregateAliases))
+                .map(key => group[key])
+                .join('_');
+        }
+        return orderedValues.join('_');
     }
-    createGroupRecords(group, alias, groupData) {
-        const groupName = this.getGroupName(group, alias);
+    createGroupRecords(group, aggregateAliases, groupData, groupByFields, groupAliasMap, groupFormatMap) {
+        const groupName = this.getGroupName(group, aggregateAliases, groupByFields, groupAliasMap, groupFormatMap);
         return {
             groupName,
             groupData
         };
     }
-    createGroupMeta(group, alias) {
-        const groupName = this.getGroupName(group, alias);
+    createGroupMeta(group, aggregateAliases, groupByFields, groupAliasMap, groupFormatMap) {
+        const groupName = this.getGroupName(group, aggregateAliases, groupByFields, groupAliasMap, groupFormatMap);
         const groupAggregateValues = {};
         for (const key in group) {
-            if (group.hasOwnProperty(key) && this.isAggregateFieldKey(key, alias)) {
+            if (group.hasOwnProperty(key) && this.isAggregateFieldKey(key, aggregateAliases)) {
                 const value = group[key];
                 groupAggregateValues[key] = value;
             }
@@ -353,19 +592,15 @@ class CrudHelperService {
     async countGroupedRecords(qb, basicFilterDto, entityAlias) {
         const { limit, offset, ...rest } = basicFilterDto;
         const filteredDto = { ...rest, limit: undefined, offset: undefined };
-        const filteredQB = this.buildFilterQuery(qb, filteredDto, entityAlias);
-        const groupByField = filteredDto.groupBy;
-        if (!groupByField || (Array.isArray(groupByField) && groupByField.length !== 1)) {
+        const filteredQB = this.buildFilterQuery(qb, filteredDto, entityAlias, undefined, undefined, undefined, FilterCombinator.AND, false, false);
+        const groupByFields = this.normalize(filteredDto.groupBy);
+        if (!groupByFields || groupByFields.length === 0) {
             throw new Error(error_messages_1.ERROR_MESSAGES.INVALID_GROUP_BY_COUNT);
         }
-        const field = Array.isArray(groupByField) ? groupByField[0] : groupByField;
-        const rawResults = await filteredQB
-            .select([])
-            .addSelect(`${entityAlias}.${field}`, 'groupField')
-            .groupBy(`${entityAlias}.${field}`)
-            .limit(undefined)
-            .offset(undefined)
-            .getRawMany();
+        this.applyGroupBySelections(filteredQB, groupByFields, entityAlias);
+        this.applyAggregates(filteredQB, ['count'], entityAlias);
+        filteredQB.limit(undefined).offset(undefined).take(undefined).skip(undefined);
+        const rawResults = await filteredQB.getRawMany();
         return rawResults.length;
     }
 }